overloaded_methods 3.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 671cad9d817d844cf7c28ece267263b222f3f631
+  data.tar.gz: 0287d2812363eeedcf6beffc4168ed244e9df11d
+SHA512:
+  metadata.gz: 130b0edff2ffe7cba60cbd2509c7ade7be273ed6a453ade0f1bbc363e11037baa30767456fd45cf49cb80e9f5f7b55d5637b6001e5480c4a958fcb56d746891f
+  data.tar.gz: 255506194bc28e2b822b0dae67daef641e16ec5c7cb5e725383f90c9369d28838b46ee52a28a03d1dfe7c2c5d93b382af6280cf36e3a06c0ead15c5d97a4f00c

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+script: rspec
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+  - 2.2.0
+  - ruby-head
+  - rbx-2
+  - jruby-head

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/License.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Corey Haines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# Overloaded Methods
+
+[![Build Status](https://travis-ci.org/coreyhaines/overloaded_methods.svg?branch=master)](https://travis-ci.org/coreyhaines/overloaded_methods)
+
+[http://github.com/coreyhaines/overloaded_methods](http://github.com/coreyhaines/overloaded_methods)
+
+## DESCRIPTION:
+
+overloaded_methods was inspired by erlang pattern matching. Basically, the idea is that you can specify a method and several code blocks based on aspects of the parameters. Here's an example:
+
+```
+overload_method :even_odd do |m|
+  m.when {|number| number % 2 == 0 }.do { :even }
+  m.when {|number| number % 2 == 1 }.do { :odd }
+end
+```
+
+You can then call even_odd(2) and get :even, even_odd(3) gives you :odd.
+
+the specs have more examples.
+
+Special thanks to Jim Weirich for suggesting some great improvements in the syntax.
+
+There is an alternate syntax with pattern/does
+```
+overload_method :even_odd do |m|
+  m.pattern {|number| number % 2 == 0 }.does { :even }
+  m.pattern {|number| number % 2 == 1 }.does { :odd }
+end
+```
+However, this syntax may or may not be deprecated in favor of the when/do syntax.
+
+Here's an example of Fibonacci calculation:
+```
+class CalculatesFibonacci
+
+  class << self
+    include OverloadedMethods
+    overload_method :entry do |m|
+      m.when{|which| which <= 1}.do{|which| which}
+      m.default{|which|
+          CalculatesFibonacci.entry(which-1) + CalculatesFibonacci.entry(which-2)
+        }
+    end
+  end
+end
+```
+
+
+## SYNOPSIS:
+
+The following is from the specs, just some examples of how to use it.
+
+```
+class WithWhenDo
+  include OverloadedMethods
+
+  overload_method :even_odd do |m|
+    m.when {|number| number % 2 == 0 }.do { :even }
+    m.when {|number| number % 2 == 1 }.do { :odd }
+  end
+
+  overload_method :hello_world do |m|
+    m.when { true }.do {'hello, world'}
+  end
+
+  overload_method :return_params do |m|
+    m.when { |param1, param2| true}.do {|param1, param2| [param1, param2]}
+  end
+
+  overload_method :two_params_collected do |m|
+    m.default { |param1, *params| [param1, params] }
+  end
+
+  overload_method :number_of_digits do |m|
+    m.when {|number| number < 10}.do {1}
+    m.when {|number| number< 100}.do {2}
+    m.default { 'more than two digits is crazy talk'}
+  end
+
+  overload_method :default_returns_parameters do |m|
+    m.default { |*params| params}
+  end
+
+end
+```
+
+## REQUIREMENTS:
+
+Ruby
+
+## INSTALL:
+
+```gem install overloaded_methods```
+
+or, if using Bundler,
+
+```gem 'overloaded_methods'```
+
+## LICENSE:
+
+See [License.txt](License.txt)

data/lib/overloaded_methods/version.rb

@@ -0,0 +1,3 @@
+module OverloadedMethods
+  VERSION = "3.2.7"
+end

data/lib/overloaded_methods.rb

@@ -0,0 +1,58 @@
+require "overloaded_methods/version"
+
+module OverloadedMethods
+
+  def overload_method name
+    collector = FunctionDefinition.new
+    yield collector
+    define_method name do |*params|
+      collector.execute params
+    end
+  end
+
+  class Clause
+    def self.match_all
+      new ->*{true}
+    end
+    def self.with_predicate(predicate)
+      new predicate
+    end
+    attr_reader :predicate
+    def initialize(predicate)
+      @predicate = predicate
+    end
+    def match?(*params)
+      @predicate.call(*params)
+    end
+    def do &block
+      @block = block
+      self
+    end
+    def return value
+      self.do {|*|value}
+    end
+    alias :does :do
+    def call *params
+      @block.call *params
+    end
+  end
+
+  class FunctionDefinition
+    def initialize
+      @clauses = []
+      @default = Clause.match_all.return(nil)
+    end
+    def when &predicate
+      Clause.with_predicate(predicate).tap { |clause| @clauses << clause }
+    end
+    alias :pattern :when
+    def execute params
+      [*@clauses, @default]
+        .find { |clause| clause.match? *params }
+        .call(*params)
+    end
+    def default &block
+      @default = Clause.match_all.do(&block)
+    end
+  end
+end

data/overloaded_methods.gemspec

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "overloaded_methods/version"
+
+Gem::Specification.new do |s|
+  s.name        = "overloaded_methods"
+  s.version     = OverloadedMethods::VERSION
+  s.authors     = ["Corey Haines", "Josh Cheek"]
+  s.email       = ["coreyhaines@gmail.com", "josh.cheek@gmail.com"]
+  s.homepage    = "https://github.com/coreyhaines/overloaded_methods"
+  s.summary     = %q{Bringing the power of predicate-based method dispatch to Ruby, where it belongs!}
+  s.description = %q{Single clause, branching method definitions are so 2007. Get with SRP and party! With overloaded_methods, you can separate out any conditional branching in your method to where it belongs: predicates! Feel the power of the chain-of-responsibility pattern in your own code!!!!!!}
+  s.license     = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 3.0"
+
+  s.post_install_message = <<'Omg, frogs <3'.gsub(/(gg+)/) { |capture| "\e[32m#{capture.gsub 'g', '.'}\e[0m" }.gsub("brown", "\e[33m").gsub("off", "\e[0m")
+              .7
+     .      .M
+      .  . .N
+      M.  ..O
+     =. .. .M
+     N . .  .N
+      O.. . . O
+        MN:. . M
+           OM...N
+             N .OM                 brown.NM8MMMMMMoff
+             O ..N             brown...MM=:Z7?Z7??MMMMIMMOM8Noff
+             M...O        brown,MMMMMMMMMM$$:=ZZ$~:$?7ZMMMMM8?Moff
+           .N .  M       brownMMI$7:==?:77MMMM7$O~+~ZO~~I=7ZMMMMoff
+           O$...N        brownM=$ZZI=MMM7ZZI=?MMZ+:$I?8Z~?ZO~=ZIMMoff
+        .MN ...O         brownM~?Z==ZZZ=MM$$=$ZZMMO=~~?$=$Z~~OO+=MMoff
+        OM ...,M      DAAAAAAAAAAAAAAAAAAAAAAAMbrown=Z=+OOI=+ZO$O+MMoff
+      NOM.. . N     DAAAAAAAAAAAAM?:DAAAAAAAAAAAAMbrown$ZZ?$+IZ7+8?M8off
+     NOM.....O     DAAAAAAAAM:ggggDAAAAAAAAAAAAAAMbrown78OI+D=78=$MMoff
+    NO.. ...MN     DAAAAAAAMgggggggDAAAAAAAAAAAAAM,MMbrownMO7?I8Z7OMoff
+   MN.... ..O       DAAAAAMgggggggggDAAAAAAAAAAAAMgg~MMbrown?NMM7O8MMoff
+  NOM..  ..MN        DAAMggggggggggggDAAAAAAAAAAMgggggggMMbrown7.MMMoff
+ NOM.. .. .OM         MggggggggggggggggDAAAAAAAMgggggggggggMM:M
+ NOM. .. ..NO        Mggggggggggggggggggg~DAAMggggggggggggggI,,M
+ NOM.. .. .MN       MMgggbrownZMMMMMMoffggggggggggggggggggggggggggggg=MM
+ NOM. . ... O       MggbrownMMMNMMMMMMMMZoffgggggggggggggggggggggggggg$MI
+ NOM8.. .. .MM      MZbrownMMMMMMMMMMMMMMMoffgggggggggM~gggggggggggggggMM
+  NOM .. . . NOM    Mgggggggggggggggggggggggg8M$ggggggggggggggggMM
+   NOMO. . . . .    M.MMMMMMMMMMMMNMMMMNMMMMMMggggggggggggggggggMM,
+     NOMM8.  .     M:MM  MMggggggggggggggggggggggggggggggggggggggMM
+           .    .MMMM     brownMMMMgggggggggggggbrown7ZMMggggggggggggggggggMM
+               .MNOM      brownMMMMMMMMMMMMMMMMMMMggggggggggggggggggggOMM
+                 H         brownMMMMMMMMMMMMMMMMMggggggg,ggggggggggggggMM
+                            brownMMMMMMMMMMMM=gggggggggMMggggggggggggggMMN
+                              brown:MMMMggggggggggggggggMgggggggMggggggMMM
+                                 MMMggggggggggggggMNggggg:7gggggggMMM .MMMMMM
+                                 MMMMgggggggggMgggMgggggMgggggggggMMMMggggggMM
+                                 MggMMMgggggggMgggMgggg=IggggggggMMgggggggggM
+                                 MggMMMMgggggMggggMggggMgggggMMM:ggggggggggMM
+                                MMggM  MMMgggMgggMMgggMggggMMMgggggggggggggM,
+                               .MggMM   MMMMMMgggMggggMgggggggggggggggggggMM
+                       ggMMMMMMMMggM   MggMMMgggMMgggOMggggggggggggggMNggMM
+                     MgggggggggggggM  MMMggMMgggMMMMMMMgggggggggggggMgg+MM
+                     :MM7ggggMggIMM  D ggM?MgggMM     MgggggggggggMMggMM,
+                          .MggMgg    ggg gM+gggM      NMggggggggMMMggMM
+                                  .MM+gZMMgggggM       MMMMMMMMMMggggM
+                                  MIgg8MM,ggggMM           .MMMggMggM
+                                 MMMgggMMMMggMI       ggOMMMggOMMggMM
+                                MgggMDggggM M        MgggggNMMggMMggM
+                                MMMMgggggM ggM      .M:gggMggggMggggM
+                                           MM          MMMMggggggMMMI
+Omg, frogs <3
+end

data/spec/overloaded_methods_spec.rb

@@ -0,0 +1,171 @@
+require 'overloaded_methods'
+
+RSpec.configure do |c|
+  c.disable_monkey_patching!
+end
+
+class CalculatesFibonacci
+  class << self
+    extend OverloadedMethods
+    overload_method :entry do |m|
+      m.when{|which| which <= 1}.do{|which| which}
+      m.default{|which|
+        CalculatesFibonacci.entry(which-1) + CalculatesFibonacci.entry(which-2)
+      }
+    end
+  end
+end
+
+RSpec.describe CalculatesFibonacci do
+  it "should return 0 for 0" do
+    expect(CalculatesFibonacci.entry(0)).to eq(0)
+  end
+  it "should return 1 for 1" do
+    expect(CalculatesFibonacci.entry(1)).to eq(1)
+  end
+  it "should return 1 for 2" do
+    expect(CalculatesFibonacci.entry(2)).to eq(1)
+  end
+  {3 => 2, 4 => 3, 5 => 5, 6 => 8}.each_pair {|which,value|
+      it "should return #{value} for #{which}" do
+        expect(CalculatesFibonacci.entry(which)).to eq(value)
+      end
+    }
+end
+
+
+class WithWhenDo
+  extend OverloadedMethods
+
+  overload_method :even_odd do |m|
+    m.when {|number| number % 2 == 0 }.do { :even }
+    m.when {|number| number % 2 == 1 }.do { :odd }
+  end
+
+  overload_method :hello_world do |m|
+    m.when { true }.do {'hello, world'}
+  end
+
+  overload_method :return_params do |m|
+    m.when { |param1, param2| true}.do {|param1, param2| [param1, param2]}
+  end
+
+  overload_method :two_params_collected do |m|
+    m.default { |param1, *params| [param1, params] }
+  end
+
+  overload_method :number_of_digits do |m|
+    m.when {|number| number < 10}.do {1}
+    m.when {|number| number< 100}.do {2}
+    m.default { 'more than two digits is crazy talk'}
+  end
+
+  overload_method :no_default do |m|
+  end
+
+  overload_method :default_returns_parameters do |m|
+    m.default { |*params| params}
+  end
+
+end
+
+class WithPatternDoes
+  extend OverloadedMethods
+  overload_method :hello_world do |m|
+    m.pattern { true }.does {'hello, world'}
+  end
+
+  overload_method :return_params do |m|
+    m.pattern { |param1, param2| true}.does {|param1, param2| [param1, param2]}
+  end
+
+  overload_method :even_odd do |m|
+    m.pattern {|number| number % 2 == 0 }.does { :even }
+    m.pattern {|number| number % 2 == 1 }.does { :odd }
+  end
+
+  overload_method :number_of_digits do |m|
+    m.pattern {|number| number < 10}.does {1}
+    m.pattern {|number| number< 100}.does {2}
+    m.default { 'more than two digits is crazy talk'}
+  end
+
+  overload_method :no_default do |m|
+  end
+
+  overload_method :default_returns_parameters do |m|
+    m.default { |*params| params}
+  end
+
+  overload_method :two_params_collected do |m|
+    m.default { |param1, *params| [param1, params] }
+  end
+
+
+end
+
+
+
+
+RSpec.describe OverloadedMethods do
+  [WithWhenDo, WithPatternDoes].each {|klass|
+    describe "#{klass.to_s}" do
+      it "should run the first method if the first pattern passes" do
+        expect(klass.new.even_odd(2)).to eq(:even)
+      end
+      it "should run the second method if the first pattern fails, second pattern passes" do
+        expect(klass.new.even_odd(3)).to eq(:odd)
+      end
+
+      describe "when only a true pattern" do
+        it "should add the method that you define" do
+          expect(klass.new).to respond_to(:hello_world)
+        end
+        it "should call the block" do
+          expect(klass.new.hello_world).to eq('hello, world')
+        end
+      end
+      describe "when calling with parameters" do
+        it "should pass the parameters to the block" do
+          returns = klass.new.return_params 'corey', 'haines'
+          expect(returns).to include('corey')
+          expect(returns).to include('haines')
+        end
+        describe "when trying to collect different parts of the parameters into an array" do
+          it "should parse out the desired parameters and put the rest into an array" do
+            return1, others = klass.new.two_params_collected 1, 2, 3
+            expect(return1).to eq(1)
+            expect(others).to include(2)
+            expect(others).to include(3)
+          end
+        end
+
+      end
+      describe "when calling with a pattern" do
+        it "should run the first method if the first pattern passes" do
+          expect(klass.new.even_odd(2)).to eq(:even)
+        end
+        it "should run the second method if the first pattern fails, second pattern passes" do
+          expect(klass.new.even_odd(3)).to eq(:odd)
+        end
+      end
+
+      describe "when using the default" do
+        it "should execute the default if no predicate passes" do
+          expect(klass.new.number_of_digits(176)).to eq('more than two digits is crazy talk')
+        end
+        it "should not crash if there is no default given" do
+          expect(klass.new.no_default).to be_nil
+        end
+        it "should pass the parameters to the default method, as well" do
+          returns = klass.new.default_returns_parameters 'Rachel', 'Davis'
+          expect(returns).to include('Rachel')
+          expect(returns).to include('Davis')
+        end
+      end
+    end
+
+    }
+
+
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: overloaded_methods
+version: !ruby/object:Gem::Version
+  version: 3.2.7
+platform: ruby
+authors:
+- Corey Haines
+- Josh Cheek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'Single clause, branching method definitions are so 2007. Get with SRP
+  and party! With overloaded_methods, you can separate out any conditional branching
+  in your method to where it belongs: predicates! Feel the power of the chain-of-responsibility
+  pattern in your own code!!!!!!'
+email:
+- coreyhaines@gmail.com
+- josh.cheek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- Gemfile
+- License.txt
+- README.md
+- lib/overloaded_methods.rb
+- lib/overloaded_methods/version.rb
+- overloaded_methods.gemspec
+- spec/overloaded_methods_spec.rb
+homepage: https://github.com/coreyhaines/overloaded_methods
+licenses:
+- MIT
+metadata: {}
+post_install_message: "              .7\n     .      .M\n      .  . .N\n      M.  ..O\n
+  \    =. .. .M\n     N . .  .N\n      O.. . . O\n        MN:. . M\n           OM...N\n
+  \            N .OM                 \e[33m.NM8MMMMMM\e[0m\n             O ..N             \e[33m...MM=:Z7?Z7??MMMMIMMOM8N\e[0m\n
+  \            M...O        \e[33m,MMMMMMMMMM$$:=ZZ$~:$?7ZMMMMM8?M\e[0m\n           .N
+  .  M       \e[33mMMI$7:==?:77MMMM7$O~+~ZO~~I=7ZMMMM\e[0m\n           O$...N        \e[33mM=$ZZI=MMM7ZZI=?MMZ+:$I?8Z~?ZO~=ZIMM\e[0m\n
+  \       .MN ...O         \e[33mM~?Z==ZZZ=MM$$=$ZZMMO=~~?$=$Z~~OO+=MM\e[0m\n        OM
+  ...,M      DAAAAAAAAAAAAAAAAAAAAAAAM\e[33m=Z=+OOI=+ZO$O+MM\e[0m\n      NOM.. . N
+  \    DAAAAAAAAAAAAM?:DAAAAAAAAAAAAM\e[33m$ZZ?$+IZ7+8?M8\e[0m\n     NOM.....O     DAAAAAAAAM:\e[32m....\e[0mDAAAAAAAAAAAAAAM\e[33m78OI+D=78=$MM\e[0m\n
+  \   NO.. ...MN     DAAAAAAAM\e[32m.......\e[0mDAAAAAAAAAAAAAM,MM\e[33mMO7?I8Z7OM\e[0m\n
+  \  MN.... ..O       DAAAAAM\e[32m.........\e[0mDAAAAAAAAAAAAM\e[32m..\e[0m~MM\e[33m?NMM7O8MM\e[0m\n
+  \ NOM..  ..MN        DAAM\e[32m............\e[0mDAAAAAAAAAAM\e[32m.......\e[0mMM\e[33m7.MMM\e[0m\n
+  NOM.. .. .OM         M\e[32m................\e[0mDAAAAAAAM\e[32m...........\e[0mMM:M\n
+  NOM. .. ..NO        M\e[32m...................\e[0m~DAAM\e[32m..............\e[0mI,,M\n
+  NOM.. .. .MN       MM\e[32m...\e[0m\e[33mZMMMMMM\e[0m\e[32m.............................\e[0m=MM\n
+  NOM. . ... O       M\e[32m..\e[0m\e[33mMMMNMMMMMMMMZ\e[0m\e[32m..........................\e[0m$MI\n
+  NOM8.. .. .MM      MZ\e[33mMMMMMMMMMMMMMMM\e[0m\e[32m.........\e[0mM~\e[32m...............\e[0mMM\n
+  \ NOM .. . . NOM    M\e[32m........................\e[0m8M$\e[32m................\e[0mMM\n
+  \  NOMO. . . . .    M.MMMMMMMMMMMMNMMMMNMMMMMM\e[32m..................\e[0mMM,\n
+  \    NOMM8.  .     M:MM  MM\e[32m......................................\e[0mMM\n
+  \          .    .MMMM     \e[33mMMMM\e[32m.............\e[0m\e[33m7ZMM\e[32m..................\e[0mMM\n
+  \              .MNOM      \e[33mMMMMMMMMMMMMMMMMMMM\e[32m....................\e[0mOMM\n
+  \                H         \e[33mMMMMMMMMMMMMMMMMM\e[32m.......\e[0m,\e[32m..............\e[0mMM\n
+  \                           \e[33mMMMMMMMMMMMM=\e[32m.........\e[0mMM\e[32m..............\e[0mMMN\n
+  \                             \e[33m:MMMM\e[32m................\e[0mM\e[32m.......\e[0mM\e[32m......\e[0mMMM\n
+  \                                MMM\e[32m..............\e[0mMN\e[32m.....\e[0m:7\e[32m.......\e[0mMMM
+  .MMMMMM\n                                 MMMM\e[32m.........\e[0mM\e[32m...\e[0mM\e[32m.....\e[0mM\e[32m.........\e[0mMMMM\e[32m......\e[0mMM\n
+  \                                M\e[32m..\e[0mMMM\e[32m.......\e[0mM\e[32m...\e[0mM\e[32m....\e[0m=I\e[32m........\e[0mMM\e[32m.........\e[0mM\n
+  \                                M\e[32m..\e[0mMMMM\e[32m.....\e[0mM\e[32m....\e[0mM\e[32m....\e[0mM\e[32m.....\e[0mMMM:\e[32m..........\e[0mMM\n
+  \                               MM\e[32m..\e[0mM  MMM\e[32m...\e[0mM\e[32m...\e[0mMM\e[32m...\e[0mM\e[32m....\e[0mMMM\e[32m.............\e[0mM,\n
+  \                              .M\e[32m..\e[0mMM   MMMMMM\e[32m...\e[0mM\e[32m....\e[0mM\e[32m...................\e[0mMM\n
+  \                      \e[32m..\e[0mMMMMMMMM\e[32m..\e[0mM   M\e[32m..\e[0mMMM\e[32m...\e[0mMM\e[32m...\e[0mOM\e[32m..............\e[0mMN\e[32m..\e[0mMM\n
+  \                    M\e[32m.............\e[0mM  MMM\e[32m..\e[0mMM\e[32m...\e[0mMMMMMMM\e[32m.............\e[0mM\e[32m..\e[0m+MM\n
+  \                    :MM7\e[32m....\e[0mM\e[32m..\e[0mIMM  D \e[32m..\e[0mM?M\e[32m...\e[0mMM
+  \    M\e[32m...........\e[0mMM\e[32m..\e[0mMM,\n                          .M\e[32m..\e[0mM\e[32m..\e[0m
+  \   \e[32m...\e[0m gM+\e[32m...\e[0mM      NM\e[32m........\e[0mMMM\e[32m..\e[0mMM\n
+  \                                 .MM+gZMM\e[32m.....\e[0mM       MMMMMMMMMM\e[32m....\e[0mM\n
+  \                                 MI\e[32m..\e[0m8MM,\e[32m....\e[0mMM           .MMM\e[32m..\e[0mM\e[32m..\e[0mM\n
+  \                                MMM\e[32m...\e[0mMMMM\e[32m..\e[0mMI       \e[32m..\e[0mOMMM\e[32m..\e[0mOMM\e[32m..\e[0mMM\n
+  \                               M\e[32m...\e[0mMD\e[32m....\e[0mM M        M\e[32m.....\e[0mNMM\e[32m..\e[0mMM\e[32m..\e[0mM\n
+  \                               MMMM\e[32m.....\e[0mM \e[32m..\e[0mM      .M:\e[32m...\e[0mM\e[32m....\e[0mM\e[32m....\e[0mM\n
+  \                                          MM          MMMM\e[32m......\e[0mMMMI\n"
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Bringing the power of predicate-based method dispatch to Ruby, where it belongs!
+test_files: []