stupidedi 1.2.5 → 1.2.6

data/lib/ruby/hash.rb

@@ -1,4 +1,15 @@
-class Hash
-  alias defined_at? include?
-  alias at []
+module Stupidedi
+  module Refinements
+
+    refine Hash do
+      def defined_at?(x)
+        include?(x)
+      end
+
+      def at(x)
+        self[x]
+      end
+    end
+
+  end
 end

data/lib/ruby/instance_exec.rb

@@ -1,26 +1,29 @@
-class Object
+module Stupidedi
+  module Refinements
 
-  if RUBY_VERSION < "1.9"
-    module InstanceExecHelper; end
-    include InstanceExecHelper
+    refine Object do
+      if RUBY_VERSION < "1.9"
+        module InstanceExecHelper; end
+        include InstanceExecHelper
 
-    # @see http://eigenclass.org/hiki/instance_exec
-    def instance_exec(*args, &block)
-      thread = Thread.current.object_id.abs
-      object = object_id.abs
-      mname  = "__instance_exec_#{thread}_#{object}"
-      InstanceExecHelper.module_eval { define_method(mname, &block) }
+        # @see http://eigenclass.org/hiki/instance_exec
+        def instance_exec(*args, &block)
+          thread = Thread.current.object_id.abs
+          object = object_id.abs
+          mname  = "__instance_exec_#{thread}_#{object}"
+          InstanceExecHelper.module_eval { define_method(mname, &block) }
 
-      begin
-        __send__(mname, *args)
-      ensure
-        begin
-          InstanceExecHelper.module_eval { remove_method(mname) }
-        rescue
+          begin
+            __send__(mname, *args)
+          ensure
+            begin
+              InstanceExecHelper.module_eval { remove_method(mname) }
+            rescue
+            end
+          end
         end
       end
     end
 
   end
-
 end

data/lib/ruby/module.rb

@@ -1,51 +1,61 @@
-class Module
+module Stupidedi
+  module Refinements
 
-  # Creates an abstract method
-  #
-  # @example
-  #   class Collection
-  #     abstract :size
-  #     abstract :add, :args => %w(item)
-  #   end
-  #
-  # @return [void]
-  def abstract(name, *params)
-    if params.last.is_a?(Hash)
-      # abstract :method, :args => %w(a b c)
-      params = params.last[:args]
-    end
+    refine Module do
+      # Creates an abstract method
+      #
+      # @example
+      #   class Collection
+      #     abstract :size
+      #     abstract :add, :args => %w(item)
+      #   end
+      #
+      # @return [void]
+      def abstract(name, *params)
+        if params.last.is_a?(Hash)
+          # abstract :method, :args => %w(a b c)
+          params = params.last[:args]
+        end
 
-    file, line, = Stupidedi.caller
+        file, line, = Stupidedi.caller
 
-    if params.empty?
-      class_eval(<<-RUBY, file, line.to_i - 1)
-        def #{name}(*args)
-          raise NoMethodError,
-            "method \#{self.class.name}.#{name} is abstract"
+        if params.empty?
+          class_eval(<<-RUBY, file, line.to_i - 1)
+            def #{name}(*args)
+              raise NoMethodError,
+                "method \#{self.class.name}.#{name} is abstract"
+            end
+          RUBY
+        else
+          class_eval(<<-RUBY, file, line.to_i - 1)
+            def #{name}(*args)
+              raise NoMethodError,
+                "method \#{self.class.name}.#{name}(#{params.join(', ')}) is abstract"
+            end
+          RUBY
         end
-      RUBY
-    else
-      class_eval(<<-RUBY, file, line.to_i - 1)
-        def #{name}(*args)
-          raise NoMethodError,
-            "method \#{self.class.name}.#{name}(#{params.join(', ')}) is abstract"
+      end
+
+      def def_delegators(target, *methods)
+        file, line, = Stupidedi.caller
+
+        for m in methods
+          if m.to_s =~ /=$/
+            class_eval(<<-RUBY, file, line.to_i - 1)
+              def #{m}(value)
+                #{target}.#{m}(value)
+              end
+            RUBY
+          else
+            class_eval(<<-RUBY, file, line.to_i - 1)
+              def #{m}(*args, &block)
+                #{target}.#{m}(*args, &block)
+              end
+            RUBY
+          end
         end
-      RUBY
+      end
     end
-  end
-
-  # Creates a method (or methods) that delegates messages to an instance
-  # variable or another instance method.
-  #
-  # @example
-  #   class WrappedCollection
-  #     delegate :size, :add, :to => :@wrapped
-  #
-  #     def initialize(wrapped)
-  #       @wrapped = wrapped
-  #     end
-  #   end
-  #
-  # @return [void]
 
+  end
 end

data/lib/ruby/object.rb

@@ -1,63 +1,68 @@
-class Object
-
-  # @group List Constructors
-  #############################################################################
-
-  # Prepend the item to the front of a new list
-  #
-  # @example
-  #   1.cons              #=> [1]
-  #   1.cons(2.cons)      #=> [1, 2]
-  #   1.cons([0, 0, 0])   #=> [1, 0, 0, 0]
-  #
-  # @return [Array]
-  def cons(array = [])
-    [self] + array
-  end
+module Stupidedi
+  module Refinements
 
-  # Append the item to rear of a new list
-  #
-  # @example
-  #   1.snoc              #=> [1]
-  #   1.snoc(2.snoc)      #=> [2, 1]
-  #   1.snoc([0, 0, 0])   #=> [0, 0, 0, 1]
-  #
-  # @return [Array]
-  def snoc(array = [])
-    array + [self]
-  end
+    refine Object do
+      # @group List Constructors
+      #############################################################################
 
-  # @group Combinators
-  #############################################################################
-
-  # Yields `self` to a block argument
-  #
-  # @example
-  #   nil.bind{|a| a.nil? }   #=> true
-  #   100.bind{|a| a.nil? }   #=> false
-  #
-  def bind
-    yield self
-  end
+      # Prepend the item to the front of a new list
+      #
+      # @example
+      #   1.cons              #=> [1]
+      #   1.cons(2.cons)      #=> [1, 2]
+      #   1.cons([0, 0, 0])   #=> [1, 0, 0, 0]
+      #
+      # @return [Array]
+      def cons(array = [])
+        [self] + array
+      end
 
-  # Yields `self` to a side-effect block argument and return `self`
-  #
-  # @example:
-  #   100.bind{|a| puts "debug: #{a}" }   #=> 100
-  #
-  # @return self
-  def tap
-    yield self
-    self
-  end
+      # Append the item to rear of a new list
+      #
+      # @example
+      #   1.snoc              #=> [1]
+      #   1.snoc(2.snoc)      #=> [2, 1]
+      #   1.snoc([0, 0, 0])   #=> [0, 0, 0, 1]
+      #
+      # @return [Array]
+      def snoc(array = [])
+        array + [self]
+      end
+
+      # @group Combinators
+      #############################################################################
+
+      # Yields `self` to a block argument
+      #
+      # @example
+      #   nil.bind{|a| a.nil? }   #=> true
+      #   100.bind{|a| a.nil? }   #=> false
+      #
+      def bind
+        yield self
+      end
+
+      # Yields `self` to a side-effect block argument and return `self`
+      #
+      # @example:
+      #   100.tap{|a| puts "debug: #{a}" }   #=> 100
+      #
+      # @return self
+      def tap
+        yield self
+        self
+      end unless nil.respond_to?(:tap)
+
+      # @endgroup
+      #############################################################################
 
-  # @endgroup
-  #############################################################################
+      # Return the "eigenclass" where singleton methods reside
+      #
+      # @return [Class]
+      def eigenclass
+        class << self; self; end
+      end
+    end
 
-  # Return the "eigenclass" where singleton methods reside
-  #
-  # @return [Class]
-  def eigenclass
-    class << self; self; end
   end
 end

data/lib/ruby/string.rb

@@ -1,73 +1,78 @@
-class String
+module Stupidedi
+  module Refinements
 
-  # Return the one-character string at the given index
-  #
-  # @example
-  #   "abc".at(0)   #=> "a"
-  #   "abc".at(2)   #=> "c"
-  #
-  # @param [Integer] n zero-based index of the character to read
-  #
-  # @return [String]
-  def at(n)
-    raise ArgumentError, "n must be positive" if n < 0
-    self[n, 1] unless n >= length
-  end
+    refine String do
+      # Return the one-character string at the given index
+      #
+      # @example
+      #   "abc".at(0)   #=> "a"
+      #   "abc".at(2)   #=> "c"
+      #
+      # @param [Integer] n zero-based index of the character to read
+      #
+      # @return [String]
+      def at(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        self[n, 1] unless n >= length
+      end
 
-  # Return the string with `n` characters removed from the front
-  #
-  # @example
-  #   "abc".drop(0)   #=> "abc"
-  #   "abc".drop(2)   #=> "c"
-  #
-  # @param [Integer] n number of characters to drop (`n > 0`)
-  #
-  # @return [String]
-  def drop(n)
-    raise ArgumentError, "n must be positive" if n < 0
-    (length >= n) ? self[n..-1] : ""
-  end
+      # Return the string with `n` characters removed from the front
+      #
+      # @example
+      #   "abc".drop(0)   #=> "abc"
+      #   "abc".drop(2)   #=> "c"
+      #
+      # @param [Integer] n number of characters to drop (`n > 0`)
+      #
+      # @return [String]
+      def drop(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        (length >= n) ? self[n..-1] : ""
+      end
 
-  # Return the first `n` characters from the front
-  #
-  # @example
-  #   "abc".take(0)   #=> ""
-  #   "abc".take(2)   #=> "ab"
-  #
-  # @param [Integer] n number of characters to select (`n > 0`)
-  #
-  # @return [String]
-  def take(n)
-    raise ArgumentError, "n must be positive" if n < 0
-    self[0, n]
-  end
+      # Return the first `n` characters from the front
+      #
+      # @example
+      #   "abc".take(0)   #=> ""
+      #   "abc".take(2)   #=> "ab"
+      #
+      # @param [Integer] n number of characters to select (`n > 0`)
+      #
+      # @return [String]
+      def take(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        self[0, n]
+      end
 
-  # Split the string in two at the given position
-  #
-  # @example
-  #   "abc".split_at(0)   #=> ["", "abc"]
-  #   "abc".split_at(2)   #=> ["ab", "c"]
-  #
-  # @param [Integer] n number of characters at which to split (`n > 0`)
-  #
-  # @return [Array(String, String)]
-  def split_at(n)
-    [take(n), drop(n)]
-  end
+      # Split the string in two at the given position
+      #
+      # @example
+      #   "abc".split_at(0)   #=> ["", "abc"]
+      #   "abc".split_at(2)   #=> ["ab", "c"]
+      #
+      # @param [Integer] n number of characters at which to split (`n > 0`)
+      #
+      # @return [Array(String, String)]
+      def split_at(n)
+        [take(n), drop(n)]
+      end
 
-  # True if the string is long enough such that {#at} is defined for the
-  # given `n`
-  #
-  # @example
-  #   "abc".defined_at?(0)  #=> true
-  #   "abc".defined_at?(3)  #=> false
-  def defined_at?(n)
-    n < length
-  end
+      # True if the string is long enough such that {#at} is defined for the
+      # given `n`
+      #
+      # @example
+      #   "abc".defined_at?(0)  #=> true
+      #   "abc".defined_at?(3)  #=> false
+      def defined_at?(n)
+        n < length
+      end
+
+      # To make String compatible with the {Stupidedi::Reader::Input} interface,
+      # we have to define `#position`... shameful!
+      def position
+        nil
+      end
+    end
 
-  # To make String compatible with the {Stupidedi::Reader::Input} interface,
-  # we have to define `#position`... shameful!
-  def position
-    nil
   end
 end

data/lib/ruby/symbol.rb

@@ -1,24 +1,27 @@
-class Symbol
+module Stupidedi
+  module Refinements
 
-  unless method_defined?(:to_proc)
-    # Returns a proc that calls self on the proc's parameter
-    #
-    # @example
-    #   [1, 2, 3].map(&:-@)       #=> [-1, -2, -3]
-    #   [-1, -2, -3].map(&:abs)   #=> [1, 2, 3]
-    #
-    def to_proc
-      lambda{|*args| args.head.__send__(self, *args.tail) }
+    refine Symbol do
+      # Returns a proc that calls self on the proc's parameter
+      #
+      # @example
+      #   [1, 2, 3].map(&:-@)       #=> [-1, -2, -3]
+      #   [-1, -2, -3].map(&:abs)   #=> [1, 2, 3]
+      #
+      def to_proc
+        lambda{|*args| args.head.__send__(self, *args.tail) }
+      end
+
+      # Calls self on the given receiver
+      #
+      # @example
+      #   :to_s.call(100)           #=> "100"
+      #   :join.call([1,2,3], "-")  #=> "1-2-3"
+      #
+      def call(receiver, *args)
+        receiver.__send__(self, *args)
+      end
     end
-  end
 
-  # Calls self on the given receiver
-  #
-  # @example
-  #   :to_s.call(100)           #=> "100"
-  #   :join.call([1,2,3], "-")  #=> "1-2-3"
-  #
-  def call(receiver, *args)
-    receiver.__send__(self, *args)
   end
 end