ruby_ext 0.4.25 → 0.5.1

data/lib/ruby_ext/more/callbacks.rb

@@ -0,0 +1,172 @@
+module RubyExt::Callbacks
+  class AbstractCallback
+    attr_accessor :terminator
+    
+    attr_reader :executor
+    def executor= executor      
+      @executor = executor.must_be.a Symbol, Proc
+    end
+    
+    attr_reader :conditions
+    def conditions= conditions
+      @conditions = {}
+      conditions.each do |k, v|
+        @conditions[k.to_sym] = if v.is_a? Symbol
+          v.to_s
+        elsif v.is_a? Array
+          v.collect{|e| e.to_s}
+        else
+          v
+        end
+      end
+      @conditions
+    end
+  
+    def terminate? target, result
+      unless terminator.nil?
+        if terminator.is_a? Proc
+          terminator.call target, result
+        else
+          result == terminator
+        end
+      else
+        false
+      end
+    end
+  
+    def run? target, inf
+      if cond = conditions[:if]
+        evaluate_if(cond, target, inf)
+      elsif cond = conditions[:unless]
+        !evaluate_if(cond, target, inf)
+      elsif cond = conditions[:only]
+        evaluate_only(cond, inf)
+      elsif cond = conditions[:except]
+        !evaluate_only(cond, inf)
+      else
+        true
+      end
+    end
+  
+    def add_to_chain target, inf, &the_next
+      if run? target, inf
+        build_block target, &the_next
+      else
+        the_next
+      end         
+    end
+    
+    alias_method :deep_clone, :clone
+    
+    protected
+      def evaluate_if cond, target, inf
+        if cond.is_a? String
+          target.send cond
+        elsif cond.is_a? Proc
+          cond.call target, inf
+        else
+          must_be.never_called
+        end
+      end
+    
+      def evaluate_only cond, inf
+        method = inf[:method].to_s
+        if cond.is_a? String
+          cond == method
+        elsif cond.is_a? Array
+          cond.include? method
+        end
+      end
+  end
+
+  class BeforeCallback < AbstractCallback    
+    def build_block target, &the_next
+      lambda do        
+        result = if executor.is_a? Symbol
+          target.send executor
+        elsif executor.is_a? Proc
+          executor.call target
+        else          
+          must_be.never_called
+        end
+
+        the_next.call unless terminate? target, result
+      end
+    end
+  end
+
+  class AroundCallback < AbstractCallback
+    def build_block target, &the_next
+      lambda do
+        if executor.is_a? Symbol
+          target.send executor, &the_next
+        elsif executor.is_a? Proc
+          executor.call target, the_next
+        else
+          must_be.never_called
+        end
+      end      
+    end
+  end
+
+  class AfterCallback < AbstractCallback
+    def build_block target, &the_next
+      lambda do
+        result = if executor.is_a? Symbol
+          target.send executor
+        elsif executor.is_a? Proc
+          executor.call target
+        else
+          must_be.never_called
+        end
+      
+        the_next.call unless terminate? target, result
+      end      
+    end
+  end
+
+  def run_callbacks callback_name, additional_information = {}, &block
+    callback_name = callback_name.to_s
+    block.must_be.defined
+  
+    callbacks = self.class.callbacks[callback_name]
+    chain_head = block
+    if callbacks and !callbacks.empty?
+      callbacks.reverse_each do |callback|
+        block = callback.add_to_chain self, additional_information, &chain_head
+        chain_head = block if block
+      end
+    end
+    chain_head.call
+  end
+
+  module ClassMethods
+    inheritable_accessor :callbacks, {}
+  
+    def set_callback callback_name, type, *executor_or_options, &block         
+      # parsing arguments
+      type, callback_name = type.to_s, callback_name.to_s
+      opt = executor_or_options.extract_options!        
+      "You can't provide both method name and block for filter!" if block and !executor_or_options.empty?
+      executor = block || executor_or_options.first
+    
+      type.must_be.in %w{before around after}
+      executor.must_be.defined
+      
+      # creating callback
+      callback = case type
+      when 'before' then BeforeCallback.new
+      when 'around' then AroundCallback.new
+      when 'after' then AfterCallback.new
+      end            
+
+      callback.executor = executor
+      callback.terminator = opt.delete :terminator
+      callback.conditions = opt
+    
+      callbacks[callback_name] ||= []
+      callbacks[callback_name] << callback
+    end
+      
+  end
+end

data/lib/ruby_ext/more/declarative_cache.rb

@@ -4,27 +4,25 @@ Module.class_eval do
   def cache_method *methods
     DeclarativeCache.cache_method self, *methods
   end
-  
+
   def cache_method_with_params *methods
     DeclarativeCache.cache_method_with_params self, *methods
-  end  
-end
-
-class Object
-  def clear_cache
-    instance_variables.each do |iv|
-      remove_instance_variable iv if iv =~ /_cache$/ or iv =~ /_cache_check$/
+  end
+  
+  def clear_cache obj
+    obj.instance_variables.each do |iv|
+      obj.send :remove_instance_variable, iv if iv =~ /_cache$/ or iv =~ /_cache_check$/
     end
   end
 end
 
-module DeclarativeCache    
+module DeclarativeCache
   DISABLED = false
 
   warn "CASHE DISABLED" if DISABLED
-  unless DISABLED    
+  unless DISABLED
     class << self
-                
+
       def cache_method klass, *methods
         methods.each do |method|
           klass.class_eval do
@@ -32,9 +30,9 @@ module DeclarativeCache
             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!" 
+              warn "can't cache the :#{method} twice!"
             else
               alias_method method_without_cache, method
 
@@ -55,21 +53,21 @@ module DeclarativeCache
           end
         end
       end
-      
-      def cache_method_with_params klass, *methods        
-        methods.each do |method|  
-          klass.class_eval do      
+
+      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!" 
+              warn "can't cache the :#{method} twice!"
             else
               alias_method method_without_cache, method
 
-              define_method method_with_cache do |*args| 
+              define_method method_with_cache do |*args|
                 unless results = instance_variable_get(iv)
                   results = Hash.new(NotDefined)
                   instance_variable_set iv, results
@@ -77,7 +75,7 @@ module DeclarativeCache
 
                 result = results[args]
 
-                if result.equal? NotDefined 
+                if result.equal? NotDefined
                   result = send method_without_cache, *args
                   results[args] = result
                 end
@@ -90,7 +88,7 @@ module DeclarativeCache
           end
         end
       end
-      
+
     end
   end
 end

data/lib/ruby_ext/more/miscellaneous.rb

@@ -1,52 +1,7 @@
 Kernel.class_eval do
   alias_method :old_p, :p
-  def p *args    
+  def p *args
     puts args.collect{|a| a.inspect}.join(' ')
     return *args
   end
-end
-
-
-# 
-# Parsing command line
-# 
-module RubyExt
-  def self.argv input = ARGV
-    # don't want to modify original input and can't use :clone (it may be not an array)
-    input = input.collect{|v| v}
-    
-    list, options = [], {}    
-    until input.empty? do
-      arg = input.shift.strip
-      if arg =~ /.+:$/ and !input.empty?
-        k = arg[0..-2].to_sym
-        v = input.shift
-        v = v.sub(/\s*,$/, '') if v
-        options[k] = simple_cast(v)
-      else
-        v = arg.gsub(/^['"]|['"]$/, '')
-        v = v.sub(/\s*,$/, '')
-        list << simple_cast(v)
-      end
-    end
-    list << options
-    list
-  end
-  
-  protected
-    def self.simple_cast v
-      if v =~ /^:[a-z_0-9]+$/i
-        v[1..-1].to_sym
-      elsif v =~ /^[0-9]+$/
-        v.to_i
-      elsif v =~ /^[0-9]*\.[0-9]+$/
-        v.to_f
-      elsif v =~ /^\/.+\/$/
-        Regexp.new v[1..-2]
-      elsif v == 'nil'
-        nil
-      else
-        v
-      end
-    end
 end

data/lib/ruby_ext/more/{observable2.rb → observable.rb}

@@ -1,22 +1,22 @@
-module Observable2
+module RubyExt::Observable
   def add_observer observer
     @observable_observers ||= []
-    @observable_observers << observer unless @observable_observers.include? observer      
+    @observable_observers << observer unless @observable_observers.include? observer
   end
-  
+
   def notify_observers method, *args
     raise "Invalid usage, method must be Symbol or String!" unless method.is_a?(Symbol) or method.is_a?(String)
-    @observable_observers.each{|observer| observer.respond_to method, *args} if @observable_observers      
+    @observable_observers.each{|observer| observer.respond_to method, *args} if @observable_observers
   end
-  
+
   def delete_observer observer
     @observable_observers.delete observer if @observable_observers
   end
-  
-  def delete_observers      
+
+  def delete_observers
     @observable_observers.clear if @observable_observers
   end
-  
+
   def observers_count
     @observable_observers ? @observable_observers.size : 0
   end

data/lib/ruby_ext/more/open_constructor.rb

@@ -1,8 +1,8 @@
-module OpenConstructor
+module RubyExt::OpenConstructor
   def set values, list = nil
     unless list
       if values.is_a? Hash
-        values.each do |k, v|          
+        values.each do |k, v|
           self.respond_to "#{k}=", v
         end
       else
@@ -15,32 +15,32 @@ module OpenConstructor
       end
     else
       if values.is_a? Hash
-        values.each do |k, v|          
+        values.each do |k, v|
           self.respond_to "#{k}=", v if list.include? k
         end
       else
         values.instance_variables.each do |name|
           accessor = name[1..name.size]
-          if list.include?(accessor.to_sym) 
+          if list.include?(accessor.to_sym)
             accessor = "#{accessor}="
             if self.respond_to?(accessor)
               self.send accessor, values.instance_variable_get(name)
             end
           end
         end
-      end            
+      end
     end
-    return self    
-  end 
-  
+    return self
+  end
+
   def set! values
     values.each do |k, v|
-      self.send "#{k}=", v      
+      self.send "#{k}=", v
     end
     return self
   end
   # alias_method :set! #, :set_with_check
-  
+
   def to_hash
     hash = {}
     instance_variables.each do |name|

data/lib/ruby_ext/more/tuple.rb

@@ -1,6 +1,6 @@
 class Tuple
   attr_accessor :first, :last
-  
+
   def initialize first = nil, last = nil
     @first, @last = first, last
   end

data/lib/ruby_ext/more.rb

@@ -1,10 +1,12 @@
 require 'ruby_ext/core'
 
+module RubyExt; end
+
 %w(
   declarative_cache
-  observable2
+  observable
   open_constructor
-  synchronize
   tuple
-  miscellaneous
+  callbacks
+  miscellaneous  
 ).each{|f| require "ruby_ext/more/#{f}"}

data/lib/ruby_ext.rb

@@ -1,4 +1 @@
-module RubyExt
-end
-
 require "ruby_ext/more"

data/lib/yaml_fix.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 
-begin  
-  require 'psych'   
+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, \

data/readme.md

@@ -1,55 +1,56 @@
-# Ruby extensions
-**ruby_ext** is a collection of various utility classes and standard library extensions for the Ruby language.
+Collection of various utility classes and standard library extensions for Ruby language.
 
 ## must - assertion tool, kind of RSpec assertions in runtime code
 
-    1.must_be.in 1..2
-    "a".must_be.in 'a', 'b', 'c'
-    key.must_be.a String
-    value.must_not_be.nil
-    must_be.never_called  
-    a.must_be == b
+``` ruby
+1.must_be.in 1..2
+"a".must_be.in 'a', 'b', 'c'
+key.must_be.a String
+value.must_not_be.nil
+must_be.never_called
+a.must_be == b
+```
 
 ## inherit - combines include & extend in one
 Do you remember this *def self.included(base) ... end* hack? You don't need it anymore.
 
-    module Feature
-      def cool_method; end        
-      class_methods do
-        def cool_class_method; end
-      end
-    end            
-  
-    class TheClass
-      inherit Feature
-    end
-  
-    TheClass.new.cool_method
-    TheClass.cool_class_method  
-  
-## cache_method & synchronize_method
-
-    def complex_calculation
-      2 * 2
-    end
-    cache_method :complex_calculation
-
-    def money_transfer amount
-      @from -= amount
-      @to += amount
-    end
-    synchronize_method :money_transfer
+``` ruby
+module Feature
+  def cool_method; end
+  class_methods do
+    def cool_class_method; end
+  end
+end
+
+class TheClass
+  inherit Feature
+end
+
+TheClass.new.cool_method
+TheClass.cool_class_method
+```
+
+## cache_method
+
+``` ruby
+def complex_calculation
+  2 * 2
+end
+cache_method :complex_calculation
+```
 
 ## OpenConstructor - adds mass assignment to any class
-  
-    class TheClass
-      include OpenConstructor
-      attr_accessor :a, :b
-    end
 
-    o = TheClass.new.set a: 'a', b: 'b'
-    o.a => 'a'
-    o.to_hash => {a: 'a', b: 'b'}
+``` ruby
+class TheClass
+  include RubyExt::OpenConstructor
+  attr_accessor :a, :b
+end
+
+o = TheClass.new.set a: 'a', b: 'b'
+o.a => 'a'
+o.to_hash => {a: 'a', b: 'b'}
+```
 
 ## More
 
@@ -57,14 +58,14 @@ These are just a small part of all handy methods and extensions, for more detail
 
 # Usage
 
-    $ sudo gem install ruby_ext
-  
-    require 'ruby_ext'
-
-Copyright (c) Alexey Petrushin, http://petrush.in, released under the MIT license.
+``` bash
+gem install ruby_ext
+```
 
-# TODO
+``` ruby
+require 'ruby_ext'
+```
 
-- config.development{} should raise 'invalid usage'
+## License
 
-[ioc]: http://en.wikipedia.org/wiki/Inversion_of_control
+Copyright (c) Alexey Petrushin, http://petrush.in, released under the MIT license.

data/spec/core/deep_clone_spec.rb

@@ -4,33 +4,33 @@ 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