ruby_ext 0.5.9 → 0.5.10

data/lib/ruby_ext/core/must.rb

@@ -40,14 +40,6 @@ class MustAssertions < BasicObject
   end
   alias_method :an, :a
 
-  # def be klass = nil
-  #   if klass.class == Array
-  #     klass.any?{|k| @obj.respond_to :is?, k}
-  #   else
-  #     @obj.respond_to :is?, klass
-  #   end
-  # end
-
   def include o
     @obj.include? o
   end
@@ -184,12 +176,4 @@ Object.class_eval do
   def must_not_be
     must_not.be
   end
-
-  # def must_have
-  #   must.have
-  # end
-  #
-  # def must_not_have
-  #   must_not.have
-  # end
 end

data/lib/ruby_ext/core/nil_class.rb

@@ -1,3 +1,8 @@
 class NilClass
   def blank?; true end
+
+  def to_openobject deep = false
+    OpenObject.new
+  end
+  alias_method :to_oo, :to_openobject
 end

data/lib/ruby_ext/core/object.rb

@@ -9,13 +9,13 @@ Object.class_eval do
     respond_to?(:empty?) ? empty? : !self
   end
 
-  def metaclass &block
-    (class << self; self; end)
-  end
-  def metaclass_eval &block
-    metaclass.class_eval(&block)
-    self
-  end
+  # def metaclass &block
+  #   (class << self; self; end)
+  # end
+  # def metaclass_eval &block
+  #   metaclass.class_eval(&block)
+  #   self
+  # end
 
   def respond_to method, *args
     respond_to?(method) ? send(method, *args) : nil

data/lib/ruby_ext/core/open_object.rb

@@ -126,6 +126,13 @@ class OpenObject < Hash
   # support :extract_options for OpenObject (Rails integration)
   def extractable_options?; true end
 
+  def deep_clone
+    clone = super
+    clone.clear
+    each{|k, v| clone[k.deep_clone] = v.deep_clone}
+    clone
+  end
+
   protected
     def method_missing m, arg = nil, &block
       type = m[-1,1]
@@ -140,29 +147,4 @@ class OpenObject < Hash
         self[m]
       end
     end
-end
-
-
-#
-# Core Extensions
-#
-class NilClass
-  def to_openobject deep = false
-    OpenObject.new
-  end
-  alias_method :to_oo, :to_openobject
-end
-
-class Hash
-  def to_openobject deep = false
-    OpenObject.initialize_from self, deep
-  end
-  alias_method :to_oo, :to_openobject
-
-  alias_method :oo_eql, :==
-  def == other
-    true if self.equal? other
-    other == self if other.is_a? OpenObject
-    oo_eql other
-  end
 end

data/lib/ruby_ext/core/string.rb

@@ -1,4 +1,4 @@
-String.class_eval do
+class String
   def indent spaces = 2
     indent = ' ' * spaces
     gsub /^/, indent
@@ -20,11 +20,6 @@ String.class_eval do
     [self]
   end
 
-  def self.secure_token
-    original = [Time.now, (1..10).map{ rand.to_s }]
-    Digest::SHA1.hexdigest(original.flatten.join('--'))
-  end
-
   def underscore
     word = self.dup
     word.gsub!(/::/, '/')

data/lib/ruby_ext/more.rb

@@ -1,5 +1,7 @@
 require 'ruby_ext/core'
 
+require 'set'
+
 module RubyExt
   %w(Callbacks DeclarativeCache Observable OpenConstructor Tuple).each do |const|
     autoload const, "ruby_ext/more/#{const.underscore}"

data/lib/ruby_ext/more/callbacks.rb

@@ -176,6 +176,22 @@ module RubyExt::Callbacks
     end
   end
 
+  # We need to prevent callback from rinning multiple times if nested
+  # (need this for wrapping methods with callbacks to correctly call super).
+  def run_callbacks_only_once callback_name, data = {}, &block
+    set = Thread.current[callback_name] ||= {}
+    if set.include? object_id
+      block.call if block
+    else
+      begin
+        set[object_id] = true
+        run_callbacks callback_name, data, &block
+      ensure
+        set.delete object_id
+      end
+    end
+  end
+
   module ClassMethods
     inheritable_accessor :callbacks, {}
 
@@ -206,5 +222,26 @@ module RubyExt::Callbacks
       (self.callbacks[callback_name] ||= []) << callback
     end
 
+    def wrap_method_with_callbacks method, callback
+      method_without_callback = :"#{method}_without_#{callback}_of_#{self.alias}"
+      if method_defined? method_without_callback
+        raise "can't wrap method #{method} with #{callback} of #{self.alias} twice!"
+      end
+
+      alias_method method_without_callback, method
+      define_method method do |*args, &block|
+        # We can't use run_callbacks, because in case of the `super`
+        # call it will be runned twice.
+        run_callbacks_only_once callback do
+          send method_without_callback, *args, &block
+        end
+      end
+    end
+
+    def wrap_with_callback callback
+      instance_methods(false).each do |method|
+        wrap_method_with_callbacks method, callback
+      end
+    end
   end
 end

data/lib/ruby_ext/more/declarative_cache.rb

@@ -1,78 +1,67 @@
-require 'monitor'
-
 module RubyExt::DeclarativeCache
-  DISABLED = false
+  class << self
 
-  warn "CASHE DISABLED" if DISABLED
-  unless DISABLED
-    class << self
+    def cache_method klass, *methods
+      methods.each do |method|
+        klass.class_eval do
+          escaped_method = escape_method method
+          method_with_cache    = :"#{escaped_method}_with_cache"
+          method_without_cache = :"#{escaped_method}_without_cache"
+          iv_check = "@#{escaped_method}_cache_check"
+          iv       = "@#{escaped_method}_cache"
 
-      def cache_method klass, *methods
-        methods.each do |method|
-          klass.class_eval do
-            escaped_method = escape_method(method)
-            method_with_cache, method_without_cache = "#{escaped_method}_with_cache".to_sym, "#{escaped_method}_without_cache".to_sym
-            iv_check = "@#{escaped_method}_cache_check"
-            iv = "@#{escaped_method}_cache"
+          alias_method method_without_cache, method
 
-            if instance_methods.include?(method_with_cache) or instance_methods.include?(method_without_cache)
-              warn "can't cache the :#{method} twice!"
-            else
-              alias_method method_without_cache, method
+          define_method method_with_cache do |*args|
+            raise "You tried to use cache without params for method with \
+params (use 'cache_method_with_params' instead)!" unless args.empty?
 
-              define_method method_with_cache do |*args|
-                raise "You tried to use cache without params for method with params (use 'cache_method_with_params' instead)!" unless args.empty?
-                unless cached = instance_variable_get(iv)
-                  unless check = instance_variable_get(iv_check)
-                    cached = send method_without_cache
-                    instance_variable_set iv, cached
-                    instance_variable_set iv_check, true
-                  end
-                end
-                cached
+            unless cached = instance_variable_get(iv)
+              unless check = instance_variable_get(iv_check)
+                cached = send method_without_cache
+                instance_variable_set iv, cached
+                instance_variable_set iv_check, true
               end
-
-              alias_method method, method_with_cache
             end
+            cached
           end
+
+          alias_method method, method_with_cache
         end
       end
+    end
 
-      def cache_method_with_params klass, *methods
-        methods.each do |method|
-          klass.class_eval do
-            escaped_method = escape_method(method)
-            method_with_cache, method_without_cache = "#{escaped_method}_with_cache".to_sym, "#{escaped_method}_without_cache".to_sym
-            iv_check = "@#{escaped_method}_cache_check"
-            iv = "@#{escaped_method}_cache"
-
-            if instance_methods.include?(method_with_cache) or instance_methods.include?(method_without_cache)
-              warn "can't cache the :#{method} twice!"
-            else
-              alias_method method_without_cache, method
-
-              define_method method_with_cache do |*args|
-                unless results = instance_variable_get(iv)
-                  results = Hash.new(NotDefined)
-                  instance_variable_set iv, results
-                end
+    def cache_method_with_params klass, *methods
+      methods.each do |method|
+        klass.class_eval do
+          escaped_method = escape_method method
+          method_with_cache    = :"#{escaped_method}_with_cache"
+          method_without_cache = :"#{escaped_method}_without_cache"
+          iv_check = "@#{escaped_method}_cache_check"
+          iv       = "@#{escaped_method}_cache"
 
-                result = results[args]
+          alias_method method_without_cache, method
 
-                if result.equal? NotDefined
-                  result = send method_without_cache, *args
-                  results[args] = result
-                end
+          define_method method_with_cache do |*args|
+            unless results = instance_variable_get(iv)
+              results = Hash.new(NotDefined)
+              instance_variable_set iv, results
+            end
 
-                result
-              end
+            result = results[args]
 
-              alias_method method, method_with_cache
+            if result.equal? NotDefined
+              result = send method_without_cache, *args
+              results[args] = result
             end
+
+            result
           end
+
+          alias_method method, method_with_cache
         end
       end
-
     end
+
   end
 end

data/lib/yaml_fix.rb

@@ -0,0 +1,9 @@
+require 'yaml'
+
+begin
+  require 'psych'
+  YAML::ENGINE.yamler = 'psych'
+rescue Exception
+  warn "can't load 'psych', the new YAML engine (probably the 'libyaml' is not installed), usng 'sych' a deprecated one, \
+there may be some problems with encoding."
+end

data/spec/core/array_spec.rb

@@ -1,4 +1,4 @@
-require "core/spec_helper"
+require "spec_helper"
 
 describe 'Array' do
   it 'sfilter' do

data/spec/core/deep_clone_spec.rb

@@ -1,6 +1,8 @@
-require "core/spec_helper"
+require "spec_helper"
 
 describe 'deep_clone' do
+  after{remove_constants :Metadata}
+
   it "basic" do
     hash, array = {}, ['value']
     hash['key'] = array
@@ -15,7 +17,7 @@ describe 'deep_clone' do
     array2.object_id.should_not == array.object_id
   end
 
-  it do
+  it 'cloning object tree' do
     class Metadata
       attr_accessor :registry
 

data/spec/core/enumerable.rb

@@ -1,4 +1,4 @@
-require "core/spec_helper"
+require "spec_helper"
 
 describe 'Enumerable' do
   it 'every' do

data/spec/core/module_spec.rb

@@ -1,151 +1,109 @@
-require "core/spec_helper"
+require "spec_helper"
 
 describe "Module" do
-  after do
-    remove_constants %w(
-      A X Y Z
-      InheritableAccessorForModule
-      InheritableAccessorForClass
-      InheritableAccessor
-      InheritableAccessorBase
-      InheritableAccessorA
-      InheritableAccessorB
-    )
-  end
+  after{remove_constants :A, :B, :C, :ABase}
 
-  it "Namespace" do
+  it "namespace" do
     class A
       class B
-        class C
-
-        end
+        class C; end
       end
     end
 
-    File.namespace.should == nil
+    A.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
+  it "alias" do
     class A
       class B
-        class C
-
-        end
+        class C; end
       end
     end
 
+    A::B::C.alias.should == 'C'
     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
+  it "is?" do
+    Fixnum.is?(Numeric).should be_true
   end
 
-  it "each_namespace" do
-    class A
-      class B
-        class C
+  it "escape_method" do
+    Module.escape_method(:">_<_=_?").should == :gt_lt_assign_qst
+  end
 
+  describe "inheritable_accessor" do
+    it "module" do
+      module A
+        module ClassMethods
+          inheritable_accessor :callbacks, [:a]
+          inheritable_accessor :layout, 'a'
         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 B
+        inherit A
+        callbacks << :b
+        self.layout = 'b'
+      end
 
-  class WrapMethod
-    def method_name value
-      10*value
+      B.callbacks.should == [:a, :b]
+      B.layout.should == 'b'
     end
-  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"
+    it "class" do
+      class A
+        class << self
+          inheritable_accessor :callbacks, [:a]
+          inheritable_accessor :layout, 'a'
+        end
+        callbacks << :a2
       end
-    end
 
-    class InheritableAccessorForClass
-      class << self
-        inheritable_accessor :callbacks2, []
-        inheritable_accessor :layout2, "for_class"
+      class B < A
+        callbacks << :b
+        self.layout = 'b'
       end
-      callbacks2 << :set_user
-    end
 
-    class InheritableAccessor < InheritableAccessorForClass
-      inherit InheritableAccessorForModule
-      callbacks << :set_model
-      callbacks2 << :set_model
-      self.layout2 = "anoter_layout"
+      A.callbacks.should == [:a, :a2]
+      B.callbacks.should == [:a, :a2, :b]
+
+      A.layout.should == 'a'
+      B.layout.should == 'b'
     end
 
-    InheritableAccessorForClass.callbacks2.should == [:set_user]
-    InheritableAccessor.callbacks.should == [:set_user, :set_model]
-    InheritableAccessor.callbacks2.should == [:set_user, :set_model]
+    it "should correcly clone attributes (from error)" do
+      module ABase
+        module ClassMethods
+          inheritable_accessor :callbacks, []
+        end
+      end
 
-    InheritableAccessorForClass.layout2.should == "for_class"
-    InheritableAccessor.layout2.should == "anoter_layout"
-    InheritableAccessor.layout.should == "for_module"
-  end
+      class A
+        inherit ABase
+        callbacks << :a
+      end
 
-  it "inheritable_accessor (from error)" do
-    module InheritableAccessorBase
-      module ClassMethods
-        inheritable_accessor :callbacks, []
+      class B
+        inherit ABase
+        callbacks << :b
       end
-    end
 
-    class InheritableAccessorA
-      inherit InheritableAccessorBase
-      callbacks << :a
+      A.callbacks.should == [:a]
+      B.callbacks.should == [:b]
     end
+  end
 
-    class InheritableAccessorB
-      inherit InheritableAccessorBase
-      callbacks << :b
+  it "delegate" do
+    class A
+      attr_accessor :target
+      delegate :a, to: :target
     end
 
-    InheritableAccessorA.callbacks.should == [:a]
-    InheritableAccessorB.callbacks.should == [:b]
+    a = A.new
+    a.target = stub
+    a.target.should_receive(:a).with(:b)
+    a.a :b
   end
 end