versionomy 0.4.1 → 0.4.2

data/lib/versionomy/schema/wrapper.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Versionomy schema wrapper class
-# 
+#
 # -----------------------------------------------------------------------------
 # 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,
@@ -18,7 +18,7 @@
 # * 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
@@ -35,17 +35,17 @@
 
 
 module Versionomy
-  
+
   module Schema
-    
-    
+
+
     # Creates a schema.
     # Returns an object of type Versionomy::Schema::Wrapper.
-    # 
+    #
     # You may either pass a root field, or provide a block to use to build
     # fields. If you provide a block, you must use the methods in
     # Versionomy::Schema::Builder in the block to create the root field.
-    
+
     def self.create(field_=nil, opts_={}, &block_)
       if field_ && block_
         raise ::ArgumentError, 'You may provide either a root field or block but not both'
@@ -61,17 +61,17 @@ module Versionomy
       end
       Schema::Wrapper.new(field_, modules_, aliases_)
     end
-    
-    
+
+
     # Schemas are generally referenced through an object of this class.
-    
+
     class Wrapper
-      
-      
+
+
       # Create a new schema wrapper object given a root field.
       # This is a low-level method. Usually you should call
       # Versionomy::Schema#create instead.
-      
+
       def initialize(field_, modules_=[], aliases_={})
         @root_field = field_
         @names = @root_field._descendants_by_name
@@ -85,43 +85,43 @@ module Versionomy
           end
         end
       end
-      
-      
+
+
       def inspect   # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)} root=#{@root_field.inspect}>"
       end
-      
+
       def to_s   # :nodoc:
         inspect
       end
-      
-      
+
+
       # Returns true if this schema is equivalent to the other schema.
       # Two schemas are equivalent if their root fields are the same--
       # which means that the entire field tree is the same-- and they
       # include the same value modules.
       # Note that this is different from the definition of <tt>==</tt>.
-      
+
       def eql?(obj_)
         return false unless obj_.kind_of?(Schema::Wrapper)
         return @root_field == obj_.root_field && @modules == obj_.modules && @aliases == obj_.aliases
       end
-      
-      
+
+
       # Returns true if this schema is compatible with the other schema.
       # Two schemas are compatible if their root fields are the same--
       # which means that the entire field tree is the same. They may,
       # however, include different value modules.
       # Note that this is different from the definition of <tt>eql?</tt>.
-      
+
       def ==(obj_)
         eql?(obj_)
       end
-      
-      
+
+
       # If the RHS is a schema, returns true if the schemas are equivalent.
       # If the RHS is a value, returns true if the value uses this schema.
-      
+
       def ===(obj_)
         if obj_.kind_of?(Value)
           obj_.schema == self
@@ -129,86 +129,86 @@ module Versionomy
           obj_ == self
         end
       end
-      
-      
+
+
       def hash  # :nodoc:
         @hash ||= @root_field.hash ^ @modules.hash
       end
-      
-      
+
+
       # Returns the root (most significant) field in this schema.
-      
+
       def root_field
         @root_field
       end
-      
-      
+
+
       # Return the canonical field name given a name, or nil if the name
       # is not recognized.
-      
+
       def canonical_name(name_)
         name_ = name_.to_sym
         name_ = @aliases[name_] || name_
         @names.include?(name_) ? name_ : nil
       end
-      
-      
+
+
       # Return the field with the given name, or nil if the given name
       # is not found in this schema. If include_aliases_ is set to true,
       # this also supports lookup by alias.
-      
+
       def field_named(name_, include_aliases_=false)
         name_ = name_.to_sym
         name_ = @aliases[name_] || name_ if include_aliases_
         field_ = @names[name_]
       end
-      
-      
+
+
       # Returns an array of names present in this schema, in no particular
       # order. Does not include aliases.
-      
+
       def names
         @names.keys
       end
-      
-      
+
+
       # Returns an array of modules that should be included in values that
       # use this schema.
-      
+
       def modules
         @modules.dup
       end
-      
-      
+
+
       # Returns a hash of field name aliases.
-      
+
       def aliases
         @aliases.dup
       end
-      
-      
+
+
     end
-    
-    
+
+
     # These methods are available in a schema definition block given to
     # Versionomy::Schema#create.
-    
+
     class Builder
-      
+
       include ::Blockenspiel::DSL
-      
+
       def initialize()  # :nodoc:
         @field = nil
         @modules = []
         @aliases = {}
         @defaults = { :integer => {}, :string => {}, :symbol => {} }
       end
-      
-      
+
+
       # Create the root field.
-      # 
+      #
       # Recognized options include:
-      # 
+      #
       # <tt>:type</tt>::
       #   Type of field. This should be <tt>:integer</tt>, <tt>:string</tt>,
       #   or <tt>:symbol</tt>. Default is <tt>:integer</tt>.
@@ -216,51 +216,51 @@ module Versionomy
       #   Default value for the field if no value is explicitly set. Default
       #   is 0 for an integer field, the empty string for a string field, or
       #   the first symbol added for a symbol field.
-      # 
+      #
       # You may provide an optional block. Within the block, you may call
       # methods of Versionomy::Schema::FieldBuilder to customize this field.
-      # 
+      #
       # Raises Versionomy::Errors::IllegalValueError if the given default
       # value is not legal.
-      # 
+      #
       # Raises Versionomy::Errors::RangeOverlapError if a root field has
       # already been created.
-      
+
       def field(name_, opts_={}, &block_)
         if @field
           raise Errors::RangeOverlapError, "Root field already defined"
         end
         @field = Schema::Field.new(name_, opts_.merge(:master_builder => self), &block_)
       end
-      
-      
+
+
       # Create a field alias.
-      
+
       def alias_field(alias_name_, field_name_)
         @aliases[alias_name_.to_sym] = field_name_.to_sym
       end
-      
-      
+
+
       # Add a module to the schema. All values that use this schema will
       # include this module. This provides a way to add schema-specific
       # capabilities to version numbers.
-      
+
       def add_module(mod_)
         @modules << mod_
       end
-      
-      
+
+
       # Provide a default bump procedure for the given type.
       # The type should be <tt>:integer</tt>, <tt>:string</tt>, or
       # <tt>:symbol</tt>. You must provide a block that takes a field value
       # and returns the "bumped" value. This procedure will be used for
       # all fields of this type, unless explicitly overridden by the field.
-      
+
       def to_bump_type(type_, &block_)
         @defaults[type_][:bump] = block_
       end
-      
-      
+
+
       # Provide a default compare procedure for the given type.
       # The type should be <tt>:integer</tt>, <tt>:string</tt>, or
       # <tt>:symbol</tt>. You must provide a block that takes two values
@@ -269,53 +269,53 @@ module Versionomy
       # positive integer if the first value is greater. This procedure will
       # be used for all fields of this type, unless explicitly overridden
       # by the field.
-      
+
       def to_compare_type(type_, &block_)
         @defaults[type_][:compare] = block_
       end
-      
-      
+
+
       # Provide a default canonicalization procedure for the given type.
       # The type should be <tt>:integer</tt>, <tt>:string</tt>, or
       # <tt>:symbol</tt>. You must provide a block that takes a field value
       # and returns the canonical value. This procedure will be used for
       # all fields of this type, unless explicitly overridden by the field.
-      
+
       def to_canonicalize_type(type_, &block_)
         @defaults[type_][:canonicalize] = block_
       end
-      
-      
+
+
       # Provide a default value for the given type.
       # The type should be <tt>:integer</tt>, <tt>:string</tt>, or
       # <tt>:symbol</tt>. You must provide a default value that will be
       # used for all fields of this type, unless explicitly overridden by
       # the field.
-      
+
       def default_value_for_type(type_, value_)
         @defaults[type_][:value] = value_
       end
-      
-      
+
+
       def _get_field  # :nodoc:
         @field
       end
-      
+
       def _get_modules  # :nodoc:
         @modules
       end
-      
+
       def _get_aliases  # :nodoc:
         @aliases
       end
-      
+
       def _get_default_setting(type_, setting_)  # :nodoc:
         @defaults[type_][setting_]
       end
-      
+
     end
-    
-    
+
+
   end
-  
+
 end

data/lib/versionomy/value.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Versionomy value
-# 
+#
 # -----------------------------------------------------------------------------
 # 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,
@@ -18,7 +18,7 @@
 # * 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
@@ -34,35 +34,39 @@
 ;
 
 
-require 'yaml'
+begin
+  require 'psych'
+rescue ::LoadError
+  require 'yaml'
+end
 
 
 module Versionomy
-  
-  
+
+
   # === Version number value
-  # 
+  #
   # A version number value is an ordered list of values, corresponding to an
   # ordered list of fields defined by a schema. For example, if the schema
   # is a simple one of the form "major.minor.tiny", then the the version
   # 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 an
   # equivalent schema.
-  
+
   class Value
-    
-    
+
+
     # 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}"
@@ -83,8 +87,8 @@ module Versionomy
       modules_ = @_format.schema.modules
       extend(*modules_) if modules_.size > 0
     end
-    
-    
+
+
     def inspect  # :nodoc:
       begin
         str_ = unparse
@@ -93,17 +97,17 @@ module Versionomy
         _inspect
       end
     end
-    
+
     def _inspect  # :nodoc:
       "#<#{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::UnparseError,
     # but instead returns the string generated by +inspect+.
-    
+
     def to_s
       begin
         unparse
@@ -111,149 +115,72 @@ module Versionomy
         _inspect
       end
     end
-    
-    
-    # Marshal this version number.
-    
-    def marshal_dump  # :nodoc:
-      format_name_ = Format.canonical_name_for(@_format, true)
-      unparsed_data_ = nil
-      if @_format.respond_to?(:unparse_for_serialization)
-        unparsed_data_ = @_format.unparse_for_serialization(self) rescue nil
-      end
-      unparsed_data_ ||= @_format.unparse(self) rescue nil
-      data_ = [format_name_]
-      case unparsed_data_
-      when ::Array
-        data_ << unparsed_data_[0]
-        data_ << unparsed_data_[1] if unparsed_data_[1]
-      when ::String
-        data_ << unparsed_data_
-      else
-        data_ << values_array
-        data_ << @_unparse_params if @_unparse_params
-      end
-      data_
-    end
-    
-    
-    # Unmarshal this version number.
-    
-    def marshal_load(data_)  # :nodoc:
-      format_ = Format.get(data_[0], true)
-      if data_[1].kind_of?(::String)
-        val_ = format_.parse(data_[1], data_[2])
-        initialize(val_.values_array, format_, val_.unparse_params)
-      else
-        initialize(data_[1], format_, data_[2])
-      end
-    end
-    
-    
-    # YAML tags. The last one is the canonical one.
-    yaml_as "tag:danielazuma.com,2009:version"
-    yaml_as "tag:verse15.com,2009:version"
-    
-    
-    # Deserialize a version number from YAML
-    
-    def self.yaml_new(klass_, tag_, data_)  # :nodoc:
-      unless data_.kind_of?(::Hash)
-        raise ::YAML::TypeError, "Invalid version format: #{val_.inspect}"
-      end
-      format_ = Format.get(data_['format'], true)
-      value_ = data_['value']
-      if value_
-        format_.parse(value_, data_['parse_params'])
-      else
-        Value.new(format_, data_['fields'], data_['unparse_params'])
-      end
-    end
-    
-    
-    # Serialize this version number to YAML format.
-    
-    def to_yaml(opts_={})
-      data_ = marshal_dump
-      ::YAML::quick_emit(nil, opts_) do |out_|
-        out_.map(taguri, to_yaml_style) do |map_|
-          map_.add('format', data_[0])
-          if data_[1].kind_of?(::String)
-            map_.add('value', data_[1])
-            map_.add('parse_params', data_[2]) if data_[2]
-          else
-            map_.add('fields', data_[1])
-            map_.add('unparse_params', data_[2]) if data_[2]
-          end
-        end
-      end
-    end
-    
-    
+
+
     # Unparse this version number and return a string.
-    # 
+    #
     # Raises Versionomy::Errors::UnparseError if unparsing failed.
-    
+
     def unparse(params_=nil)
       @_format.unparse(self, params_)
     end
-    
-    
+
+
     # Return the schema defining the structure and semantics of this
     # version number.
-    
+
     def schema
       @_format.schema
     end
-    
-    
+
+
     # Return the format defining the schema and formatting/parsing of
     # this version number.
-    
+
     def format
       @_format
     end
-    
-    
+
+
     # Return the unparsing parameters for this value.
     # Returns nil if this value was not created using a parser.
-    
+
     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.
     # This is the order of the fields actually present in this value, in
     # order from most to least significant.
-    
+
     def field_names
       @_field_path.map{ |field_| field_.name }
     end
-    
-    
+
+
     # Returns true if this value contains the given field, which may be specified
     # as a field object, name, or index.
-    
+
     def has_field?(field_)
       case field_
       when Schema::Field
@@ -266,38 +193,38 @@ module Versionomy
         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, field name,
     # or field index.
-    
+
     def [](field_)
       @_values[_interpret_field(field_)]
     end
-    
-    
+
+
     # Returns the value as an array of field values, in field order.
     # This is the order of the fields actually present in this value, in
     # order from most to least significant.
-    
+
     def values_array
       @_field_path.map{ |field_| @_values[field_.name] }
     end
-    
-    
+
+
     # Returns the value as a hash of values keyed by field name.
-    
+
     def values_hash
       @_values.dup
     end
-    
-    
+
+
     # Returns a new version number created by bumping the given field. The
     # field may be specified as a field object, field name, or field index.
     # Returns self unchanged if the field was not recognized or could not
     # be modified.
-    
+
     def bump(field_)
       name_ = _interpret_field(field_)
       return self unless name_ && @_values.include?(name_)
@@ -315,13 +242,13 @@ module Versionomy
       end
       self
     end
-    
-    
+
+
     # Returns a new version number created by resetting the given field. The
     # field may be specified as a field object, field name, or field index.
     # Returns self unchanged if the field was not recognized or could not
     # be modified.
-    
+
     def reset(field_)
       name_ = _interpret_field(field_)
       return self unless name_ && @_values.include?(name_)
@@ -337,33 +264,33 @@ module Versionomy
       end
       self
     end
-    
-    
+
+
     # Returns a new version number created by cloning this version number
     # and changing the given field values.
-    # 
+    #
     # You should pass in a hash of field names to values. These are the
     # fields to modify; any other fields will be left alone, unless they
     # are implicitly changed by the modifications you are making.
     # For example, changing the :release_type on a value using the standard
     # format, may change which fields are present in the resulting value.
-    # 
+    #
     # You may also pass a delta hash to modify the unparse params stored in
     # the value.
-    
+
     def change(values_={}, unparse_params_={})
       unparse_params_ = @_unparse_params.merge(unparse_params_) if @_unparse_params
       values_ = _canonicalize_values_hash(values_)
       Value.new(@_values.merge(values_), @_format, unparse_params_)
     end
-    
-    
+
+
     # Attempts to convert this value to the given format, and returns the
     # resulting value.
-    # 
+    #
     # Raises Versionomy::Errors::ConversionError if the value could not
     # be converted.
-    
+
     def convert(format_, convert_params_=nil)
       if format_.kind_of?(::String) || format_.kind_of?(::Symbol)
         format_ = Format.get(format_)
@@ -389,18 +316,18 @@ module Versionomy
         end
       end
     end
-    
-    
+
+
     def hash  # :nodoc:
       @_hash ||= @_values.hash
     end
-    
-    
+
+
     # Returns true if this version number is equivalent to the given number.
     # This type of equality means their schemas are compatible and their
     # field values are equal.
     # Note that this is different from the definition of <tt>==</tt>.
-    
+
     def eql?(obj_)
       if obj_.kind_of?(::String)
         obj_ = @_format.parse(obj_) rescue nil
@@ -413,25 +340,25 @@ module Versionomy
       end
       true
     end
-    
-    
+
+
     # Returns true if this version number is value-equal to the given number.
     # This type of equality means that they are equivalent, or that it is
     # possible to convert the RHS to the LHS's format, and that they would
     # be equivalent after such a conversion has taken place.
     # Note that this is different from the definition of <tt>eql?</tt>.
-    
+
     def ==(obj_)
       (self <=> obj_) == 0
     end
-    
-    
+
+
     # Compare this version number with the given version number,
     # returning 0 if the two are value-equal, a negative number if the RHS
     # is greater, or a positive number if the LHS is greater.
     # The comparison may succeed even if the two have different schemas,
     # if the RHS can be converted to the LHS's format.
-    
+
     def <=>(obj_)
       if obj_.kind_of?(::String)
         obj_ = @_format.parse(obj_)
@@ -450,12 +377,12 @@ module Versionomy
       end
       0
     end
-    
-    
+
+
     # Compare this version number with the given version number.
     # The comparison may succeed even if the two have different schemas,
     # if the RHS can be converted to the LHS's format.
-    
+
     def <(obj_)
       val_ = (self <=> obj_)
       unless val_
@@ -463,12 +390,12 @@ module Versionomy
       end
       val_ < 0
     end
-    
-    
+
+
     # Compare this version number with the given version number.
     # The comparison may succeed even if the two have different schemas,
     # if the RHS can be converted to the LHS's format.
-    
+
     def >(obj_)
       val_ = (self <=> obj_)
       unless val_
@@ -476,20 +403,137 @@ module Versionomy
       end
       val_ > 0
     end
-    
-    
+
+
     include ::Comparable
-    
-    
+
+
     # Field values may be retrieved by calling them as methods.
-    
+
     def method_missing(symbol_)
       self[symbol_] || super
     end
-    
-    
+
+
+    # :stopdoc:
+
+
+    # Marshal support
+
+    # Marshal this version number
+    def marshal_dump
+      format_name_ = Format.canonical_name_for(@_format, true)
+      unparsed_data_ = nil
+      if @_format.respond_to?(:unparse_for_serialization)
+        unparsed_data_ = @_format.unparse_for_serialization(self) rescue nil
+      end
+      unparsed_data_ ||= @_format.unparse(self) rescue nil
+      data_ = [format_name_]
+      case unparsed_data_
+      when ::Array
+        data_ << unparsed_data_[0]
+        data_ << unparsed_data_[1] if unparsed_data_[1]
+      when ::String
+        data_ << unparsed_data_
+      else
+        data_ << values_array
+        data_ << @_unparse_params if @_unparse_params
+      end
+      data_
+    end
+
+    # Unmarshal this version number.
+    def marshal_load(data_)
+      format_ = Format.get(data_[0], true)
+      if data_[1].kind_of?(::String)
+        val_ = format_.parse(data_[1], data_[2])
+        initialize(val_.values_array, format_, val_.unparse_params)
+      else
+        initialize(data_[1], format_, data_[2])
+      end
+    end
+
+
+    if defined?(::Psych)
+
+      # YAML support through psych
+
+      # YAML tags. The last one is the canonical one.
+      yaml_tag "tag:danielazuma.com,2009:version"
+      yaml_tag "tag:verse15.com,2009:version"
+
+      # Deserialize a version number from YAML
+      def init_with(coder_)  # :nodoc:
+        format_ = Format.get(coder_['format'], true)
+        value_ = coder_['value']
+        if value_
+          value_ = format_.parse(value_, coder_['parse_params'])
+          initialize(value_.values_array, format_, value_.unparse_params)
+        else
+          initialize(coder_['fields'], format_, coder_['unparse_params'])
+        end
+      end
+
+      # Serialize this version number to YAML format.
+      def encode_with(coder_)  # :nodoc:
+        data_ = marshal_dump
+        coder_['format'] = data_[0]
+        if data_[1].kind_of?(::String)
+          coder_['value'] = data_[1]
+          coder_['parse_params'] = data_[2] if data_[2]
+        else
+          coder_['fields'] = data_[1]
+          coder_['unparse_params'] = data_[2] if data_[2]
+        end
+      end
+
+    else
+
+      # YAML support through syck
+
+      # YAML tags. The last one is the canonical one.
+      yaml_as "tag:danielazuma.com,2009:version"
+      yaml_as "tag:verse15.com,2009:version"
+
+      # Deserialize a version number from YAML
+      def self.yaml_new(klass_, tag_, data_)  # :nodoc:
+        unless data_.kind_of?(::Hash)
+          raise ::YAML::TypeError, "Invalid version format: #{data_.inspect}"
+        end
+        format_ = Format.get(data_['format'], true)
+        value_ = data_['value']
+        if value_
+          format_.parse(value_, data_['parse_params'])
+        else
+          Value.new(data_['fields'], format_, data_['unparse_params'])
+        end
+      end
+
+      # Serialize this version number to YAML format.
+      def to_yaml(opts_={})
+        data_ = marshal_dump
+        ::YAML.quick_emit(nil, opts_) do |out_|
+          out_.map(taguri, to_yaml_style) do |map_|
+            map_.add('format', data_[0])
+            if data_[1].kind_of?(::String)
+              map_.add('value', data_[1])
+              map_.add('parse_params', data_[2]) if data_[2]
+            else
+              map_.add('fields', data_[1])
+              map_.add('unparse_params', data_[2]) if data_[2]
+            end
+          end
+        end
+      end
+
+    end
+
+
+    # :startdoc:
+
+
     private
-    
+
     def _interpret_field(field_)   # :nodoc:
       case field_
       when Schema::Field
@@ -501,8 +545,8 @@ module Versionomy
         @_format.schema.canonical_name(field_)
       end
     end
-    
-    
+
+
     def _canonicalize_values_hash(values_)  # :nodoc:
       schema_ = @_format.schema
       new_values_ = {}
@@ -512,9 +556,9 @@ module Versionomy
       end
       new_values_
     end
-    
-    
+
+
   end
-  
-  
+
+
 end