ruby_ext 0.4.11 → 0.4.12

data/lib/ruby_ext/prototype_inheritance.rb

@@ -1,110 +0,0 @@
-# 
-# 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
-
-
-# 
-# Prototypes
-# 
-class Class
-  def prototype
-    unless @prototype
-      unless const_defined? :Prototype
-        class_eval "module Prototype; end", __FILE__, __LINE__        
-      end      
-      @prototype = const_get :Prototype
-      
-      fixed_include @prototype
-    end
-    @prototype
-  end
-  
-  def class_prototype
-    unless @class_prototype
-      unless const_defined? :ClassPrototype
-        class_eval "module ClassPrototype; end", __FILE__, __LINE__        
-      end      
-      @class_prototype = const_get :ClassPrototype
-      
-      (class << self; self end).fixed_include @class_prototype
-    end
-    @class_prototype
-  end
-end
-
-
-# 
-# Inheritance logic
-# 
-class Class  
-  def define_instance_methods &block
-    prototype.class_eval &block    
-    # self.include prototype
-  end
-
-  def define_class_methods &block
-    self.class_prototype.class_eval &block
-    # self.extend self.class.prototype
-  end
-  
-  def inherit *classes
-    classes.each do |klass|
-      raise "You can inherit classes only ('#{klass}')!" unless klass.class == Class
-      
-      prototype.fixed_include klass.prototype
-      # self.include prototype
-      
-      class_prototype.fixed_include klass.class_prototype
-      # (class << self; self end).include class_prototype
-      
-      # callback
-      klass.inherited self if klass.respond_to? :inherited
-    end
-  end
-end
-
-
-# 
-# Sugar
-# 
-Class.class_eval do
-  alias_method :instance_methods_without_prototype, :instance_methods  
-  def instance_methods *args, &block
-    if block
-      define_instance_methods &block
-    else
-      instance_methods_without_prototype
-    end
-  end
-  
-  alias_method :class_methods, :define_class_methods
-end

data/lib/ruby_ext/should.rb

@@ -1,166 +0,0 @@
-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/rubyopt.rb

@@ -1,7 +0,0 @@
-unless defined?(JRuby)
-  begin
-    gem 'rush'
-    autoload :Rush, 'rush'
-  rescue Exception
-  end
-end

data/spec/_prototype_inheritance_spec.rb

@@ -1,190 +0,0 @@
-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