ruby_ext 0.4.6

data/lib/ruby_ext/should.rb

@@ -0,0 +1,166 @@
+class AssertionError < StandardError; end
+
+Object.class_eval do
+  def should_be! method
+    unless self.send("#{method}?") == true
+      raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should be #{method}
+      ", caller
+    end
+    
+    return self
+  end
+  alias_method :should_have!, :should_be!
+  
+  def should_not_be! method
+    unless self.send("#{method}?") == false
+      raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should not be #{method}
+      ", caller
+    end
+    
+    return self
+  end
+  alias_method :should_not_have!, :should_not_be!
+  
+  def should! cmd, arg = NotDefined
+    result = case cmd
+    when :be_never_called then
+      false
+      
+    when :be_nil then
+      self.equal? nil
+      
+    when :be_a
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+      
+    when :be_an
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+      
+    when :be
+      if arg.class == Array
+        arg.any?{|klass| self.respond_to :is?, klass}
+      else
+        self.respond_to :is?, arg
+      end
+      
+    when :include then
+      self.include? arg
+      
+    when :be_in then
+      arg.include? self
+
+    when :be_true then
+      self
+
+    when :be_false then
+      !self
+
+    when :be_empty then
+      self.empty?
+
+    else
+      if arg.equal? NotDefined
+        self.send cmd
+      else
+        self.send cmd, arg
+      end
+    end
+
+    unless result
+      unless arg.equal? NotDefined
+        raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should #{cmd} #{arg.inspect}
+        ", caller
+      else
+        raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should #{cmd}
+        ", caller
+      end
+    end
+
+    return self
+  end
+
+  def should_not! cmd, arg = NotDefined
+    result =
+    case cmd
+      when :be_never_called then
+      false
+
+    when :be_nil then
+      self.equal? nil
+
+    when :be_a
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+      
+    when :be_an
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+
+    when :be
+      if arg.class == Array
+        arg.any?{|klass| self.respond_to :is?, klass}
+      else
+        self.respond_to :is?, arg
+      end
+
+    when :include then
+      self.include? arg
+
+    when :be_in then
+      arg.include? self
+
+    when :be_true then
+      self
+
+    when :be_false then
+      !self
+
+    when :be_empty then
+      self.empty?
+
+    else
+      if arg.equal? NotDefined
+        self.send cmd
+      else
+        self.send cmd, arg
+      end
+    end
+
+    if result
+      unless arg.equal? NotDefined
+        raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should not #{cmd} #{arg.inspect}
+        ", caller
+      else
+        raise AssertionError, "
+  ASSERTION FAILED (#{caller[0]}):
+  #{self.inspect} should not #{cmd}
+        ", caller
+      end
+    end
+
+    return self
+  end
+end

data/lib/ruby_ext/string.rb

@@ -0,0 +1,44 @@
+String.class_eval do
+  def dirname
+    File.expand_path(File.dirname(self))
+  end
+  
+  def parent_dirname
+    File.expand_path(File.dirname(self) + "/..")
+  end
+  
+  def to_reader
+    self.to_sym
+  end
+  
+  def to_writer
+    "#{self}=".to_sym
+  end
+  
+  def to_iv
+    "@#{self}"
+  end
+  
+  def interpolate binding
+    binding.must_be.a Binding
+    return gsub(/\#\{.+?\}/) do |term|
+      identifier = term.slice(2 .. term.size-2)
+      binding.eval identifier
+    end
+  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!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/ruby_ext/symbol.rb

@@ -0,0 +1,21 @@
+Symbol.class_eval do
+  def <=> other
+    self.to_s <=> other.to_s
+  end
+  
+  def to_reader
+    self
+  end
+  
+  def to_writer
+    "#{self}=".to_sym
+  end
+ 
+   def to_iv
+    "@#{self}"
+  end
+
+  def + other
+    (self.to_s + other.to_s).to_sym
+  end
+end

data/lib/ruby_ext/synchronize.rb

@@ -0,0 +1,24 @@
+require 'monitor'
+
+class Module
+  def synchronize_method *methods
+    methods.each do |method|              
+      als = "sync_#{escape_method(method)}"
+      
+      raise "Can't synchronize the '#{method}' twice!" if instance_methods.include?(als)
+      
+      alias_method als, method
+      script = "\
+def #{method} *p, &b
+  @monitor ||= Monitor.new
+  @monitor.synchronize{#{als} *p, &b}
+end"
+      class_eval script, __FILE__, __LINE__
+    end
+  end
+  
+  def synchronize_all_methods include_super = false
+    methods = self.instance_methods(include_super).collect{|m| m.to_sym}
+    synchronize_method *methods
+  end
+end

data/lib/ruby_ext/tuple.rb

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

data/lib/ruby_ext.rb

@@ -0,0 +1,50 @@
+core = [
+  'facets/array/indexable', # Array first!, last!
+  'facets/enumerable/every',
+  'facets/enumerable/group_by',
+  'facets/exception/detail', # pretty print
+  'facets/duplicable', # false.dup(), false.clone() and so on.
+  'facets/blank',
+  'facets/numeric/round.rb', # round_at, round_to
+  'facets/hash',
+  'facets/string/interpolate',
+  # 'facets/ostruct',
+  # 'facets/openobject' it has broken implementation and is completelly rewritend in ruby-ext
+]
+
+more = [
+  # 'facets/basicobject', causes problem with rspec
+  # 'facets/opencascade', causes problem with redefined OpenObject
+]
+
+(core + more).each{|f| require f}
+
+{
+  :BasicObject => 'basic_object',
+  :OpenObject => 'open_object',
+  :OpenConstructor => 'open_constructor',
+  :Observable2 => 'observable2',
+  :ExtraBlankSlate => 'extra_blank_slate', # do I need it?  
+  :Tuple => 'tuple',
+}.each{|klass, file| Kernel.autoload klass, "ruby_ext/#{file}"}
+
+%w{
+  file
+  array
+  hash
+  kernel 
+  module
+  not_defined
+  object
+  class
+  string
+  symbol
+  
+  deep_clone  
+  declarative_cache
+  must
+  prepare_arguments  
+  synchronize
+  micelaneous
+  multiple_inheritance
+}.each{|f| require "ruby_ext/#{f}"}

data/lib/spec_ext.rb

@@ -0,0 +1,10 @@
+require 'spec'
+
+Spec::Example::ExampleGroup.class_eval do
+  def remove_constants *args
+    args = args.first if args.size == 1 and args.first.is_a?(Array)
+    # args.each{|c| raise "Invalid constant name '#{c}'!" unless c =~ /^[a-z_][a-z_0-9]*$/i}
+    # args = args.first if args.first.is_a?(Array)
+    args.each{|c| Object.send :remove_const, c if Object.const_defined? c}       
+  end
+end

data/readme.md

@@ -0,0 +1,66 @@
+# Ruby extensions
+**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
+
+## 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
+
+## 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'}
+
+## More
+
+These are just a small part of all handy methods and extensions, for more details please go to specs.
+
+# Usage
+
+	$ 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.
+
+[ioc]: http://en.wikipedia.org/wiki/Inversion_of_control

data/spec/_prototype_inheritance_spec.rb

@@ -0,0 +1,190 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/prototype_inheritance"
+
+describe "Prototype Inheritance" do
+  after :each do
+    remove_constants %w(A B C)
+  end
+  
+  it "should define and override methods" do
+    class A
+      instance_methods do
+        def instance_method
+          'first version'
+        end
+      end
+      class_methods do
+        def class_method
+          'first version'
+        end
+      end
+    end
+    
+    A.new.instance_method.should == "first version"
+    A.class_method.should == "first version"
+    
+    
+    A.instance_methods do
+      def instance_method
+        'second version'
+      end
+    end
+    
+    A.class_methods do
+      def class_method
+        'second version'
+      end
+    end
+    
+    A.new.instance_method.should == "second version"
+    A.class_method.should == "second version"
+  end
+
+  it "showcase" do
+    class A
+      instance_methods do
+        def a; end
+        
+        def overrided_method
+          'a version'
+        end
+      end
+  
+      class_methods do
+        def class_a; end
+      end
+  
+      def self.inherited target      
+        target.prototype.send :attr_accessor, :some_accessor
+      end
+    end    
+           
+    class B
+      instance_methods do
+        def b; end
+        
+        def overrided_method
+          'b version'
+        end
+      end
+      
+      class_methods do
+        def class_b; end
+      end
+    end
+    
+    class C
+      inherit A, B
+    end
+    
+    c = C.new   
+    c.should respond_to(:a)
+    c.should respond_to(:b)    
+    c.should respond_to(:some_accessor)
+    
+    C.should respond_to(:class_a)
+    C.should respond_to(:class_b)
+  end  
+  
+  it "should inherit all ancestors class methods (and take order into account by overriding)" do
+    class A
+      instance_methods do
+        def a; end
+        
+        def overrided
+          'a'
+        end
+      end
+  
+      class_methods do        
+        def class_a; end
+      end
+    end
+    
+    class B
+      inherit A
+      
+      instance_methods do
+        def b; end
+        
+        def overrided
+          'b'
+        end
+      end
+  
+      class_methods do
+        def class_b; end
+      end
+    end
+  
+    class C
+      inherit B
+    end
+    
+    c = C.new
+    c.should respond_to(:a)
+    c.should respond_to(:b)
+    c.overrided.should == 'b'
+    
+    C.should respond_to(:class_a)
+    C.should respond_to(:class_b)
+    
+    C.instance_methods do
+      def overrided
+        'c'
+      end
+    end
+    c = C.new
+    c.overrided.should == 'c'
+  end
+  
+  it "shouldn't redefine ancestors class methods (from error)" do
+    class A
+      class_methods do
+        def class_method; end
+      end
+    end
+    
+    class B
+      inherit A
+  
+      class_methods do
+        def class_method2; end
+      end
+    end
+    
+    A.should_not respond_to(:class_method2)
+  end
+  
+  it "methods defined on base class after inheritance must be propagated to all descendants" do
+    class A; end            
+    
+    class B
+      inherit A
+    end
+    
+    B.instance_methods.should_not include('method_added_after_inheritance')
+    A.prototype.send(:define_method, :method_added_after_inheritance){}
+    A.instance_methods.should include('method_added_after_inheritance')
+    B.instance_methods.should include('method_added_after_inheritance')
+  end
+  
+  it "classes included in base class after inheritance must be propagated to all descendants" do
+    class A; end
+    
+    class B
+      inherit A
+    end
+    
+    class C
+      instance_methods do
+        def module_added_after_inheritance; end
+      end
+    end
+    
+    A.instance_methods.should_not include('module_added_after_inheritance')
+    A.inherit C
+    A.instance_methods.should include('module_added_after_inheritance')
+    B.instance_methods.should include('module_added_after_inheritance')
+  end
+end

data/spec/array_spec.rb

@@ -0,0 +1,8 @@
+require "#{File.dirname __FILE__}/helper"
+require "ruby_ext/array"
+
+describe 'Array' do
+  it 'sfilter' do
+    %w{alfa betta gamma}.sfilter('lfa', /et/).should == ['gamma']
+  end
+end

data/spec/declarative_cache_spec.rb

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