ruby_ext 0.4.6

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rake'
+require 'fileutils'
+current_dir = File.expand_path(File.dirname(__FILE__))
+Dir.chdir current_dir
+
+
+# 
+# Specs
+# 
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"].select{|f| f !~ /\/_/}
+  t.libs = ["#{current_dir}/lib"]
+end
+
+
+# 
+# Gem
+# 
+require 'rake/clean'
+require 'rake/gempackagetask'
+
+gem_options = {
+  :name => "ruby_ext",
+  :version => "0.4.6",
+  :summary => "Ruby language extensions",  
+  :dependencies => %w(facets)
+}
+
+spec = Gem::Specification.new do |s|
+  gem_options.delete(:dependencies).each{|d| s.add_dependency d}
+  gem_options.each{|k, v| s.send "#{k}=", v}
+  
+  s.author = "Alexey Petrushin"
+  s.homepage = "http://github.com/alexeypetrushin/#{gem_options[:name]}"
+  s.require_path = "lib"
+  s.files = (%w{Rakefile readme.md} + Dir.glob("{lib,spec}/**/*"))
+  
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true  
+end
+
+package_dir = "#{current_dir}/build"
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+  p.need_zip = true
+  p.package_dir = package_dir
+end
+
+task :push do
+  # dir = Dir.chdir package_dir do
+  gem_file = Dir.glob("#{package_dir}/#{gem_options[:name]}*.gem").first
+  system "gem push #{gem_file}"
+  # end
+end
+
+task :clean do
+  system "rm -r #{package_dir}"
+end
+
+task :release => [:gem, :push, :clean]

data/lib/ruby_ext/array.rb

@@ -0,0 +1,13 @@
+class Array
+  def sfilter *filters
+    filters = filters.first if filters.size == 1 and filters.first.is_a?(Array)
+    filters.collect!{|o| o.is_a?(Regexp) ? o : /#{Regexp.escape o}/}
+    self.select do |line|
+      !filters.any?{|re| line =~ re}
+    end
+  end
+  
+  def self.wrap value
+    Array(value)
+  end
+end

data/lib/ruby_ext/basic_object.rb

@@ -0,0 +1,22 @@
+if defined? ::BasicObject
+  # A class with no predefined methods that behaves similarly to Builder's
+  # BlankSlate. Used for proxy classes.
+  class BasicObject < ::BasicObject
+    begin
+      undef_method :==
+      undef_method :equal?
+    rescue
+    end
+
+    # Let ActiveSupport::BasicObject at least raise exceptions.
+    def raise(*args)
+      ::Object.send(:raise, *args)
+    end
+  end
+else
+  class BasicObject #:nodoc:
+    instance_methods.each do |m|
+      undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
+    end
+  end
+end

data/lib/ruby_ext/class.rb

@@ -0,0 +1,11 @@
+Class.class_eval do
+  def alias name = nil
+    if name
+      name.must_be.a String
+      name.must_not_be.blank
+      @alias = name.to_s
+    else
+      @alias ||= self.name.split('::').last
+    end
+  end
+end

data/lib/ruby_ext/declarative_cache.rb

@@ -0,0 +1,85 @@
+require 'monitor'
+
+class Module
+  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_method
+    instance_variables.each do |iv|
+      remove_instance_variable iv if iv =~ /^@cached_/
+    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
+            als = "cached_#{escape_method(method)}"
+            iv_check = "@#{als}_check"
+            iv = "@#{als}"
+          
+            raise "Can't cache the #{method} twice!" if instance_methods.include?(als)
+            
+            alias_method als, method
+            
+            define_method method 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 als
+                  instance_variable_set iv, cached
+                  instance_variable_set iv_check, true
+                end
+              end
+              cached
+            end
+          end
+        end
+      end
+      
+      def cache_method_with_params klass, *methods        
+        methods.each do |method|  
+          klass.class_eval do      
+            als = "cached_#{escape_method(method)}"
+            iv = "@#{als}"
+            
+            raise "Can't cache the '#{method}' twice!" if instance_methods.include?(als)
+            
+            alias_method als, method
+                    
+            define_method method 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 als, *args
+                results[args] = result
+              end
+            
+              result
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_ext/deep_clone.rb

@@ -0,0 +1,62 @@
+class Object
+  def deep_clone
+    clone = self.clone
+    instance_variables.each do |name|
+      value = instance_variable_get name
+      clone.instance_variable_set name, value.deep_clone
+    end
+    clone
+  end
+end
+
+Hash.class_eval do
+  def deep_clone
+    clone = super
+    clone.clear
+    each{|k, v| clone[k.deep_clone] = v.deep_clone}
+    clone
+  end
+end
+
+OpenObject.class_eval do
+  def deep_clone
+    clone = super
+    clone.clear
+    each{|k, v| clone[k.deep_clone] = v.deep_clone}
+    clone
+  end
+end
+
+Struct.class_eval do    
+  def deep_clone
+    clone = super
+    clone.clear    
+    each_pair{|k, v| clone[k.deep_clone] = v.deep_clone}
+    clone
+  end
+end
+
+Array.class_eval do
+  def deep_clone
+    clone = super
+    clone.clear
+    each{|v| clone << v.deep_clone}
+    clone
+  end
+end
+
+[Class, Proc].each do |klass|
+  klass.class_eval do
+    def deep_clone
+      self
+    end
+  end
+end
+
+[Symbol, TrueClass, FalseClass, Numeric, TrueClass, FalseClass, NilClass].each do |klass|
+  klass.send :alias_method, :clone, :self
+end
+
+[String, Symbol, Range, Regexp, Time, Date].each do |klass|
+  klass.send :alias_method, :deep_clone, :clone
+end

data/lib/ruby_ext/extra_blank_slate.rb

@@ -0,0 +1,16 @@
+class ExtraBlankSlate
+  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  
+  CUSTOM_UNDEFINE = [:p, :select, :puts]
+    
+  undefine = Kernel.instance_methods + Object.instance_methods + CUSTOM_UNDEFINE
+  ExtraBlankSlate.instance_methods.each{|m| undefine.delete m}
+  
+  undefine.each do |m|
+    script = %{\
+def #{m} *p, &b
+  method_missing :#{m}, *p, &b
+end}
+    class_eval script, __FILE__, __LINE__
+  end    
+end

data/lib/ruby_ext/file.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+
+File.class_eval do
+  class << self
+    
+    def write(path, data)
+      File.open(path, "wb") do |file|
+        return file.write(data)
+      end
+    end
+    
+    def create_directory dir
+      FileUtils.mkdir_p dir unless File.exist? dir
+    end
+    
+    def delete_directory dir
+      FileUtils.rm_r dir, :force => true if File.exist? dir
+    end
+  end
+end

data/lib/ruby_ext/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+  def subset keys = nil, &block
+    h = {}
+    if keys
+      self.each do |k, v|
+        h[k] = v if keys.include? k
+      end
+    else
+      self.each do |k, v|
+        h[k] = v if block.call k
+      end
+    end
+    h
+  end
+end

data/lib/ruby_ext/kernel.rb

@@ -0,0 +1,69 @@
+Kernel.class_eval do
+  def respond_to sym, *args
+    return nil if not respond_to? sym
+    send sym, *args
+  end
+  
+  #  def _ &b
+  #    raise "Block isn't provided!" unless b
+  #    return b 
+  #  end
+  
+  def singleton_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    self
+    else
+      (class << self; self; end)
+    end
+  end  
+  alias_method :metaclass, :singleton_class
+  alias_method :metaclass_eval, :singleton_class
+  
+  # Removes the namespace (exact match and underscored) of given class (or self) from stacktrace
+  def raise_without_self *args
+    error, message, klasses = nil
+    if args.size == 1
+      error = RuntimeError
+      message = args[0]
+      klasses = [self]
+    elsif args.size == 2
+      message, klasses = args
+      error = RuntimeError
+      
+      klasses = Array(klasses)
+      klasses << self
+    elsif args.size == 3
+      error, message, klasses = args
+      
+      klasses = Array(klasses)
+      klasses << self
+    else
+      raise RuntimeError, "Invalid arguments!", caller
+    end
+    
+    klasses.collect!{|c| (c.class == Class or c.class == Module or c.class == String) ? c : c.class}
+    
+    # obtaining the namespace of each class
+    klasses.collect! do |c|
+      if c.respond_to? :namespace
+        c = c.namespace while c.namespace
+        c
+      else
+        c
+      end
+    end
+    
+    # building regexp
+    skip = []
+    klasses.each do |c|
+      skip.push(/\/#{c.to_s}/) # exact match
+      skip.push(/\/#{c.to_s.underscore}/) # underscored
+    end
+
+    # cleaning stacktrace
+    stack = caller.select{|path| !skip.any?{|re| re =~ path}}
+    
+    raise error, message, stack
+  end
+end

data/lib/ruby_ext/micelaneous.rb

@@ -0,0 +1,14 @@
+# 
+# string_or_symbol?
+# 
+class Object
+  def string_or_symbol?; false end
+end
+
+class String
+  def string_or_symbol?; true end
+end
+
+class Symbol
+  def string_or_symbol?; true end
+end

data/lib/ruby_ext/module.rb

@@ -0,0 +1,119 @@
+require 'set'
+
+Module.class_eval do
+  def is?(base)
+    ancestors.include?(base)
+  end
+  
+  def wrap_method( sym, prefix = "old_", &blk )
+    old_method = "#{prefix}_#{sym}".to_sym
+    alias_method old_method, sym
+    define_method(sym) do |*args|
+      instance_exec(old_method, *args, &blk)
+    end
+  end
+  
+  def namespace
+    if @module_namespace_defined
+      @module_namespace
+    else
+      @module_namespace_defined = true
+      @module_namespace = Module.namespace_for name
+    end
+  end
+  
+  def each_namespace &block
+    current = namespace
+    while current do
+      block.call current
+      current = current.namespace
+    end
+  end
+  
+  def each_ancestor include_standard = false, &block
+    if include_standard
+      ancestors.each{|a| block.call a unless a == self}
+    else
+      exclude = [self, Object, Kernel]
+      ancestors.each do |a|
+        block.call a unless exclude.include? a
+      end
+    end
+  end
+  
+  def self_ancestors_and_namespaces &b
+    b.call self
+    each_ancestor &b
+    each_namespace &b
+  end
+  
+  def self.namespace_for class_name
+    list = class_name.split("::")
+    if list.size > 1
+      list.pop
+      return eval(list.join("::"), TOPLEVEL_BINDING, __FILE__, __LINE__)
+    else
+      return nil
+    end
+  end
+  
+  def inheritable_accessor attribute_name, default_value
+    raise "Can be used only for Class and Module" unless self.class.is? Module
+    # raise "Default value can't be nil!" unless default_value
+    
+    iv_name = "@#{attribute_name}"
+    iv_defined = "@#{attribute_name}_defined"
+    
+    define_method attribute_name do
+      unless instance_variable_get(iv_defined)
+        iv = nil
+        ancestors[1..-1].each do |a|
+          if a.respond_to?(attribute_name) and (value = a.send(attribute_name))
+            iv = value.deep_clone
+            break 
+          end
+        end
+        iv ||= default_value.deep_clone
+        instance_variable_set iv_name, iv
+        instance_variable_set iv_defined, true
+        iv
+      else
+        instance_variable_get iv_name
+      end      
+    end
+  
+    define_method "#{attribute_name}=" do |value|
+      # raise "Value can't be nil!" unless value
+      instance_variable_set iv_name, value
+      instance_variable_set iv_defined, true
+    end
+  end
+  
+  raise "Internal error, it shouldn't be loaded twice!" if defined? ESCAPE_METHOD_SYMBOLS # some tricky error when runing spec with rake  
+  ESCAPE_METHOD_SYMBOLS = [
+    ['==', 'assign'],
+    ['>', 'gt'],
+    ['<', 'lt'],
+    ['>=', 'gte'],
+    ['<=', 'lte'],
+    ['?', 'qst'],
+    ['!', 'imp'],
+    ['<=>', 'lorg'],
+    ['*', 'mp'],
+    ['+', 'add'],
+    ['-', 'sub'],
+    ['=', 'assign'],
+    ['**', 'pw'],
+    ['=~', 'sim'],
+    ['[]', 'sb'],
+  ]  
+  
+  def escape_method method
+    m = method.to_s.clone
+    ESCAPE_METHOD_SYMBOLS.each{|from, to| m.gsub! from, to}
+    raise "Invalid method name '#{method}'!" unless m =~ /^[_a-zA-Z0-9]+$/
+    m
+  end
+  
+  public :include
+end

data/lib/ruby_ext/multiple_inheritance.rb

@@ -0,0 +1,76 @@
+# 
+# Fix for ruby's broken include.
+# Included modules doesn't propagated to it's children.
+# 
+# Test case:
+# module A; end
+# module B
+#   include A
+# end
+# 
+# module Plugin; end
+# A.send(:include, Plugin)
+# 
+# p "Ancestors of A: " + A.ancestors.join(', ') # => "Ancestors of A: A, Plugin"
+# p "Ancestors of B: " + B.ancestors.join(', ') # => "Ancestors of B: B, A" << NO PLUGIN!
+# 
+class Module
+  def directly_included_by
+    @directly_included_by ||= Set.new
+  end
+  
+  def fixed_include mod
+    unless mod.directly_included_by.include? self
+      mod.directly_included_by.add self
+    end
+
+    include mod
+    directly_included_by.each do |child|
+      child.fixed_include self
+    end
+  end
+end
+
+
+# 
+# Inheritance
+# 
+class Module
+  def class_prototype
+    unless @class_prototype
+      unless const_defined? :ClassMethods
+        class_eval "module ClassMethods; end", __FILE__, __LINE__        
+      end      
+      @class_prototype = const_get :ClassMethods
+      
+      (class << self; self end).fixed_include @class_prototype
+    end
+    @class_prototype
+  end
+  
+  def class_methods &block
+    if block      
+      class_prototype.class_eval &block      
+      extend class_prototype
+    else
+      class_prototype.instance_methods
+    end
+  end
+  
+  def inherit *modules
+    modules.each do |mod|
+      # Instance Methods
+      fixed_include mod
+      
+      # Class Methods
+      if self.class == Module        
+        class_prototype.fixed_include mod.class_prototype
+      else
+        (class << self; self end).fixed_include mod.class_prototype
+      end          
+      
+      # callback
+      mod.inherited self if mod.respond_to? :inherited
+    end
+  end
+end