Fix some stuff and add specs

README.md

@@ -5,3 +5,97 @@ Versionub is a simple library to manage versions, somewhat like Versionomy but a
 another version type :)
 
 It uses Parslet for parsing capabilities.
+
+``` ruby
+require 'versionub'
+
+# Create version numbers that understand their own semantics
+v1 = Versionub.create(major: 1, minor: 3, tiny: 2)
+v1.major                                 # => 1
+v1.minor                                 # => 3
+v1.tiny                                  # => 2
+v1.release_type                          # => :final
+v1.patchlevel                            # => 0
+
+# Parse version numbers, including common prerelease syntax
+v2 = Versionub.parse('1.4a3')
+v2.major                                 # => 1
+v2.minor                                 # => 4
+v2.tiny                                  # => 0
+v2.release_type                          # => :alpha
+v2.alpha_version                         # => 3
+v2 > v1                                  # => true
+v2.to_s                                  # => '1.4a3'
+
+# Version numbers are semantically self-adjusting.
+v3 = Versionub.parse('1.4.0b2')
+v3.major                                 # => 1
+v3.minor                                 # => 4
+v3.tiny                                  # => 0
+v3.release_type                          # => :beta
+v3.alpha_version                         # raises NoMethodError
+v3.beta_version                          # => 2
+v3 > v2                                  # => true
+v3.to_s                                  # => '1.4.0b2'
+
+# Comparisons are semantic, so will behave as expected even if the
+# formatting is set up differently.
+v9 = Versionub.parse('2.0.0.0')
+v9.to_s                                  # => '2.0.0.0'
+v9 == Versionub.parse('2')              # => true
+
+# Patchlevels are supported when the release type is :final
+v10 = Versionub.parse('2.0-1')
+v10.patchlevel                           # => 1
+v10.to_s                                 # => '2.0.0-1'
+v11 = Versionub.parse('2.0p1')
+v11.patchlevel                           # => 1
+v11.to_s                                 # => '2.0p1'
+v11 == v10                               # => true
+
+# You can create your own format from scratch
+Versionub.register :windows do
+  parse do
+    rule(:part) { match['0-9'].repeat }
+
+    rule(:separator) { match['.-_\s'] }
+
+    rule(:version) {
+      part.as(:major) >> separator.maybe >>
+      str('SP').maybe >> part.as(:minor)
+    }
+
+    root :version
+  end
+
+  def major
+    @data[:major].to_s if @data[:major]
+  end
+
+  def minor
+    @data[:minor].to_s if @data[:minor]
+  end
+
+  include Comparable
+
+  def <=> (value)
+    value = Versionub.parse(value)
+
+    if (tmp = (minor <=> value.minor)) != 0
+      return tmp
+    end
+
+    if (tmp = (major <=> value.major)) != 0
+      return tmp
+    end
+
+    0
+  end
+end
+
+v12 = Versionub.parse('2008 SP2', :windows)
+v12.major                                  # => 2008
+v12.minor                                  # => 2
+v12.to_s                                   # => '2008 SP2'
+v12 == Versionub.parse('2008.2', :windows) # => true
+```

Rakefile

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'rake'
+
+task :default => :test
+
+task :test do
+  Dir.chdir 'spec'
+
+  sh 'rspec versionomy_spec.rb --color --format doc'
+end

lib/versionub.rb

@@ -21,9 +21,15 @@ module Versionub
   Types = {}
 
   def self.parse (text, type=:standard)
+    return text if text.is_a?(Versionub::Type::Instance)
+
     Types[type.to_sym].parse(text.to_s)
   end
 
+  def self.create (data, type=:standard)
+     Types[type.to_sym].create(data)
+  end
+
   def self.register (type, &block)
     Types[type.to_sym] = Versionub::Type.new(type.to_sym, &block)
   end

lib/versionub/type.rb

@@ -23,24 +23,6 @@ module Versionub
 
 class Type
   class Instance
-    def self.parser (&block)
-      if block
-        @parser = Class.new(Parslet::Parser)
-        @parser.class_eval(&block)
-      end
-
-      @parser
-    end
-
-    def self.transformer (&block)
-      if block
-        @transformer = Class.new(Parslet::Transform)
-        @transformer.class_eval(&block)
-      end
-
-      @transformer
-    end
-
     attr_reader :type
 
     def initialize (type, text, data)
@@ -56,6 +38,28 @@ def to_hash
     def to_s
       @text
     end
+
+    class << self
+      attr_accessor :parser, :transformer
+
+      def parse (&block)
+        if block
+          @parser = Class.new(Parslet::Parser)
+          @parser.class_eval(&block)
+        end
+
+        @parser
+      end
+
+      def transform (&block)
+        if block
+          @transformer = Class.new(Parslet::Transform)
+          @transformer.class_eval(&block)
+        end
+
+        @transformer
+      end
+    end
   end
 
   attr_reader :name
@@ -71,11 +75,15 @@ def parse (text)
     data = @instance.parser.new.parse(text)
 
     if @instance.transformer
-      data = @instance.transformer.apply(data)
+      data = @instance.transformer.new.apply(data)
     end
 
     @instance.new(name, text, data)
   end
+
+  def create (data)
+    @instance.new(name, nil, data)
+  end
 end
 
 end