ruby-ext 0.2.16 → 0.4.0

data/spec/ruby_ext/declarative_cache_spec.rb

@@ -0,0 +1,115 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+require "ruby_ext/declarative_cache"
+
+describe 'DeclarativeCache' do
+  class CachedClass
+    attr_accessor :value
+    def value_get; @value end
+    cache_method :value_get
+    
+    attr_accessor :value2
+    def value2_get; @value2 end    
+    
+    attr_accessor :params
+    def params_get param; @params[param] end         
+    
+    attr_accessor :multiplier
+    def *(arg)
+      @multiplier * arg
+    end
+    cache_method_with_params '*'
+  end            
+  
+  DeclarativeCache.cache_method CachedClass, :value2_get
+  DeclarativeCache.cache_method_with_params CachedClass, :params_get  
+  
+  it "Simple Cache" do
+    o = CachedClass.new
+    o.value = 0
+    o.value2 = 0    
+    o.value_get.should == 0
+    o.value2_get.should == 0
+    
+    o.value = 1
+    o.value2 = 1
+    o.value_get.should == 0
+    o.value2_get.should == 0
+  end
+  
+  it "clear_cache_method" do
+    o = CachedClass.new
+    o.value = 0
+    o.value_get.should == 0
+
+    o.value = 1
+    o.value_get.should == 0
+
+    o.clear_cache_method
+    o.value_get.should == 1
+  end
+  
+  it "should check for parameters" do
+    o = CachedClass.new
+    lambda{o.value_get(1)}.should raise_error(/cache_method_with_params/)
+  end
+  
+  it "Cache With Params" do
+    o = CachedClass.new
+    o.params = {:a => :b}
+    o.params_get(:a).should == :b
+    o.params = {:a => :c}
+    o.params_get(:a).should == :b
+  end
+  
+  it "should works with operators" do
+    o = CachedClass.new
+    o.multiplier = 2
+    (o * 2).should == 4
+    o.multiplier = 3
+    (o * 2).should == 4
+  end
+  
+  class CachedClass2
+    class << self
+      attr_accessor :value
+      def value_get; @value end
+      cache_method :value_get
+    end
+  end        
+  
+  it "Simple Cache" do
+    CachedClass2.value = 0
+    CachedClass2.value_get.should == 0
+    CachedClass2.value = 1
+    CachedClass2.value_get.should == 0
+  end
+  
+  module CachedModule
+    attr_accessor :value
+    def value_get; @value end
+    cache_method :value_get
+  end
+  
+  class CachedClass3
+    include CachedModule
+  end
+  
+  it "should also works with modules (from error)" do
+    o = CachedClass.new
+    o.value = 0
+    o.value_get.should == 0
+    
+    o.value = 1
+    o.value_get.should == 0
+  end
+  
+  class CachedClass4
+    attr_accessor :value
+    def value_get; @value end    
+  end
+  
+  it "should not allow to cache twice" do
+    CachedClass4.cache_method :value_get
+    lambda{CachedClass4.cache_method :value_get}.should raise_error(/twice/)
+  end
+end

data/spec/ruby_ext/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/ruby_ext/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/ruby_ext/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/ruby_ext/kernel_spec.rb

@@ -0,0 +1,53 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_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 RuntimeError => 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 RuntimeError => 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 RuntimeError => 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/ruby_ext/module_spec.rb

@@ -0,0 +1,128 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+require "ruby_ext/module"
+
+
+describe "Module" do
+  class A
+    class B
+      class C
+        
+      end
+    end
+  end
+  
+  it "Namespace" do
+    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
+    A::B::C.name.should == "A::B::C"
+  end
+  
+  class X; end
+  class Y < X; end
+  class Z < Y; end
+  
+  
+  it "each_ancestor" do
+    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
+    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
+  
+  module M
+    def m_m; end        
+    module ClassMethods
+      def cm_m; end
+    end
+  end            
+  
+  class C
+    inherit M
+  end
+  
+  it "inherit" do
+    C.respond_to?(:cm_m).should be_true
+    C.new.respond_to?(:m_m).should be_true        
+  end
+  
+  module M2
+    include M
+    
+    module ClassMethods
+      def cm2_m; end
+    end
+  end
+  
+  class D
+    inherit M2
+  end
+  
+  it "should inherit all ancestors class methods" do
+    D.respond_to?(:cm_m).should be_true
+    D.respond_to?(:cm2_m).should be_true
+    D.new.respond_to?(:m_m).should be_true
+  end
+  
+  class C2
+    inherit M
+  end
+  
+  it "Shouldn't redefine ancestors class methods" do
+    C2.respond_to?(:cm2_m).should be_false
+  end
+  
+  it "inherited_instance_methods" do
+    im = Set.instance_methods - Set.inherited_instance_methods
+    im.should include("union")
+    im.should_not include("object_id")
+  end
+  
+  it "escape_method" do
+    Object.escape_method("><=?")
+  end
+end

data/spec/ruby_ext/must_spec.rb

@@ -0,0 +1,23 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+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
+      "".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
+end

data/spec/ruby_ext/observable2_spec.rb

@@ -0,0 +1,42 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_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/ruby_ext/open_constructor_spec.rb

@@ -0,0 +1,36 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_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/{prepare_arguments_spec.rb → ruby_ext/prepare_arguments_spec.rb}

@@ -1,9 +1,5 @@
-require 'spec'
-
-dir = File.dirname __FILE__
-require "#{dir}/spec_require"
-require "#{dir}/../lib/ruby_ext/should"
-require "#{dir}/../lib/ruby_ext/prepare_arguments"
+require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+require "ruby_ext/prepare_arguments"
 
 describe "Prepare Arguments" do
   

data/spec/ruby_ext/should_spec.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_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/ruby_ext/synchronize_spec.rb

@@ -0,0 +1,80 @@
+require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+require "ruby_ext/synchronize"
+
+describe "Synchronize" do
+  it "synchronize_method" do
+    class SAccount
+      attr_reader :from, :to
+      
+      def initialize
+        super
+        @from, @to = 0, 0
+      end
+      
+      def transfer
+        @from -= 1
+        @to += 1
+      end
+      synchronize_method :transfer
+    end
+    
+    a, threads = SAccount.new, []
+    100.times do 
+      t = Thread.new do
+        100.times{a.transfer}
+      end
+      threads << t
+    end        
+    threads.each{|t| t.join}
+    
+    a.from.should == -10_000
+    a.to.should == 10_000
+  end
+  
+  it "synchronize_all_methods" do
+    class SAccount2
+      attr_reader :from, :to
+      
+      def initialize
+        super
+        @from, @to = 0, 0
+      end
+      
+      def transfer
+        @from -= 1
+        @to += 1
+      end
+      synchronize_all_methods
+    end
+    
+    a, threads = SAccount2.new, []
+    100.times do 
+      t = Thread.new do
+        100.times{a.transfer}
+      end
+      threads << t
+    end        
+    threads.each{|t| t.join}
+    
+    a.from.should == -10_000
+    a.to.should == 10_000
+  end
+  
+  it "singleton" do
+    class SAccount3                
+      class << self
+        def a; end
+        synchronize_method :a
+      end        
+    end
+    SAccount3.a
+  end
+  
+  it "shouldn't allow to synchronize twice" do
+    class SAccount4
+      def a; end        
+    end
+    SAccount4.synchronize_method :a
+    lambda{SAccount4.synchronize_method :a}.should raise_error(/twice/)
+  end
+end

data/spec/ruby_ext_spec_helper.rb

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

data/spec/vresource/class_loader_spec.rb

@@ -0,0 +1,101 @@
+require "#{File.dirname __FILE__}/../vresource_spec_helper"
+require "vresource/class_loader"
+
+describe "ClassLoader" do  
+  ClassLoader = VResource::ClassLoader
+  
+  before :all do
+    @original_dir = "#{File.dirname(__FILE__)}/class_loader_spec_data"
+    @dir = "#{File.dirname(__FILE__)}/class_loader_spec"
+    
+    FileUtils.rm_r @dir if File.exist? @dir
+    FileUtils.cp_r @original_dir, @dir
+    
+    @provider = VResource::FileSystemProvider.new(@dir)
+    VResource.add_resource_provider @provider
+    VResource.hook!
+  end
+  
+  after :all do
+    VResource.unhook!
+    FileUtils.rm_r @dir if File.exist? @dir
+    [:LoadCount, :ModuleA, :ScopeA].each{|c| Object.send :remove_const, c if Object.const_defined? c}    
+  end
+
+  it "should load classes only one time" do
+    class CustomObserver
+      attr_reader :list
+      def initialize
+        @list = []
+      end
+      
+      def update_class klass
+        @list << klass
+      end
+    end
+    obs = CustomObserver.new
+    ClassLoader.add_observer obs
+    
+    ::LoadCount
+    ::LoadCount
+    ClassLoader.delete_observers
+    
+    obs.list.inject(0){|count, klass| klass == ::LoadCount ? count + 1 : count}.should == 1
+  end
+  
+  it "should load classes from multiple directories"
+  
+  it "class should have the same name as package" do
+    ::ModuleA::SameName
+    ::ModuleA::SameName::SomeClass
+  end
+  
+  it "infinity loop" do
+    lambda{ModuleA::InfinityLoop}.should raise_error(/Class Name .+ doesn't correspond to File Name/)
+  end
+  
+  it "core" do
+    ::ModuleA::ModuleB::ClassC.new
+  end
+  
+  module ::ModuleA
+    class << self
+      def anonymous
+        ClassInsideAnonymousClass
+      end
+    end
+  end
+  
+  it "Should works inside Anonymous Class" do
+    ::ModuleA.anonymous
+  end
+  
+  it "should raise exception if class isn't defined in scope" do
+    ::ScopeA::ScopeA1
+    ClassLoader.error_on_defined_constant = true
+    lambda{::ScopeA::ScopeB1}.should raise_error(/Class '.+' is not defined in the '.+' Namespace!/)
+  end
+
+  it "Class Reloading" do
+    fname = "#{@dir}/ModuleA/ClassReloading.rb"
+    File.write fname, %{\
+class ClassReloading
+def test
+  1
+end
+end}
+
+    test = ::ModuleA::ClassReloading.new
+    test.test.should == 1
+
+    File.write fname, %{\
+class ClassReloading
+def test
+  2
+end
+end}
+
+    ClassLoader.reload_class(::ModuleA::ClassReloading.name)
+    test.test.should == 2
+  end
+end

data/spec/vresource/class_loader_spec_data/ClassA.rb

@@ -0,0 +1,4 @@
+class ClassA
+  
+end
+# Do not delete this comment on last line! It's the Test!

data/{old/spec/RubyExt/ForClassLoader → spec/vresource/class_loader_spec_data}/ModuleA/ClassInsideAnonymousClass.rb

@@ -1,3 +1,3 @@
 class ClassInsideAnonymousClass
-	
+  
 end

data/{old/spec/RubyExt/ForClassLoader → spec/vresource/class_loader_spec_data}/ModuleA/InfinityLoop.rb

@@ -1,3 +1,3 @@
 class InvalidInfinityLoopName
-	
+  
 end

data/spec/vresource/class_loader_spec_data/ModuleA/ModuleB/ClassC.rb

@@ -0,0 +1,3 @@
+class ClassC
+  ClassB
+end