strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/sync/stroke_diff/scalar_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Scalar diff" do
+
+  scalars = [
+      1, -1, 12345678901234567890,
+      3.1415926, 2.71828182, -0.333,
+      :sym1, :sym2,
+      false, true, nil,
+      Object.new, Object.new  # okay, these are not scalaras, but relevant to the spec
+    ]
+  
+  scalars.each do |s1|
+    it "should patch scalar #{s1.inspect}" do
+      scalars.each do |s2|
+        s1.stroke_patch(s1.stroke_diff(s2)).should == s2
+      end
+    end
+  end
+end
+
+
+# TODO: spec merging

data/spec/lib/strokedb/sync/stroke_diff/spec_helper.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+def should_merge(base, a, b, r)
+  c, r1, r2 = base.stroke_merge(base.stroke_diff(a), base.stroke_diff(b))
+  c.should be_false
+  r1.should == r
+  r2.should == r
+  # another order
+  c, r1, r2 = base.stroke_merge(base.stroke_diff(b), base.stroke_diff(a))
+  c.should be_false
+  r1.should == r
+  r2.should == r
+end
+
+def should_yield_conflict(base, a, b, ra, rb)
+  c, r1, r2 = base.stroke_merge(base.stroke_diff(a), base.stroke_diff(b))
+  c.should be_true
+  r1.should == ra
+  r2.should == rb
+  # another order
+  c, r1, r2 = base.stroke_merge(base.stroke_diff(b), base.stroke_diff(a))
+  c.should be_true
+  r1.should == rb
+  r2.should == ra
+end

data/spec/lib/strokedb/sync/stroke_diff/string_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "String diff" do
+  
+  before(:each) do
+    @str = "str"
+    @obj = Object.new
+  end
+  
+  it "should correctly patch string with string diff" do
+    2000.times {
+      from = gen_str
+      to   = gen_str
+      from.stroke_patch(from.stroke_diff(to)).should == to
+    }
+  end
+  
+  [ nil,
+    1, 2**64, -1.0,
+    :sym,
+    [:arr],
+    {:arr => 1},
+    @obj
+  ].each do |obj|
+    it "should correctly patch string with a replacement #{obj.inspect}" do
+      @arr.stroke_patch(@arr.stroke_diff(obj)).should == obj
+    end
+  end
+  
+  def gen_str
+    letters = %w(a b c d)
+    str = ""
+    len = rand(letters.size*2)
+    len.times {
+      str << letters[rand(letters.size)]
+    }
+    str
+  end
+end
+
+describe "String automerge" do
+  
+  it "should do a trivial merge" do
+  #  should_merge("abc", "abcd", "axc", "axcd")
+  end
+  
+  
+  def should_merge(base, a, b, r)
+    c, r1, r2 = base.stroke_merge(base.stroke_diff(a), base.stroke_diff(b))
+    c.should be_false
+    r1.should == r1
+    r2.should == r
+    # another order
+    c, r1, r2 = base.stroke_merge(base.stroke_diff(b), base.stroke_diff(a))
+    c.should be_false
+    r1.should == r1
+    r2.should == r
+  end
+
+end
+

data/spec/lib/strokedb/util/attach_dsl_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "attach_dsl DSL :-)" do
+  
+  before(:each) do
+    module MetaDSL
+      def on_initialize(&block)
+        store_dsl_options("on_initialize", block)
+      end
+    end
+
+    module HasMany
+      attach_dsl MetaDSL
+      def has_many(*args)
+        store_dsl_options("has_many", { :module => HasMany, :args => args } )
+      end
+      on_initialize do |doc|
+        blah_blah
+      end
+    end
+    
+    module ValidatePresenceOf
+      attach_dsl MetaDSL
+      def validate_presence_of(*args)
+        store_dsl_options("validate_presence_of", { :module => ValidatePresenceOf, :args => args } )
+      end
+      on_initialize do |doc|
+        blah_blah
+      end
+    end
+
+    module App1
+      attach_dsl HasMany, ValidatePresenceOf
+      has_many :blah, :blah => :blah
+      validate_presence_of :blah, :blah
+    end
+  end
+  
+  it "should return a list of DSL options" do
+    App1.dsl.keys.to_set.should == %w[has_many validate_presence_of].to_set
+    App1.dsl["has_many"].should == {:module => HasMany, :args => [:blah, {:blah => :blah}]} 
+    App1.dsl["has_many"][:module].dsl["on_initialize"].should be_a_kind_of(Proc)
+  end
+  
+end

data/spec/lib/strokedb/util/inflect_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Inflect" do
+
+  it "#singular should return singular of word" do
+    English::Inflect.singular('boy').should == 'boy'
+    English::Inflect.singular('boys').should == 'boy'
+  end
+  
+  it "#prural should return plural of word" do
+    English::Inflect.plural('hive').should == 'hives'
+  end
+
+end

data/spec/lib/strokedb/util/lazy_array_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "LazyArray instance" do
+
+  before(:each) do
+    @array = LazyArray.new
+  end
+
+  it "should have class Array" do
+    # Make it look like array for outer world
+    @array.class.should == Array
+  end
+
+  it "should be inherited from Array" do
+    @array.class.ancestors.first.should == Array
+  end
+end
+
+
+
+describe "LazyArray instance with block specified" do
+
+  before(:each) do
+    @loader = proc { [1,2,3] }
+    @array = LazyArray.new.load_with(&@loader)
+  end
+
+  it "should call loading proc on #[index]=" do
+    @array[0]="10"
+    @array.should == ["10",2,3]
+  end
+
+  it "should call loading proc on #[index]" do
+    @array[0].should == 1
+  end
+
+  it "should call loading proc on #[start,length]" do
+    @array[0,2].should == [1,2]
+  end
+
+  it "should call loading proc on #[range]" do
+    @array[0..1].should == [1,2]
+  end
+
+  it "should call loading proc on #slice(index)" do
+    @array.slice(0).should == 1
+  end
+
+  it "should call loading proc on #slice(start,length)" do
+    @array.slice(0,2).should == [1,2]
+  end
+
+
+  it "should call loading proc on #slice(range)" do
+    @array.slice(0..1).should == [1,2]
+  end
+
+  it "should call loading proc on #at(index)" do
+    @array.at(0).should == 1
+  end
+
+  it "should call loading proc on #first" do
+    @array.first.should == 1
+  end
+
+  it "should call loading proc on #last" do
+    @array.last.should == 3
+  end
+
+  it "should yield mapped value in #each block" do
+    array_yielded = []
+    @array.each do |val|
+      array_yielded << val
+    end
+    array_yielded.should == [1,2,3]
+  end
+
+  it "should call loading proc on #each" do
+    i = 0
+    @array.each do |e|
+      e.should == [1,2,3][i]
+      i+=1
+    end
+  end
+
+  it "should call loading proc on #each_with_index" do
+    @array.each_with_index do |e, i|
+      e.should == [1,2,3][i]
+    end
+  end
+
+  it "should call loading proc on #inject" do
+    i = 0
+    @array.inject([]) do |c, e|
+      e.should == [1,2,3][i]
+      i += 1
+    end
+  end
+
+  it "should call loading proc on #map" do
+    i = 0
+    @array.map do |e|
+      e.should == [1,2,3][i]
+      i+=1
+    end
+  end
+
+  it "should call loading proc on #zip" do
+    @array.zip([1,2,3]).should == [1,2,3].zip([1,2,3])
+  end
+
+  it "should call unloading proc on #push" do
+    @array.push "10"
+    @array.should == [1,2,3,"10"]
+  end
+
+  it "should call unloading proc on #<<" do
+    @array << "10"
+    @array.should == [1,2,3,"10"]
+  end
+
+  it "should call unloading proc on #unshift" do
+    @array.unshift "10"
+    @array.should == ["10",1,2,3]
+  end
+
+  it "should call loading proc on #pop" do
+    @array.pop.should == 3
+  end
+
+  it "should call loading proc on #shift" do
+    @array.shift.should == 1
+  end
+
+  it "should call loading proc on #inspect" do
+    @array.inspect
+    @array.should == [1,2,3]
+  end
+
+  it "should call loading proc on #find" do
+    @array.find{|v| v == 2}.should == 2
+  end
+
+  it "should call loading proc on #index" do
+    @array.index(2).should == 1
+  end
+
+  it "should call loading proc on #to_a" do
+    @array.to_a.should == [1,2,3]
+  end
+
+  it "should call loading proc on #==" do
+    @array.should == [1,2,3]
+  end
+
+end
+

data/spec/lib/strokedb/util/lazy_mapping_array_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "LazyMappingArray instance" do
+  before(:each) do
+    @array = LazyMappingArray.new
+  end
+
+  it "should have class Array" do
+    @array.class.should == Array
+  end
+
+  it "should be inherited from Array" do
+    @array.class.ancestors.first.should == Array
+  end
+
+  it "should work in case statements" do
+    @array.should be_a_kind_of(Array)
+  end
+end
+
+describe "LazyMappingArray instance with map/unmap specified" do
+  before(:each) do
+    @original = [1,2,3,[1],[2]]
+    @mapper = proc {|arg| arg.to_s }
+    @unmapper = proc {|arg| arg.to_i }
+    @array = LazyMappingArray.new(@original).map_with(&@mapper).unmap_with(&@unmapper)
+  end
+
+  it "should call unmapping proc on #[index]=" do
+    @array[0]="10"
+    Array.new(@array).first.should == 10
+  end
+
+  it "should work with #[index]=(array)" do
+    @array[1,0] = %w[ 1 2 3 ]
+    @original[1,0] = [1,2,3]
+    # TODO: huge bug inside!
+    # p @array
+    # p @array.to_a
+    # p @original
+    # p @original.map(&@mapper)
+    @array.to_a.should == @original.map(&@mapper)
+  end
+
+  it "should call mapping proc on #[index]" do
+    @array[0].should == @mapper.call(@original[0])
+  end
+
+  it "should call mapping proc on #[start,length]" do
+    @array[0,2].to_a.should == @original[0,2].map(&@mapper)
+    @array[3,2].to_a.should == @original[3,2].map(&@mapper)
+  end
+
+  it "should call mapping proc on #[range]" do
+    @array[0..1].to_a.should == @original[0..1].map(&@mapper)
+    @array[3..4].to_a.should == @original[3..4].map(&@mapper)
+  end
+
+  it "should call mapping proc on #slice(index)" do
+    @array.slice(0).should == @mapper.call(@original.slice(0))
+  end
+
+  it "should call mapping proc on #slice(start,length)" do
+    @array.slice(0,2).to_a.should == @original.slice(0,2).map(&@mapper)
+  end
+
+  it "should call mapping proc on #slice(range)" do
+    @array.slice(0..1).to_a.should == @original.slice(0..1).map(&@mapper)
+  end
+
+  it "should call mapping proc on #at(index)" do
+    @array.at(0).should == @mapper.call(@original.at(0))
+  end
+
+  it "should call mapping proc on #first" do
+    @array.first.should == @mapper.call(@original.first)
+  end
+
+  it "should call mapping proc on #last" do
+    @array.last.should == @mapper.call(@original.last)
+  end
+
+  it "should yield mapped value in #each block" do
+    mapped_original = []
+    @original.each do |val|
+      mapped_original << @mapper.call(val)
+    end
+    array_yielded = []
+    @array.each do |val|
+      array_yielded << val
+    end
+    array_yielded.should == mapped_original
+  end
+
+  it "should call mapping proc on #each" do
+    i = 0
+    @array.each do |e|
+      e.should == @mapper.call(@original[i])
+      i+=1
+    end
+  end
+
+  it "should call mapping proc on #each_with_index" do
+    @array.each_with_index do |e, i|
+      e.should == @mapper.call(@original[i])
+    end
+  end
+
+  it "should call mapping proc on #inject" do
+    i = 0
+    @array.inject([]) do |c, e|
+      e.should == @mapper.call(@original[i])
+      i+=1
+    end
+  end
+
+  it "should call mapping proc on #map" do
+    i = 0
+    @array.map do |e|
+      e.should == @mapper.call(@original[i])
+      i+=1
+    end
+  end
+
+  it "should call mapping proc on #zip" do
+    @array.zip(@original){|a, o| a.should == @mapper.call(o)  }
+  end
+
+  it "should call unmapping proc on #push" do
+    @array.push "10"
+    Array.new(@array).last.should == 10
+  end
+
+  it "should call unmapping proc on #<<" do
+    @array << "10"
+    Array.new(@array).last.should == 10
+  end
+
+  it "should call unmapping proc on #unshift" do
+    @array.unshift "10"
+    Array.new(@array).first.should == 10
+  end
+
+  it "should call mapping proc on #pop" do
+    @array << "10"
+    @array.pop.should == "10"
+  end
+
+  it "should call mapping proc on #shift" do
+    @array[0] = "10"
+    @array.shift.should == "10"
+  end
+
+  it "should call mapping proc on #index" do
+    @array.index(1).should == 0
+  end
+  
+  it "should call unmapping proc on #-" do
+    @array << "20"
+    @array << "10"
+    @array = @array - ["10"]
+    Array.new(@array).last.should == 20
+  end
+  
+  it "should call unmapping proc on #include?" do
+    @array.should include("1")
+    @array.should_not include("10")
+  end
+
+  it "should be == to similar non-lazy array" do
+    @array.should == @original.map{|v| @mapper.call(v)}
+  end
+  
+end