hook_lying_syncer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50543d3682fdd1714cba83c22081c01cbe134447
+  data.tar.gz: 8dd510ad63d6e6dc0440356ea1aa0089d87685f1
+SHA512:
+  metadata.gz: b0d3dc628398cb5816bf5bd6f643a7becbff5c90ab5a93df13176c20e2782a0fafb8074a92c840c3d4537f0ff1b99855ddf53ccd872922b7f4c72490994fb1bb
+  data.tar.gz: 58ad28b4921f4d9340aebd3991591a1e6031d16294b340996d3b263e9f0871b5731f78cac3acce59f905581fc6ba9abb50abe75c1d99fdf29285b313dd0d39e2

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dave Aronson
+
+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,80 @@
+hook_lying_syncer
+=================
+
+This project presents a way for Ruby coders to keep method_missing and
+respond_to_missing? in sync.
+
+## Background
+
+The whole idea of finding a way to automagically keep method_missing and
+respond_to_missing? in sync, was originally inspired by [Avdi
+Grimm](http://about.avdi.org/)'s [blog
+post](http://devblog.avdi.org/2011/12/07/defining-method_missing-and-respond_to-at-the-same-time/)
+about the need to sync them.  I came up with a quick and dirty hack, and a
+still-hacky improvement that seems to have been mangled by a blog platform
+change or some such.
+
+Then at RubyConf 2014, [Betsy Haibel](http://betsyhaibel.com/) gave a talk on
+metaprogramming, including the need.  That inspired me to take another whack at
+it, this time using the different approach shown in this repo (essentially, a
+decorator class).
+
+I got some suggestions and other help from [Chris
+Hoffman](https://github.com/yarmiganosca), mainly in figuring out that I
+shouldn't do the in-block object access the way I was trying to!  :-)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hook_lying_syncer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hook_lying_syncer
+
+
+
+## Usage
+
+Create a HookLyingSyncer by passing it something to wrap, a lambda to turn the
+method name into the subparts of interest, and a block to execute when there's
+a match.
+
+* The "something to wrap" can be any object, even a class.  Note however that
+  if you wrap a class, that will not affect its instances!  You can affect
+  future instances by using a wrapper to override .new, but if you need to
+  affect _extant_ instances, you have to wrap them yourself.
+
+* The lambda must return an Array with some truthy content (or at least
+  _something_ that responds positively to #any?) if the method name is one
+  you're interested in, and either an empty Array (or at least _something_ that
+  responds negatively to #any?) or something falsey (i.e., false or nil)
+  otherwise.  If you are not comfortable making lambdas, feel free to copy the
+  lambda_maker method in the tests.
+
+* The block will be called when the lambda indicates that a method of interest
+  has been called.  The block will receive three arguments: the original object
+  the HookLyingSyncer wrapped, the matches returned by the lambda, and the list
+  of arguments (if any) passed in the method call.
+
+See the tests for examples.
+
+## Status
+
+I have barely begun to work on this repo, so it's still a bit rough, as a
+project per se.  My plan is to turn it into a gem.
+
+## Contributing
+
+1. Fork it ( https://github.com/davearonson/hook_lying_syncer/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/hook_lying_syncer.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hook_lying_syncer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hook_lying_syncer"
+  spec.version       = HookLyingSyncer::VERSION
+  spec.authors       = ["Dave Aronson"]
+  spec.email         = ["hook_lying_syncer_gemspec.2.TRex@Codosaur.us"]
+  spec.summary       = %q{Keeps method_missing and respond_to_missing? in sync.}
+  spec.description   = %q{Provides a decorator class you can wrap objects in (even classes!) to keep method_missing and respond_to_missing? in sync.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"  
+end

data/lib/hook_lying_syncer.rb

@@ -0,0 +1,44 @@
+require "hook_lying_syncer/version"
+
+class HookLyingSyncer
+
+  # object is the object being wrapped, for purposes of endowing it with some
+  # pattern of methods it should respond to.
+  #
+  # matcher is a lambda that returns any words of interest to the block, given
+  # the called method name.  if there are any, it should return an array.  if
+  # there are none, it may return an empty array, nil, or false, and the method
+  # name will be ass-u-me'd to be "not of interest".
+  #
+  # block is what you want to do with the object, the matches, and any
+  # additional args given to the dynamic method.  ideally this should include
+  # actually declaring the method, so further uses won't be inefficiently done
+  # via method_missing.  maybe a later version of hls will do that for you.
+  def initialize(object, matcher, &block)
+    @object = object
+    @matcher = matcher
+    @block = block
+  end
+
+  private
+
+  def respond_to_missing?(sym, include_all=false)
+    matches = find_matches(sym)
+    matches.any? ? true : @object.send(:respond_to?, sym, include_all)
+  end
+
+  def method_missing(sym, *args, &blk)
+    matches = find_matches(sym)
+    if matches.any?
+      @block.call(@object, matches, *args)
+    else
+      @object.send(sym, *args, &blk)
+    end
+  end
+
+  def find_matches(sym)
+    result = @matcher.call(sym)
+    result ? result : []
+  end
+
+end

data/lib/hook_lying_syncer/version.rb

@@ -0,0 +1,3 @@
+class HookLyingSyncer
+  VERSION = "0.0.1"
+end

data/spec/hook_lying_syncer_spec.rb

@@ -0,0 +1,271 @@
+require 'hook_lying_syncer'
+
+def lambda_maker(prefix, separator, suffix=nil)
+  lambda { |method_name|
+    matches = /\A#{prefix}(\w+)#{suffix}\Z/.match(method_name)
+    matches[1].split(separator) if matches
+  }
+end
+
+class Person
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+  def self.find(params)
+    self.seek("Looking for", params)
+  end
+  def self.need(params)
+    self.seek("I need", params)
+  end
+  def self.what_are_they
+    "Are we not men?  We are Devo!  D-E-V-O!"
+  end
+  private
+  def self.seek(look_how, params)
+    wants = [].tap { |list| params.each { |key, val| list << "#{val} #{key}" } }
+
+    # there's got to be some way to do this more cleanly...
+    # wouldn't be surprised if Rails has something like Array#sentencize....
+    wants[-1] = "and #{wants[-1]}" if wants.length > 1
+    separator = wants.length > 2 ? ", " : " "
+    description = wants.join(separator)
+
+    "#{look_how} a person with #{ description }"
+  end
+end
+
+describe HookLyingSyncer do
+
+  describe "on instances" do
+
+    before do
+      @person = Person.new("Dave")
+      kinds_getter = lambda_maker("find_", "_", "_widgets")
+      @syncer = HookLyingSyncer.new(@person, kinds_getter) do |p, kinds, *args|
+        addons = args.any? ? ", with #{args.join(" and ")}" : nil
+        "#{p.name} wants #{kinds.join(" ")} widgets#{addons}"
+      end
+    end
+
+    describe "respond_to_missing?" do
+
+      it "can handle dynamically defined methods" do
+        expect(@syncer.respond_to? :find_green_widgets).to equal true
+      end
+
+      it "can handle the original object's methods" do
+        expect(@syncer.respond_to? :name).to equal true
+      end
+
+      it "still rejects unknown methods" do
+        expect(@syncer.respond_to? :blargh).to equal false
+      end
+
+    end
+
+    describe "method_missing" do
+
+      describe "can handle dynamically defined methods" do
+
+        it "with no args" do
+          expect(@syncer.find_green_widgets).to eql "Dave wants green widgets"
+        end
+
+        it "with an arg" do
+          expect(@syncer.find_green_widgets(:stripes)).to eql(
+            "Dave wants green widgets, with stripes")
+        end
+
+        it "with multiple args" do
+          expect(@syncer.find_green_widgets(:stripes, :spots)).to eql(
+            "Dave wants green widgets, with stripes and spots")
+        end
+
+        it "with multiple subparts" do
+          expect(@syncer.find_big_green_widgets).to eql(
+            "Dave wants big green widgets")
+        end
+
+      end
+
+      describe "can handle the object's original methods" do
+
+        it "using the original object" do
+          expect(@syncer.name).to eql "Dave"
+        end
+
+        it "even if the object-pointing var is changed" do
+          @person = Person.new("Chris")
+          expect(@person.name).to eql "Chris" # just a sanity check
+          expect(@syncer.name).to eql "Dave"
+        end
+
+      end
+
+      it "doesn't prevent blowup on totally unknown methods" do
+        expect { @syncer.blarg }.to raise_error NoMethodError
+      end
+
+      it "can add methods" do
+        method_matcher = lambda { |name| name == :foo ? [name] : nil }
+        syncer = HookLyingSyncer.new(@person, method_matcher) do |p, wants, *args|
+          def foo
+            :foo
+          end
+        end
+        expect(syncer.foo).to equal :foo
+      end
+
+      it "can override methods" do
+        method_matcher = lambda { |name| name == :name ? [name] : nil }
+        syncer = HookLyingSyncer.new(@person, method_matcher) do |p, wants, *args|
+          p.name.reverse.capitalize
+        end
+        expect(syncer.name).to eql "Evad"
+      end
+
+    end
+
+    describe "with multiple levels" do
+
+      before do
+        name_getter = lambda_maker("say_to_", "_and_")
+        @inner = @syncer
+        @outer = HookLyingSyncer.new(@inner, name_getter) do |inner, names, *args|
+          "#{inner.name} says \"#{args.join("\" and \"")}\" to #{names.map(&:capitalize).join(" and ")}"
+        end
+      end
+
+      describe "respond_to_missing?" do
+
+        it "can handle dynamically defined methods" do
+          expect(@person.respond_to? :say_to_fred).to equal false
+          expect(@inner.respond_to? :say_to_fred).to equal false
+          expect(@outer.respond_to? :say_to_fred).to equal true
+        end
+
+        it "can handle the original object's methods" do
+          expect(@outer.respond_to? :name).to equal true
+        end
+
+        it "still rejects unknown methods" do
+          expect(@outer.respond_to? :blargh).to equal false
+        end
+
+      end
+
+      describe "method_missing" do
+
+        it "can handle dynamically defined methods" do
+          expect(@outer.say_to_fred_and_ethel("hail", "well met")).to eql(
+            "Dave says \"hail\" and \"well met\" to Fred and Ethel")
+        end
+
+        it "can handle the inner object's methods" do
+          expect(@outer.name).to eql "Dave"
+        end
+
+        it "can handle the inner syncer's methods" do
+          expect(@outer.find_big_green_widgets(:stripes, :spots)).to eql(
+            "Dave wants big green widgets, with stripes and spots")
+        end
+
+        it "still barfs on unknown methods" do
+          expect { @outer.blarg }.to raise_error NoMethodError
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "can wrap classes" do
+
+    before do
+      wants_getter = lambda_maker("find_by_", "_and_")
+      @syncer = HookLyingSyncer.new(Person, wants_getter) do |c, wants, *args|
+        if wants.length != args.length
+          raise "#{wants.length} qualities but #{args.length} values"
+        end
+        c.find wants.zip(args).to_h
+      end
+    end
+
+    it "and receive method-name-parts and args" do
+      expect(@syncer.find_by_eyes_and_hair_and_skin(:red, :blue, :green)).to eql(
+        "Looking for a person with red eyes, blue hair, and green skin")
+    end
+
+    it "to override class methods" do
+      method_matcher = lambda { |name| name == :what_are_they ? [name] : nil }
+      what_they_are = "three little maids from school"
+      syncer = HookLyingSyncer.new(Person, method_matcher) do |c, wants, *args|
+        what_they_are
+      end
+      expect(syncer.what_are_they).to eql what_they_are
+    end
+
+    it "to add class methods" do
+      method_matcher = lambda { |name| name == :foo ? [name] : nil }
+      syncer = HookLyingSyncer.new(Person, method_matcher) do |c, wants, *args|
+        def c.foo
+          :foo
+        end
+      end
+      expect(syncer.foo).to equal :foo
+    end
+
+    it "to override the class's .new method" do
+      method_matcher = lambda { |name| name == :new ? [name] : nil }
+      syncer = HookLyingSyncer.new(Person, method_matcher) do |c, wants, *args|
+        c.new(args[0].reverse.capitalize)
+      end
+      expect(syncer.new("Dave").name).to eql "Evad"
+    end
+
+    it "to add instance methods" do
+      method_matcher = lambda { |name| name == :new ? [name] : nil }
+      syncer = HookLyingSyncer.new(Person, method_matcher) do |c, wants, *args|
+        c.new(args).tap { |obj|
+          def obj.foo
+            :foo
+          end
+        }
+      end
+      expect(syncer.new("Dave").foo).to equal :foo
+    end
+
+    it "can still call the class's methods" do
+      expect(@syncer.what_are_they).to eql Person.what_are_they
+    end
+
+    describe "wrapping an already wrapped class" do
+
+      before do
+        needs_getter = lambda_maker("need_with_", "_and_")
+        @outer = HookLyingSyncer.new(@syncer, needs_getter) do |c, wants, *args|
+          c.need wants.zip(args).to_h
+        end
+      end
+
+      it "can call the new thing" do
+        expect(@outer.need_with_eyes_and_hair(:red, :blue)).to eql(
+          "I need a person with red eyes and blue hair")
+      end
+
+      it "can still call the old thing" do
+        expect(@outer.find_by_eyes_and_hair(:red, :blue)).to eql(
+          "Looking for a person with red eyes and blue hair")
+      end
+
+      it "can still call the class's methods" do
+        expect(@syncer.what_are_they).to eql Person.what_are_they
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: hook_lying_syncer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dave Aronson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: Provides a decorator class you can wrap objects in (even classes!) to
+  keep method_missing and respond_to_missing? in sync.
+email:
+- hook_lying_syncer_gemspec.2.TRex@Codosaur.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hook_lying_syncer.gemspec
+- lib/hook_lying_syncer.rb
+- lib/hook_lying_syncer/version.rb
+- spec/hook_lying_syncer_spec.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.4.2
+signing_key: 
+specification_version: 4
+summary: Keeps method_missing and respond_to_missing? in sync.
+test_files:
+- spec/hook_lying_syncer_spec.rb