has_versions 0.3.0 → 0.4.0

data/.gitignore

@@ -1,42 +1,6 @@
-# simplecov generated
 coverage
-
-# rdoc generated
 rdoc
-
-# yard generated
 doc
 .yardoc
-
-# bundler
 .bundle
-
-# jeweler generated
-pkg
-
-# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
-#
-# * Create a file at ~/.gitignore
-# * Include files you want ignored
-# * Run: git config --global core.excludesfile ~/.gitignore
-#
-# After doing this, these files will be ignored in all your git projects,
-# saving you from having to 'pollute' every project you touch with them
-#
-# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
-#
-# For MacOS:
-#
-#.DS_Store
-#
-# For TextMate
-#*.tmproj
-#tmtags
-#
-# For emacs:
-#*~
-#\#*
-#.\#*
-#
-# For vim:
-#*.swp
+Gemfile.lock

data/Gemfile.lock

@@ -1,63 +1,35 @@
 PATH
   remote: .
   specs:
-    has_versions (0.3.0)
-      activesupport (~> 3)
+    has_versions (0.4.0)
+      activesupport (~> 3.0)
       i18n
       simple_uuid
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.0.5)
-    builder (3.0.0)
-    cucumber (0.10.0)
-      builder (>= 2.1.2)
+    activesupport (3.1.0)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.0.3)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
       diff-lcs (~> 1.1.2)
-      gherkin (~> 2.3.2)
-      json (~> 1.4.6)
-      term-ansicolor (~> 1.0.5)
-    diff-lcs (1.1.2)
-    gherkin (2.3.4)
-      json (~> 1.4.6)
-    i18n (0.5.0)
-    json (1.4.6)
-    reek (1.2.8)
-      ruby2ruby (~> 1.2)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    roodi (2.1.0)
-      ruby_parser
-    rspec (2.5.0)
-      rspec-core (~> 2.5.0)
-      rspec-expectations (~> 2.5.0)
-      rspec-mocks (~> 2.5.0)
-    rspec-core (2.5.1)
-    rspec-expectations (2.5.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.5.0)
-    ruby2ruby (1.2.5)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    ruby_parser (2.0.6)
-      sexp_processor (~> 3.0)
-    sexp_processor (3.0.5)
-    simple_uuid (0.1.1)
-    simplecov (0.4.1)
-      simplecov-html (~> 0.4.3)
-    simplecov-html (0.4.3)
-    term-ansicolor (1.0.5)
-    yard (0.6.5)
+    rspec-mocks (2.6.0)
+    simple_uuid (0.2.0)
+    yard (0.6.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.0.0)
-  cucumber
   has_versions!
-  reek (~> 1.2.8)
-  roodi (~> 2.1.0)
-  rspec (~> 2)
-  simplecov (>= 0.3.8)
+  rspec (~> 2.0)
   yard (~> 0.6.0)

data/Rakefile

@@ -1,4 +1,4 @@
-require 'bundler'
+require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core'
@@ -7,23 +7,23 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-require 'cucumber/rake/task'
-Cucumber::Rake::Task.new(:features)
+# require 'cucumber/rake/task'
+# Cucumber::Rake::Task.new(:features)
 
-require 'reek/rake/task'
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = true
-  t.verbose = false
-  t.source_files = 'lib/**/*.rb'
-end
+# require 'reek/rake/task'
+# Reek::Rake::Task.new do |t|
+#   t.fail_on_error = true
+#   t.verbose = false
+#   t.source_files = 'lib/**/*.rb'
+# end
 
-require 'roodi'
-require 'roodi_task'
-RoodiTask.new do |t|
-  t.verbose = false
-end
+# require 'roodi'
+# require 'roodi_task'
+# RoodiTask.new do |t|
+#   t.verbose = false
+# end
 
 task :default => :spec
 
-require 'yard'
-YARD::Rake::YardocTask.new
+# require 'yard'
+# YARD::Rake::YardocTask.new

data/has_versions.gemspec

@@ -27,14 +27,14 @@ Gem::Specification.new do |s|
   s.licenses = ["MIT"]
 
   s.add_runtime_dependency("i18n", [">= 0"])
-  s.add_runtime_dependency("activesupport", ["~> 3"])
+  s.add_runtime_dependency("activesupport", ["~> 3.0"])
   s.add_runtime_dependency("simple_uuid", [">= 0"])
-  s.add_development_dependency("rspec", ["~> 2"])
+  s.add_development_dependency("rspec", ["~> 2.0"])
   s.add_development_dependency("yard", ["~> 0.6.0"])
-  s.add_development_dependency("cucumber", [">= 0"])
   s.add_development_dependency("bundler", ["~> 1.0.0"])
-  s.add_development_dependency("simplecov", [">= 0.3.8"])
-  s.add_development_dependency("reek", ["~> 1.2.8"])
-  s.add_development_dependency("roodi", ["~> 2.1.0"])
+  # s.add_development_dependency("cucumber", [">= 0"])
+  # s.add_development_dependency("simplecov", [">= 0.3.8"])
+  # s.add_development_dependency("reek", ["~> 1.2.8"])
+  # s.add_development_dependency("roodi", ["~> 2.1.0"])
 end
 

data/lib/has_versions/apply/simple.rb

@@ -14,7 +14,7 @@ module HasVersions
     module Simple
       def apply(*patches)
         self.class.new.tap do |version| #TODO is new the right thing here? it doe scall initialize (allocate does not)
-          ours = snapshot.with_indifferent_access #TEST is it necessary to deep dup the snapshot?
+          ours = snapshot.dup #TEST is it necessary to deep dup the snapshot?
           
           patches.each do |patch|
             patch.each do |key, (a, b)|

data/lib/has_versions/attributes.rb

@@ -1,34 +1,10 @@
 module HasVersions
   module Attributes
-
     def versioned_attributes
-      versioning_configuration.attributes.inject(HashWithIndifferentAccess.new) do |memo, (key, options)|
-
-        memo[key] = versioning_encode_value(__send__(key), options)
+      versioning_configuration.attributes.inject({}) do |memo, attribute|
+        memo[attribute] = versioning_encode_value(attribute, send(attribute))
         memo
       end
     end
-
-    private
-
-    def versioning_decode_value(value, options)
-      return value if value.nil?
-
-      if options[:expected] && !value.kind_of?(options[:expected]) && options[:decoder]
-        options[:decoder].call(value)
-      else
-        value
-      end
-    end
-
-    def versioning_encode_value(value, options)
-      return value if value.nil?
-
-      if options[:encoder]
-        options[:encoder].call(value)
-      else
-        value
-      end
-    end
   end
 end

data/lib/has_versions/configuration.rb

@@ -2,27 +2,14 @@ module HasVersions
 
   class Configuration
     attr_accessor :attributes
-    attr_accessor :types
-
-    DEFAULT_TYPES = {
-      set: { expected: Set, decoder: ->(value) { Set.new(value) } },
-      time_with_zone: { expected: ActiveSupport::TimeWithZone, encoder: ->(value) { value.utc.xmlschema(6) }, decoder: ->(value) { Time.xmlschema(value).in_time_zone } }
-    }.freeze
 
     def initialize(&block)
-      @attributes = {}.with_indifferent_access
-      @types = DEFAULT_TYPES.with_indifferent_access
+      self.attributes = []
       instance_eval(&block)
     end
 
-    def type(name, options={})
-      @types[name] = options.with_indifferent_access
-    end
-
-    def attribute(name, options={})
-      options.merge!(@types[options[:type]]) if @types[options[:type]]
-      @attributes[name] = options.with_indifferent_access
+    def attribute(name)
+      attributes << name.to_s
     end
   end
-
 end

data/lib/has_versions/diff/simple.rb

@@ -1,7 +1,7 @@
 module HasVersions
   module Diff
     # takes a version and returns a diff (patch) from self
-    # version must respond to #snapshot with an attributes hash
+    # version must respond to #snapshot with an attributes hash (or something that responds to [] and keys)
     # diff format is:
     #  {
     #    attribute_name: [a, b]

data/lib/has_versions/merge/always_conflicted.rb

@@ -0,0 +1,9 @@
+module HasVersions
+  module Merge
+    class AlwaysConflicted < Base
+      def conflicted?
+        true
+      end
+    end
+  end
+end

data/lib/has_versions/merge/base.rb

@@ -0,0 +1,22 @@
+module HasVersions
+  module Merge
+    class Base
+      attr_accessor :versions, :options
+      attr_accessor :resolution, :conflicts
+
+      def initialize(versions, options={})
+        @versions = versions
+        @options = options
+        @conflicts = {}.with_indifferent_access
+      end
+
+      def merge
+        # implemented by subclasses
+      end
+
+      def conflicted?
+        !self.conflicts.empty?
+      end
+    end
+  end
+end

data/lib/has_versions/merge/choose_first.rb

@@ -0,0 +1,9 @@
+module HasVersions
+  module Merge
+    class ChooseFirst < Base
+      def merge
+        self.resolution = versions.first
+      end
+    end
+  end
+end

data/lib/has_versions/merge/diff3.rb

@@ -0,0 +1,66 @@
+module HasVersions
+  module Merge
+    module Diff3
+
+      # 3-way merge, extended to support more than one other
+      # base ours *theirs.uniq  take
+      # A    A    [A]           A (ours)
+      # A    B    [A]           B (ours)
+      # A    A    [B]           B (theirs)
+      # B    A    [A]           A (ours)
+      # B    A    [A,B]         conflict
+      # B    A    [C]           conflict
+      #
+      # cases where values are missing:
+      # m    A     A            A
+      # m    B     A            conflict
+      # A    m     A            A
+      # A    m     B            B
+      # A    A     m            A
+      # A    B     m            B
+      # m    m     A            A
+      # m    A     m            A
+      #
+      # returns an array [clean, result]
+      # where clean is a boolean
+      # and result is an array in the conflicts case, or a single value in the clean case
+
+      def diff3(base, ours, *theirs)
+        theirs = theirs.uniq
+
+        # if there is more than one possible value, it is already a conflict
+        if theirs.size > 1
+          # add ours to conflicts if it is different from base
+          if ours != base && !theirs.include?(ours)
+            theirs << ours
+          end
+          return [false, theirs]
+        end
+
+        theirs = theirs.first
+
+        if ours == base && base == theirs
+          [true, ours]
+        elsif base == theirs
+          [true, ours]
+        elsif ours == base
+          [true, theirs]
+        elsif ours == theirs
+          [true, ours]
+        elsif ours == :_missing
+          [true, theirs]
+        elsif theirs == :_missing
+          [true, ours]
+        else
+          [false, [ours, theirs]]
+        end
+      end
+
+      private
+
+      def value_or_missing(snapshot, key)
+        snapshot.keys.include?(key) ? snapshot[key] : :_missing
+      end
+    end
+  end
+end

data/lib/has_versions/merge/fast_forward.rb

@@ -0,0 +1,34 @@
+module HasVersions
+  module Merge
+    class FastForward < Base
+      # Takes exactly two versions and resolves the merge using ancestry.
+      # One of the two versions must be an ancestor of the other.
+      #
+      # expects versions to define contains? which returns true if the given version
+      # is an ancestor of the receiver
+      # eg if v1 is an ancestor of v2, then
+      # v2.contains?(v1) #=> true
+      #
+      # raises MergeFailed if anything but two versions are given, or if neither version
+      # is an ancestor of the other.
+
+      def initialize(versions, options={})
+        super
+        if versions.size != 2
+          raise HasVersions::MergeFailed, "Cannot fast forward merge with #{versions.size} versions"
+        end
+      end
+
+      def merge
+        v1, v2 = versions
+        if v1.contains?(v2)
+          self.resolution = v1
+        elsif v2.contains?(v1)
+          self.resolution = v2
+        else
+          raise HasVersions::MergeFailed, "cannot fast forward if neither version is an ancestor"
+        end
+      end
+    end
+  end
+end

data/lib/has_versions/merge/merge_base.rb

@@ -0,0 +1,75 @@
+module HasVersions
+  module Merge
+    module MergeBase
+      # Finds optimal merge bases for any number of versions
+      # Essentially a copy of git's algorithm
+      # Expects versions to respond to parents with an array of parent versions
+      def merge_bases(versions)
+        versions = versions.dup
+        one = versions.shift
+        twos = versions
+        
+        bases = determine_merge_bases(one, twos)
+        if twos.include?(one)
+          return bases
+        end
+
+        if bases.size == 1
+          return bases
+        end
+
+        bases.each_with_index do |base1, i|
+          next if base1 == bases.last
+          
+          bases.each_with_index do |base2, j|
+            next if base1.nil? || base2.nil?
+            sub_bases = determine_merge_bases(base1, [base2])
+            sub_bases.each do |sub_base|
+              bases[i] = nil if sub_base == base1
+              bases[j] = nil if sub_base == base2
+            end
+          end
+        end
+
+        bases.compact
+      end
+
+      private
+
+      def determine_merge_bases(one, twos)
+        stale = Set.new
+        parent1 = Set.new
+        parent2 = Set.new
+        result = Set.new
+
+        interesting = []
+
+        if twos.include?(one)
+          return [one]
+        end
+
+        parent1 << one
+        parent2 += twos
+
+        interesting << one
+        interesting += twos
+        
+        while !(interesting - stale.to_a).empty?
+          candidate = interesting.shift
+          if parent1.include?(candidate) && parent2.include?(candidate) && !stale.include?(candidate)
+            result << candidate
+          end
+
+          candidate.parents.each do |parent|
+            stale << parent if stale.include?(candidate)
+            parent1 << parent if parent1.include?(candidate)
+            parent2 << parent if parent2.include?(candidate)
+            interesting << parent
+          end
+        end
+
+        result.to_a.reject { |r| stale.include?(r) }
+      end
+    end
+  end
+end

data/lib/has_versions/merge/octopus.rb

@@ -0,0 +1,42 @@
+module HasVersions
+  module Merge
+    # Merge >2 versions
+    # Works by doing a 3-way merge for first 2 versions, then merging the result with
+    # the next version for each version given.
+    # eg for 4 versions there are three merges: v1+v2, then (v1+v2)+v3, then ((v1+v2)+v3)+v4
+    # conflicts will be an accumulation of all conflicting values from each merge
+    class Octopus < Base
+      def initialize(versions, options={})
+        super
+        if versions.size <= 2
+          raise HasVersions::MergeFailed, "Cannot octopus merge with #{versions.size} versions, expect >2"
+        end
+      end
+
+      def merge
+        self.resolution = versions.inject(resolution) do |res, version|
+          if res
+            merge = ThreeWay.new([res, version], options)
+            merge.merge
+            add_conflicts(merge.conflicts)
+            res = merge.resolution
+          else
+            res = version
+          end
+          res
+        end
+        resolution.parents = versions
+        resolution
+      end
+
+      private
+      def add_conflicts(conflicts)
+        conflicts.each do |attribute, values|
+          self.conflicts[attribute] ||= []
+          self.conflicts[attribute] += values
+          self.conflicts[attribute].uniq!
+        end
+      end
+    end
+  end
+end

data/lib/has_versions/merge/three_way.rb

@@ -0,0 +1,53 @@
+module HasVersions
+  module Merge
+    # Merges two versions using ancestry and 3-way diff
+    # expects versions to respond to parents= to set parents
+    # does not check ancestry when setting parents - use FastForward if one version
+    # is an ancestor of another or they are identical
+    class ThreeWay < Base
+      include MergeBase
+      include Diff3
+
+      def initialize(versions, options={})
+        super
+        if versions.size != 2
+          raise HasVersions::MergeFailed, "Cannot 3-way merge with #{versions.size} versions, expect 2"
+        end
+      end
+
+      # assume the first version is ours
+      def merge
+        version_class = options[:version_class] || versions.first.class
+        # find merge base or bases
+        bases = merge_bases(versions)
+        # raise if there is more than one base
+        # TODO could potentially just choose one (that's what git does)
+        raise MergeFailed, "More than one merge base" if bases.size > 1
+
+        base = bases.first.try(:snapshot) || {}.with_indifferent_access
+        ours = versions.first.snapshot
+        theirs = versions.last.snapshot
+
+        self.resolution = version_class.new
+        self.resolution.parents = versions
+
+        # get the full list of attributes in each version and the merge base
+        attributes = (versions.collect { |v| v.snapshot.keys }.flatten + base.keys).uniq
+
+        # do 3-way merge on each attribute
+        attributes.each do |key|
+          clean, result = diff3(value_or_missing(base, key), value_or_missing(ours, key), value_or_missing(theirs, key))
+          if clean
+            resolution.snapshot[key] = result
+          else
+            resolution.snapshot[key] = ours[key]
+            conflicts[key] = result
+          end
+        end
+
+        resolution
+      end
+    end
+  end
+end
+

data/lib/has_versions/merge.rb

@@ -1,6 +1,8 @@
 module HasVersions
 
-  class MergeConflict < VersioningError
+  class MergeFailed < VersioningError; end
+
+  class MergeConflict < MergeFailed
     attr_accessor :conflicts
     attr_accessor :result
  
@@ -13,49 +15,18 @@ module HasVersions
   module Merge
     extend ActiveSupport::Autoload
 
-    autoload :Stupid
-
-    module Diff3
-
-      # 3-way merge, extended to support more than one other
-      # base ours *theirs.uniq  take
-      # A    A    [A]           A (ours)
-      # A    B    [A]           B (ours)
-      # A    A    [B]           B (theirs)
-      # B    A    [A]           A (ours)
-      # B    A    [A,B]         conflict
-      # B    A    [C]           conflict
-      #
-      # returns an array [clean, result]
-      # where clean is a boolean
-      # and result is an array in the conflicts case, or a single value in the clean case
-
-      def diff3(base, ours, *theirs)
-        theirs = theirs.uniq
-
-        # if there is more than one possible value, it is already a conflict
-        if theirs.size > 1
-          # add ours to conflicts if it is different from base
-          if ours != base && !theirs.include?(ours)
-            theirs << ours
-          end
-          return [false, theirs]
-        end
-
-        theirs = theirs.first
-
-        if ours == base && base == theirs
-          [true, ours]
-        elsif base == theirs
-          [true, ours]
-        elsif ours == base
-          [true, theirs]
-        elsif ours == theirs
-          [true, ours]
-        else
-          [false, [ours, theirs]]
-        end
-      end
-    end
+    autoload :Base
+
+    autoload :FastForward
+    autoload :ThreeWay
+    autoload :Octopus
+
+    # strategies for testing
+    autoload :ChooseFirst
+    autoload :AlwaysConflicted
+
+    autoload :Diff3
+    autoload :MergeBase
+
   end
 end

data/lib/has_versions/orm/cassandra_object.rb

@@ -0,0 +1,15 @@
+module HasVersions
+  module Orm
+    module CassandraObject
+      def versioning_encode_value(name, value)
+        return if value.nil?
+        attribute_definitions[name.to_sym].coder.encode(value)
+      end
+
+      def versioning_decode_value(name, value)
+        return if value.nil?
+        attribute_definitions[name.to_sym].coder.decode(value)
+      end
+    end
+  end
+end