ruby_ext 0.4.6

data/spec/deep_clone_spec.rb

@@ -0,0 +1,37 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/deep_clone"
+
+describe 'deep_clone' do
+  it "basic" do
+    hash, array = {}, ['value']
+    hash['key'] = array
+    
+    hash2 = hash.deep_clone
+    array2 = hash2['key']
+    
+    hash2.should == hash
+    hash2.object_id.should_not == hash.object_id
+    
+    array2.should == array
+    array2.object_id.should_not == array.object_id
+  end
+  
+  it do
+    class Metadata
+      attr_accessor :registry
+    
+      def initialize
+        @registry = {}
+      end
+    end
+    
+    m = Metadata.new
+    m.registry[:a] = 1
+    
+    m2 = m.deep_clone
+    m2.registry.should include(:a)
+    m2.registry[:b] = 2
+    
+    m.registry.should == {:a => 1}
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,20 @@
+require 'spec'
+require 'spec_ext'
+
+ruby_ext_dir = File.expand_path("#{File.dirname(__FILE__)}/../..")
+$LOAD_PATH << "#{ruby_ext_dir}/lib"
+
+%w{
+  file
+  kernel 
+  open_object
+  module
+  not_defined
+  object
+  class
+  string
+  symbol
+  extra_blank_slate
+  must
+  deep_clone  
+}.each{|f| require "ruby_ext/#{f}"}

data/spec/kernel_spec/TheNamespace/ClassA.rb

@@ -0,0 +1,7 @@
+module TheNamespace
+  class ClassA
+    def self.problem_method
+      raise_without_self "Some problem"
+    end
+  end
+end

data/spec/kernel_spec/another_class.rb

@@ -0,0 +1,5 @@
+class AnotherClass
+  def self.exclude_multiple_classes
+    TheNamespace::ClassB.exclude_multiple_classes
+  end
+end

data/spec/kernel_spec/the_namespace/class_b.rb

@@ -0,0 +1,11 @@
+module TheNamespace
+  class ClassB
+    def self.problem_method
+      raise_without_self "Some problem" 
+    end
+    
+    def self.exclude_multiple_classes
+      raise_without_self "Some problem", AnotherClass
+    end
+  end
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,53 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/kernel"
+
+describe 'Kernel' do
+  class Respond
+    def test; 2 end
+  end
+  
+  after :all do
+    [:TheNamespace, :AnotherClass].each{|c| Object.send :remove_const, c if Object.const_defined? c}
+  end
+
+  it "respond_to" do
+    r = Respond.new
+    r.respond_to(:not_exist).should be_nil
+    r.respond_to(:test).should == 2
+  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"
+    
+    begin
+      TheNamespace::ClassA.problem_method
+    rescue StandardError => e
+      e.message.should =~ /Some problem/
+      stack = e.backtrace
+      stack.any?{|line| line =~ /ClassA/}.should be_false
+      stack.any?{|line| line =~ /kernel_spec/}.should be_true
+    end
+
+    begin
+      TheNamespace::ClassB.problem_method
+    rescue StandardError => e
+      e.message.should =~ /Some problem/
+      stack = e.backtrace
+      stack.any?{|line| line =~ /class_b/}.should be_false
+      stack.any?{|line| line =~ /kernel_spec/}.should be_true
+    end    
+    
+    begin
+      AnotherClass.exclude_multiple_classes
+    rescue StandardError => e
+      e.message.should =~ /Some problem/
+      stack = e.backtrace
+      stack.any?{|line| line =~ /class_b/}.should be_false
+      stack.any?{|line| line =~ /another_class/}.should be_false
+      stack.any?{|line| line =~ /kernel_spec/}.should be_true
+    end
+  end
+end

data/spec/module_spec.rb

@@ -0,0 +1,160 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/module"
+require 'ruby_ext/multiple_inheritance'
+
+describe "Module" do
+  after :each do
+    remove_constants %w(
+      A X Y Z
+      InheritableAccessorForModule
+      InheritableAccessorForClass
+      InheritableAccessor
+      InheritableAccessorBase
+      InheritableAccessorA
+      InheritableAccessorB
+    )
+  end
+  
+  it "Namespace" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
+    File.namespace.should == nil
+    A::B::C.namespace.should == A::B
+  end
+  
+  # class AnonymousClass
+  #   class << self
+  #     def anonymous_name
+  #       self.name
+  #     end
+  #   end
+  # end  
+  
+  it "name" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
+    A::B::C.name.should == "A::B::C"
+  end
+  
+  it "each_ancestor" do
+    class X; end
+    class Y < X; end
+    class Z < Y; end
+    
+    list = []
+    Z.each_ancestor{|a| list << a}
+    list.should include Y
+    list.should include X
+    list.should_not include Z
+    list.should_not include Object
+    list.should_not include Kernel
+    
+    list = []
+    Z.each_ancestor(true){|a| list << a}
+    list.should include Y
+    list.should include X
+    list.should_not include Z
+    list.should include Object
+    list.should include Kernel
+  end
+  
+  it "each_namespace" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
+    list = []
+    A::B::C.each_namespace{|n| list << n}
+    list.should == [A::B, A]
+  end
+  
+  it "is?" do
+    File.is?(IO).should be_true
+  end
+  
+  class WrapMethod
+    def method_name value
+      10*value
+    end
+  end
+  
+  it "wrap_method" do
+    WrapMethod.wrap_method :method_name do |old, value|
+      send(old, value)*value
+    end
+    WrapMethod.new.method_name(10).should == 1000
+  end  
+  
+  it "escape_method" do
+    Object.escape_method("><=?")
+  end
+  
+  it "inheritable_accessor" do
+    module InheritableAccessorForModule
+      module ClassMethods
+        inheritable_accessor :callbacks, [:set_user]
+        inheritable_accessor :layout, "for_module"
+      end
+    end
+    
+    class InheritableAccessorForClass
+      class << self
+        inheritable_accessor :callbacks2, []      
+        inheritable_accessor :layout2, "for_class"  
+      end
+      callbacks2 << :set_user      
+    end
+    
+    class InheritableAccessor < InheritableAccessorForClass
+      inherit InheritableAccessorForModule
+      callbacks << :set_model
+      callbacks2 << :set_model     
+      self.layout2 = "anoter_layout" 
+    end    
+    
+    InheritableAccessorForClass.callbacks2.should == [:set_user]
+    InheritableAccessor.callbacks.should == [:set_user, :set_model]
+    InheritableAccessor.callbacks2.should == [:set_user, :set_model]
+    
+    InheritableAccessorForClass.layout2.should == "for_class"
+    InheritableAccessor.layout2.should == "anoter_layout"
+    InheritableAccessor.layout.should == "for_module"
+  end
+  
+  it "inheritable_accessor (from error)" do
+    module InheritableAccessorBase
+      module ClassMethods
+        inheritable_accessor :callbacks, []
+      end
+    end
+    
+    class InheritableAccessorA
+      inherit InheritableAccessorBase
+      callbacks << :a
+    end
+    
+    class InheritableAccessorB
+      inherit InheritableAccessorBase
+      callbacks << :b
+    end
+    
+    InheritableAccessorA.callbacks.should == [:a]
+    InheritableAccessorB.callbacks.should == [:b]
+  end
+end

data/spec/multiple_inheritance_spec.rb

@@ -0,0 +1,131 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/multiple_inheritance"
+
+describe "Multiple Inheritance" do
+  after :each do
+    remove_constants %w(M A M2 B AddedAfterInheritance)
+  end
+
+  it "showcase" do
+    module M
+      def instance_method; end
+
+      class_methods do
+        def class_method; end
+      end
+
+      def self.inherited target      
+        target.send :attr_accessor, :some_accessor
+      end
+    end     
+           
+    M.should respond_to(:class_method)
+
+    class A
+      inherit M
+    end
+    
+    A.should respond_to(:class_method)
+    A.new.should respond_to(:instance_method)
+    A.new.should respond_to(:some_accessor)
+    
+    M.directly_included_by.should == [A].to_set    
+  end  
+
+  it "should inherit all ancestors class methods" do
+    module M
+      def instance_method; end
+
+      class_methods do        
+        def class_method; end
+      end
+    end
+    
+    module M2
+      inherit M
+
+      class_methods do
+        def class_method2; end
+      end
+    end
+
+    class B
+      inherit M2
+    end
+    
+    M2.should respond_to(:class_method)
+    
+    B.should respond_to(:class_method)
+    B.should respond_to(:class_method2)
+    B.new.should respond_to(:instance_method)
+    
+    M.directly_included_by.should == [M2].to_set
+    M2.directly_included_by.should == [B].to_set
+  end
+  
+  it "shouldn't redefine ancestors class methods" do
+    module M
+      class_methods do
+        def class_method; end
+      end
+    end
+    
+    module M2
+      inherit M
+
+      class_methods do
+        def class_method2; end
+      end
+    end
+    
+    class A
+      inherit M
+    end
+    
+    A.should_not respond_to(:class_method2)
+  end
+  
+  it "should also allow to explicitly use ClassMethods prototype (from error)" do
+    module A
+      module ClassMethods
+        attr_accessor :callbacks
+      end
+    end
+    
+    class B
+      inherit A
+    end
+    
+    B.should respond_to(:callbacks)
+  end
+  
+  it "methods defined on base class after inheritance must be propagated to all descendants" do
+    module M; end            
+    
+    class A
+      inherit M
+    end
+    
+    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')
+  end
+  
+  it "modules included in base class after inheritance must be propagated to all descendants" do
+    module M; end
+    
+    class A
+      inherit M
+    end
+    
+    module AddedAfterInheritance
+      def module_added_after_inheritance; end
+    end
+    
+    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')
+  end
+end

data/spec/must_spec.rb

@@ -0,0 +1,29 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/array"
+require "ruby_ext/must"
+
+describe 'Assert' do
+  it 'must & must_not' do
+      lambda{must_be.never_called}.should raise_error(/ever/)
+      lambda{nil.must_not_be.nil}.should raise_error(/nil/)
+      1.must_not_be.nil
+      1.must_be.== 1
+      lambda{1.must_be.== 2}.should raise_error(%r{==})
+      1.must_be.in 1, 2
+      0.must_be.in 0..1
+      "".must_be.a String
+      1.must_be.< 2
+  end   
+  
+  it 'must_be & must_not_be' do
+    [].must_be.empty    
+    [''].must_not_be.empty
+    
+    lambda{[''].must_be.empty}.should raise_error(/must be/)
+    lambda{[].must_not_be.empty}.should raise_error(/must not be/)
+  end
+  
+  it "should return result" do
+    [].must_be.empty.should == []
+  end
+end

data/spec/observable2_spec.rb

@@ -0,0 +1,42 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/observable2"
+
+describe "Observable" do
+  class AnObservable
+    include Observable2
+  end
+  
+  it "Method without Parameters" do
+    mock = mock("Observer")
+    obs = AnObservable.new
+    obs.add_observer mock
+    mock.should_receive(:update).with(2)
+    obs.notify_observers :update, 2      
+  end
+  
+#      it "Method without Parameters" do
+#        mock = mock("Observer")
+#        obs = AnObservable.new
+#        obs.add_observer(mock, :method => :custom_update, :filter => lambda{|o| o == 2})
+#        mock.should_receive(:custom_update).with(2)
+#        obs.notify_observers 2
+#        obs.notify_observers 4
+#      end
+#      
+#      it "With Block" do
+#        mock = mock("Observer")
+#        mock.should_receive(:got)
+#        obs = AnObservable.new
+#        obs.add_observer{mock.got}
+#        obs.notify_observers
+#      end
+#      
+#      it "With Block and Filter" do
+#        mock = mock("Observer")
+#        obs = AnObservable.new
+#        obs.add_observer(:filter => lambda{|o| o == 2}){|o| mock.got o}
+#        mock.should_receive(:got).with(2)
+#        obs.notify_observers 2
+#        obs.notify_observers 4                  
+#      end
+end

data/spec/open_constructor_spec.rb

@@ -0,0 +1,36 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/open_constructor"
+
+describe 'OpenConstructor' do
+  class Test
+    include OpenConstructor
+    attr_accessor :name, :value
+  end
+
+  it 'should initialize atributes from Hash' do
+    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')
+    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')
+    t2 = Test.new.set t, [:name]
+    [t2.name, t2.value].should == ['name', nil]
+    
+    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'}
+    t = Test.new.set h
+    t.to_hash.should == h
+  end
+end

data/spec/open_object_spec.rb

@@ -0,0 +1,29 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/array"
+
+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_not == {:a => :c}
+  end
+  
+  it "must be hash (from error)" do
+    {}.to_openobject.is_a?(Hash).should be_true
+  end
+  
+  it 'merge! should be indifferent to string and symbol' do
+    oo = OpenObject.new
+    oo.merge! :a => true
+    oo.a.should be_true
+    oo.merge! 'b' => true    
+    oo.b.should be_true
+  end
+end

data/spec/prepare_arguments_spec.rb

@@ -0,0 +1,46 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/prepare_arguments"
+
+describe "Prepare Arguments" do
+  
+  it "basic parsing" do
+    ArgumentsParser.register :m, [:object, :array, :hash]
+    ArgumentsParser.parse_arguments_for(:m, :o, 1).should == [:o, [1], {}]
+  end
+  
+  it "basic method wrapping" do
+    class BMWTest
+      def add content, options
+        :ok
+      end
+      prepare_arguments_for :add, {:type => :object, :required => true}, :hash
+    end
+    
+    BMWTest.new.add('text').should == :ok
+  end
+  
+  it "except_last_hash for array" do
+    ArgumentsParser.register :m, [{:type => :array, :range => :except_last_hash}, :hash]
+    ArgumentsParser.parse_arguments_for(:m, 1, 2, 3, :a => :b).should == [[1, 2, 3], {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, :a => :b).should == [[], {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, 1, 2, 3).should == [[1, 2, 3], {}]
+  end
+  
+  it "except_last_hash for object" do
+    ArgumentsParser.register :m, [{:type => :object, :range => :except_last_hash}, :hash]
+    ArgumentsParser.parse_arguments_for(:m, 1, :a => :b).should == [1, {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, :a => :b).should == [nil, {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, 1).should == [1, {}]
+  end
+  
+  it "default value" do
+    ArgumentsParser.register :m, [{:type => :object, :default => ""}]
+    ArgumentsParser.parse_arguments_for(:m).should == [""]
+  end
+  
+  it "string" do
+    ArgumentsParser.register :m, [:string]
+    ArgumentsParser.parse_arguments_for(:m).should == [""]
+  end
+  
+end

data/spec/should_spec.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/should"
+
+describe 'Assert' do
+  it 'should! & should_not!' do
+    lambda{should! :be_never_called}.should raise_error(/ever/)
+    lambda{nil.should_not! :be_nil}.should raise_error(/nil/)
+    1.should_not! :be_nil
+    1.should! :==, 1
+    lambda{1.should! :==, 2}.should raise_error(%r{==})
+    1.should! :be_in, [1, 2]
+    "".should! :be_a, String
+    String.should! :be, String      
+    1.should! :<, 2
+  end    
+  
+  it 'should_be! & should_not_be!' do
+    [].should_be! :empty
+    [''].should_not_be! :empty
+    
+    lambda{[''].should_be! :empty}.should raise_error(/should be/)
+    lambda{[].should_not_be! :empty}.should raise_error(/should not be/)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--reverse