gemmyrb 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3738de0bcb6474f41bc2f0959d5fc57c056e1c2d
-  data.tar.gz: 6d5a3339c10b4ecd92e29d4f380b66f536748756
+  metadata.gz: 57241faae027cf6e4416104dcedd95dcdb6f3d56
+  data.tar.gz: 6f4caf998b97cd0e9fdc84f243f19813248e0541
 SHA512:
-  metadata.gz: f9afef465e6795c1e168dda4178c1cf77d45508f9069e279891ee022b08cd27ac64390de49ada10978ab494898bdad6b1c3a8f67ce24c6b62154e8a5ec4484de
-  data.tar.gz: f5183dea0d4e286ac33bffa45d060d379b0ddf3c108e098d8f8c408cf0b6ae67a2b7e5497519fb20ea7496df8be53ad47ca5e9e8a426c68807ae18aa16787718
+  metadata.gz: 2fef2f0b535f1829842689b3c6d5dc92cbf223dac26ea3b0dceb60476a075309e59e3ee3be8e25b93b198734bc2e8c15f8c3a5030cfb4cb21a832fb13ddc51d5
+  data.tar.gz: ce6f3a3f1c5d7b54eac6e72fc1341bf3748a6926bc054cda10d6512e7905a22ca87d291ddd6c6dc8a485e70fb05750c42c1b0b6bc7a14e7a44125190bc16c4f3

data/README.md

@@ -22,4 +22,4 @@ documents:
 - _List of methods intended for general Ruby use_
   - [examples/03_ruby_extensions_list.rb](./examples/03_ruby_extensions_list.rb)
 - _Shell commands and other one-off processes_
-  - [examples/04_shell_commands.rb](./04_shell_commands.rb)
+  - [examples/04_shell_commands.rb](./examples/04_shell_commands.rb)

data/lib/gemmy/cli.rb

@@ -14,7 +14,7 @@ class Gemmy::CLI < Thor
   def self.run(arguments: nil)
     # Store a copy of the arguments.
     # The originals are shifted so they don't intefere with gets
-    arguments = ARGV.clone
+    arguments ||= ARGV.clone
     ARGV.clear
 
     # Can't make this conditional on "__FILE__ == $0"

data/lib/gemmy/components/dynamic_steps.rb

@@ -19,7 +19,7 @@
 #
 module Gemmy::Components::DynamicSteps
 
-  Gemmy::Patches.refinements.each { |r| using r }
+  Gemmy::Patches.class_refinements.each { |r| using r }
 
   # Error raised when a string matches multiple step regexes.
   # It's frequently accidental to come into this situation,

data/lib/gemmy/components.rb

@@ -9,7 +9,7 @@
     end
 
     def self.list
-      [
+      @@list ||= [
         Gemmy::Components::DynamicSteps
       ]
     end

data/lib/gemmy/patches/array_patch.rb

@@ -1,19 +1,191 @@
 # Array patches
 #
 module Gemmy::Patches::ArrayPatch
-  # checks if any of the results of an array do not respond truthily
-  # to a block
-  #
-  # For example, to check if any items of an array are truthy:
-  #   [false, nil, ''].any_not? &:blank?
-  #   => false
-  #
-  def any_not?(&blk)
-    any? { |item| ! blk.call(item) }
+
+  module ClassMethods
+
+    module Zip
+      # facets
+      def self.zip(*arrays)
+        return [] if arrays.empty?
+        return arrays[0].zip(*arrays[1..-1])
+      end
+    end
+
   end
 
-  refine Array do
-    include Gemmy::Patches::ArrayPatch
+  module InstanceMethods
+
+    module KeyBy
+      # facets
+      def key_by
+        return to_enum(:key_by) unless block_given?
+        h = {}
+        each do |v|
+          h[yield(v)] = v
+        end
+        return h
+      end
+    end
+
+    module After
+      # facets
+      def after(value)
+        return nil unless include? value
+        self[(index(value).to_i + 1) % length]
+      end
+    end
+
+    module Before
+      # facets
+      def before(value)
+        return nil unless include? value
+        self[(index(value).to_i - 1) % length]
+      end
+    end
+
+    module Duplicates
+      # facets
+      def duplicates(min=2)
+        h = Hash.new( 0 )
+        each {|i|
+          h[i] += 1
+        }
+        h.delete_if{|_,v| v < min}.keys
+      end
+    end
+
+    module ExtractOptions
+      # facets
+      def extract_options!
+        if Hash === last && last.extractable_options?
+          pop
+        else
+          {}
+        end
+      end
+    end
+
+    module RejectValues
+      # facets
+      def reject_values(*values)
+        reject { |x| values.include?(x) }
+      end
+    end
+
+    module Recurse
+      # facets
+      def recurse(*types, &block)
+        types = [self.class] if types.empty?
+        a = inject([]) do |array, value|
+          case value
+          when *types
+            array << value.recurse(*types, &block)
+          else
+            array << value
+          end
+          array
+        end
+        yield a
+      end
+    end
+
+    module Probability
+      # facets
+      def probability
+        probs = Hash.new(0.0)
+        size = 0.0
+        each do |e|
+          probs[e] += 1.0
+          size += 1.0
+        end
+        probs.keys.each{ |e| probs[e] /= size }
+        probs
+      end
+    end
+
+    module NotEmpty
+      # facets
+      def not_empty?
+        !empty?
+      end
+    end
+
+    module Median
+      # facets
+      def median(offset=0)
+        return nil if self.size == 0
+
+        tmp = self.sort
+        mid = (tmp.size / 2).to_i + offset
+
+        tmp[mid]
+      end
+    end
+
+    module Mode
+      # facets
+      def mode
+        max = 0
+        c = Hash.new 0
+        each {|x| cc = c[x] += 1; max = cc if cc > max}
+        c.select {|k,v| v == max}.map {|k,v| k}
+      end
+    end
+
+    module NonUniq
+
+      # facets
+      def nonuniq
+        h1 = {}
+        h2 = {}
+        each {|i|
+          h2[i] = true if h1[i]
+          h1[i] = true
+        }
+        h2.keys
+      end
+    end
+
+    module Arrange
+      # facets
+      # creates ranges from array
+      def arrange
+        array = uniq.sort_by { |e| Range === e ? e.first : e }
+        array.inject([]) do |c, value|
+          unless c.empty?
+            last = c.last
+            last_value    = (Range === last  ? last.last   : last)
+            current_value = (Range === value ? value.first : value)
+            if (last_value.succ <=> current_value) == -1
+              c << value
+            else
+              first  = (Range === last ? last.first : last)
+              second = [Range === last ? last.last : last, Range === value ? value.last : value].max
+              c[-1] = [first..second]
+              c.flatten!
+            end
+          else
+            c << value
+          end
+        end
+      end
+      alias rangify arrange
+    end
+
+    module AnyNot
+      # checks if any of the results of an array do not respond truthily
+      # to a block
+      #
+      # For example, to check if any items of an array are truthy:
+      #   [false, nil, ''].any_not? &:blank?
+      #   => false
+      #
+      def any_not?(&blk)
+        any? { |item| ! blk.call(item) }
+      end
+    end
+
   end
 
 end

data/lib/gemmy/patches/hash_patch.rb

@@ -2,85 +2,100 @@
 #
 module Gemmy::Patches::HashPatch
 
-  # The opposite of Hash#dig
-  # Takes a list of keys followed by a value to set
-  #
-  # Example:
-  #
-  #   a = {a: {b: {}} }
-  #   a.bury(:a, :b, :c, 0)
-  #   puts a[:a][:b][:c]
-  #   => 0
-  #
-  # Source: https://github.com/dam13n/ruby-bury/blob/master/hash.rb
-  #
-  def bury *args
-    Gemmy::Patches::HashPatch._bury(self, *args)
+  module ClassMethods
   end
 
-  # The bury method, taking the input hash as a parameter
-  # Used by the Hash#bury instance method
-  def self._bury(caller_hash, *args)
-    if args.count < 2
-      raise ArgumentError.new("2 or more arguments required")
-    elsif args.count == 2
-      caller_hash[args[0]] = args[1]
-    else
-      arg = args.shift
-      caller_hash[arg] = {} unless caller_hash[arg]
-      _bury(caller_hash[arg], *args) unless args.empty?
+  module InstanceMethods
+
+    # The opposite of Hash#dig
+    # Takes a list of keys followed by a value to set
+    #
+    # Example:
+    #
+    #   a = {a: {b: {}} }
+    #   a.bury(:a, :b, :c, 0)
+    #   puts a[:a][:b][:c]
+    #   => 0
+    #
+    # Source: https://github.com/dam13n/ruby-bury/blob/master/hash.rb
+    #
+    module Bury
+      def bury *args
+        Gemmy::Patches::HashPatch::InstanceMethods::Bury._bury(self, *args)
+      end
+      # The bury method, taking the input hash as a parameter
+      # Used by the Hash#bury instance method
+      def self._bury(caller_hash, *args)
+        if args.count < 2
+          raise ArgumentError.new("2 or more arguments required")
+        elsif args.count == 2
+          caller_hash[args[0]] = args[1]
+        else
+          arg = args.shift
+          caller_hash[arg] = {} unless caller_hash[arg]
+          _bury(caller_hash[arg], *args) unless args.empty?
+        end
+        caller_hash
+      end
     end
-    caller_hash
-  end
 
-  # Turns a hash into one that's "autovivified"
-  # meaning it's default values for keys is an empty hash.
-  # The result is that you can set nested keys without initializing
-  # more than one hash layer.
-  #
-  # Usage:
-  #   hash = {}.autovivified
-  #   hash[:a][:b] = 0
-  #   puts hash[:a][:b]
-  #   => 0
-  #
-  def autovivified
-    Gemmy::Patches::HashPatch._autovivified(self)
-  end
+    # Turns a hash into one that's "autovivified"
+    # meaning it's default values for keys is an empty hash.
+    # The result is that you can set nested keys without initializing
+    # more than one hash layer.
+    #
+    # Usage:
+    #   hash = {}.autovivified
+    #   hash[:a][:b] = 0
+    #   puts hash[:a][:b]
+    #   => 0
+    #
+    module Autovivified
+      def self._autovivified(caller_hash)
+        result = Hash.new do |hash,key|
+          hash[key] = Hash.new(&hash.default_proc)
+        end
+        result.deep_merge caller_hash
+      end
+      def autovivified
+        Gemmy::Patches::HashPatch::InstanceMethods::Autovivified._autovivified(self)
+      end
+    end
 
-  def self._autovivified(caller_hash)
-    result = Hash.new { |hash,key| hash[key] = Hash.new(&hash.default_proc) }
-    result.deep_merge caller_hash
-  end
+    # Sets up a hash to mirror all changes to a database file
+    # All nested gets & sets require a list of keys, passed as subsequent args.
+    # Instead of [] and []=, use get and set
+    #
+    # Everything in the db is contained in a hash with one predefined
+    # key, :data. The value is an empty, autovivified hash.
+    #
+    # This also makes the caller hash autovivified
+    #
+    # Example:
+    #
+    # hash = {}.persisted("db.yaml")
+    # hash.set(:a, :b, 0)           # => this writes to disk and memory
+    # hash.get(:a, :b)              # => reads from memory
+    # hash.get(:a, :b, disk: true)  # => reads from disk
+    #
 
-  # Sets up a hash to mirror all changes to a database file
-  # All nested gets & sets require a list of keys, passed as subsequent args.
-  # Instead of [] and []=, use get and set
-  #
-  # Everything in the db is contained in a hash with one predefined
-  # key, :data. The value is an empty, autovivified hash.
-  #
-  # This also makes the caller hash autovivified
-  #
-  # Example:
-  #
-  # hash = {}.persisted("db.yaml")
-  # hash.set(:a, :b, 0)           # => this writes to disk and memory
-  # hash.get(:a, :b)              # => reads from memory
-  # hash.get(:a, :b, disk: true)  # => reads from disk
-  #
-  def persisted(path)
-    require 'yaml/store'
-    Gemmy::Patches::HashPatch._autovivified(self).tap do |hash|
-      hash.instance_exec do
-        @db = YAML::Store.new path
-        @db.transaction do
-          @db[:data] = Gemmy::Patches::HashPatch._autovivified({})
+    module Persisted
+      def persisted(path)
+        require 'yaml/store'
+        autovivified = Gemmy::Patches::HashPatch::InstanceMethods::Autovivified.method(:_autovivified)
+        autovivified.call(self).tap do |hash|
+          hash.instance_exec do
+            @db = YAML::Store.new path
+            @db.transaction do
+              @db[:data] = autovivified.call({})
+            end
+          end
+          hash.extend Gemmy::Patches::HashPatch::PersistedHash
         end
       end
-      hash.extend Gemmy::Patches::HashPatch::PersistedHash
     end
-  end
+
+  end # end instance methods
 
   # Helper methods for the persistence patch
   #
@@ -89,16 +104,13 @@ module Gemmy::Patches::HashPatch
       disk ? @db.transaction { @db[:data].dig(*keys) } : dig(*keys)
     end
     def set(*keys, val)
-      Gemmy::Patches::HashPatch._bury(self, *keys, val)
+      bury = Gemmy::Patches::HashPatch::InstanceMethods::Bury.method(:_bury)
+      bury.call(self, *keys, val)
       @db.transaction do
-        Gemmy::Patches::HashPatch._bury(@db[:data], *(keys + [val]))
+        bury.call(@db[:data], *(keys + [val]))
       end
       val
     end
   end
 
-  refine Hash do
-    include Gemmy::Patches::HashPatch
-  end
-
 end

data/lib/gemmy/patches/integer_patch.rb

@@ -0,0 +1,53 @@
+module Gemmy::Patches::IntegerPatch
+
+  module ClassMethods
+
+  end
+
+  module InstanceMethods
+
+    module Factorial
+      # facets
+      def factorial
+        return 1 if zero?
+        f = 1
+        2.upto(self) { |n| f *= n }
+        f
+      end
+    end
+
+    module MultipleOf
+      # facets
+      def multiple_of?(number)
+        if number.zero?
+          zero? ? true : false
+        else
+          self % number == 0
+        end
+      end
+    end
+
+    module Odd
+      def odd?
+        ! even?
+      end
+    end
+
+    module Of
+      # facets
+      def of(&block)
+        Array.new(self, &block)
+      end
+      alias times_map of
+    end
+
+    module Collapse
+      # facets
+      def collapse
+        flatten.compact
+      end
+    end
+
+  end
+
+end

data/lib/gemmy/patches/method_patch.rb

@@ -2,21 +2,26 @@
 #
 module Gemmy::Patches::MethodPatch
 
-  # Bind an argument to a method.
-  # Very useful for the proc shorthand.
-  # For example say there's a method "def add(a,b); print a + b; end"
-  # You can run it for each number in a list:
-  #    [1,2,3].each &method(:add).bind(1)
-  #    => 234
-  #
-  def bind *args
-    Proc.new do |*more|
-      self.call *(args + more)
-    end
+  module ClassMethods
   end
 
-  refine Method do
-    include Gemmy::Patches::MethodPatch
+  module InstanceMethods
+
+    # Bind an argument to a method.
+    # Very useful for the proc shorthand.
+    # For example say there's a method "def add(a,b); print a + b; end"
+    # You can run it for each number in a list:
+    #    [1,2,3].each &method(:add).bind(1)
+    #    => 234
+    #
+    module Bind
+      def bind *args
+        Proc.new do |*more|
+          self.call *(args + more)
+        end
+      end
+    end
+
   end
 
 end

data/lib/gemmy/patches/object_patch.rb

@@ -2,61 +2,81 @@
 #
 module Gemmy::Patches::ObjectPatch
 
-  # Turns on verbose mode, showing warnings
-  #
-  def verbose_mode
-    $VERBOSE = true
+  module ClassMethods
   end
 
-  # Generic error. Raises RuntimeError
-  # @param msg [String] optional
-  #
-  def error(msg='')
-    raise RuntimeError, msg
-  end
+  module InstanceMethods
 
-  # Prints a string then gets input
-  # @param txt [String]
-  #
-  def _prompt(txt)
-    puts txt
-    gets.chomp
-  end
+    # Turns on verbose mode, showing warnings
+    #
+    module VerboseMode
+      def verbose_mode
+        $VERBOSE = true
+      end
+    end
 
-  # Shifts one ARGV and raises a message if it's undefined.
-  # @param msg [String]
-  #
-  def get_arg_or_error(msg)
-    ([ARGV.shift, msg].tap &method(:error_if_blank)).shift
-  end
+    # Generic error. Raises RuntimeError
+    # @param msg [String] optional
+    #
+    module Error
+      def error(msg='')
+        raise RuntimeError, msg
+      end
+    end
 
-  # Writes a string to a file
-  # @param file [String] path to write to
-  # @param text [String] text to write
-  #
-  def write(file:, text:)
-    File.open(file, 'w') { |f| f.write text }
-  end
+    # Prints a string then gets input
+    # @param txt [String]
+    #
+    module Prompt
+      def _prompt(txt)
+        puts txt
+        gets.chomp
+      end
+    end
 
-  # if args[0] (object) is blank, raises args[1] (message)
-  # @param args [Array] - value 1 is obj, value 2 is msg
-  #
-  def error_if_blank(args)
-    obj, msg = args
-    obj.blank? && error(msg)
-  end
+    # Shifts one ARGV and raises a message if it's undefined.
+    # @param msg [String]
+    #
+    module GetArgOrError
+      def get_arg_or_error(msg)
+        ([ARGV.shift, msg].tap &method(:error_if_blank)).shift
+      end
+    end
 
-  # shorter proc shorthands
-  #
-  alias m method
+    # Writes a string to a file
+    # @param file [String] path to write to
+    # @param text [String] text to write
+    #
+    module Write
+      def write(file:, text:)
+        File.open(file, 'w') { |f| f.write text }
+      end
+    end
 
-  # method which does absolutely nothing, ignoring all arguments
-  #
-  def nothing(*args)
-  end
+    # if args[0] (object) is blank, raises args[1] (message)
+    # @param args [Array] - value 1 is obj, value 2 is msg
+    #
+    module ErrorIfBlank
+      def error_if_blank(args)
+        obj, msg = args
+        obj.blank? && error(msg)
+      end
+    end
+
+    module M
+      # shorter proc shorthands
+      def m(*args)
+        method(*args)
+      end
+    end
+
+    # method which does absolutely nothing, ignoring all arguments
+    #
+    module Nothing
+      def nothing(*args)
+      end
+    end
 
-  refine Object do
-    include Gemmy::Patches::ObjectPatch
   end
 
 end

data/lib/gemmy/patches/string_patch.rb

@@ -2,20 +2,25 @@
 #
 module Gemmy::Patches::StringPatch
 
-  # reference 'strip_heredoc' (provided by active support) by 'unindent'
-  #
-  # this takes an indented heredoc and treats it as if the first line is not
-  # indented.
-  #
-  # Instead of using alias, a method is defined here to enable modular
-  # patches
-  #
-  def unindent
-    strip_heredoc
+  module ClassMethods
   end
 
-  refine String do
-    include Gemmy::Patches::StringPatch
+  module InstanceMethods
+
+    # reference 'strip_heredoc' (provided by active support) by 'unindent'
+    #
+    # this takes an indented heredoc and treats it as if the first line is not
+    # indented.
+    #
+    # Instead of using alias, a method is defined here to enable modular
+    # patches
+    #
+    module Unindent
+      def unindent
+        strip_heredoc
+      end
+    end
+
   end
 
 end

data/lib/gemmy/patches/symbol_patch.rb

@@ -2,18 +2,24 @@
 #
 module Gemmy::Patches::SymbolPatch
 
-  # Patch symbol so the proc shorthand can take extra arguments
-  # http://stackoverflow.com/a/23711606/2981429
-  #
-  # Example: [1,2,3].map &:*.with(2)
-  # => [2,4,6]
-  #
-  def with(*args, &block)
-    ->(caller, *rest) { caller.send(self, *rest, *args, &block) }
+  module ClassMethods
   end
 
-  refine Symbol do
-    include Gemmy::Patches::SymbolPatch
+  module InstanceMethods
+
+    # Patch symbol so the proc shorthand can take extra arguments
+    # http://stackoverflow.com/a/23711606/2981429
+    #
+    # Example: [1,2,3].map &:*.with(2)
+    # => [2,4,6]
+    #
+    module With
+      def with(*args, &block)
+        ->(caller, *rest) { caller.send(self, *rest, *args, &block) }
+      end
+    end
+
   end
 
+
 end

data/lib/gemmy/patches/thread_patch.rb

@@ -5,14 +5,17 @@
 #
 module Gemmy::Patches::ThreadPatch
 
-  # Ensure that threads bubble up their errors
-  #
-  def self.included(base)
-    Thread.abort_on_exception = true
+  module ClassMethods
+    module Included
+      # Ensure that threads bubble up their errors
+      #
+      def self.included(base)
+        Thread.abort_on_exception = true
+      end
+    end
   end
 
-  refine Thread do
-    include Gemmy::Patches::ThreadPatch
+  module InstanceMethods
   end
 
 end

data/lib/gemmy/patches.rb

@@ -1,23 +1,89 @@
 # Gemmy provides patches for a few of the core classes.
 #
-# See {Gemmy#load_globally} for how to load these on the root namespace
+# Use Gemmy#load_globally to load these on the root namespace
 # For a refinements-based approach, use this in a class/module definition:
 #
-# Gemmy::Patches.refinements.each { |klass| using klass }
+# Gemmy::Patches.class_refinements.each { |klass| using klass }
 #
-# Note that there are nuances for how refinements are used. You can't refer to
-# the patches using define_method, for example.
+# Note that there are nuances for how refinements are used.
+# You can't refer to the patches using define_method, for example.
 #
 # See examples/01_using_as_refinement.rb for more info
+# (linked from the README at github.com/maxpleaner/gemmy
 #
 module Gemmy::Patches
 
-  def self.refinements(only: nil, except: nil)
-    core_patches.select do |core_klass, patch_klass|
-      return false if only && !only.include?(core_klass)
-      return false if except && except.include?(core_klass)
-      true
-    end.values
+  # The usage of this method is to load all the patches for some core classes.
+  # With no arguments it will include all patches
+  # There are two optional params (keyword arguments).
+  # @param only [Array<Symbol>] if provided, will only patch those classes
+  # @param except [Array<Symbol>] if provided, will exclude those classes
+  # @return [Array<Class>] to be iteratively passed to 'using'
+  def self.class_refinements(only: nil, except: nil)
+    return @@refined if defined? @@refined
+    @@refined = core_patches.reduce([]) do |arr, (core_klass_sym, patch_klass)|
+      next if only && !only.include?(core_klass_sym)
+      next if except && except.include?(core_klass_sym)
+      core_klass = const_get core_klass_sym.to_s
+      class_patches = patch_klass.const_get "ClassMethods"
+      instance_patches = patch_klass.const_get "InstanceMethods"
+      class_patches.constants.each do |patch_class_sym|
+        patch_class = class_patches.const_get patch_class_sym
+        patch_as_class_method(core_klass, patch_class)
+        arr.push patch_class
+      end
+      instance_patches.constants.each do |patch_class_sym|
+        patch_class = instance_patches.const_get patch_class_sym
+        patch_as_instance_method(core_klass, patch_class)
+        arr.push patch_class
+      end
+      arr
+    end.compact
+    @@refined
+  end
+
+  # Cherry pick methods to patch.
+  # @param hash [Hash] with a particular structure:
+  #   top level keys are Symbols referring to core classes, i.e. :String
+  #   top level values are hashes.
+  #   second level keys are either :ClassMethods or :InstanceMethods
+  #                                referring to the scope
+  #   second level values are arrays of symbols (one per method)
+  #
+  # To give an example:
+  #
+  #   Gemmy::Patches.method_refinements(
+  #     Array: { InstanceMethods: [:Recurse, :KeyBy] }
+  #   ).each { |r| using r }
+  #
+  def self.method_refinements(hash)
+    hash.map do |core_klass_sym, patch_types|
+      core_class = const_get(core_klass_sym)
+      patch_types.map do |type_sym, patch_method_syms|
+        patch_methods = core_patches[core_klass_sym].const_get type_sym.to_s
+        patch_method_syms.map do |patch_method_sym|
+          method_class = patch_methods.const_get(patch_method_sym)
+          if type_sym == :InstanceMethods
+            patch_as_instance_method(core_class, method_class)
+          elsif type_sym == :ClassMethods
+            patch_as_class_method(core_class, method_class)
+          end
+          method_class
+        end
+      end
+    end.flatten.compact
+  end
+
+  def self.patch_as_class_method(core_klass, patch_klass)
+    patch_klass.send(:refine, core_klass.singleton_class) do
+      include patch_klass
+    end
+  end
+
+  def self.patch_as_instance_method(core_klass, patch_klass)
+    patch_klass.send(:refine, core_klass) do
+      include patch_klass
+    end
   end
 
   def self.core_patches
@@ -25,10 +91,11 @@ module Gemmy::Patches
       String: Gemmy::Patches::StringPatch,
       Symbol: Gemmy::Patches::SymbolPatch,
       Object: Gemmy::Patches::ObjectPatch,
-      Array:   Gemmy::Patches::ArrayPatch,
+      Array: Gemmy::Patches::ArrayPatch,
       Method: Gemmy::Patches::MethodPatch,
-      Hash:     Gemmy::Patches::HashPatch,
+      Hash: Gemmy::Patches::HashPatch,
       Thread: Gemmy::Patches::ThreadPatch,
+      Integer: Gemmy::Patches::IntegerPatch
     }.with_indifferent_access
   end
 

data/lib/gemmy/tasks/make_gem.rb

@@ -21,7 +21,7 @@
 #
 class Gemmy::Tasks::MakeGem
 
-  Gemmy::Patches.refinements.each { |r| using r }
+  Gemmy::Patches.class_refinements.each { |r| using r }
 
   # Builds a skeleton ruby gem.
   # Prompts for some input using gets.chomp

data/lib/gemmy/tests/component_tests/dynamic_steps_tests.rb

@@ -1,6 +1,6 @@
 module Gemmy::Tests::ComponentTests::DynamicStepsTests
 
-  Gemmy::Patches.refinements.each { |r| using r }
+  Gemmy::Patches.class_refinements.each { |r| using r }
 
   def self.run
     runner_class = Class.new
@@ -18,4 +18,5 @@ module Gemmy::Tests::ComponentTests::DynamicStepsTests
       puts "  step".blue
     end
   end
+
 end

data/lib/gemmy/tests/patch_test.rb

@@ -26,7 +26,7 @@ module Gemmy::Tests
 
     class PatchedClass
 
-      Gemmy::Patches.refinements.each { |r| using r }
+      Gemmy::Patches.class_refinements.each { |r| using r }
 
       extend Gemmy::Tests::PatchTests::Error
 

data/lib/gemmy/version.rb

@@ -1,3 +1,3 @@
 class Gemmy
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/gemmy.rb

@@ -15,13 +15,28 @@ class Gemmy
   # This is the method handling the global case
   #
   def self.load_globally
-    Patches.core_patches.each do |core_klass_name, patch_klass|
-      core_klass_name.to_s.constantize.include patch_klass
+    core_patches = Patches.core_patches.map do |core_klass_name, patch_klass|
+      core_klass = core_klass_name.to_s.constantize
+      instance_method_class = patch_klass.const_get("InstanceMethods")
+      class_method_class = patch_klass.const_get("ClassMethods")
+      instance_classes = instance_method_class.constants.map do |klass_sym|
+        klass = instance_method_class.const_get klass_sym
+        core_klass.include klass
+        klass
+      end
+      class_classes = class_method_class.constants.map do |klass_sym|
+        klass = class_method_class.const_get klass_sym
+        core_klass.extend klass
+        klass
+      end
+      [instance_classes, class_classes]
     end
-    Components.list.each do |patch_klass|
+    components = Components.list.map do |patch_klass|
       Object.include patch_klass
       Object.extend patch_klass
+      patch_klass
     end
+    [components, core_patches].flatten
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemmyrb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - max pleaner
@@ -102,6 +102,7 @@ files:
 - lib/gemmy/patches.rb
 - lib/gemmy/patches/array_patch.rb
 - lib/gemmy/patches/hash_patch.rb
+- lib/gemmy/patches/integer_patch.rb
 - lib/gemmy/patches/method_patch.rb
 - lib/gemmy/patches/object_patch.rb
 - lib/gemmy/patches/string_patch.rb