versionomy 0.0.4 → 0.1.0

data/lib/versionomy/value.rb

@@ -3,7 +3,7 @@
 # Versionomy value
 # 
 # -----------------------------------------------------------------------------
-# Copyright 2008 Daniel Azuma
+# Copyright 2008-2009 Daniel Azuma
 # 
 # All rights reserved.
 # 
@@ -45,32 +45,36 @@ module Versionomy
   # number "1.4.2" would have the values <tt>[1, 4, 2]</tt> in that order,
   # corresponding to the fields <tt>[:major, :minor, :tiny]</tt>.
   # 
-  # Version number values are comparable with other values that have the same
-  # form.
+  # Version number values are comparable with other values that have an
+  # equivalent schema.
   
   class Value
     
     
-    def initialize(schema_, values_=nil, parse_params_=nil, subvalue_=nil)  # :nodoc:
-      @schema = schema_
-      val_ = nil
-      case values_
-      when Hash
-        val_ = values_[@schema.name]
-      when Array
-        val_ = values_.first
-        values_ = values_[1..-1]
-      else
-        val_ = values_
-        values_ = nil
+    # Create a value, given a hash or array of values, and a format. Both
+    # these parameters are required.
+    # 
+    # The values should either be a hash of field names and values, or an
+    # array of values that will be interpreted in field order.
+    # 
+    # You can also optionally provide default unparsing parameters for the
+    # value.
+    
+    def initialize(values_, format_, unparse_params_=nil)
+      unless values_.kind_of?(::Hash) || values_.kind_of?(::Array)
+        raise ::ArgumentError, "Expected hash or array but got #{values_.class}"
       end
-      @value = val_ ? @schema.canonicalize_value(val_) : @schema.initial_value
-      @parse_params = parse_params_ || Hash.new
-      if subvalue_
-        @subvalue = subvalue_
-      else
-        subschema_ = @schema._subschema(@value)
-        @subvalue = subschema_ ? Versionomy::Value._new(subschema_, values_) : nil
+      @format = format_
+      @unparse_params = unparse_params_
+      @field_path = []
+      @values = {}
+      field_ = @format.schema.root_field
+      while field_
+        value_ = values_.kind_of?(Hash) ? values_[field_.name] : values_.shift
+        value_ = value_ ? field_.canonicalize_value(value_) : field_.default_value
+        @field_path << field_
+        @values[field_.name] = value_
+        field_ = field_.child(value_)
       end
     end
     
@@ -79,42 +83,25 @@ module Versionomy
       begin
         str_ = unparse
         "#<#{self.class}:0x#{object_id.to_s(16)} #{str_.inspect}>"
-      rescue Versionomy::Errors::ParseError
+      rescue Errors::UnparseError
         _inspect
       end
     end
     
     def _inspect  # :nodoc:
-      "#<#{self.class}:0x#{object_id.to_s(16)}#{_inspect2}>"
-    end
-    
-    def _inspect2  # :nodoc:
-      " #{@schema.name}=#{@value.inspect}#{@subvalue ? @subvalue._inspect2 : ''}"
-    end
-    
-    
-    # Get the value of the most significant field
-    
-    def _toplevel_value  # :nodoc:
-      @value
-    end
-    
-    
-    # Get a value representing all fields except the most significant field
-    
-    def _subvalue  # :nodoc:
-      @subvalue
+      "#<#{self.class}:0x#{object_id.to_s(16)} " +
+        @field_path.map{ |field_| "#{field_.name}=#{@values[field_.name].inspect}" }.join(' ')
     end
     
     
     # Returns a string representation generated by unparsing.
-    # If unparsing fails, does not raise Versionomy::Errors::ParseError,
+    # If unparsing fails, does not raise Versionomy::Errors::UnparseError,
     # but instead returns the string generated by +inspect+.
     
     def to_s
       begin
         unparse
-      rescue Versionomy::Errors::ParseError
+      rescue Errors::UnparseError
         _inspect
       end
     end
@@ -122,151 +109,152 @@ module Versionomy
     
     # Unparse this version number.
     # 
-    # Raises Versionomy::Errors::ParseError if unparsing failed.
+    # Raises Versionomy::Errors::UnparseError if unparsing failed.
     
-    def unparse(params_={})
-      format_ = @schema.get_format(params_[:format])
-      if format_.nil?
-        raise Versionomy::Errors::UnknownFormatError
-      end
-      format_.unparse(@schema, self, params_)
+    def unparse(params_=nil)
+      @format.unparse(self, params_)
     end
     
     
-    # Parse another string using the same schema, and same parse parameters
-    # as this value, subject to the given modifications.
+    # Return the schema defining the form of this version number
     
-    def parse(str_, params_={})
-      @schema.parse(str_, @parse_params.merge(params_))
+    def schema
+      @format.schema
     end
     
     
-    # Return the schema defining the form of this version number
+    # Return the format defining the form of this version number
     
-    def schema
-      @schema
+    def format
+      @format
     end
     
     
-    # Return the parsing parameters for this value.
+    # Return the unparsing parameters for this value.
+    # Returns nil if this value was not created using a parser.
     
-    def parse_params
-      @parse_params
+    def unparse_params
+      @unparse_params ? @unparse_params.dup : nil
+    end
+    
+    
+    # Iterates over each field, in field order, yielding the field name and value.
+    
+    def each_field
+      @field_path.each do |field_|
+        yield(field_, @values[field_.name])
+      end
+    end
+    
+    
+    # Iterates over each field, in field order, yielding the
+    # Versionomy::Schema::Field object and value.
+    
+    def each_field_object  # :nodoc:
+      @field_path.each do |field_|
+        yield(field_, @values[field_.name])
+      end
     end
     
     
     # Returns an array of recognized field names for this value, in field order.
     
-    def fields
-      @subvalue ? @subvalue.fields.unshift(@schema.name) : [@schema.name]
+    def field_names
+      @field_path.map{ |field_| field_.name }
     end
     
     
-    # Returns true if this value contains the given field.
+    # Returns true if this value contains the given field, which may be specified
+    # as a field object or name.
     
-    def has_field?(symbol_)
-      symbol_ = symbol_.to_sym
-      if symbol_ == @schema.name
-        true
-      elsif @subvalue
-        @subvalue.has_field?(symbol_)
+    def has_field?(field_)
+      case field_
+      when Schema::Field
+        @field_path.include?(field_)
+      when ::String, ::Symbol
+        @values.has_key?(field_.to_sym)
       else
-        false
+        raise ::ArgumentError
       end
     end
     
     
     # Returns the value of the given field, or nil if the field is not recognized.
+    # The field may be specified as a field object or field name.
     
-    def [](symbol_)
-      symbol_ = symbol_ ? symbol_.to_sym : @schema.name
-      if symbol_ == @schema.name
-        @value
-      elsif @subvalue
-        @subvalue[symbol_]
-      else
-        nil
-      end
+    def [](field_)
+      field_ = field_.name if field_.kind_of?(Schema::Field)
+      @values[field_.to_sym]
     end
     
     
     # Returns the value as an array of field values, in field order.
     
-    def values
-      @subvalue ? @subvalue.values.unshift(@value) : [@value]
+    def values_array
+      @field_path.map{ |field_| @values[field_.name] }
     end
     
     
     # Returns the value as a hash of values keyed by field name.
     
-    def value_hash
-      hash_ = {@schema.name => @value}
-      @subvalue ? @subvalue.value_hash.merge(hash_) : hash_
+    def values_hash
+      @values.dup
     end
     
     
     # Returns a new version number created by bumping the given field.
     
-    def bump(symbol_)
-      if (symbol_ == @schema.name)
-        bumped_ = @schema.bump_value(@value)
-        if bumped_ == @value
-          self
-        else
-          Versionomy::Value._new(@schema, bumped_, @parse_params)
-        end
-      else
-        if @subvalue
-          bumped_ = @subvalue.bump(symbol_)
-          if @subvalue.equal?(bumped_)
-            self
-          else
-            Versionomy::Value._new(@schema, @value, @parse_params, bumped_)
-          end
+    def bump(name_)
+      name_ = name_.name if name_.kind_of?(Schema::Field)
+      name_ = name_.to_sym
+      values_ = []
+      @field_path.each do |field_|
+        oldval_ = @values[field_.name]
+        if field_.name == name_
+          newval_ = field_.bump_value(oldval_)
+          return self if newval_ == oldval_
+          values_ << newval_
+          return Value.new(values_, @format, @unparse_params)
         else
-          self
+          values_ << oldval_
         end
       end
+      self
     end
     
     
     # Returns a new version number created by changing the given field values.
     
-    def change(values_={})
-      Versionomy::Value._new(@schema, value_hash.merge(values_), @parse_params)
+    def change(values_={}, unparse_params_={})
+      unparse_params_ = @unparse_params.merge(unparse_params_) if @unparse_params
+      Value.new(@values.merge(values_), @format, unparse_params_)
     end
     
     
     def hash  # :nodoc:
-      @hash ||= @schema.name.hash ^ @value.hash ^ @subvalue.hash
+      @hash ||= @values.hash
     end
     
     
     # Returns true if this version number is equal to the given verison number.
-    # Equality means the values and field names are the same, although the
-    # schemas may actually be different.
+    # Equality means the schemas and values are the same.
     
     def eql?(obj_)
-      if obj_.kind_of?(String)
-        obj_ = parse(obj_) rescue nil
+      if obj_.kind_of?(::String)
+        obj_ = @format.parse(obj_) rescue nil
       end
-      if obj_.kind_of?(Versionomy::Value)
-        if @schema.name != obj_.schema.name || @value != obj_._toplevel_value
-          false
-        elsif @subvalue
-          @subvalue.eql?(obj_._subvalue)
-        else
-          true
-        end
-      else
-        false
+      return false unless obj_.kind_of?(Value)
+      index_ = 0
+      obj_.each_field_object do |field_, value_|
+        return false if field_ != @field_path[index_] || value_ != @values[field_.name]
+        index_ += 1
       end
+      true
     end
     
     
     # Returns true if this version number is equal to the given verison number.
-    # Equality means the values and field names are the same, even if the schemas
-    # are different.
+    # Equality means the schemas and values are the same.
     
     def ==(obj_)
       eql?(obj_)
@@ -274,49 +262,42 @@ module Versionomy
     
     
     # Compare this version number with the given version number.
-    # Version numbers with the same field names and types are comparable,
-    # even if the schemas are different.
     
     def <=>(obj_)
-      if obj_.kind_of?(String)
-        obj_ = parse(obj_)
-      end
-      if !obj_.kind_of?(Versionomy::Value)
-        raise ArgumentError, "comparison of Versionomy::Value with #{obj_.class} failed"
+      if obj_.kind_of?(::String)
+        obj_ = @format.parse(obj_)
       end
-      if @schema.name != obj_.schema.name
-        raise SchemaMismatchError
-      end
-      val_ = @schema.compare_values(@value, obj_._toplevel_value)
-      if val_ == 0
-        if @subvalue.nil? && obj_._subvalue.nil?
-          0
-        elsif !@subvalue.nil? && !obj_._subvalue.nil?
-          @subvalue <=> obj_._subvalue
-        else
-          raise SchemaMismatchError
-        end
-      else
-        val_
+      return nil unless obj_.kind_of?(Value)
+      index_ = 0
+      obj_.each_field_object do |field_, value_|
+        return nil unless field_ == @field_path[index_]
+        val_ = field_.compare_values(@values[field_.name], value_)
+        return val_ if val_ != 0
+        index_ += 1
       end
+      0
     end
     
     
     # Compare this version number with the given version number.
-    # Version numbers with the same field names and types are comparable,
-    # even if the schemas are different.
     
     def <(obj_)
-      (self <=> obj_) < 0
+      val_ = (self <=> obj_)
+      unless val_
+        raise Errors::SchemaMismatchError
+      end
+      val_ < 0
     end
     
     
     # Compare this version number with the given version number.
-    # Version numbers with the same field names and types are comparable,
-    # even if the schemas are different.
     
     def >(obj_)
-      (self <=> obj_) > 0
+      val_ = (self <=> obj_)
+      unless val_
+        raise Errors::SchemaMismatchError
+      end
+      val_ > 0
     end
     
     
@@ -327,15 +308,6 @@ module Versionomy
     end
     
     
-    class << self
-      
-      # :stopdoc:
-      alias_method :_new, :new
-      private :new
-      # :startdoc:
-      
-    end
-    
   end
   
   

data/lib/versionomy/version.rb

@@ -3,7 +3,7 @@
 # Versionomy version
 # 
 # -----------------------------------------------------------------------------
-# Copyright 2008 Daniel Azuma
+# Copyright 2008-2009 Daniel Azuma
 # 
 # All rights reserved.
 # 
@@ -36,14 +36,14 @@
 
 module Versionomy
   
-  VERSION_STRING = '0.0.4'
-  VERSION = parse(VERSION_STRING)
+  # Current gem version, as a frozen string.
+  VERSION_STRING = '0.1.0'.freeze
+  
+  # Current gem version, as a Versionomy::Value.
+  VERSION = ::Versionomy.parse(VERSION_STRING, ::Versionomy::Formats.standard)
   
 end
 
 
-module Blockenspiel  # :nodoc:
-  
-  VERSION = Versionomy.parse(VERSION_STRING)
-  
-end
+::Blockenspiel.const_set(:VERSION,
+  ::Versionomy.parse(::Blockenspiel::VERSION_STRING, ::Versionomy::Formats.standard))

data/lib/versionomy.rb

@@ -3,7 +3,7 @@
 # Versionomy entry point
 # 
 # -----------------------------------------------------------------------------
-# Copyright 2008 Daniel Azuma
+# Copyright 2008-2009 Daniel Azuma
 # 
 # All rights reserved.
 # 
@@ -34,13 +34,28 @@
 ;
 
 
-require 'rubygems'
-require 'blockenspiel'
+begin
+  require 'blockenspiel'
+rescue LoadError
+  require 'rubygems'
+  require 'blockenspiel'
+end
 
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/errors.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/schema.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/value.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/format.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/standard.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/interface.rb")
-require File.expand_path("#{File.dirname(__FILE__)}/versionomy/version.rb")
+
+dir_ = File.expand_path('versionomy', File.dirname(__FILE__))
+
+includes_ = [
+ 'errors',
+ 'schema',
+ 'schema/field',
+ 'schema/wrapper',
+ 'format',
+ 'format/base',
+ 'format/delimiter',
+ 'formats',
+ 'formats/standard',
+ 'value',
+ 'interface',
+ 'version',
+]
+includes_.each{ |file_| require "#{dir_}/#{file_}" }

data/tests/tc_custom_format.rb

@@ -0,0 +1,66 @@
+# -----------------------------------------------------------------------------
+# 
+# Versionomy parsing tests on standard schema
+# 
+# This file contains tests for parsing on the standard schema
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2008-2009 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+
+require 'test/unit'
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/versionomy.rb")
+
+
+module Versionomy
+  module Tests  # :nodoc:
+    
+    class TestCustomFormat < Test::Unit::TestCase  # :nodoc:
+      
+      
+      # Test parsing with custom format for patchlevel
+      
+      def test_parsing_custom_patchlevel_format
+        format_ = Versionomy.default_format.modified_copy do
+          field(:patchlevel, :requires_previous_field => false) do
+            recognize_number(:delimiter_regexp => '\s?sp', :default_delimiter => ' SP')
+          end
+        end
+        value1_ = Versionomy.parse('2008 SP2', format_)
+        assert_equal(2, value1_.patchlevel)
+        value2_ = value1_.format.parse('2008 sp3')
+        assert_equal(3, value2_.patchlevel)
+      end
+      
+      
+    end
+    
+  end
+end