has_versions 0.4.9 → 0.5.0

data/spec/has_versions/configuration_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe 'Configuration' do
-  subject do
-    HasVersions::Configuration.new do
-      type :baz, expected: Hash
-      attribute :foo
-      attribute :bar
-      attribute :baz, type: :baz
-    end
-  end
-
-  it 'should include specified attributes' do
-    subject.attributes.should include(:foo)
-    subject.attributes.should include(:bar)
-  end
-
-  it 'should set options on attributes' do
-    subject.attributes[:baz].should include(type: :baz)
-  end
-
-  it 'should allow indifferent access to attributes' do
-    subject.attributes.should include("foo")
-  end
-
-  it 'should include specified types' do
-    subject.types.should include(:baz)
-  end
-
-  it 'should propagate type options to typed attributes' do
-    subject.attributes[:baz].should include(expected: Hash)
-  end
-end

data/spec/has_versions/diff_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-class DiffingVersion < Version; end
-
-describe DiffingVersion do
-  class DiffingVersion
-    include HasVersions::Diff::Simple
-
-    def versioning_decode_value(key, value)
-      if key == 'name'
-        value.upcase
-      else
-        value
-      end
-    end
-
-    def versioning_codable?(name)
-      true
-    end
-  end
- 
-  let (:foo) { described_class.new(name: 'foo', argyle: 'socks') }
-  let (:foo2) { described_class.new(name: 'foo2', stripey: 'socks') }
-
-  it 'should return empty when diffed with itself' do
-    foo.diff(foo).should be_empty
-  end
-
-  it 'should return a patch when diffed with another version' do
-    foo.diff(foo2).should include(name: ['FOO', 'FOO2'])
-  end
-
-  it 'should include patches for attributes added' do
-    foo.diff(foo2).should include(stripey: [nil, 'socks'])
-  end
-
-  it 'should include patches for attributes deleted' do
-    foo.diff(foo2).should include(argyle: ['socks', nil])
-  end
-end

data/spec/has_versions/merge/diff3_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe "Merge" do
-  describe "Diff3" do
-
-    it 'should behave like a 3-way merge' do
-      extend HasVersions::Merge::Diff3
-      
-      diff3('A','A','A').should == [true, 'A']
-      diff3('A','B','A').should == [true, 'B']
-      diff3('A','A','B').should == [true, 'B']
-      diff3('B','A','A').should == [true, 'A']
-      diff3('B','A','C').should == [false, ['A', 'C']]
-    end
-
-    it 'should take multiple theirs' do
-      extend HasVersions::Merge::Diff3
-
-      diff3('A','A',*['A','A']).should == [true, 'A']
-      diff3('A','A',*['B','B']).should == [true, 'B']
-      diff3('A','A',*['B','B']).should == [true, 'B']
-      diff3('A','A',*['A','B']).should == [false, ['A','B']]
-      diff3('A','A',*['B','C']).should == [false, ['B','C']]
-      diff3('A','B',*['C','D']).should == [false, ['C','D','B']]
-    end
-
-    it 'should handle _missing values'
-  end
-end

data/spec/has_versions/merge/merge_base_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe "Merge" do
-  describe "MergeBase" do
-    include HasVersions::Merge::MergeBase
-
-    it 'should find no bases for one version' do
-      v = MergingVersion.new
-      merge_bases([v]).should == []  
-    end
-
-    it 'should find merge base for a version and its parent' do
-      p1 = MergingVersion.new
-      v1 = MergingVersion.new
-      v1.parents = p1
-      merge_bases([v1, p1]).should == [p1]
-    end
-
-    it 'should find merge base for versions with multiple ancestors' do
-      p1 = MergingVersion.new
-      p2 = MergingVersion.new
-      v1 = MergingVersion.new
-      v1.parents = p1
-      p1.parents = p2
-      merge_bases([v1, p1]).should == [p1]
-    end
-
-    it 'should find merge base for two versions with the same parent' do
-      p1 = MergingVersion.new
-      v1 = MergingVersion.new
-      v2 = MergingVersion.new
-      v1.parents = v2.parents = [p1]
-      merge_bases([v1, v2]).should == [p1]
-    end
-
-    it 'should find merge base for multiple versions with different parents' do
-      p1, p2, v1, v2, v3 = *5.times.collect { MergingVersion.new }
-      p2.parents = [p1]
-      v1.parents = [p1]
-      v2.parents = [p2]
-      v3.parents = [v2]
-      merge_bases([v1, v2, v3]).should == [p1]
-    end
-    
-    it 'should find no base for versions with no common ancestry' do
-      v1 = MergingVersion.new
-      v2 = MergingVersion.new
-      merge_bases([v1, v2]).should == []  
-    end
-
-    #TODO this is broken
-    it 'should find multiple bases for versions with criss-cross ancestry' do
-      p1, p2, p3, v1, v2 = *5.times.collect { MergingVersion.new }
-      p2.parents = [p1]
-      p3.parents = [p1]
-      v1.parents = [p3, p2]
-      v2.parents = [p2, p3]
-      merge_bases([v1, v2]).should == [p2, p3]
-    end
-  end
-end

data/spec/has_versions/merge/octopus_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe HasVersions::Merge::Octopus do
-
-  it 'should only accept 3+ versions' do
-    expect { merge([MergingVersion.new]) }.to raise_error(HasVersions::MergeFailed)
-    expect { merge([MergingVersion.new]*2) }.to raise_error(HasVersions::MergeFailed)
-  end
-
-  it 'should merge identical versions' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo1')
-    v3 = MergingVersion.new(name: 'foo1')
-    merge([v1, v2, v3]).resolution.snapshot.should include(name: 'foo1')
-  end
-
-  it 'should merge many versions' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo1')
-    v3 = MergingVersion.new(name: 'foo1')
-    v4 = MergingVersion.new(name: 'foo1')
-    v5 = MergingVersion.new(name: 'foo1')
-    v6 = MergingVersion.new(name: 'foo1')
-    merge([v1, v2, v3, v4, v5, v6]).resolution.snapshot.should include(name: 'foo1')
-  end
-
-  it 'should detect conflicts' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo2')
-    v3 = MergingVersion.new(name: 'foo3')
-    merge([v1, v2, v3]).conflicts.should include(name: ['foo1', 'foo2', 'foo3'])
-  end
-
-  it 'should merge ancestors cleanly' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo2')
-    v3 = MergingVersion.new(name: 'foo3')
-
-    v3.parents = v2
-    v2.parents = v1
-    merge([v1, v2, v3]).conflicts.should be_empty
-    merge([v1, v2, v3]).resolution.snapshot.should include(name: 'foo3')
-  end
-
-  it 'should merge missing attributes' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    v3 = MergingVersion.new(hat: 'silly')
-    merge([v1, v2, v3]).resolution.snapshot.should include(name: 'foo1', socks: 'stripey', hat: 'silly')
-  end
-
-  it 'should save the partial merge result' do
-    v1 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    v2 = MergingVersion.new(name: 'foo2', socks: 'argyle')
-    v3 = MergingVersion.new(name: 'foo3', socks: 'argyle')
-    p1 = MergingVersion.new(name: 'foo', socks: 'argyle')
-    v1.parents = v2.parents = v3.parents = p1
-    merge([v1, v2, v3]).conflicts.should include(name: ['foo1', 'foo2', 'foo3'])
-    merge([v1, v2, v3]).resolution.snapshot.should include(socks: 'stripey')
-  end
-
-  it 'should set parents' do
-    v1 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    v2 = MergingVersion.new(name: 'foo2', socks: 'argyle')
-    v3 = MergingVersion.new(name: 'foo3', socks: 'argyle')
-    merge([v1, v2, v3]).resolution.parents.should == [v1, v2, v3]
-  end
-
-  def merge(versions, options={})
-    s = HasVersions::Merge::Octopus.new(versions, options)
-    s.merge
-    s
-  end
-end

data/spec/has_versions/merge/three_way_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe HasVersions::Merge::ThreeWay do
-
-  it 'should only accept 2 versions' do
-    expect { merge([MergingVersion.new]) }.to raise_error(HasVersions::MergeFailed)
-    expect { merge([MergingVersion.new]*3) }.to raise_error(HasVersions::MergeFailed)
-  end
-
-  it 'should merge identical versions' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo1')
-    merge([v1, v2]).resolution.snapshot.should include(name: 'foo1')
-  end
-
-  it 'should detect conflicts' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo2')
-    merge([v1, v2]).conflicts.should include(name: ['foo1', 'foo2'])
-  end
-
-  it 'should merge ancestors cleanly' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo2')
-
-    v2.parents = [v1]
-    merge([v1, v2]).conflicts.should be_empty
-    merge([v1, v2]).resolution.snapshot.should include(name: 'foo2')
-  end
-
-  it 'should merge missing attributes' do
-    v1 = MergingVersion.new(name: 'foo1')
-    v2 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    merge([v1, v2]).resolution.snapshot.should include(name: 'foo1', socks: 'stripey')
-  end
-
-  it 'should save the partial merge result' do
-    v1 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    v2 = MergingVersion.new(name: 'foo2', socks: 'argyle')
-    p1 = MergingVersion.new(name: 'foo', socks: 'argyle')
-    v1.parents = v2.parents = p1
-    merge([v1, v2]).conflicts.should include(name: ['foo1', 'foo2'])
-    merge([v1, v2]).resolution.snapshot.should include(socks: 'stripey')
-  end
-
-  it 'should set parents' do
-    v1 = MergingVersion.new(name: 'foo1', socks: 'stripey')
-    v2 = MergingVersion.new(name: 'foo2', socks: 'argyle')
-    merge([v1, v2]).resolution.parents.should == [v1, v2]
-  end
-
-  def merge(versions, options={})
-    s = HasVersions::Merge::ThreeWay.new(versions, options)
-    s.merge
-    s
-  end
-end

data/spec/has_versions/reset_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-class ResetObjectVersion < Version; end
-
-class ResetObject
-  include HasVersions::Versioned
-
-  include HasVersions::Reset::Simple
-
-  attr_accessor :name
-  attr_accessor :set
-
-  has_versions(ResetObjectVersion) do
-    attribute :name
-  end
-end
-
-describe "Reset" do
-  describe "Simple" do
-    subject do
-      ResetObject.new.reset!(ResetObjectVersion.new(set: [1,2,3]))
-    end
-
-    its(:set) { should be_a(Set) }
-  end
-
-  describe "FromVersion" do
-    class ResetObject
-      extend HasVersions::Reset::FromVersion
-    end
-
-    subject do
-      ResetObject.from_version(ResetObjectVersion.new(name: 'foo'))
-    end
-
-    it { should be_a(ResetObject) }
-
-    its(:name) { should == 'foo' }
-  end
-end

data/spec/has_versions/stage_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-class StagingObjectVersion < Version; end
-
-# class StagingObject
-#   include HasVersions::Versioned
-#   include HasVersions::Stage
-# 
-#   attr_accessor :name
-# 
-#   has_versions(StagingObjectVersion) do
-#     attribute :name
-#   end
-# end
-# 
-# describe StagingObject do
-# end

data/spec/has_versions/versioned_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-class VersionedObject
-  include HasVersions::Versioned
-
-  attr_accessor :name
-  attr_accessor :time
-  attr_accessor :color
-end
-
-class VersionedObjectVersion < Version; end
-
-describe VersionedObject do
-  it { should respond_to(:versioning_configuration) }
-  it { should respond_to(:version_class) }
-
-  it 'should not be versioned' do
-    described_class.is_versioned?.should be_false
-  end
-
-  context "configured" do
-    subject do
-      described_class.has_versions(VersionedObjectVersion) do
-        attribute :name
-        attribute :time
-      end
-      described_class.versioned_attribute(:color)
-
-      described_class
-    end
-
-    it 'should be versioned' do
-      subject.is_versioned?.should be_true
-    end
-
-    it 'should have attributes' do
-      subject.versioning_configuration.attributes.should == ["name", "time", "color"]
-    end
-
-    its(:version_class) { should be(VersionedObjectVersion) }
-    its(:versioning_configuration) { should be_a(HasVersions::Configuration) }  
-  end
-
-  describe "configured instance" do
-    subject do
-      v = VersionedObject.new
-      v.name = 'foo'
-      v.time = Time.parse("1970-01-01 2:43")
-      v
-    end
-
-    its(:versioned_attributes) { should include(name: 'foo') }
-
-    its(:to_version) { should be_a(VersionedObjectVersion) }
-
-    it 'should set attributes in to_version' do
-      subject.to_version.snapshot.should include(name: 'foo')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,17 +0,0 @@
-# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-# $LOAD_PATH.unshift(File.dirname(__FILE__))
-
-# p "#{$LOAD_PATH.inspect}"
-
-require 'rspec'
-require 'has_versions'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f| 
-  require f
-end
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-end

data/spec/support/matchers/be_a_uuid.rb

@@ -1,7 +0,0 @@
-require 'rspec/expectations'
-
-RSpec::Matchers.define :be_a_uuid do |expected|
-  match do |actual|
-    actual =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ # c14ba018-2f15-11e0-9a06-b6e5e5c60f13
-  end
-end

data/spec/support/version.rb

@@ -1,17 +0,0 @@
-class Version
-  attr_accessor :snapshot
-
-  def initialize(snapshot=nil)
-    @snapshot = (snapshot || {}).with_indifferent_access
-  end
-end
-
-class MergingVersion < Version
-  def parents
-    @parents || []
-  end
-
-  def parents=(parents)
-    @parents = Array(parents)
-  end
-end

data/test/test_helper.rb

@@ -1,3 +0,0 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-Bundler.require