has_versions 0.4.9 → 0.5.0

data/Rakefile

@@ -1,29 +1,12 @@
 require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-# 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 'rake/testtask'
 
-# require 'roodi'
-# require 'roodi_task'
-# RoodiTask.new do |t|
-#   t.verbose = false
-# end
-
-task :default => :spec
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
 
-# require 'yard'
-# YARD::Rake::YardocTask.new

data/has_versions.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name = "has_versions"
-  s.version = '0.4.9'
+  s.version = '0.5.0'
 
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Grant Rodgers"]
@@ -23,9 +23,8 @@ Gem::Specification.new do |s|
   ]
   s.licenses = ["MIT"]
 
-  s.add_runtime_dependency("i18n", [">= 0"])
-  s.add_runtime_dependency("activesupport", ["~> 3.0"])
-  s.add_runtime_dependency("simple_uuid", [">= 0"])
-  s.add_development_dependency("rspec", ["~> 2.0"])
-  s.add_development_dependency("yard", ["~> 0.6.0"])
+  # s.add_runtime_dependency("i18n", [">= 0"])
+  s.add_runtime_dependency("activesupport", "~> 3.2")
+  s.add_development_dependency("rake")
+  # s.add_runtime_dependency("simple_uuid", [">= 0"])
 end

data/lib/has_versions/attributes.rb

@@ -3,14 +3,14 @@ module HasVersions
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def versioned_fields
+      def versioned_attributes
         versioning_configuration.attributes
       end
     end
 
     def versioned_attributes
-      self.class.versioned_fields.inject({}) do |memo, attribute|
-        memo[attribute] = versioning_encode_value(attribute, self[attribute])
+      self.class.versioned_attributes.inject({}) do |memo, attribute|
+        memo[attribute] = versioning_encode_value(attribute, send(attribute))
         memo
       end
     end

data/lib/has_versions/configuration.rb

@@ -1,5 +1,4 @@
 module HasVersions
-
   class Configuration
     attr_accessor :attributes
 

data/lib/has_versions/reset.rb

@@ -1,15 +1,21 @@
 module HasVersions
   module Reset
-    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
 
-    autoload :Simple
- 
-    module FromVersion
+    module ClassMethods
       def from_version(version)
         new.tap do |object|
           object.reset!(version)
         end
       end
     end
+
+    def reset!(version)
+      self.class.versioned_attributes.each do |attribute|
+        value = versioning_decode_value(attribute, version.snapshot[attribute])
+        send("#{attribute}=", value)
+      end
+      self
+    end
   end
 end

data/lib/has_versions/version_methods/diff.rb

@@ -0,0 +1,40 @@
+module HasVersions
+  module VersionMethods
+    module Diff
+      def diff(original = parent)
+        original_snapshot = original.nil? ? {} : original.decoded_snapshot
+
+        output = {}
+        decoded_snapshot.each do |attribute, new_value|
+          original_value = original_snapshot[attribute]
+
+          if original_value != new_value
+            output[attribute] = [original_value, new_value]
+          end
+        end
+
+        output
+      end
+
+      def modified_attributes
+        diff.keys
+      end
+
+      def different_attributes
+        modified_attributes.select do |attribute|
+          target.send(attribute) != decoded_snapshot[attribute]
+        end
+      end
+
+      def decoded_snapshot
+        @decoded_snapshot ||= begin
+          decoded = {}
+          target.class.versioned_attributes.each do |attribute|
+            decoded[attribute] = target.versioning_decode_value(attribute, snapshot[attribute])
+          end
+          decoded
+        end
+      end
+    end
+  end
+end

data/lib/has_versions/version_methods/log.rb

@@ -0,0 +1,45 @@
+module HasVersions
+  module VersionMethods
+    class LogCollection
+      include Enumerable
+
+      def initialize(version)
+        @version = version
+      end
+
+      def walk
+        walker = Walker.new(@version)
+        while v = walker.next
+          yield v
+        end
+      end
+      alias_method :each, :walk
+
+      def all
+        all = []
+        walk { |v| all << v }
+        all
+      end
+      alias_method :to_a, :all
+
+      class Walker
+        attr_accessor :current_version
+        def initialize(version)
+          self.current_version = version
+        end
+
+        def next
+          version = self.current_version
+          self.current_version = version.try(:parent)
+          version
+        end
+      end
+    end
+
+    module Log
+      def log
+        @log ||= LogCollection.new(self)
+      end
+    end
+  end
+end

data/lib/has_versions/versioned.rb

@@ -7,33 +7,30 @@ module HasVersions
       class_attribute :version_class
 
       include HasVersions::Attributes
-      include HasVersions::Reset::Simple
-      include HasVersions::Diff::Simple
-      extend HasVersions::Reset::FromVersion
+      include HasVersions::Reset
     end
 
     module ClassMethods
       def has_versions(version_class, &block)
         self.versioning_configuration = HasVersions::Configuration.new(&block)
         self.version_class = version_class
+        version_class.class_eval do
+          include HasVersions::VersionMethods::Diff
+          include HasVersions::VersionMethods::Log
+        end
       end
 
       def versioned_attribute(name)
         self.versioning_configuration ||= HasVersions::Configuration.new
         versioning_configuration.attribute(name)
       end
-
-      def is_versioned?
-        !versioning_configuration.blank?
-      end
     end
 
-    # generates a version from the current object
     def to_version
-      version_class.new.tap do |version|
-        version.snapshot = versioned_attributes
-        version.target = self
-      end
+      version = version_class.new
+      version.snapshot = versioned_attributes
+      version.target = self
+      version
     end
   end
 end

data/lib/has_versions.rb

@@ -3,16 +3,10 @@ require 'active_support/all'
 module HasVersions
   extend ActiveSupport::Autoload
 
-  autoload :Configuration
-  autoload :Versioned
   autoload :Attributes
-
-  autoload :Stage
-
-  autoload :Apply
-  autoload :Diff
-  autoload :Merge
+  autoload :Configuration
   autoload :Reset
+  autoload :Versioned
 
   module Orm
     extend ActiveSupport::Autoload
@@ -20,7 +14,12 @@ module HasVersions
     autoload :CassandraObject
   end
 
-  class VersioningError < StandardError; end
+  module VersionMethods
+    extend ActiveSupport::Autoload
+
+    autoload :Diff
+    autoload :Log
+  end
 end
 
 ActiveSupport.on_load :cassandra_object do

data/test/has_versions/attributes_test.rb

@@ -1,20 +1,25 @@
-require 'test_helper'
-
-class HasVersions::AttributesTest < MiniTest::Spec
-  class VersionedObject
-    include HasVersions::Versioned
+require 'helper'
 
+class HasVersions::AttributesTest < MiniTest::Unit::TestCase
+  class VersionedModel < TestModel
     attr_accessor :name
-    attr_accessor :time
+    attr_accessor :weight
     attr_accessor :color
 
     has_versions(Class.new) do
       attribute :name
-      attribute :time
+      attribute :weight
     end
   end
 
-  def test_versioned_fields
-    assert_equal ['name', 'time'], VersionedObject.versioned_fields
+  def test_class_versioned_attributes
+    assert_equal ['name', 'weight'], VersionedModel.versioned_attributes
+  end
+
+  def test_instance_versioned_attributes
+    record = VersionedModel.new(name: 'joe', weight: 142.0, color: 'green')
+    expected = {'name' => 'joe', 'weight' => '142.0'}
+
+    assert_equal expected, record.versioned_attributes
   end
-end
+end

data/test/has_versions/configuration_test.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class HasVersions::ConfigurationTest < MiniTest::Unit::TestCase
+  def test_configuration
+    configuration = HasVersions::Configuration.new do
+      attribute :foo
+      attribute :bar
+    end
+
+    assert_equal %w(foo bar), configuration.attributes
+  end
+end

data/test/has_versions/reset_test.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class HasVersions::ResetTest < MiniTest::Unit::TestCase
+  class ResetModel < TestModel
+    attr_accessor :name
+    attr_accessor :color
+
+    has_versions(TestVersion) do
+      attribute :name
+    end
+
+    def versioning_decode_value(name, value)
+      "hello, #{value}"
+    end
+  end
+
+  def test_from_version
+  end
+
+  def test_reset
+    reset_model = ResetModel.new(name: "bob", color: "green")
+    version = TestVersion.new(snapshot: {name: "joe", color: "blue"})
+
+    reset_model.reset!(version)
+
+    assert_equal "hello, joe", reset_model.name
+    assert_equal "green", reset_model.color
+  end
+end

data/test/has_versions/version_methods/diff_test.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+class HasVersions::VersionMethods::DiffTest < MiniTest::Unit::TestCase
+  class DiffModel < TestModel
+    attr_accessor :name
+    attr_accessor :color
+    attr_accessor :weight
+
+    has_versions(TestVersion) do
+      attribute :name
+      attribute :weight
+    end
+
+    def versioning_decode_value(name, value)
+      "decoded: #{value}"
+    end
+  end
+
+  def test_diff_with_parent
+    target = DiffModel.new
+    parent = TestVersion.new(target: target, snapshot: {name: 'foo', color: 'green', weight: '4.3'})
+    child = TestVersion.new(target: target, parent: parent, snapshot: {name: 'bar', color: 'orange', weight: '4.3'})
+
+    diff = child.diff
+
+    assert_equal({'name' => ['decoded: foo', 'decoded: bar']}, diff)
+  end
+
+  def test_diff_with_parameter
+    target = DiffModel.new
+    this_version = TestVersion.new(target: target, snapshot: {name: 'foo', color: 'green', weight: '4.3'})
+    other_version = TestVersion.new(target: target, snapshot: {name: 'bar', color: 'orange', weight: '4.3'})
+
+    diff = this_version.diff(other_version)
+
+    assert_equal({'name' => ['decoded: bar', 'decoded: foo']}, diff)
+  end
+
+  def test_diff_with_nil
+    target = DiffModel.new
+    version = TestVersion.new(target: target, snapshot: {name: 'bar', color: 'orange', weight: '4.3'})
+
+    diff = version.diff
+
+    assert_equal({'name' => [nil, 'decoded: bar'], 'weight' => [nil, 'decoded: 4.3']}, diff)
+  end
+
+  def test_modified_attributes
+    target = DiffModel.new
+    version = TestVersion.new(target: target, snapshot: {'name' => 'joe', 'weight' => '129'})
+
+    assert_equal version.snapshot.keys, version.modified_attributes
+  end
+
+  def test_different_attributes
+    target = DiffModel.new(name: 'decoded: sam', color: 'decoded: green', weight: 'decoded: 129')
+    version = TestVersion.new(target: target, snapshot: {'name' => 'joe', 'weight' => '129'})
+
+    assert_equal ['name'], version.different_attributes
+  end
+
+  def test_decoded_snapshot
+    target = DiffModel.new
+    version = TestVersion.new(target: target, snapshot: {name: 'foo', color: 'green', weight: '4.3'})
+
+    assert_equal({"name" => "decoded: foo", "weight" => "decoded: 4.3"}, version.decoded_snapshot)
+  end
+end

data/test/has_versions/version_methods/log_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class HasVersions::VersionMethods::LogTest < MiniTest::Unit::TestCase
+  class LogVersion < TestVersion
+    include HasVersions::VersionMethods::Log
+  end
+
+  def test_walk
+    grandparent = LogVersion.new
+    parent = LogVersion.new parent: grandparent
+    child = LogVersion.new parent: parent
+
+    ancestors = []
+    child.log.walk do |v|
+      ancestors << v
+    end
+
+    assert_equal [child, parent, grandparent], ancestors
+  end
+
+  def test_all
+    grandparent = LogVersion.new
+    parent = LogVersion.new parent: grandparent
+    child = LogVersion.new parent: parent
+
+    assert_equal [child, parent, grandparent], child.log.all
+    assert_equal [child, parent, grandparent], child.log.to_a
+  end
+
+  def test_is_enumerable
+    assert LogVersion.new.log.respond_to?(:collect)
+  end
+end

data/test/has_versions/versioned_test.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+class HasVersions::VersionedTest < MiniTest::Unit::TestCase
+  def test_versioned_attribute
+    versioned_model = Class.new(TestModel) do
+      versioned_attribute 'hello'
+    end
+
+    assert_equal ['hello'], versioned_model.versioned_attributes
+  end
+
+  def test_to_version
+    record = Class.new(TestModel) do
+      attr_accessor :name
+
+      has_versions(TestVersion) do
+        attribute :name
+      end
+    end.new(name: 'wee')
+
+    version = record.to_version
+
+    assert_kind_of TestVersion, version
+    assert_equal record, version.target
+    assert_equal record.versioned_attributes, version.snapshot
+  end
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+require 'bundler/setup'
+Bundler.require
+
+require 'minitest/autorun'
+require 'support/test_version'
+require 'support/test_model'

data/test/support/test_model.rb

@@ -0,0 +1,21 @@
+class TestModel
+  include HasVersions::Versioned
+
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+
+  def versioning_encode_value(name, value)
+    value.to_s
+  end
+
+  def versioning_decode_value(name, value)
+    value
+  end
+
+  def versioning_codable?(name)
+    true
+  end
+end

data/test/support/test_version.rb

@@ -0,0 +1,15 @@
+class TestVersion
+  attr_reader :snapshot
+  attr_accessor :parent
+  attr_accessor :target
+
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+
+  def snapshot=(hash)
+    @snapshot = hash.stringify_keys
+  end
+end