ruby_ext 0.4.6

data/lib/ruby_ext/must.rb

@@ -0,0 +1,192 @@
+class AssertionError < StandardError; end
+
+class MustAssertions < ExtraBlankSlate
+  attr_reader :obj
+  
+  def initialize obj
+    @obj = obj
+  end
+  
+  def == o
+    @obj == o
+  end
+  
+  def =~ o
+    @obj =~ o
+  end
+  
+  def never_called
+    false
+  end
+  
+  def nil
+    @obj.equal? nil
+  end
+  
+  def defined
+    !nil
+  end
+  
+  def respond_to method
+    @obj.respond_to? method
+  end
+    
+  def a klass
+    if klass.class == Array
+      klass.any?{|k| @obj.is_a? k}
+    else
+      @obj.is_a? klass
+    end
+  end
+  alias_method :an, :a
+        
+  # def be klass = nil
+  #   if klass.class == Array
+  #     klass.any?{|k| @obj.respond_to :is?, k}
+  #   else
+  #     @obj.respond_to :is?, klass
+  #   end
+  # end
+    
+  def include o
+    @obj.include? o
+  end
+    
+  def in *args
+    if args.size == 1 
+      obj = args.first
+      if obj.is_a?(Array) or obj.is_a?(Range)
+        obj.include? @obj
+      else
+        args.include? @obj
+      end
+    else
+      args.include? @obj
+    end
+  end
+
+  def true
+    !!@obj
+  end
+
+  def false
+    !@obj
+  end
+
+  def empty
+    @obj.empty?
+  end
+  
+  def blank
+    @obj.blank?
+  end
+  
+  def present
+    !@obj.blank?
+  end
+  
+  def > o
+    @obj > o
+  end
+  
+  def < o
+    @obj < o
+  end
+  
+  def >= o
+    @obj >= o
+  end
+  
+  def <= o
+    @obj <= o
+  end
+  
+  def exist arg
+    @obj.exist? arg
+  end
+  
+  def be
+    @prefix = 'be'
+    self
+  end
+  
+  def have
+    @prefix = 'have'
+    self
+  end
+  
+  def self.assertions
+    special = %w{be have}
+    instance_methods.select{|m| m !~ /^__/ and m != 'be'}
+  end
+
+  protected
+    def method_missing m, *args, &b
+      raise RuntimeError, "Assertion '#{m}' is unknown!", caller[1..-1]
+    end
+  
+    def failed method, negative, *args
+      stack = caller.sfilter('must.rb')
+      
+      unless args.empty?
+        Kernel.raise AssertionError, "
+  ASSERTION FAILED (#{stack.first}):
+  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method} #{args.first.inspect}
+        ", stack
+      else
+        Kernel.raise AssertionError, "
+  ASSERTION FAILED (#{stack.first}):
+  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method}
+        ", stack
+      end
+    end
+end
+
+class Must < MustAssertions
+  assertions.each do |m|
+    desition = "_#{m}"
+    alias_method desition, m
+    define_method m do |*args|
+      failed m, false, *args unless __send__(desition, *args)      
+      @obj
+    end
+  end
+end
+
+class MustNot < MustAssertions
+  assertions.each do |m|
+    desition = "_#{m}"
+    alias_method desition, m
+    define_method m do |*args|
+      failed m, true, *args if __send__(desition, *args)
+      @obj
+    end
+  end
+end
+
+Object.class_eval do
+  
+  def must
+    Must.new(self)
+  end
+  
+  def must_not
+    MustNot.new(self)
+  end
+  
+  def must_be
+    must.be
+  end
+  
+  def must_not_be
+    must_not.be
+  end
+  
+  # def must_have
+  #   must.have
+  # end
+  # 
+  # def must_not_have
+  #   must_not.have
+  # end
+end

data/lib/ruby_ext/not_defined.rb

@@ -0,0 +1,2 @@
+module NotDefined
+end

data/lib/ruby_ext/object.rb

@@ -0,0 +1,8 @@
+Object.class_eval do
+  def self; self end    
+   
+  public :extend 
+#  def copy
+#    Marshal.load(Marshal.dump self) # Stub
+#  end
+end

data/lib/ruby_ext/observable2.rb

@@ -0,0 +1,23 @@
+module Observable2
+  def add_observer observer
+    @observable_observers ||= []
+    @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      
+  end
+  
+  def delete_observer observer
+    @observable_observers.delete observer if @observable_observers
+  end
+  
+  def delete_observers      
+    @observable_observers.clear if @observable_observers
+  end
+  
+  def observers_count
+    @observable_observers ? @observable_observers.size : 0
+  end
+end

data/lib/ruby_ext/open_constructor.rb

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

data/lib/ruby_ext/open_object.rb

@@ -0,0 +1,157 @@
+raise "You shouldn't use OpenObject defined in facets, it's incopatible with this version!" if defined?(OpenObject)
+
+class OpenObject < Hash
+  
+  PUBLIC_METHODS = %w(as send each size is_a? clone dup empty? blank? present? merge merge! stringify_keys stringify_keys! symbolize_keys symbolize_keys! to_query)
+  PUBLIC_METHODS_RE = /(^__|^object_)/
+
+  protected(*public_instance_methods.select{ |m| !PUBLIC_METHODS.include?(m) and m !~ PUBLIC_METHODS_RE })
+
+  def inspect
+    "#<#{self.class}:#{self.object_id} #{super}>"
+  end
+
+  def to_a; super end
+
+  def to_proc; super end
+
+  def to_openobject deep = false
+    unless deep
+      self
+    else
+      r = OpenObject.new
+      each do |k, v|
+        r[k] = if v.is_a? Hash
+          v.to_openobject
+        else
+          v
+        end
+      end
+      r
+    end 
+  end
+
+  def each &block; super(&block) end
+
+  def merge other
+    d = dup
+    other.each{|k, v| d[k] = v}
+    d
+    # d = dup
+    # d.send(:update, other)
+    # d
+  end
+  
+  def merge! other
+    other.each{|k, v| self[k] = v}
+  end
+
+  def update other
+    other.to_hash.each{|k,v| self[k.to_s] = v}
+    self
+  end
+
+  def delete key
+    super key.to_s
+  end
+
+  def == other
+    return false unless other.respond_to?(:each) and other.respond_to?(:size) and other.respond_to?(:[]) and self.size == other.size
+    other.each do |k, v|      
+      return false unless self[k] == v
+    end
+    true
+  end
+
+  def []= k, v
+    super k.to_s, v
+  end
+
+  def [] k
+    super k.to_s
+  end
+  
+  def include? k
+    super k.to_s
+  end
+  
+  def to_hash deep = false
+    unless deep
+      {}.update(self)
+    else
+      h = {}
+      each do |k, v|
+        if v.is_a? OpenObject
+          h[k] = v.to_hash(true)
+        else
+          h[k] = v
+        end
+      end
+      h
+    end
+  end
+  alias_method :to_h, :to_hash
+  
+  def to_json *args
+    to_hash.to_json *args
+  end
+  
+  # hack to works well with RSpec
+  def should; super end
+  def should_not; super end
+  
+  def respond_to? m
+    true
+  end
+
+  protected
+    def method_missing m, arg = nil, &block
+      m = m.to_s
+      type = m[-1,1]
+      # key = m.to_s.sub(/[=?!]$/,'').to_s
+      if type == '='
+        self[m[0..-2]] = arg
+      elsif type == '!'        
+        self[m[0..-2]]
+      elsif type == '?'
+        !self[m[0..-2]].blank?
+      else
+        self[m]
+      end
+    end
+end
+
+
+# 
+# Core Extensions
+# 
+class NilClass
+  def to_openobject deep = false
+    OpenObject.new
+  end
+end
+
+class Hash
+  def to_openobject deep = false
+    unless deep
+      OpenObject.new.update self 
+    else
+      r = OpenObject.new
+      each do |k, v|
+        r[k] = if v.is_a? Hash
+          v.to_openobject
+        else
+          v
+        end
+      end
+      r
+    end
+  end
+  
+  alias_method :oo_eql, :==
+  def == other
+    true if self.equal? other
+    other == self if other.is_a? OpenObject
+    oo_eql other
+  end
+end

data/lib/ruby_ext/prepare_arguments.rb

@@ -0,0 +1,105 @@
+class ArgumentsParser
+  class << self
+    def register method, arguments
+      # check and prepare metadata
+      arguments.collect!{|meta| meta.is_a?(Hash) ? meta : {:type => meta}}
+      arguments.each{|meta| meta.must.include :type}
+      
+      # register
+      @registry ||= {}
+      @registry[method] = arguments
+    end
+    
+    def parse_arguments_for method, *args, &block
+      metadata = @registry[method]
+      index = 0
+      parsed_args = metadata.collect do |options| 
+        send options[:type], args, block, options, index, (index == metadata.size - 1)
+      end
+      args.must_be.empty
+      return parsed_args
+    end
+    
+    protected
+    def string args, block, options, index, last
+      object(args, block, options, index, last) || ""
+    end
+    
+    def object args, block, options, index, last
+      a = if range = options[:range]
+        if range == :except_last_hash
+          if args.size == 1 and args.last.is_a? Hash
+            nil
+          else
+            args.shift
+          end
+        else
+          must_be.never_called
+        end
+      else
+        args.shift
+      end
+      
+      a = _common_options a, options
+      a
+    end
+    
+    def array args, block, options, index, last
+      a = if last
+        args
+      elsif range = options[:range]
+        if range == :except_last_hash
+          if args.last.is_a? Hash
+            tmp = args[0..-2]
+            args[0..-2] = nil
+            tmp
+          else
+            tmp = args[0..-1]
+            args.clear
+            tmp
+          end
+        else
+          must_be.never_called
+        end
+      else
+        args.shift
+      end
+      
+      a = _common_options a, options
+      a ||= []
+      a = [a] unless a.is_a?(Array)
+      a
+    end
+
+    def hash args, block, options, index, last
+      a = object(args, block, options, index, last) || {}
+      a.must_be.a Hash
+      a
+    end
+    
+    def _common_options a, options
+      a.must_not_be.nil if options[:require]
+      if (default = options[:default]) and a.eql?(nil)
+        a = default
+      end
+      a
+    end
+  end
+end
+
+Module.class_eval do
+  def prepare_arguments_for method, *args
+    # Register parsers
+    ArgumentsParser.register method, args
+  
+    # Wrap method
+    old_method = :"#{method}_wparg"
+    alias_method old_method, method
+    code = <<END
+def #{method} *args, &block
+#{old_method} *ArgumentsParser.parse_arguments_for(:#{method}, *args), &block
+end
+END
+    class_eval code, __FILE__, __LINE__
+  end
+end

data/lib/ruby_ext/prototype_inheritance.rb

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