ruby_ext 0.4.11 → 0.4.12

data/spec/core/array_spec.rb

@@ -0,0 +1,7 @@
+require "core/spec_helper"
+
+describe 'Array' do
+  it 'sfilter' do
+    %w{alpha betta gamma}.sfilter('lpha', /et/).should == ['gamma']
+  end
+end

data/spec/{deep_clone_spec.rb → core/deep_clone_spec.rb}

@@ -1,5 +1,4 @@
-require "spec_helper"
-require "ruby_ext/deep_clone"
+require "core/spec_helper"
 
 describe 'deep_clone' do
   it "basic" do
@@ -32,6 +31,6 @@ describe 'deep_clone' do
     m2.registry.should include(:a)
     m2.registry[:b] = 2
     
-    m.registry.should == {:a => 1}
+    m.registry.should == {a: 1}
   end
 end

data/spec/core/enumerable.rb

@@ -0,0 +1,9 @@
+require "core/spec_helper"
+
+describe 'Enumerable' do
+  it 'every' do
+    list = %w{alpha betta gamma}
+    list.every.upcase!
+    list.should == %w{ALPHA BETTA GAMMA}
+  end
+end

data/spec/{kernel_spec.rb → core/kernel_spec.rb}

@@ -1,5 +1,4 @@
-require "spec_helper"
-require "ruby_ext/kernel"
+require "core/spec_helper"
 
 describe 'Kernel' do
   class Respond
@@ -17,10 +16,9 @@ describe 'Kernel' do
   end
   
   it "raise_without_self" do
-    dir = File.dirname __FILE__
-    require "#{dir}/kernel_spec/TheNamespace/ClassA"
-    require "#{dir}/kernel_spec/the_namespace/class_b"
-    require "#{dir}/kernel_spec/another_class"
+    require "#{spec_dir}/TheNamespace/ClassA"
+    require "#{spec_dir}/the_namespace/class_b"
+    require "#{spec_dir}/another_class"
     
     begin
       TheNamespace::ClassA.problem_method

data/spec/{module_spec.rb → core/module_spec.rb}

@@ -1,9 +1,7 @@
-require "spec_helper"
-require "ruby_ext/module"
-require 'ruby_ext/multiple_inheritance'
+require "core/spec_helper"
 
 describe "Module" do
-  after :each do
+  after do
     remove_constants %w(
       A X Y Z
       InheritableAccessorForModule

data/spec/{multiple_inheritance_spec.rb → core/multiple_inheritance_spec.rb}

@@ -1,11 +1,10 @@
-require "spec_helper"
-require "ruby_ext/multiple_inheritance"
+require "core/spec_helper"
 
 describe "Multiple Inheritance" do
-  after :each do
+  after do
     remove_constants %w(M A M2 B AddedAfterInheritance)
   end
-
+  
   it "showcase" do
     module M
       def instance_method; end
@@ -14,8 +13,8 @@ describe "Multiple Inheritance" do
         def class_method; end
       end
 
-      def self.inherited target      
-        target.send :attr_accessor, :some_accessor
+      inherited do
+        attr_accessor :some_accessor
       end
     end     
            
@@ -106,10 +105,10 @@ describe "Multiple Inheritance" do
       inherit M
     end
     
-    A.instance_methods.should_not include('method_added_after_inheritance')
+    A.instance_methods.should_not include(:method_added_after_inheritance)
     M.send(:define_method, :method_added_after_inheritance){}
-    M.instance_methods.should include('method_added_after_inheritance')
-    A.instance_methods.should include('method_added_after_inheritance')
+    M.instance_methods.should include(:method_added_after_inheritance)
+    A.instance_methods.should include(:method_added_after_inheritance)
   end
   
   it "modules included in base class after inheritance must be propagated to all descendants" do
@@ -123,9 +122,26 @@ describe "Multiple Inheritance" do
       def module_added_after_inheritance; end
     end
     
-    M.instance_methods.should_not include('module_added_after_inheritance')
+    M.instance_methods.should_not include(:module_added_after_inheritance)
     M.inherit AddedAfterInheritance
-    M.instance_methods.should include('module_added_after_inheritance')
-    A.instance_methods.should include('module_added_after_inheritance')
+    M.instance_methods.should include(:module_added_after_inheritance)
+    A.instance_methods.should include(:module_added_after_inheritance)
+  end
+  
+  it "use case from error" do
+    class ItemSpec
+    end
+    
+    class PageSpec < ItemSpec
+    end
+    
+    module ::ItemSpecHelper
+    end
+    
+    module ::PageSpecHelper
+    end
+    
+    ItemSpec.inherit ItemSpecHelper
+    PageSpec.inherit PageSpecHelper
   end
 end

data/spec/core/must_spec.rb

@@ -0,0 +1,32 @@
+require "core/spec_helper"
+
+describe 'Assert' do
+  it 'must & must_not' do
+    -> {must_be.never_called}.should raise_error(/ever/)
+    -> {nil.must_not_be.nil}.should raise_error(/nil/)
+    1.must_not_be.nil
+    1.must_be.== 1
+    -> {1.must_be.== 2}.should raise_error(%r{==})
+    1.must_be.in 1, 2
+    1.must_be.in [1, 2]
+    0.must_be.in 0..1
+    "".must_be.a String
+    "".must_be.a String, Symbol
+    1.must_be.< 2
+    
+    1.must_be.defined
+    -> {nil.must_be.defined}.should raise_error(/must be defined/)
+  end   
+  
+  it 'must_be & must_not_be' do
+    [].must_be.empty    
+    [''].must_not_be.empty
+    
+    -> {[''].must_be.empty}.should raise_error(/must be/)
+    -> {[].must_not_be.empty}.should raise_error(/must not be/)
+  end
+  
+  it "should return result" do
+    [].must_be.empty.should == []
+  end
+end

data/spec/{open_object_spec.rb → core/open_object_spec.rb}

@@ -1,18 +1,17 @@
-require "spec_helper"
-require "ruby_ext/array"
+require "core/spec_helper"
 
 describe 'OpenObject' do
   it 'should be comparable with hashes' do
     {}.to_openobject.should == {}
     {}.should == {}.to_openobject
     
-    {:a => :b}.to_openobject.should == {:a => :b}
-    {'a' => :b}.to_openobject.should == {:a => :b}
+    {a: :b}.to_openobject.should == {a: :b}
+    {'a' => :b}.to_openobject.should == {a: :b}
     
-    {:a => :b}.to_openobject.should == {'a' => :b}
+    {a: :b}.to_openobject.should == {'a' => :b}
     {'a' => :b}.to_openobject.should == {'a' => :b}
     
-    {:a => :b}.to_openobject.should_not == {:a => :c}
+    {a: :b}.to_openobject.should_not == {a: :c}
   end
   
   it "must be hash (from error)" do
@@ -21,7 +20,7 @@ describe 'OpenObject' do
   
   it 'merge! should be indifferent to string and symbol' do
     oo = OpenObject.new
-    oo.merge! :a => true
+    oo.merge! a: true
     oo.a.should be_true
     oo.merge! 'b' => true    
     oo.b.should be_true

data/spec/core/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec_ext'
+require 'ruby_ext/core'

data/spec/{declarative_cache_spec.rb → more/declarative_cache_spec.rb}

@@ -1,5 +1,4 @@
-require "spec_helper"
-require "ruby_ext/declarative_cache"
+require "more/spec_helper"
 
 describe 'DeclarativeCache' do
   class CachedClass
@@ -36,7 +35,27 @@ describe 'DeclarativeCache' do
     o.value2_get.should == 0
   end
   
-  it "clear_cache_method" do
+  it "should define <method>_with_cache and <method>_without_cache methods" do
+    o = CachedClass.new
+    
+    # without params
+    o.value = 0
+    o.value_get.should == 0    
+    o.value = 1
+    o.value_get.should == 0
+    o.value_get_with_cache.should == 0
+    o.value_get_without_cache.should == 1
+    
+    # with params
+    o.params = {a: :b}
+    o.params_get(:a).should == :b
+    o.params = {a: :c}
+    o.params_get(:a).should == :b
+    o.params_get_with_cache(:a).should == :b
+    o.params_get_without_cache(:a).should == :c
+  end
+  
+  it "clear_cache" do
     o = CachedClass.new
     o.value = 0
     o.value_get.should == 0
@@ -44,7 +63,7 @@ describe 'DeclarativeCache' do
     o.value = 1
     o.value_get.should == 0
 
-    o.clear_cache_method
+    o.clear_cache
     o.value_get.should == 1
   end
   
@@ -55,9 +74,9 @@ describe 'DeclarativeCache' do
   
   it "Cache With Params" do
     o = CachedClass.new
-    o.params = {:a => :b}
+    o.params = {a: :b}
     o.params_get(:a).should == :b
-    o.params = {:a => :c}
+    o.params = {a: :c}
     o.params_get(:a).should == :b
   end
   
@@ -108,8 +127,16 @@ describe 'DeclarativeCache' do
     def value_get; @value end    
   end
   
-  it "should not allow to cache twice" do
+  it "should not cache twice, and should works" do
+    CachedClass4.cache_method :value_get    
+    
+    Object.should_receive(:warn){|msg| msg =~ /twice/}
     CachedClass4.cache_method :value_get
-    lambda{CachedClass4.cache_method :value_get}.should raise_error(/twice/)
+    
+    o = CachedClass.new
+    o.value = 0
+    o.value_get.should == 0
+    o.value = 1
+    o.value_get.should == 0
   end
 end

data/spec/{observable2_spec.rb → more/observable2_spec.rb}

@@ -1,5 +1,4 @@
-require "spec_helper"
-require "ruby_ext/observable2"
+require "more/spec_helper"
 
 describe "Observable" do
   class AnObservable
@@ -17,7 +16,7 @@ describe "Observable" do
      # it "Method without Parameters" do
      #   mock = mock("Observer")
      #   obs = AnObservable.new
-     #   obs.add_observer(mock, :method => :custom_update, :filter => lambda{|o| o == 2})
+     #   obs.add_observer(mock, method: :custom_update, filter: -> {|o| o == 2})
      #   mock.should_receive(:custom_update).with(2)
      #   obs.notify_observers 2
      #   obs.notify_observers 4
@@ -34,7 +33,7 @@ describe "Observable" do
      # it "With Block and Filter" do
      #   mock = mock("Observer")
      #   obs = AnObservable.new
-     #   obs.add_observer(:filter => lambda{|o| o == 2}){|o| mock.got o}
+     #   obs.add_observer(filter: -> {|o| o == 2}){|o| mock.got o}
      #   mock.should_receive(:got).with(2)
      #   obs.notify_observers 2
      #   obs.notify_observers 4                  

data/spec/{open_constructor_spec.rb → more/open_constructor_spec.rb}

@@ -1,5 +1,4 @@
-require "spec_helper"
-require "ruby_ext/open_constructor"
+require "more/spec_helper"
 
 describe 'OpenConstructor' do
   class Test
@@ -8,28 +7,28 @@ describe 'OpenConstructor' do
   end
 
   it 'should initialize atributes from Hash' do
-    t = Test.new.set(:name => 'name', :value => 'value')
+    t = Test.new.set(name: 'name', value: 'value')
     [t.name, t.value].should == ['name', 'value']
   end
   
   it 'should initialize atributes from any Object' do
-    t = Test.new.set(:name => 'name', :value => 'value')
+    t = Test.new.set(name: 'name', value: 'value')
     t2 = Test.new.set t
     [t2.name, t2.value].should == ['name', 'value']
   end
   
   it 'restrict copied values' do
-    t = Test.new.set(:name => 'name', :value => 'value')
+    t = Test.new.set(name: 'name', value: 'value')
     t2 = Test.new.set t, [:name]
     [t2.name, t2.value].should == ['name', nil]
     
-    t = {:name => 'name', :value => 'value'}
+    t = {name: 'name', value: 'value'}
     t2 = Test.new.set t, [:name]
     [t2.name, t2.value].should == ['name', nil]
   end
   
   it 'to_hash' do
-    h = {:name => 'name', :value => 'value'}
+    h = {name: 'name', value: 'value'}
     t = Test.new.set h
     t.to_hash.should == h
   end

data/spec/more/safe_hash_spec.rb

@@ -0,0 +1,133 @@
+require 'more/spec_helper'
+
+describe "SafeHash and SafeNil" do
+  it "should allow check for value presence" do
+    h = SafeHash.new a: :b
+    h.a?.should be_true
+    h.b?.should be_false
+    
+    h.should include(:a)
+    h.should_not include(:b)
+  end
+  
+  it "? should return boolean (from error)" do
+    h = SafeHash.new
+    lambda{raise "" unless h.a?.class.equal?(NilClass)}.should raise_error
+    lambda{raise "" unless h.a.a?.class.equal?(NilClass)}.should raise_error
+  end
+  
+  it "passing block should be threated as invalid usage" do
+    h = SafeHash.new
+    lambda{h.development{}}.should raise_error(/invalid usage/)
+  end
+  
+  it "should treat assigned nil as value (from error)" do
+    h = SafeHash.new v: nil
+    h.v?.should be_true
+    h.v!.should == nil
+  end
+  
+  it "should not allow direct modification of hash" do
+    h = SafeHash.new
+    lambda{h.a = 1}.should raise_error(/forbidden/)
+    lambda{h[:a] = 1}.should raise_error(/forbidden/)
+    lambda{h.a.b = 1}.should raise_error(/forbidden/)
+  end
+  
+  it "should not allo"
+  
+  # it "should allow owerride values" do
+  #   h = SafeHash.new a: :b
+  #   h.b = :c
+  #   h.b!.should == :c
+  # end
+  
+  it "general behaviour" do
+    h = SafeHash.new key: :value
+    
+    h.key.should == :value
+    h.key(:missing).should == :value
+    
+    h[:key].should == :value
+    h[:key, :missing].should == :value
+    
+    h['key'].should == :value
+    h['key', :missing].should == :value
+        
+    h.a.b.c[:d].e('missing').should == 'missing'
+    h.a.b.c[:d][:e, 'missing'].should == 'missing'
+  end
+  
+  it "should build hierarchies of SafeHash" do
+    h = SafeHash.new a: {a: :b}
+    
+    h.a.a.should == :b
+    h.a.missing.b.c('missing').should == 'missing'
+  end
+  
+  it "should require setting if ! used" do
+    h = SafeHash.new a: :v, b: {c: :v}
+    
+    h.a!.should == :v
+    h.b.c!.should == :v
+    h.b!.c!.should == :v
+    
+    lambda{h.j!}.should raise_error(/no key :j/) 
+    lambda{h.j.b.c!}.should raise_error(/no key :c/)
+  end
+  
+  it "should be able to update itself" do
+    h = SafeHash.new 
+    h.b?.should be_false
+    h.merge! a: :a
+    h.a!.should == :a
+  end
+  
+  it "should implement include?" do
+    h = SafeHash.new a: :b
+    h.include?(:a).should be_true
+    h.include?('a').should be_true
+    h.include?(:b).should be_false
+
+    h.b.include?(:a).should be_false
+  end
+  
+  describe "merge" do
+    it "should not override by default" do
+      h = SafeHash.new a: :b
+      lambda{h.merge! a: :c}.should raise_error(/can't override/)            
+    end
+    
+    it "should skip existing if specified" do
+      h = SafeHash.new a: :b
+      h.merge!({a: :c, d: :e}, blank: true)
+      h.a!.should == :b
+      h.d!.should == :e
+    end
+    
+    it "merging hashes should not be countig as overriding" do
+      h = SafeHash.new b: {c: :d}
+      h.merge! b: {e: :f}, override: false
+    end
+    
+    it "should override if specified" do
+      h = SafeHash.new a: {b: :c}
+      h.merge!({a: {b: :c2}}, override: true)
+      h.a!.b!.should == :c2
+    end
+    
+    it "should perform deep merge by default" do
+      h = SafeHash.new a: {b: {c: :d}}
+      h.merge!({a: {b: {c2: :d2}}})
+      h.a!.b!.c?.should be_true
+      h.a!.b!.c2?.should be_true
+    end        
+  end
+  
+  it "merge_if_blank" do
+    h = SafeHash.new a: :b
+    h.merge_if_blank! a: :c, d: :e
+    h.a!.should == :b
+    h.d!.should == :e
+  end
+end