ghost_dog 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWJkODQ1MWVhYTc1NzYyZjdlODNjZjc3YjFjYTQyODJlMjYzNDExOA==
+  data.tar.gz: !binary |-
+    YWJhMzMxMDdkMDZhMjAwZDEwYjRlZjcxNzFhMWNiNzk1Mjk1YTYxMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YTBiMGUzOGEzZWVlMGM2ZDhhZWU4MTg0NTNjMjcyYjE1NWIwYjVlY2RmMDYx
+    MTgwYjg2NTgzNjQyNGI3MWY2NmYwOWIyOGE0ZGZjZjg1M2M1NDU2MjA1NzJm
+    NzQ3ZDZkYjk2NDQ0ODk5ZDIwNTQ1YjI5ZDg3ODU1ZmQwMTI1MTI=
+  data.tar.gz: !binary |-
+    MmYzYTlmNGY0YTljYTliODcxNDM2YWI4YzZlYzFiNjdkMmIzZDBiYzYxMzc3
+    ZDcyYTc5ZDQyMWQzM2RjMDY4ZTc3OTRjOWM4NDU5M2YzYTViZjA4ZTBhMjFk
+    OTU1ZTUwYTIzMjM0MTQwYjNmMjRiM2Y4MzJjOWVjNTZhYzc0NjA=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+ghost_dog

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p194

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ghost-dog.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrew Warner
+
+MIT License
+
+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,125 @@
+# Ghost Dog
+
+![](https://travis-ci.org/a-warner/ghost_dog.png)
+
+Making method_missing easier to deal with since 2013...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ghost_dog'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ghost_dog
+
+## Motivation
+
+I've written similar looking `method_missing` and `repond_to?` code frequently enough
+that I finally decided it was time for an abstraction.  This might not be the best
+abstraction, but it was the simplest way of thinking about it for me.  Feel free to fork
+the project and add your own interfaces for it.
+
+Ghost Dog is built around the simple type `Responder`, which implements `matches?` and `call`.  `matches?` is used
+to determine whether a `Responder` can be used for a missing method (and therefore used in both `respond_to?`
+and `method_missing`) and `call` is used to actually respond to a method invocation.  Most of the time you shouldn't
+be dealing directly with the `Responder` class; instead, you'll define methods either via the shorthand or with
+the DSL.
+
+In order to define a `ghost_method`, you need to implement a Matcher, which can either be a simple regex with 
+capture groups or a proc. When using a regex, any capture groups will be passed to your responding block. When using 
+a proc, anything returned by the proc will be passed to your responding block.  The matcher block should return 
+something truthy if the method is available, otherwise it should return something falsy.  See below for additional 
+examples.
+
+## Usage
+
+Check out the specs for full usage information.  Here are some quick examples:
+
+Simple syntax:
+
+```ruby
+class Minimal
+  include GhostDog
+
+  ghost_method /^tell_me_(.+)$/ do |what_to_tell|
+    what_to_tell.gsub('_', ' ')
+  end
+end
+```
+
+```sh
+>> Minimal.new.tell_me_hello_world # "hello world"
+```
+
+More complex example, using the DSL version:
+
+```ruby
+class ComplexExample
+  include GhostDog
+
+  def names
+    ['ishmael', 'dave']
+  end
+
+  ghost_method do
+    match_with do |method_name|
+      if match = method_name.match(/^call_me_(#{names.join('|')})$/)
+        match.to_a.drop(1)
+      end
+    end
+
+    respond_with do |name|
+      "what's going on #{name}?"
+    end
+  end
+end
+```
+
+```sh
+>> ComplexExample.new.call_me_ishmael # "what's going on ishmael?"
+>> ComplexExample.new.call_me_samuel # NoMethodError
+```
+
+Implementing a (fairly) complex example (using `detect_by` instead of `find_by`) as a duplicate of ActiveRecord's dynamic finders:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  class << self
+    include GhostDog
+
+    ghost_method do
+      create_method false
+
+      match_with do |method_name|
+        cols = column_names.join('|')
+        if match = method_name.match(/\Adetect_by_(#{cols})((?:_and_(?:#{cols}))*)\z/)
+          [[match[1]] + match[2].split('_and_').select(&:present?)]
+        end
+      end
+
+      respond_with do |*args|
+        columns_to_find_by = args.shift
+        unless args.length == columns_to_find_by.length
+          raise ArgumentError, "Wrong number of arguments (#{args.length} for #{columns_to_find_by.length})"
+        end
+
+        where(Hash[columns_to_find_by.zip(args)])
+      end
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ghost_dog.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ghost_dog/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ghost_dog"
+  spec.version       = GhostDog::VERSION
+  spec.authors       = ["Andrew Warner"]
+  spec.email         = ["wwarner.andrew@gmail.com"]
+  spec.description   = %q{Making method_missing easier since 2013}
+  spec.summary       = %q{Making method_missing easier since 2013}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

data/lib/ghost_dog/responder/dsl.rb

@@ -0,0 +1,38 @@
+module GhostDog
+  class Responder
+    class DSL
+      def initialize
+        @options = { :create_method => true }
+      end
+
+      def to_responder
+        raise "Incomplete ghost method - must specify matcher and responding_block" unless [@matcher, @responder].all?
+
+        Responder.new(@matcher, @options, @responder)
+      end
+
+      private
+
+      def create_method(value)
+        @options[:create_method] = value
+      end
+
+      def respond_with(&block)
+        @responder = block
+      end
+
+      def match_with(matcher_as_arg = nil, &matcher_as_block)
+        raise "Must specify either exactly one of a matcher instance or a matcher block" unless !!matcher_as_arg ^ block_given?
+
+        matcher = matcher_as_block || matcher_as_arg
+
+        @matcher =
+          if matcher.respond_to? :matches
+            matcher
+          else
+            Responder.const_get("#{matcher.class}Matcher").new(matcher)
+          end
+      end
+    end
+  end
+end

data/lib/ghost_dog/responder/proc_matcher.rb

@@ -0,0 +1,9 @@
+module GhostDog
+  class Responder
+    class ProcMatcher < Struct.new(:block)
+      def matches(receiver, method_name)
+        receiver.instance_exec(method_name, &block)
+      end
+    end
+  end
+end

data/lib/ghost_dog/responder/regexp_matcher.rb

@@ -0,0 +1,11 @@
+module GhostDog
+  class Responder
+    class RegexpMatcher < Struct.new(:regexp)
+      def matches(receiver, method_name)
+        if match = regexp.match(method_name)
+          match.to_a.drop(1)
+        end
+      end
+    end
+  end
+end

data/lib/ghost_dog/responder.rb

@@ -0,0 +1,66 @@
+require 'ghost_dog/responder/proc_matcher'
+require 'ghost_dog/responder/regexp_matcher'
+require 'ghost_dog/responder/dsl'
+
+module GhostDog
+  class Responder
+    attr_reader :matcher, :responding_block, :options
+    def initialize(matcher, options, responding_block)
+      @matcher = matcher
+      @options = options
+      @responding_block = responding_block
+    end
+
+    def matches(receiver, method)
+      matcher.matches(receiver, method)
+    end
+    alias_method :matches?, :matches
+
+    def call(instance, klass, method, passed_args, passed_block)
+      match_result = Array[matches(instance, method)].flatten(1)
+
+      if create_method?
+        klass.class_exec(responding_block) do |respond_with|
+          define_method(method) do |*args, &block|
+            instance_exec(*(match_result + args), &respond_with)
+          end
+        end
+
+        instance.send(method, *passed_args, &passed_block)
+      else
+        instance.instance_exec(*(match_result + passed_args), &responding_block)
+      end
+    end
+
+    def self.from(matcher, options, block)
+      raise ArgumentError, "Must specify a block to create a ghost_method" unless block
+
+      if matcher.nil?
+        unless options.empty?
+          raise ArgumentError, "You cannot specify creation options if you're \
+              using the shorthand...specify those options in the DSL instead"
+        end
+
+        using_dsl(&block)
+      else
+        using_dsl do
+          options.each {|k, v| send(k, v) }
+          match_with(matcher)
+          respond_with(&block)
+        end
+      end
+    end
+
+    private
+
+    def create_method?
+      options[:create_method]
+    end
+
+    def self.using_dsl(&block)
+      Responder::DSL.new.tap do |dsl|
+        dsl.instance_eval(&block)
+      end.to_responder
+    end
+  end
+end

data/lib/ghost_dog/version.rb

@@ -0,0 +1,3 @@
+module GhostDog
+  VERSION = "0.0.1"
+end

data/lib/ghost_dog.rb

@@ -0,0 +1,85 @@
+require 'ghost_dog/version'
+require 'ghost_dog/responder'
+require 'delegate'
+
+module GhostDog
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module InstanceMethods
+    def respond_to?(method, include_private = false)
+      super || !!responding_ghost_method(method.to_s)
+    end
+
+    private
+
+    def _ghost_methods
+      _klass_where_ghost_method_definitions_are.send(:_ghost_method_definitions)
+    end
+
+    def _klass_where_ghost_method_definitions_are
+      if self.class == Class
+        self.singleton_class
+      else
+        self.class
+      end
+    end
+
+    def responding_ghost_method(method)
+      @_considered_methods ||= []
+      return if @_considered_methods.include?(method)
+
+      @_considered_methods << method
+
+      _ghost_methods.detect do |matcher|
+        matcher.matches?(self, method)
+      end
+    ensure
+      @_considered_methods = []
+    end
+
+    def method_missing(method, *args, &block)
+      if matcher = responding_ghost_method(method.to_s)
+        matcher.call(self, _klass_where_ghost_method_definitions_are, method.to_s, args, block)
+      else
+        super
+      end
+    end
+
+    def inherited(child)
+      _setup_ghost_dog_singleton_class_inheritance(child)
+      super
+    end
+
+    def _setup_ghost_dog_singleton_class_inheritance(child)
+      if singleton_class.respond_to?(:_setup_ghost_dog_inheritance, :include_private)
+        singleton_class.send(:_setup_ghost_dog_inheritance, child.singleton_class)
+      end
+    end
+  end
+
+  module ClassMethods
+    protected
+
+    def ghost_method(matcher = nil, options = {}, &block)
+      _ghost_method_definitions << Responder.from(matcher, options, block)
+    end
+
+    private
+
+    def _ghost_method_definitions
+      @_ghost_methods ||= []
+    end
+
+    def inherited(child)
+      _setup_ghost_dog_inheritance(child)
+      super
+    end
+
+    def _setup_ghost_dog_inheritance(child)
+      child.instance_variable_set('@_ghost_methods', _ghost_method_definitions)
+    end
+  end
+end

data/spec/lib/ghost_dog_spec.rb

@@ -0,0 +1,371 @@
+require 'spec_helper'
+
+describe GhostDog do
+  subject { described_class }
+  it { should_not be_nil }
+
+  context 'simple responder' do
+    class Minimal
+      include GhostDog
+
+      ghost_method /^tell_me_(.+)$/ do |what_to_tell|
+        what_to_tell.gsub('_', ' ')
+      end
+    end
+
+    let(:obj) { Minimal.new }
+    subject { obj }
+    its(:tell_me_hello_world) { should == "hello world" }
+    it { should respond_to(:tell_me_hello_world) }
+
+    context 'defines method' do
+      let(:obj) { Minimal.new }
+      before { obj.tell_me_whatup }
+
+      its(:public_methods) { should include :tell_me_whatup }
+      its(:tell_me_whatup) { should == "whatup" }
+    end
+  end
+
+  context 'class level responder' do
+    class ClassLevel
+      class << self
+        include GhostDog
+
+        ghost_method /^say_([^_]+)_to_(.+)$/ do |what, name|
+          "#{what}, #{name}!"
+        end
+      end
+    end
+
+    let(:obj) { ClassLevel }
+    subject { obj }
+
+    its(:say_hello_to_andrew) { should == "hello, andrew!" }
+    it { should respond_to(:say_goodbye_to_max) }
+    it { should_not respond_to(:tell_max_hello) }
+    its(:public_methods) { should include :say_hello_to_andrew }
+
+    context 'another class' do
+      class AnotherClass; end
+      let(:obj) { AnotherClass }
+      it { should_not respond_to(:say_hello_to_andrew) }
+    end
+  end
+
+  context 'inheritable method_missing' do
+    class SuperKlass
+      class << self
+        include GhostDog
+
+        ghost_method /^call_an_([^_]+)_overridable_method$/ do |text|
+          "#{text} #{overridable_method}"
+        end
+
+        def overridable_method
+          "SuperKlass"
+        end
+      end
+
+      include GhostDog
+
+      ghost_method /^instance_methods_say_(.+)$/ do |what_to_say|
+        "#{greeting} #{what_to_say}"
+      end
+
+      def greeting
+        "Super greeting"
+      end
+    end
+
+    class SubKlass < SuperKlass
+      def self.overridable_method
+        "SubKlass"
+      end
+
+      def greeting
+        "Sub greeting"
+      end
+    end
+
+    subject { obj }
+
+    context SuperKlass do
+      let(:obj) { SuperKlass }
+      its(:call_an_awesome_overridable_method) { should == 'awesome SuperKlass' }
+
+      context 'instance' do
+        let(:obj) { SuperKlass.new }
+        its(:instance_methods_say_salutations) { should == "Super greeting salutations" }
+      end
+    end
+
+    context SubKlass do
+      let(:obj) { SubKlass }
+      its(:call_an_awesome_overridable_method) { should == 'awesome SubKlass' }
+
+      context 'instance' do
+        let(:obj) { SubKlass.new }
+        its(:instance_methods_say_salutations) { should == "Sub greeting salutations" }
+      end
+    end
+  end
+
+  context 'complex matchers' do
+    class ComplexExample
+      include GhostDog
+
+      def names
+        ['ishmael', 'dave']
+      end
+
+      ghost_method do
+        match_with do |method_name|
+          if match = method_name.match(/^call_me_(#{names.join('|')})$/)
+            match.to_a.drop(1)
+          end
+        end
+
+        respond_with do |name|
+          "what's going on #{name}?"
+        end
+      end
+    end
+
+    subject { obj }
+
+    let(:obj) { ComplexExample.new }
+
+    it { should_not respond_to(:call_me_john) }
+    ['ishmael', 'dave'].each do |name|
+      it { should respond_to(:"call_me_#{name}") }
+      its(:"call_me_#{name}") { should == "what's going on #{name}?" }
+    end
+
+    context 'custom matcher class' do
+      class CustomMatcher
+        def matches(receiver, method_name)
+          method_name == 'andrew' && method_name
+        end
+      end
+
+      class CustomMatcher2
+        def matches(receiver, method_name)
+          method_name == 'john' && method_name
+        end
+      end
+
+      class CustomMatcherExample
+        include GhostDog
+
+        ghost_method do
+          match_with CustomMatcher.new
+
+          respond_with do |name|
+            "that's a cool matcher #{name}"
+          end
+        end
+
+        ghost_method CustomMatcher2.new do |name|
+          "more concise, #{name}!"
+        end
+      end
+
+      let(:obj) { CustomMatcherExample.new }
+
+      it { should respond_to(:andrew) }
+      its(:andrew) { should == "that's a cool matcher andrew" }
+      it { should respond_to(:john) }
+      its(:john) { should == "more concise, john!" }
+
+    end
+
+    context 'superclass and subclass' do
+      def self.setup_superclass(super_class)
+
+        super_class.class_eval do
+          include GhostDog
+
+          ghost_method do
+            match_with do |method_name|
+              if match = method_name.match(/^(#{names.join('|')})$/)
+                match.to_a.drop(1)
+              end
+            end
+
+            respond_with do |name|
+              "hello mr #{name}"
+            end
+          end
+        end
+
+      end
+
+      def self.setup_subclasses(sub_class_1, sub_class_2)
+        sub_class_1.class_eval do
+          def names; ['james', 'john']; end
+        end
+
+        sub_class_2.class_eval do
+          def names; ['anna', 'margaret']; end
+        end
+      end
+
+      def self.name_examples_for(names)
+        names.each do |name|
+          it { should respond_to(name) }
+          its(name) { should == "hello mr #{name}" }
+        end
+      end
+
+      def self.non_responding_examples_for(names)
+        names.map(&:to_sym).each do |name|
+          it { should_not respond_to(name) }
+          it 'should raise NoMethodError' do
+            expect { send(name) }.to raise_exception NoMethodError
+          end
+        end
+      end
+
+      def self.name_examples(ctx, obj, options)
+        context ctx do
+          let(:obj) { obj }
+          name_examples_for(options.fetch(:responds_to))
+          non_responding_examples_for(options.fetch(:non_responses))
+        end
+      end
+
+      class SuperClass; end
+      setup_superclass(SuperClass)
+      class SubClassA < SuperClass; end
+      class SubClassB < SuperClass; end
+      setup_subclasses(SubClassA, SubClassB)
+
+      subject { obj }
+
+      name_examples(SubClassA, SubClassA.new,
+                    :responds_to => ['james', 'john'],
+                    :non_responses => ['anna', 'margaret'])
+      name_examples(SubClassB, SubClassB.new,
+                    :responds_to => ['anna', 'margaret'],
+                    :non_responses => ['james', 'john'])
+
+      class SuperEigenClass; end
+      setup_superclass(SuperEigenClass.singleton_class)
+      class SubEigenclassA < SuperEigenClass; end
+      class SubEigenclassB < SuperEigenClass; end
+      setup_subclasses(SubEigenclassA.singleton_class, SubEigenclassB.singleton_class)
+
+      name_examples(SubEigenclassA.singleton_class, SubEigenclassA,
+                    :responds_to => ['james', 'john'],
+                    :non_responses => ['anna', 'margaret'])
+      name_examples(SubEigenclassB.singleton_class, SubEigenclassB,
+                    :responds_to => ['anna', 'margaret'],
+                    :non_responses => ['james', 'john'])
+    end
+  end
+
+  context 'missing method' do
+    class Broken
+      include GhostDog
+
+      ghost_method /\Ahello_(.+)\Z/ do |name|
+        method_that_doesnt_exist(name)
+      end
+
+      ghost_method do
+        match_with do |method_name|
+          nothing_to_see_here(method_name)
+        end
+
+        respond_with do |something|
+          raise "I shouldn't be called..."
+        end
+      end
+    end
+
+    subject { Broken.new }
+
+    context 'in method definition' do
+      it 'should raise error' do
+        expect { subject.hello_world }.to raise_error NoMethodError
+      end
+    end
+
+    context 'in method matcher' do
+      it 'should raise error' do
+        expect { subject.foo_bar }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  context 'calling ghost method from a ghost method' do
+    class DoubleGhost
+      include GhostDog
+
+      ghost_method /\Ahello_(.+)\Z/ do |name|
+        "hello to you, #{name}"
+      end
+
+      ghost_method /\Afoo_(.+)\Z/ do |after_foo|
+        send(:"hello_#{after_foo}")
+      end
+    end
+
+    subject { DoubleGhost.new }
+
+    its(:foo_bar) { should == "hello to you, bar" }
+  end
+
+  context "doesn't define method" do
+    class DontDefineMethod; end
+
+    def self.dont_create_method_examples_for(klass, &block)
+      klass.class_eval do
+        include GhostDog
+
+        ghost_method /\Aforest_whitaker_is_(\w+)\z/, :create_method => false do |what_he_is|
+          "#{prefix} forest is #{what_he_is}?"
+        end
+
+        ghost_method do
+          create_method false
+
+          match_with do |method_name|
+            method_name.to_s =~ /\A(#{name})_is_a_fan_of_forest\z/ && $1
+          end
+
+          respond_with { |name| "#{name} sure is!" }
+        end
+
+        def name
+          'andrew'
+        end
+
+        def prefix
+          "did you know that"
+        end
+      end
+
+      context klass do
+        subject { block.call }
+
+        before do
+          subject.forest_whitaker_is_awesome
+          subject.andrew_is_a_fan_of_forest
+        end
+
+        its(:forest_whitaker_is_awesome) { should == "did you know that forest is awesome?" }
+        its(:public_methods) { should_not include :forest_whitaker_is_awesome }
+        it { should respond_to(:forest_whitaker_is_awesome) }
+
+        its(:andrew_is_a_fan_of_forest) { should == "andrew sure is!" }
+        its(:public_methods) { should_not include :andrew_is_a_fan_of_forest }
+        it { should respond_to(:andrew_is_a_fan_of_forest) }
+      end
+    end
+
+    dont_create_method_examples_for(DontDefineMethod) { DontDefineMethod.new }
+    dont_create_method_examples_for(DontDefineMethod.singleton_class) { DontDefineMethod }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ghost_dog'
+require 'pry'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ghost_dog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Warner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Making method_missing easier since 2013
+email:
+- wwarner.andrew@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ghost_dog.gemspec
+- lib/ghost_dog.rb
+- lib/ghost_dog/responder.rb
+- lib/ghost_dog/responder/dsl.rb
+- lib/ghost_dog/responder/proc_matcher.rb
+- lib/ghost_dog/responder/regexp_matcher.rb
+- lib/ghost_dog/version.rb
+- spec/lib/ghost_dog_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Making method_missing easier since 2013
+test_files:
+- spec/lib/ghost_dog_spec.rb
+- spec/spec_helper.rb