ruby_ext 0.4.11 → 0.4.12

data/lib/ruby_ext/gems.rb

@@ -1 +0,0 @@
-gem 'facets', '2.9.0'

data/lib/ruby_ext/more.rb

@@ -0,0 +1,11 @@
+require 'ruby_ext/core'
+
+%w(
+  declarative_cache
+  observable2
+  open_constructor
+  synchronize
+  tuple
+  safe_hash
+  micelaneous
+).each{|f| require "ruby_ext/more/#{f}"}

data/lib/ruby_ext/more/declarative_cache.rb

@@ -0,0 +1,96 @@
+require 'monitor'
+
+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
+  end
+end
+
+module DeclarativeCache    
+  DISABLED = false
+
+  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, 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|
+                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
+              end
+
+              alias_method method, method_with_cache
+            end
+          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
+
+                result = results[args]
+
+                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
+  end
+end

data/lib/ruby_ext/more/micelaneous.rb

@@ -0,0 +1,7 @@
+Kernel.class_eval do
+  alias_method :old_p, :p
+  def p *args    
+    puts args.collect{|a| a.inspect}.join(' ')
+    return *args
+  end
+end

data/lib/ruby_ext/{open_constructor.rb → more/open_constructor.rb}

@@ -33,13 +33,13 @@ module OpenConstructor
     return self    
   end 
   
-  def set_with_check values
+  def set! values
     values.each do |k, v|
       self.send k.to_writer, v      
     end
     return self
   end
-  alias_method :set!, :set_with_check
+  # alias_method :set! #, :set_with_check
   
   def to_hash
     hash = {}

data/lib/ruby_ext/more/safe_hash.rb

@@ -0,0 +1,214 @@
+# require 'singleton'
+
+class SafeHash < BasicObject
+  attr_reader :hash
+  
+  alias_method :send, :__send__
+  
+  def initialize hash = {}
+    reinitialize hash
+  end
+  
+  def []= key, value    
+    ::SafeHash.forbidden! key
+    # value = ::SafeHash.new value if value.is_a? ::Hash
+    # @hash[key.to_sym] = value
+  end
+  
+  def set! key, value
+    value = ::SafeHash.new value if value.is_a? ::Hash
+    @hash[key.to_sym] = value
+  end
+  def set *args; raise "you probably mistyped :set! method!" end
+  
+  def include? key
+    @hash.include? key.to_sym
+  end
+  
+  def tap &b
+    b.call self
+    self
+  end
+  
+  def [] key, if_not_exist = ::NotDefined
+    last = key[-1]
+    if last == '!'
+      key = key[0..-2].to_sym
+      if @hash.include? key
+        @hash[key]
+      else
+        raise "no key :#{key}"
+      end
+    elsif last == '?'
+      key = key[0..-2].to_sym
+      @hash.include? key
+    else
+      key = key.to_sym
+      if @hash.include? key
+        @hash[key]
+      elsif if_not_exist == ::NotDefined        
+        SafeNil.new key
+      else        
+        return if_not_exist
+      end
+    end
+  end
+  
+  def reinitialize hash
+    @hash = {}
+    merge! hash
+    # hash.each do |k, v|
+    #   v = ::SafeHash.new v if v.is_a? ::Hash 
+    #   @hash[k.to_sym] = v
+    # end
+    # @hash.freeze
+  end
+  
+  def method_missing m, obj = ::NotDefined, &b
+    raise "invalid usage, can't pass block to (:#{m})!" if b
+    last = m[-1]    
+    if last == '='
+      ::SafeHash.forbidden! m[0..-2]
+      # self[m[0..-2]] = obj
+    else
+      self[m, obj]
+    end
+  end
+  
+  def to_yaml *args
+    @hash.to_yaml *args
+  end
+  
+  def inspect
+    @hash.inspect
+  end
+  
+  def delete key
+    @hash.delete key.to_sym
+  end
+  
+  def merge! hash, options = {}
+    # parsing arguments
+    deep = options[:deep] || true
+    override = options[:override] || false
+    blank = options[:blank] || false
+    options.validate_options! :deep, :override, :blank
+    raise "invalid options, can't do both :blank and :override simultaneously!" if blank and override
+      
+    # merging    
+    hash.each do |k, v|
+      k = k.to_sym
+      if @hash.include? k
+        if deep and (old_v = @hash[k]).respond_to(:is_a_safe_hash?) and v.is_a?(::Hash)
+          old_v.merge! v, options
+        else
+          if blank
+            # do nothing
+          elsif override
+            self.set! k, v
+          else
+            raise "can't override :#{k} config value!" unless override
+          end          
+        end
+      else
+        self.set! k, v
+      end
+    end
+  end
+  def merge *args; raise "you probably mistyped :merge! method!" end
+    
+  def merge_if_blank! hash, options = {}
+    options[:blank] = true
+    merge! hash, options
+  end
+  def merge_if_blank *args; raise "you probably mistyped :merge_if_blank method!" end
+  
+  # deep conversion, check and converts nested SafeHashes to Hashes
+  def to_hash options = {}
+    r = {}
+    @hash.each do |k, v|
+      k = k.to_s if options[:to_s]
+      r[k] = if v.respond_to :is_a_safe_hash?
+        v.to_hash options
+      else
+        v
+      end
+    end
+    r
+  end
+  alias_method :to_h, :to_hash
+    
+  def is_a_safe_hash?
+    true
+  end
+    
+  
+  class SafeNil < BasicObject
+    # include ::Singleton
+    
+    def initialize key
+      @key = key
+    end
+
+    def [] key, if_not_exist = ::NotDefined
+      last = key[-1]
+      if last == '!'
+        raise "no key :#{key}"
+      elsif last == '?'
+        false
+      elsif if_not_exist == ::NotDefined
+        SafeNil.new key
+      else
+        return if_not_exist
+      end
+    end
+
+    def method_missing m, if_not_exist = ::NotDefined, &b
+      raise "invalid usage, can't pass block to (:#{m})!" if b
+      last = m[-1]
+      if last == '='
+        ::SafeHash.forbidden! m[0..-2]
+        # raise "No key '#{@key}'!"
+      else
+        self[m, if_not_exist]
+      end
+    end
+    
+    def include? key
+      false
+    end
+    
+    def to_b
+      false
+    end
+    
+    def to_yaml *args
+      nil.to_yaml *args
+    end
+    
+    def to_h
+      {}
+    end
+    
+    def to_s
+      raise "can't convert SafeNil for key '#{@key}' to String!"
+    end
+    
+    def inspect
+      nil.inspect
+    end
+  end
+  
+  
+  class << self
+    def forbidden! key
+      raise "direct modifications of SafeHash is forbidden, use :merge instead (you are trying to assign :#{key} value)!"
+    end
+  end
+  
+  
+  protected
+    def p *a
+      ::Object.send :p, *a
+    end
+end

data/lib/ruby_ext/{synchronize.rb → more/synchronize.rb}

@@ -1,13 +1,13 @@
 require 'monitor'
 
-class Module
+Module.class_eval do
   def synchronize_method *methods        
     methods.each do |method|     
-      raise "Can't synchronize system method #{method}" if method.to_s =~ /^__/
+      raise "can't synchronize system method #{method}" if method =~ /^__/
       
-      als = "sync_#{escape_method(method)}"
+      als = "sync_#{escape_method(method)}".to_sym
       
-      raise "Can't synchronize the '#{method}' twice!" if instance_methods.include?(als)
+      raise "can't synchronize the '#{method}' twice!" if instance_methods.include?(als)
       
       alias_method als, method
       script = "\
@@ -20,7 +20,7 @@ end"
   end
   
   def synchronize_all_methods include_super = false
-    methods = self.instance_methods(include_super).collect{|m| m.to_sym}
+    methods = self.instance_methods(include_super).collect{|m| m}
     synchronize_method *methods
   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/readme.md

@@ -1,55 +1,55 @@
 # Ruby extensions
-**ruby-ext** is a collection of various utility classes and standard library extensions for the Ruby language.
+**ruby_ext** is a collection of various utility classes and standard library extensions for the 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
+    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	
-	
+    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 complex_calculation
+      2 * 2
+    end
+    cache_method :complex_calculation
 
-	def money_transfer amount
-		@from -= amount
-		@to += amount
-	end
-	synchronize_method :money_transfer
+    def money_transfer amount
+      @from -= amount
+      @to += amount
+    end
+    synchronize_method :money_transfer
 
 ## OpenConstructor - adds mass assignment to any class
-	
-	class TheClass
-		include OpenConstructor
-		attr_accessor :a, :b
-	end
+  
+    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'}
+    o = TheClass.new.set a: 'a', b: 'b'
+    o.a => 'a'
+    o.to_hash => {a: 'a', b: 'b'}
 
 ## More
 
@@ -57,10 +57,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'
+    $ sudo gem install ruby_ext
+  
+    require 'ruby_ext'
 
-Copyright (c) 2009 Alexey Petrushin [http://bos-tec.com](http://bos-tec.com), released under the MIT license.
+Copyright (c) Alexey Petrushin [http://4ire.net](http://4ire.net), released under the MIT license.
+
+# TODO
+
+- config.development{} should raise 'invalid usage'
 
 [ioc]: http://en.wikipedia.org/wiki/Inversion_of_control