gemmyrb 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57241faae027cf6e4416104dcedd95dcdb6f3d56
-  data.tar.gz: 6f4caf998b97cd0e9fdc84f243f19813248e0541
+  metadata.gz: 959c5dce4ee3611f0e6a9a1ee91a8da5ed128b3b
+  data.tar.gz: 2a2349bd342e424e17246d58d951b6e99dd74538
 SHA512:
-  metadata.gz: 2fef2f0b535f1829842689b3c6d5dc92cbf223dac26ea3b0dceb60476a075309e59e3ee3be8e25b93b198734bc2e8c15f8c3a5030cfb4cb21a832fb13ddc51d5
-  data.tar.gz: ce6f3a3f1c5d7b54eac6e72fc1341bf3748a6926bc054cda10d6512e7905a22ca87d291ddd6c6dc8a485e70fb05750c42c1b0b6bc7a14e7a44125190bc16c4f3
+  metadata.gz: 7115fb4d4a8f4a152be9e24ac51bfd120101cd73d69d3356579aeda8526a83e7f77b99362571fdd2d1646849b0b6bbe703d34619f1234077b51245b61efcacd5
+  data.tar.gz: dc1d6dafb2a9e55032622f6aebbd38e540a6ba55998f1d3aa3048a71248fd50dfe9ef228e394c5072290ae8de90afadbc350d350e26ca14a596f549bef402207

data/README.md

@@ -19,7 +19,12 @@ documents:
 - _Loading the gem's code in different scopes_
   - [examples/01_using_as_refinement.rb](./examples/01_using_as_refinement.rb)
   - [examples/02_using_globally.rb](./examples/02_using_globally.rb)
-- _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](./examples/04_shell_commands.rb)
+  - [examples/03_shell_commands.rb](./examples/03_shell_commands.rb)
+
+**To see a full list of the patched methods (there are a lot since I've
+included many from facets), see the [rubydoc](http://www.rubydoc.info/gems/gemmyrb)**
+
+Specifically, look at the constants defined on Gemmy::Patches. There is one
+module for each of the core classes being patched. Each individual method
+is also contained in its own module (to make modular inclusion possible)

data/lib/gemmy/patches/array_patch.rb

@@ -6,7 +6,7 @@ module Gemmy::Patches::ArrayPatch
 
     module Zip
       # facets
-      def self.zip(*arrays)
+      def zip(*arrays)
         return [] if arrays.empty?
         return arrays[0].zip(*arrays[1..-1])
       end
@@ -16,6 +16,14 @@ module Gemmy::Patches::ArrayPatch
 
   module InstanceMethods
 
+    module Exclude
+      # facets
+      # the opposite of include
+      def exclude?(x)
+        ! include? x
+      end
+    end
+
     module KeyBy
       # facets
       def key_by

data/lib/gemmy/patches/class_patch.rb

@@ -0,0 +1,14 @@
+module Gemmy::Patches::ClassPatch
+  module InstanceMethods
+    module ToProc
+      # facets
+      # I.e if an initializer takes one arg, then you can do
+      # %w{ arg1 arg2 }.map &ClassToInitialize
+      def to_proc
+        proc{|*args| new(*args)}
+      end
+    end
+  end
+  module ClassMethods
+  end
+end

data/lib/gemmy/patches/exception_patch.rb

@@ -0,0 +1,40 @@
+module Gemmy::Patches::ExceptionPatch
+
+  module ClassMethods
+
+    module Raised
+      # facets
+      # does an exception raise an error?
+      def self.raised? #:yeild:
+        begin
+          yield
+          false
+        rescue self
+          true
+        end
+      end
+    end
+
+    module Suppress
+      # facets
+      def suppress(*err_classes)
+        err_classes.each do |e|
+          unless e < self
+            raise ArgumentError, "exception #{e} not a subclass of #{self}"
+          end
+        end
+        err_classes = err_classes.empty? ? [self] : err_classes
+        begin
+          yield
+        rescue Exception => e
+          raise unless err_classes.any? { |cls| e.kind_of?(cls) }
+        end
+      end
+    end
+
+  end
+
+  module InstanceMethods
+  end
+
+end

data/lib/gemmy/patches/float_patch.rb

@@ -0,0 +1,16 @@
+module Gemmy::Patches::FloatPatch
+  module ClassMethods
+  end
+  module InstanceMethods
+
+    module RoundTo
+      # facets
+      # i.e. 2.046.round_to(0.01) == 2.05
+      def round_to( n ) #n=1
+        return self if n == 0
+        (self * (1.0 / n)).round.to_f / (1.0 / n)
+      end
+    end
+
+  end
+end

data/lib/gemmy/patches/hash_patch.rb

@@ -3,10 +3,194 @@
 module Gemmy::Patches::HashPatch
 
   module ClassMethods
+    # facets
+    # Hash.zip(["a","b","c"], [1,2,3])
+    # => { "a"=>1, "b"=>2, "c"=>3 }
+    module Zip
+      def zip(keys,values) # or some better name
+        h = {}
+        keys.size.times{ |i| h[ keys[i] ] = values[i] }
+        h
+      end
+    end
   end
 
   module InstanceMethods
 
+    module UpdateKeys
+      # facets
+      # in place
+      def update_keys #:yield:
+        if block_given?
+          keys.each { |old_key| store(yield(old_key), delete(old_key)) }
+        else
+          to_enum(:update_keys)
+        end
+      end
+    end
+
+    module UpdateValues
+      # facets
+      # in place
+      def update_values #:yield:
+        if block_given?
+          each{ |k,v| store(k, yield(v)) }
+        else
+          to_enum(:update_values)
+        end
+      end
+    end
+
+    module ToOpenStruct
+      # facets
+      def to_ostruct
+        OpenStruct.new(self)
+      end
+      def recursive_to_ostruct(exclude={})
+        return exclude[self] if exclude.key?( self )
+        o = exclude[self] = OpenStruct.new
+        h = self.dup
+        each_pair do |k,v|
+          h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
+        end
+        o.merge!(h)
+      end
+    end
+
+    module Rekey
+      # facets
+      # rekey according to a block, i.e. {a: 1}.rekey &:to_s
+      def rekey(key_map=nil, &block)
+        raise ArgumentError, "argument or block" if key_map && block
+
+        if !(key_map or block)
+          block = lambda{|k| k.to_sym}
+        end
+
+        if block
+          hash = dup.clear
+          if block.arity.abs == 1
+            each_pair do |k, v|
+              hash[block[k]] = v     #hash[block[k] || k] = v
+            end
+          else
+            each_pair do |k, v|
+              hash[block[k,v]] = v   #hash[block[k,v] || k] = v
+            end
+          end
+        else
+          #hash = dup.clear  # to keep default_proc
+          #(keys - key_map.keys).each do |key|
+          #  hash[key] = self[key]
+          #end
+          #key_map.each do |from, to|
+          #  hash[to] = self[from] if key?(from)
+          #end
+          hash = dup  # to keep default_proc
+          key_map.each_pair do |from, to|
+            hash[to] = hash.delete(from) if hash.key?(from)
+          end
+        end
+
+        hash
+      end
+    end
+
+    module Recurse
+      # facets
+      # h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
+      # g = h.recurse{|h| h.inject({}){|h,(k,v)| h[k.to_s] = v; h} }
+      # g  #=> {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+      def recurse(*types, &block)
+        types = [self.class] if types.empty?
+        h = inject({}) do |hash, (key, value)|
+          case value
+          when *types
+            hash[key] = value.recurse(*types, &block)
+          else
+            hash[key] = value
+          end
+          hash
+        end
+        yield h
+      end
+    end
+
+    module HasKeys
+      # facets
+      # checks if a list of keys are all present
+      def keys?(*check_keys)
+        unknown_keys = check_keys - self.keys
+        return unknown_keys.empty?
+      end
+    end
+
+    module OnlyKeys
+      # facets
+      # checks if these are the only keys
+      def only_keys?(*check_keys)
+        unknown_keys = self.keys - check_keys
+        return unknown_keys.empty?
+      end
+    end
+
+    module Join
+      # facets
+      # returns a string
+      def join(pair_divider='', elem_divider=nil)
+        elem_divider ||= pair_divider
+        s = []
+        each{ |k,v| s << "#{k}#{pair_divider}#{v}" }
+        s.join(elem_divider)
+      end
+    end
+
+    module Inverse
+      # facets
+      # h = {"a"=>3, "b"=>3, "c"=>3, "d"=>2, "e"=>9, "f"=>3, "g"=>9}
+      # h.invert           #=> {2=>"d", 3=>"f", 9=>"g"}
+      # h.inverse          #=> {2=>"d", 3=>["f", "c", "b", "a"], 9=>["g", "e"]}
+      # h.inverse.inverse  #=> {"a"=>3, "b"=>3, "c"=>3, "d"=>2, "e"=>9, "f"=>3, "g"=>9}
+      def inverse
+        i = Hash.new
+        self.each_pair{ |k,v|
+          if (Array === v)
+            v.each{ |x| i[x] = ( i.has_key?(x) ? [k,i[x]].flatten : k ) }
+          else
+            i[v] = ( i.has_key?(v) ? [k,i[v]].flatten : k )
+          end
+        }
+        return i
+      end
+    end
+
+    module Diff
+      # facets
+      # returns the key-vals from <self> that are not the same in <hash>
+      def diff(hash)
+        h1 = self.dup.delete_if{ |k,v| hash[k] == v }
+        h2 = hash.dup.delete_if{ |k,v| has_key?(k) }
+        h1.merge(h2)
+      end
+    end
+
+    module Except
+      # facets
+      # excludes vertain keys
+      def except(*less_keys)
+        hash = dup
+        less_keys.each{ |k| hash.delete(k) }
+        hash
+      end
+    end
+
+    module DeleteUnless
+      # facets
+      def delete_unless #:yield:
+        delete_if{ |key, value| ! yield(key, value) }
+      end
+    end
+
     # The opposite of Hash#dig
     # Takes a list of keys followed by a value to set
     #

data/lib/gemmy/patches/integer_patch.rb

@@ -2,6 +2,27 @@ module Gemmy::Patches::IntegerPatch
 
   module ClassMethods
 
+    module RomanValues
+      # facets
+      def roman_values
+        [
+          ["M", 1000],
+          ["CM", 900],
+          ["D",  500],
+          ["CD", 400],
+          ["C",  100],
+          ["XC",  90],
+          ["L",   50],
+          ["XL",  40],
+          ["X",   10],
+          ["IX",   9],
+          ["V",    5],
+          ["IV",   4],
+          ["I",    1]
+        ].to_h
+      end
+    end
+
   end
 
   module InstanceMethods

data/lib/gemmy/patches/object_patch.rb

@@ -1,12 +1,203 @@
 # Object patches. Can be called with implicit receiver
 #
+# Patches which are originally specified as being for Kernel (by facets,
+# for examples), are implemented here as patches on Object because Kernel is
+# a module and Ruby doesn't support refinements on Modules. Object includes
+# and extends Kernel so it's the same effect.
+#
 module Gemmy::Patches::ObjectPatch
 
+  # This class is redundant here, since Object's instance methods
+  # are available at the class scope anyway.
   module ClassMethods
   end
 
   module InstanceMethods
 
+    module Iteself
+      # facets
+      def itself
+        def itself
+          self
+        end
+      end
+    end
+
+    module Try
+      # facets
+      # nicer than the builtin
+      # @example.try.name    #=> "bob"
+      # @people.try(:collect){ |p| p.name }
+      def try(method=nil, *args, &block)
+        if method
+          __send__(method, *args, &block)
+        else
+          self
+        end
+      end
+    end
+
+    module Not
+      # facets
+      # true.nil?.not? == !true.nil?
+      def not?
+        !self
+      end
+    end
+
+    module Truthy
+      def truthy
+        !! self
+      end
+    end
+
+    module Falsy
+      def Falsy
+        ! self
+      end
+    end
+
+    module NotNil
+      # facets
+      def not_nil?
+        ! nil?
+      end
+    end
+
+    module Maybe
+      # Random generator that returns true or false. Can also take a block that has a 50/50 chance to being executed…
+      # facets
+      def maybe(chance = 0.5, &block)
+        if block
+          yield if rand < chance
+        else
+          rand < chance
+        end
+      end
+    end
+
+    module InstanceAssign
+      # facets
+      # assign instance variables with a hash
+      def instance_assign(hash)
+        hash.each do |k,v|
+          k = "@#{k}" if k !~ /^@/
+          instance_variable_set(k, v)
+        end
+        self
+      end
+    end
+
+    module HierarchicalSend
+      # facets
+      # Send a message to each ancestor in an object's class hierarchy. The method will only be called if the method is defined for the ancestor.
+      # This can be very useful for setting up a `preinitialize` system.
+      #
+      # Example:
+      # m = Module.new do
+      #       attr :a
+      #       def preinitialize
+      #         @a = 1
+      #       end
+      #     end
+      #
+      # c = Class.new do
+      #       include m
+      #       def initialize
+      #         hierarchical_send(:preinitialize)
+      #       end
+      #     end
+
+      # c.new.a  #=> 1
+      def hierarchical_send(method_name, *args, &block)
+        method_name = method_name.to_s if RUBY_VERSION < '1.9'
+        this = self
+        self.class.hierarchically do |anc|
+          ## is there really no better way to check for the method?
+          if anc.instance_methods(false).include?(method_name) or
+               anc.public_instance_methods(false).include?(method_name) or
+               anc.private_instance_methods(false).include?(method_name) or
+               anc.protected_instance_methods(false).include?(method_name)
+            im = anc.instance_method(method_name)
+            ##im.arity == 0 ? im.bind(this).call(&block) : im.bind(this).call(*args, &block)
+            im.bind(this).call(*args, &block)
+          end
+        end
+      end
+    end
+
+    module Ergo
+      # facets
+      # This is like #tap, but #tap yields self and returns self,
+      # where as #ergo yields self but returns the result.
+      def ergo(&b)
+        if block_given?
+          b.arity > 0 ? yield(self) : instance_eval(&b)
+        else
+          self
+        end
+      end
+    end
+
+    module DeepCopy
+      # facets
+      def deep_copy
+        Marshal::load(Marshal::dump(self))
+      end
+    end
+
+    module Constant
+      # facets
+      # like Module#const_get accessible at all levels
+      # and handles module hierarchy.
+      # constant("Process::Sys")
+      def constant(const)
+        const = const.to_s.dup
+        base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+        const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+      end
+    end
+
+    module Bool
+      # facets
+      def bool?
+        (true == self or false == self)
+      end
+    end
+
+    module AttrSingletonAccessor
+      # facets
+      # obj = Object.new
+      # obj.attr_singleton_accessor :x, :y
+      def attr_singleton_accessor(*args)
+        #h, a = *args.partition{|a| Hash===a}
+        (class << self ; self ; end).send( :attr_accessor, *args )
+        #(class << self ; self ; end).send( :attr_accessor, *h.keys )
+        #h.each { |k,v| instance_variable_set("@#{k}", v) }
+      end
+    end
+
+    module AttrSingletonReader
+      # facets
+      def attr_singleton_reader(*args)
+        #h, a = *args.partition{|a| Hash===a}
+        (class << self ; self ; end).send( :attr_reader, *args )
+        #(class << self ; self ; end).send( :attr_reader, *h.keys )
+        #h.each { |k,v| instance_variable_set("@#{k}", v) }
+      end
+    end
+
+    module AttrSingletonWriter
+      # facets
+      def attr_singleton_writer(*args)
+        #h, a = *args.partition{|a| Hash===a}
+        (class << self ; self ; end).send( :attr_writer, *args )
+        #(class << self ; self ; end).send( :attr_writer, *h.keys )
+        #h.each { |k,v| instance_variable_set("@#{k}", v) }
+      end
+    end
+
+
     # Turns on verbose mode, showing warnings
     #
     module VerboseMode
@@ -24,6 +215,15 @@ module Gemmy::Patches::ObjectPatch
       end
     end
 
+    module Ask
+      # facets
+      def ask(prompt=nil)
+        $stdout << "#{prompt}"
+        $stdout.flush
+        $stdin.gets.chomp!
+      end
+    end
+
     # Prints a string then gets input
     # @param txt [String]
     #

data/lib/gemmy/patches/proc_patch.rb

@@ -0,0 +1,83 @@
+module Gemmy::Patches::ProcPatch
+  module ClassMethods
+  end
+  module InstanceMethods
+
+    module ToMethod
+      # facets
+      # converts a proc to a method on an object
+      # object = Object.__new__
+      # function = lambda { |x| x + 1 }
+      # function.to_method(object, 'foo')
+      # object.foo(1)  #=> 2
+      def to_method(object, name=nil)
+        ##object = object || eval("self", self)
+        block, time = self, Time.now
+        method_name = name || "__bind_#{time.to_i}_#{time.usec}"
+        begin
+          object.singleton_class.class_eval do
+            define_method(method_name, &block)
+            method = instance_method(method_name)
+            remove_method(method_name) unless name
+            method
+          end.bind(object)
+        rescue TypeError
+          object.class.class_eval do
+            define_method(method_name, &block)
+            method = instance_method(method_name)
+            remove_method(method_name) unless name
+            method
+          end.bind(object)
+        end
+      end
+    end
+
+    # facets
+    # can be used for higher-order methods
+    # a = lambda { |x| x + 4 }
+    # b = lambda { |y| y / 2 }
+
+    # (a * b).call(4)  #=> 6
+    # (b * a).call(4)  #=> 4
+    module Multiply
+      def *(x)
+        if Integer===x
+          # collect times
+          c = []
+          x.times{|i| c << call(i)}
+          c
+        else
+          # compose procs
+          lambda{|*a| self[x[*a]]}
+        end
+      end
+    end
+
+    module Compose
+      # facets
+      # similar to multiply
+      #
+      # a = lambda { |x| x + 4 }
+      # b = lambda { |y| y / 2 }
+
+      # a.compose(b).call(4)  #=> 6
+      # b.compose(a).call(4)  #=> 4
+      def compose(g)
+        raise ArgumentError, "arity count mismatch" unless arity == g.arity
+        lambda{ |*a| self[ *g[*a] ] }
+      end
+    end
+
+    module BindTo
+      # facets
+      # a = [1,2,3]
+      # p1 = Proc.new{ join(' ') }
+      # p2 = p1.bind_to(a)
+      # p2.call  #=> '1 2 3'
+      def bind_to(object)
+        Proc.new{object.instance_eval(&self)}
+      end
+    end
+
+  end
+end

data/lib/gemmy/patches/string_patch.rb

@@ -7,6 +7,223 @@ module Gemmy::Patches::StringPatch
 
   module InstanceMethods
 
+    module Words
+      # facets
+      def words
+        self.split(/\s+/)
+      end
+    end
+
+    module Rotate
+      # facets
+      # 'abcdefgh'.rotate(2)  #=> 'cdefghab'
+      # 'abcdefgh'.rotate(-2) #=> 'ghabcdef'
+      def rotate(count=1)
+        count+=self.length if count<0
+        self.slice(count,self.length-count)+self.slice(0,count)
+      end
+    end
+
+    module Range
+      # facets
+      # Gets the start/end indexes of a match to <pattern>
+      # only considers first match
+      def range(pattern, offset=0)
+        unless Regexp === pattern
+          pattern = Regexp.new(Regexp.escape(pattern.to_s))
+        end
+        string = self[offset..-1]
+        if md = pattern.match(string)
+          return (md.begin(0)+offset)..(md.end(0)+offset-1)
+        end
+        nil
+      end
+    end
+
+    module RangeAll
+      # facets
+      # like #range patch but returns start/end indexes of all matches
+      def range_all(pattern, reuse=false)
+        r = []; i = 0
+        while i < self.length
+          rng = range(pattern, i)
+          if rng
+            r << rng
+            i += reuse ? 1 : rng.end + 1
+          else
+            break
+          end
+        end
+        r.uniq
+      end
+    end
+
+    module IsNumber
+      # facets
+      def is_number?
+        !!self.match(/\A[+-]?\d+?(_?\d+?)*?(\.\d+(_?\d+?)*?)?\Z/)
+      end
+    end
+
+    module EachMatch
+      # facets
+      # iterator over matches from regex
+      def each_match(re) #:yield:
+        if block_given?
+          scan(re) { yield($~) }
+        else
+          m = []
+          scan(re) { m << $~ }
+          m
+        end
+      end
+    end
+
+    module LineWrap
+      # facets
+      # wrap lines at width
+      def line_wrap(width, tabs=4)
+        s = gsub(/\t/,' ' * tabs) # tabs default to 4 spaces
+        s = s.gsub(/\n/,' ')
+        r = s.scan( /.{1,#{width}}/ )
+        r.join("\n") << "\n"
+      end
+    end
+
+    module Lchomp
+      # facets
+      def lchomp(match)
+        if index(match) == 0
+          self[match.size..-1]
+        else
+          self.dup
+        end
+      end
+    end
+
+    module IndexAll
+      # facets
+      # standard String#index only shows the first match
+      def index_all(s, reuse=false)
+        s = Regexp.new(Regexp.escape(s)) unless Regexp===s
+        ia = []; i = 0
+        while (i = index(s,i))
+          ia << i
+          i += (reuse ? 1 : $~[0].size)
+        end
+        ia
+      end
+    end
+
+    module Indent
+      # facets
+      def indent(n, c=' ')
+        if n >= 0
+          gsub(/^/, c * n)
+        else
+          gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+        end
+      end
+    end
+
+    module ExpandTabs
+      # turns tabs to spaces
+      def expand_tabs(n=8)
+        n = n.to_int
+        raise ArgumentError, "n must be >= 0" if n < 0
+        return gsub(/\t/, "") if n == 0
+        return gsub(/\t/, " ") if n == 1
+        str = self.dup
+        while
+          str.gsub!(/^([^\t\n]*)(\t+)/) { |f|
+            val = ( n * $2.size - ($1.size % n) )
+            $1 << (' ' * val)
+          }
+        end
+        str
+      end
+    end
+
+    module Exclude
+      # facets
+      def exclude?(str)
+        !include?(str)
+      end
+    end
+
+    module CompressLines
+      # facets
+      # replace newlines or N spaces with one space
+      def compress_lines(spaced = true)
+        split($/).map{ |line| line.strip }.join(spaced ? ' ' : '')
+      end
+    end
+
+    module AlignCenter
+      # facets
+      def align_center(n, sep="\n", c=' ')
+        return center(n.to_i,c.to_s) if sep==nil
+        q = split(sep.to_s).collect { |line|
+          line.center(n.to_i,c.to_s)
+        }
+        q.join(sep.to_s)
+      end
+    end
+
+    module AlignLeft
+      # facets
+      def align_left(n, sep="\n", c=' ')
+        return ljust(n.to_i,c.to_s) if sep==nil
+        q = split(sep.to_s).map do |line|
+          line.strip.ljust(n.to_i,c.to_s)
+        end
+        q.join(sep.to_s)
+      end
+    end
+
+    module AsciiOnly
+      # facets
+      # remove non ascii characters
+      def ascii_only(alt='')
+        encoding_options = {
+          :invalid                     => :replace,  # Replace invalid byte sequences
+          :undef                       => :replace,  # Replace anything not defined in ASCII
+          :replace                     => alt,       # Use a blank for those replacements
+          :UNIVERSAL_NEWLINE_DECORATOR => true       # Always break lines with \n
+        }
+        self.encode(Encoding.find('ASCII'), encoding_options)
+      end
+    end
+
+    module AlignRight
+      # facets
+      def align_right(n, sep="\n", c=' ')
+        return rjust(n.to_i,c.to_s) if sep==nil
+        q = split(sep.to_s).map do |line|
+          line.rjust(n.to_i,c.to_s)
+        end
+        q.join(sep.to_s)
+      end
+    end
+
+    module Subtract
+      # facets
+      # removes all instances of a pattern from a string 
+      def -(pattern)
+        gsub(pattern, '')
+      end
+    end
+
+    module Random
+      # facets
+      # a random string of length n with a given character set
+      def self.random(len=32, character_set = ["A".."Z", "a".."z", "0".."9"])
+        characters = character_set.map { |i| i.to_a }.flatten
+        characters_len = characters.length
+        (0...len).map{ characters[rand(characters_len)] }.join
+      end
+    end
+
     # reference 'strip_heredoc' (provided by active support) by 'unindent'
     #
     # this takes an indented heredoc and treats it as if the first line is not

data/lib/gemmy/patches/symbol_patch.rb

@@ -5,7 +5,16 @@ module Gemmy::Patches::SymbolPatch
   module ClassMethods
   end
 
-  module InstanceMethods
+module InstanceMethods
+
+    module Variablize
+      # facets
+      # take a symbol and make it fine for an instance variable name
+      def variablize
+        name = to_s.gsub(/\W/, '_')
+        "@#{name}".to_sym
+      end
+    end
 
     # Patch symbol so the proc shorthand can take extra arguments
     # http://stackoverflow.com/a/23711606/2981429

data/lib/gemmy/patches.rb

@@ -95,7 +95,11 @@ module Gemmy::Patches
       Method: Gemmy::Patches::MethodPatch,
       Hash: Gemmy::Patches::HashPatch,
       Thread: Gemmy::Patches::ThreadPatch,
-      Integer: Gemmy::Patches::IntegerPatch
+      Integer: Gemmy::Patches::IntegerPatch,
+      Class: Gemmy::Patches::ClassPatch,
+      Exception: Gemmy::Patches::ExceptionPatch,
+      Float: Gemmy::Patches::FloatPatch,
+      Proc: Gemmy::Patches::ProcPatch
     }.with_indifferent_access
   end
 

data/lib/gemmy/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemmyrb
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - max pleaner
@@ -101,10 +101,14 @@ files:
 - lib/gemmy/components/dynamic_steps.rb
 - lib/gemmy/patches.rb
 - lib/gemmy/patches/array_patch.rb
+- lib/gemmy/patches/class_patch.rb
+- lib/gemmy/patches/exception_patch.rb
+- lib/gemmy/patches/float_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/proc_patch.rb
 - lib/gemmy/patches/string_patch.rb
 - lib/gemmy/patches/symbol_patch.rb
 - lib/gemmy/patches/thread_patch.rb