gemmyrb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 18532f58f02f659faa596f0ed22dd3f85acfa1a4
+  data.tar.gz: 17ee68de85cf655f22bb5190e33a27378ecee904
+SHA512:
+  metadata.gz: 32ef4734ff5168c54883208469f150927eb09053786e8dc6f5721f6d449061f509a60b0a1028eca628d973ef042339d4e55ee9be8d9c3edba1aea3ecf2e60d7c
+  data.tar.gz: cee902db7fa77e8e555f6473bf4bd1191353206df35697d0ade31a5bcb0a13322db9335ebbb59a330810cb4aacc3c1ad3e04c0f035b5dabf99d06b0799360c85

data/README.md

@@ -0,0 +1,18 @@
+### Gemmy gem
+
+This is a general purpose gem.
+
+I'm continually adding small core patches and utility classes.
+
+It is on RubyGems and can be installed with `gem install gemmyrb`
+
+**note**
+
+because there is an existing gem named `gemmy`, the name passed
+to `gem install` is `gemmyrb`. But `require 'gemmy'` is still used. 
+
+For more information, see the following documents:
+
+- [examples/01_using_as_refinement.rb](.examples/01_using_as_refinement.rb)
+- [examples/02_using_globally.rb](.examples/02_using_globally.rb)
+- [examples/03_full_api.rb](.examples/03_full_api.rb)

data/bin/gemmy

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'gemmy'
+
+Gemmy::CLI.run

data/lib/gemmy/cli.rb

@@ -0,0 +1,41 @@
+# Command line interface
+#
+# Run from command line:
+#   gemmy <arguments>
+#   e.g. gemmy help
+#
+# Start from code with Gemmy::CLI.run
+#
+class Gemmy::CLI < Thor
+
+  # Start the CLI
+  # @param arguments [Array<String>] passed to thor, defaults to ARGV
+  #
+  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
+    ARGV.clear
+
+    # Can't make this conditional on "__FILE__ == $0"
+    # Because of the way gem executables are run
+    start arguments
+  end
+
+  # Task to make a gem
+  # @param name [String] the name of the gem
+  # Other options are requested via gets
+  #
+  desc "make_gem NAME", "make a skeleton ruby gem project"
+  def make_gem(name)
+    Gemmy::Tasks::MakeGem.run(name)
+  end
+
+  # Test the gem.
+  #
+  desc "test", "test the gem"
+  def test
+    Gemmy::Tests.run
+  end
+
+end

data/lib/gemmy/components/dynamic_steps.rb

@@ -0,0 +1,92 @@
+# Mimics the Cucumber API:
+#   {DynamicSteps#step} runs a step
+#   {DynamicSteps#define_step} defines a step
+#
+# The usage is the same as Cucumber:
+#
+#   define_step /I print (.+) (.+) times/ do |string, n|
+#     n.times { print string }
+#   end
+#
+#   step "I print hello 2 times"
+#   => 'hellohello'
+#
+# Like Cucumber, it will raise an error if there is > 1 matching step
+# {DynamicSteps::AmbiguousMatchError} can be rescued if desired.
+#
+# It also raises an error if no matcher was found
+#
+module Gemmy::Components::DynamicSteps
+
+  Gemmy::Patches.refinements.each { |r| using r }
+
+  # A hash mapping regex to proc
+  #
+  attr_reader :steps
+
+  # Error raised when a string matches multiple step regexes.
+  # It's frequently accidental to come into this situation,
+  # and having this check prevents surprise errors.
+  #
+  class AmbiguousMatchError < StandardError; end
+
+  # Error raised when no matcher is found for a string
+  #
+  class NoMatchFoundError < StandardError; end
+
+  def steps
+    @steps ||= {}
+  end
+
+  # Defines a regex => proc mapping
+  # A good pattern for regex is to use (.+) as match groups, and
+  # mirror those as sequential named parameters in the block.
+  #
+  # Match groups are left-greedy, for example:
+  #   "1 2 3 4 5".match(/(.+) (.+)/).tap &:shift
+  #   # => ['1 2 3 4', '5']
+  #
+  def define_step(regex, &blk)
+    steps[regex] = blk
+  end
+
+  # run a step.
+  # searches @step keys for regex which matches the string
+  # then runs the associated proc, passing the regex match results
+  #
+  def step(string)
+    matching_steps = find_matching_steps(string)
+    if matching_steps.keys.length > 1
+      # Failure, multiple matching steps
+      raise(
+        AmbiguousMatchError,
+        "step #{string} matched: #{matching_steps.keys.join(", ")}"
+      )
+    elsif matching_steps.keys.length == 0
+      # Failure, no matching step
+      raise(
+        NoMatchFoundError,
+        "step #{string} had no match"
+      )
+    else
+      # Success, run the proc
+      matching_step = matching_steps.values[0]
+      matching_step[:proc].call(*(matching_step[:matches]))
+    end
+  end
+
+  # Searches the keys in @steps for a regex the matches the string.
+  # If one is found, it adds the regex as a key in the results hash.
+  # The value is a hash with two keys: :matches (an array) and :proc
+  #
+  def find_matching_steps(string)
+    matching_steps = steps.reduce({}) do |matching_steps, (regex, proc)|
+      match_results = string.match(regex).to_a.tap &:shift
+      if match_results.any_not? &:blank?
+        matching_steps[regex] = { matches: match_results, proc: proc }
+      end
+      matching_steps
+    end
+  end
+
+end

data/lib/gemmy/components.rb

@@ -0,0 +1,17 @@
+  # Different collections of functionality
+  #
+  module Gemmy::Components
+    def self.included(base)
+      list.each do |klass|
+        base.include klass
+        base.extend klass
+      end
+    end
+
+    def self.list
+      [
+        Gemmy::Components::DynamicSteps
+      ]
+    end
+
+  end

data/lib/gemmy/patches/array_patch.rb

@@ -0,0 +1,19 @@
+# Global patches. Could be applied to Object or Kernel
+#
+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) }
+  end
+
+  refine Array do
+    include Gemmy::Patches::ArrayPatch
+  end
+
+end

data/lib/gemmy/patches/hash_patch.rb

@@ -0,0 +1,104 @@
+# Hash patches
+#
+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)
+  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
+
+  # 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
+
+  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
+  #
+  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({})
+        end
+      end
+      hash.extend Gemmy::Patches::HashPatch::PersistedHash
+    end
+  end
+
+  # Helper methods for the persistence patch
+  #
+  module PersistedHash
+    def get(*keys, disk: false)
+      disk ? @db.transaction { @db[:data].dig(*keys) } : dig(*keys)
+    end
+    def set(*keys, val)
+      Gemmy::Patches::HashPatch._bury(self, *keys, val)
+      @db.transaction do
+        Gemmy::Patches::HashPatch._bury(@db[:data], *(keys + [val]))
+      end
+      val
+    end
+  end
+
+  refine Hash do
+    include Gemmy::Patches::HashPatch
+  end
+
+end

data/lib/gemmy/patches/method_patch.rb

@@ -0,0 +1,22 @@
+# Method patches. To the 'Method' class i.e. `method(:puts)`
+#
+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
+  end
+
+  refine Method do
+    include Gemmy::Patches::MethodPatch
+  end
+
+end

data/lib/gemmy/patches/object_patch.rb

@@ -0,0 +1,62 @@
+# Object patches. Can be called with implicit receiver
+#
+module Gemmy::Patches::ObjectPatch
+
+  # Turns on verbose mode, showing warnings
+  #
+  def verbose_mode
+    $VERBOSE = true
+  end
+
+  # Generic error. Raises RuntimeError
+  # @param msg [String] optional
+  #
+  def error(msg='')
+    raise RuntimeError, msg
+  end
+
+  # Prints a string then gets input
+  # @param txt [String]
+  #
+  def _prompt(txt)
+    puts txt
+    gets.chomp
+  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
+
+  # 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', &:write.with(text))
+  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
+
+  # shorter proc shorthands
+  #
+  alias m method
+
+  # method which does absolutely nothing, ignoring all arguments
+  #
+  def nothing(*args)
+  end
+
+  refine Object do
+    include Gemmy::Patches::ObjectPatch
+  end
+
+end

data/lib/gemmy/patches/string_patch.rb

@@ -0,0 +1,21 @@
+# String patches
+#
+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
+  end
+
+  refine String do
+    include Gemmy::Patches::StringPatch
+  end
+
+end

data/lib/gemmy/patches/symbol_patch.rb

@@ -0,0 +1,19 @@
+# Symbol patches
+#
+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) }
+  end
+
+  refine Symbol do
+    include Gemmy::Patches::SymbolPatch
+  end
+
+end

data/lib/gemmy/patches/thread_patch.rb

@@ -0,0 +1,18 @@
+# Thread patches
+# This does some core configuration to Thread as soon as the patches are
+# included, so functionality will be changed even without calling any of these
+# methods
+#
+module Gemmy::Patches::ThreadPatch
+
+  # Ensure that threads bubble up their errors
+  #
+  def self.included(base)
+    Thread.abort_on_exception = true
+  end
+
+  refine Thread do
+    include Gemmy::Patches::ThreadPatch
+  end
+
+end

data/lib/gemmy/patches.rb

@@ -0,0 +1,25 @@
+# Gemmy provides patches for a few of the core classes.
+#
+# For example:
+#   Gemmy::Patches.load(only: [:string])
+#   Gemmy::Patches.load(except: [:symbol, :global])
+#
+module Gemmy::Patches
+
+  def self.refinements
+    core_patches.values
+  end
+
+  def self.core_patches
+    @@core_patches ||= {
+      String: Gemmy::Patches::StringPatch,
+      Symbol: Gemmy::Patches::SymbolPatch,
+      Object: Gemmy::Patches::ObjectPatch,
+      Array:   Gemmy::Patches::ArrayPatch,
+      Method: Gemmy::Patches::MethodPatch,
+      Hash:     Gemmy::Patches::HashPatch,
+      Thread: Gemmy::Patches::ThreadPatch,
+    }
+  end
+
+end

data/lib/gemmy/tasks/make_gem.rb

@@ -0,0 +1,189 @@
+# A task to create skeleton structure for a ruby gem
+#
+# Only one method is intended for public use, {Tasks::MakeGem#run}.
+#
+# It takes one argument - the name of the ruby gem.
+#
+# It then prompts for a few more defails (summary, email, and name).
+#
+# Here's the structure it creates:
+#
+# ├── <name>.gemspec
+# ├── Gemfile
+# └── lib
+#   ├── <name>.rb
+#   └── version.rb
+#
+# At which point you can run "gem build" then "gem install"
+#
+class Gemmy::Tasks::MakeGem
+
+  Gemmy::Patches.refinements.each { |r| using r }
+
+  # Builds a skeleton ruby gem.
+  # Prompts for some input using gets.chomp
+  #
+  def self.run(name)
+    new.make_gem(name)
+  end
+
+  # calls a sequence of commands to build out the gem directory
+  #
+  def make_gem(name)
+    @name = name
+    @class_name = name.capitalize
+
+    usage_io
+    create_root_dir
+    create_lib_dir
+    create_version_file
+    create_main_file
+    gemspec_info_io
+    create_gemspec_file
+    create_gemfile
+    create_reinstall_file
+  end
+
+  attr_reader :name, :root_dir, :lib, :version_file, :main_file, :summary,
+              :author, :email, :gemspec_file, :class_name, :rubygems_version,
+              :gemfile
+
+  private
+
+  # A reinstall file is very helpful for development
+  def create_reinstall_file
+    file_txt = <<-TXT.unindent
+      #!/usr/bin/env ruby
+      puts `gem uninstall -x #{name}`
+      puts `gem build #{name}.gemspec`
+      Dir.glob("./*.gem").each { |path| puts `gem install #{path}` }
+    TXT
+    file_path = "#{root_dir}/reinstall"
+    File.open(file_path, 'w') do |file|
+      file.write file_txt
+    end
+    `chmod a+x #{file_path}`
+  end
+
+  # prints usage instructions unless the gem name was specified
+  #
+  def usage_io
+    usage = <<-TXT.unindent
+      \nUsage: make_gem <name>
+    TXT
+    raise usage if @name.blank?
+    self
+  end
+
+  # creates a root directory for the gem
+  #
+  def create_root_dir
+    @root_dir = name
+    `mkdir #{root_dir}`
+    puts "created root dir".green
+    self
+  end
+
+  # creates a lib directory for the gme
+  #
+  def create_lib_dir
+    @lib = "#{root_dir}/lib"
+    `mkdir #{lib}`
+    puts "created lib dir".green
+    self
+  end
+
+  # creates a version file for the gem
+  #
+  def create_version_file
+    @version_file = "#{lib}/version.rb"
+    version_text = <<-TXT.unindent
+      module #{class_name}
+        VERSION = '0.0.0'
+      end
+    TXT
+    write file: version_file, text: version_text
+    puts "wrote version file".green
+    self
+  end
+
+  # creates a main file for the gem.
+  # this file explicitly requires each of the gem's dependencies.
+  #
+  def create_main_file
+    @main_file = "#{lib}/#{name}.rb"
+    main_text = <<-TXT.unindent
+      require 'colored'
+      require 'pry'
+      require 'active_support/all'
+      require 'thor'
+      module #{class_name}
+      end
+      Gem.find_files("#{name}/**/*.rb").each &method(:require)
+    TXT
+    write file: main_file, text: main_text
+    puts "wrote main file".green
+    self
+  end
+
+  # prompts for some additional info required for the gemspec
+  #
+  def gemspec_info_io
+    puts "Some info is needed for the gemspec:".red
+    @summary = _prompt "add a one-line summary."
+    @author = _prompt "enter the author's name"
+    @email = _prompt "enter the author's email"
+    @rubygems_version = `gem -v`.chomp
+    self
+  end
+
+  # creates a gemspec file
+  # add gem dependencies here, not the Gemfile
+  # the Gemfile contains a reference to this file
+  #
+  def create_gemspec_file
+    @gemspec_file = "./#{root_dir}/#{name}.gemspec"
+    gemspec_text = <<-TXT.unindent
+      require_relative './lib/version.rb'
+      Gem::Specification.new do |s|
+        s.name        = name
+        s.version     = #{class_name}::VERSION
+        s.date        = "#{Time.now.strftime("%Y-%m-%d")}"
+        s.summary     = "#{summary}"
+        s.description = ""
+        s.platform    = Gem::Platform::RUBY
+        s.authors     = ["#{author}"]
+        s.email       = '#{email}'
+        s.homepage    = "http://github.com/maxpleaner/gemmy"
+        s.files       = Dir["lib/**/*.rb", "bin/*", "**/*.md", "LICENSE"]
+        s.require_path = 'lib'
+        s.required_rubygems_version = ">= #{rubygems_version}"
+        s.executables = Dir["bin/*"].map &File.method(:basename)
+        s.add_dependency "colored", '~> 1.2'
+        s.add_dependency 'activesupport', '~> 4.2', '>= 4.2.7'
+        s.add_dependency 'pry', '~> 0.10.4'
+        s.add_dependency 'thor', '~> 0.19.4'
+        s.license     = 'MIT'
+      end
+    TXT
+    write file: gemspec_file, text: gemspec_text
+    puts "wrote gemspec".green
+    self
+  end
+
+  # creates a gemfile which contains a reference to the gemspec
+  # in a ruby gem, gems are listed in the gemspec, not the gemfile.
+  #
+  def create_gemfile
+    @gemfile = "./#{root_dir}/Gemfile"
+    gemfile_text = <<-TXT.unindent
+      source "http://www.rubygems.org"
+      gemspec
+    TXT
+    write file: gemfile, text: gemfile_text
+    puts "wrote gemfile".green
+    self
+  end
+
+end
+

data/lib/gemmy/tasks.rb

@@ -0,0 +1,4 @@
+  # Tasks which are accessible through the CLI
+  # They can also be programatically run in Ruby
+  #
+  module Gemmy::Tasks; end

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

@@ -0,0 +1,21 @@
+module Gemmy::Tests::ComponentTests::DynamicStepsTests
+
+  Gemmy::Patches.refinements.each { |r| using r }
+
+  def self.run
+    runner_class = Class.new
+    runner_class.include Gemmy::Components::DynamicSteps
+    runner = runner_class.new
+    runner.define_step(/(.+) case (.+)/) do |a,b|
+      error("failed") unless (a=='test') && (b=='pass')
+    end
+    puts "  define_step".blue
+    runner.step "test case pass"
+    begin
+      runner.step "test case fail"
+    rescue RuntimeError => e
+      error("unexpected fail") unless e.message==("failed")
+      puts "  step".blue
+    end
+  end
+end

data/lib/gemmy/tests/component_tests.rb

@@ -0,0 +1,11 @@
+module Gemmy::Tests
+
+  module ComponentTests
+    def self.run
+      Gemmy::Tests.run_test_class DynamicStepsTests
+    end
+  end
+
+  TestSets << ComponentTests
+
+end

data/lib/gemmy/tests/patch_test.rb

@@ -0,0 +1,127 @@
+module Gemmy::Tests
+
+  module PatchTests
+
+    def self.run
+      # call each of the patch_class methods
+      %i{
+        array_test symbol_test method_test thread_test
+        global_test string_test hash_test
+      }.each { |method_name| PatchedClass.send method_name }
+    end
+
+    module Error
+      # Allow using raise with one argument only
+      # raises RuntimeError
+      #
+      # this is included in the global patches,
+      # but the test suite doesn't depend on it.
+      #
+      # @param msg [String]
+      #
+      def error(msg='')
+        raise(RuntimeError, msg)
+      end
+    end
+
+    class PatchedClass
+
+      Gemmy::Patches.refinements.each { |r| using r }
+
+      extend Gemmy::Tests::PatchTests::Error
+
+      def self.thread_test
+        # Threads abort on exception
+        Thread.new { fail }
+        sleep 0.25
+        error "thread didn't bubble up error"
+      rescue
+        puts "  Threads abort on exception".blue
+      end
+
+      def self.hash_test
+        # Hash#autovivified
+        hash = {}.autovivified
+        hash[:a][:b] = 0
+        error unless hash[:a][:b] == 0
+        puts "  Hash#autovivified".blue
+
+        # Hash#bury
+        hash = { a: { b: { } } }
+        hash.bury(:a, :b, :c, 0)
+        error unless hash[:a][:b][:c] == 0
+        puts "  Hash#bury".blue
+
+        # Hash#persisted
+        db = "test_db.yaml"
+        hash = {}.persisted db
+        hash.set(:a, :b, 0)
+        error unless hash.get(:a, :b) == 0
+        error unless hash.get(:a, :b, disk: true) == 0
+        error unless YAML.load(File.read db)[:data][:a][:b] == 0
+        File.delete(db)
+        puts "  Hash#persisted".blue
+      end
+
+      def self.array_test
+        # Array#any_not?
+        false_case = [[]].any_not? &:empty?
+        true_case = [[1]].any_not? &:empty?
+        error unless true_case && !false_case
+        puts "  Array#any_not?".blue
+      end
+
+      def self.symbol_test
+        # Symbol#with
+        result = [[]].map &:concat.with([1])
+        error unless result == [[1]]
+        puts "  Symbol#with".blue
+      end
+
+      def self.method_test
+        # Method#bind
+        def self.add(a,b)
+          a + b
+        end
+        result = [0].map &method(:add).bind(1)
+        error unless result == [1]
+        puts "  Method#bind".blue
+      end
+
+      def self.global_test
+        # m is an alias for method
+        def self.sample_method(x)
+          x
+        end
+        result = [0].map &m(:sample_method)
+        error unless result == [0]
+        puts "  Object#m".blue
+
+        # error_if_blank
+        # error an error if an object is blank
+        blank = nil
+        not_blank = 0
+        error_if_blank not_blank
+        begin
+          error_if_blank blank
+          error("this won't be raised")
+        rescue RuntimeError => e
+          error if e.message == "this won't be raised"
+          puts "  Object#error_if_blank".blue
+        end
+      end
+
+      def self.string_test
+        # String#unindent
+        result = "  0".unindent
+        error unless result == "0"
+        puts "  String#unindent".blue
+      end
+
+    end
+
+  end
+
+  TestSets << PatchTests
+
+end

data/lib/gemmy/tests.rb

@@ -0,0 +1,16 @@
+# Test out the gem
+# Can be called from the command line: gemmy test
+#
+module Gemmy::Tests
+  TestSets = []
+
+  def self.run
+    TestSets.each &method(:run_test_class)
+  end
+
+  def self.run_test_class(klass)
+    klass.run
+    puts "#{klass} passed".green
+  end
+
+end

data/lib/gemmy/version.rb

@@ -0,0 +1,3 @@
+class Gemmy
+  VERSION = '0.0.0'
+end

data/lib/gemmy.rb

@@ -0,0 +1,34 @@
+require 'thor'
+require 'colored'
+require 'active_support/all'
+require 'pry'
+require 'colored'
+
+# Container class for all the functionality.
+#
+class Gemmy
+
+  # There are two main usages:
+  #   - namespaced (using refinements and explicit include/extend calls)
+  #   - global
+  #
+  # 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
+    end
+    Components.list.each do |patch_klass|
+      Object.include patch_klass
+      Object.extend patch_klass
+    end
+  end
+end
+
+# Load files in order of their "/" count
+# to preserve constant hierarchies
+#
+Gem.find_files("gemmy/**/*.rb").sort_by do |x|
+  x.split("/").length
+end.each &method(:require)
+

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: gemmyrb
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- max pleaner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.6
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.4
+description: ''
+email: maxpleaner@gmail.com
+executables:
+- gemmy
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/gemmy
+- lib/gemmy.rb
+- lib/gemmy/cli.rb
+- lib/gemmy/components.rb
+- lib/gemmy/components/dynamic_steps.rb
+- lib/gemmy/patches.rb
+- lib/gemmy/patches/array_patch.rb
+- lib/gemmy/patches/hash_patch.rb
+- lib/gemmy/patches/method_patch.rb
+- lib/gemmy/patches/object_patch.rb
+- lib/gemmy/patches/string_patch.rb
+- lib/gemmy/patches/symbol_patch.rb
+- lib/gemmy/patches/thread_patch.rb
+- lib/gemmy/tasks.rb
+- lib/gemmy/tasks/make_gem.rb
+- lib/gemmy/tests.rb
+- lib/gemmy/tests/component_tests.rb
+- lib/gemmy/tests/component_tests/dynamic_steps_tests.rb
+- lib/gemmy/tests/patch_test.rb
+- lib/gemmy/version.rb
+homepage: http://github.com/maxpleaner/gemmy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: general utils
+test_files: []