method_found 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9de7a0b0880e53f1c96603d88fa416c025a4e29d
-  data.tar.gz: 4b65ed2fbf1926df69dc140341c677240fcc3a4d
+  metadata.gz: c80b59b4cfa2a683e9eaf250f975cebeff2594f0
+  data.tar.gz: 7004c79a99fddd803d098f4ebabe5541d8ebfeae
 SHA512:
-  metadata.gz: 0ad77664bf164a317b348a0af8822ec3532b2b688909fb216635abf7dacba6b70a185ee8cf8b53025972969ff7e96e42f1babd4a999d143a22700d1ca62b3f32
-  data.tar.gz: d35e820982307478a88e09ccf0b7c2c35725123f429d9795466c3b7451a51e278e395c73f0b0710e2c8d38f81797da7653503da5d090efd9796f454bb4cc0c2e
+  metadata.gz: ccb77ec85e8d6b98b66315c53853088308ba74a760dabe638499717f597ccdf9c2dcf44378cb1c4c1a26cf35202963fc8116c6154d785581f7a43b7dee4e96f6
+  data.tar.gz: b76fbe65a0a186bb5f361ab251c9d514e20b020aa0ac0949dfacfcf832e8a997392c519c23e85615227599ec0ed97feeedf5facdd1372792692fa41a2fac69e9

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+Guardfile

data/Guardfile

@@ -39,32 +39,4 @@ guard :rspec, cmd: "bundle exec rspec" do
   # Ruby files
   ruby = dsl.ruby
   dsl.watch_spec_files_for(ruby.lib_files)
-
-  # Rails files
-  rails = dsl.rails(view_extensions: %w(erb haml slim))
-  dsl.watch_spec_files_for(rails.app_files)
-  dsl.watch_spec_files_for(rails.views)
-
-  watch(rails.controllers) do |m|
-    [
-      rspec.spec.call("routing/#{m[1]}_routing"),
-      rspec.spec.call("controllers/#{m[1]}_controller"),
-      rspec.spec.call("acceptance/#{m[1]}")
-    ]
-  end
-
-  # Rails config changes
-  watch(rails.spec_helper)     { rspec.spec_dir }
-  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
-  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
-
-  # Capybara features specs
-  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
-  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
-
-  # Turnip features and steps
-  watch(%r{^spec/acceptance/(.+)\.feature$})
-  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
-    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
-  end
 end

data/README.md

@@ -5,6 +5,7 @@
 
 [gem]: https://rubygems.org/gems/method_found
 [travis]: https://travis-ci.org/shioyama/method_found
+[docs]: http://www.rubydoc.info/gems/method_found
 
 Intercept `method_missing` and do something useful with it.
 
@@ -13,23 +14,29 @@ Intercept `method_missing` and do something useful with it.
 Add to your Gemfile:
 
 ```ruby
-gem 'method_found', '~> 0.1.2'
+gem 'method_found', '~> 0.1.3'
 ```
 
 And bundle it.
 
 ## Usage
 
-Include an instance of `MethodFound` with a regex to match and block which
-takes the method name, regex matches, and arguments and does something with it:
+Include an instance of `MethodFound::Builder` with a block defining all
+patterns to match. Identify a pattern with the `intercept` method, like this:
 
 ```ruby
 class Foo
-  include(MethodFound.new(/\Asay_([a-z]+)/Z/) do |method_name, matches, *arguments|
-    "#{matches[0]}!"
-  end)
+  include MethodFound::Builder.new {
+    intercept /\Asay_([a-z]+)\Z/ do |method_name, matches, *arguments, &block|
+      "#{matches[1]}!"
+    end
+  }
 end
+```
+
+Now you can say things:
 
+```ruby
 foo = Foo.new
 foo.say_hello
 #=> "hello!"
@@ -37,7 +44,13 @@ foo.say_bye
 #=> "bye!"
 ```
 
+That's it!
+
+## More Information
+
+- [Github repository](https://www.github.com/shioyama/method_found)
+- [API documentation][docs]
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/method_found/builder.rb

@@ -0,0 +1,40 @@
+module MethodFound
+=begin
+
+Creates set of interceptors to include into a class.
+
+@example
+  class Post
+    builder = MethodFound::Builder.new {
+      intercept /\Asay_([a-z]+)\Z/ do |method_name, matches, *arguments|
+        "#{matches[1]}!"
+      end
+
+      intercept /\Ayell_([a-z]+)\Z/ do |method_name, matches, *arguments|
+        "#{matches[1]}!!!"
+      end
+    }
+  end
+
+  foo = Foo.new
+  foo.say_hello
+  #=> "hello!"
+  foo.yell_hello
+  #=> "hello!!!"
+=end
+  class Builder < Module
+    attr_reader :interceptors
+
+    # @yield Yields builder as context to block, to allow calling builder
+    #   methods to create interceptors in included class.
+    def initialize(&block)
+      @interceptors = []
+      instance_eval &block
+    end
+
+    def intercept(*args, &block)
+      @interceptors.push(interceptor = Interceptor.new(*args, &block))
+      include interceptor
+    end
+  end
+end

data/lib/method_found/interceptor.rb

@@ -1,30 +1,84 @@
 module MethodFound
+=begin
+
+Class for intercepting method calls using method_missing. Initialized by
+passing in a matcher object which can be a Regexp, a proc or lambda, or a
+string/symbol.
+
+=end
   class Interceptor < Module
-    attr_reader :regex
+    attr_reader :matcher
 
-    def initialize(regex = nil, &intercept_block)
-      define_method_missing(regex, &intercept_block) unless regex.nil?
+    # Creates an interceptor module to include into a class.
+    # @param (see #define_method_missing)
+    def initialize(matcher = nil, &intercept_block)
+      define_method_missing(matcher, &intercept_block) unless matcher.nil?
     end
 
-    def define_method_missing(regex, &intercept_block)
-      @regex = regex
+    # Define method_missing and respond_to_missing? on this interceptor. Can be
+    # called after interceptor has been created.
+    # @param [Regexp,Proc,String,Symbol] matcher Matcher for intercepting
+    #   method calls.
+    # @yield [method_name, matches, &block] Yiels method_name matched, set of
+    #   matches returned from matcher, and block passed to method when called.
+    def define_method_missing(matcher, &intercept_block)
+      @matcher = matcher_ = Matcher.new(matcher)
+      assign_intercept_method(&intercept_block)
+      method_cacher = method(:cache_method)
+
       define_method :method_missing do |method_name, *arguments, &method_block|
-        if matches = regex.match(method_name)
-          instance_exec(method_name, matches, *arguments, &intercept_block)
+        if matches = matcher_.match(method_name)
+          method_cacher.(method_name, matches)
+          send(method_name, *arguments, &method_block)
         else
           super(method_name, *arguments, &method_block)
         end
       end
 
       define_method :respond_to_missing? do |method_name, include_private = false|
-        (method_name =~ regex) || super(method_name, include_private)
+        if matches = matcher_.match(method_name)
+          method_cacher.(method_name, matches)
+        else
+          super(method_name, include_private)
+        end
       end
     end
 
     def inspect
       klass = self.class
       name  = klass.name || klass.inspect
-      "#<#{name}: #{regex.inspect}>"
+      "#<#{name}: #{matcher.inspect}>"
+    end
+
+    private
+
+    def cache_method(method_name, matches)
+      intercept_method = @intercept_method
+      define_method method_name do |*arguments, &block|
+        send(intercept_method, method_name, matches, *arguments, &block)
+      end
+    end
+
+    def assign_intercept_method(&intercept_block)
+      @intercept_method ||= "__intercept_#{SecureRandom.hex}".freeze.tap do |method_name|
+        define_method method_name, &intercept_block
+      end
+    end
+
+    class Matcher < Struct.new(:matcher)
+      def match(method_name)
+        if matcher.is_a?(Regexp)
+          matcher.match(method_name)
+        elsif matcher.respond_to?(:call)
+          matcher.call(method_name) && [method_name.to_s]
+        else
+          (matcher.to_sym == method_name) && [method_name.to_s]
+        end
+      end
+
+      def inspect
+        matcher.inspect
+      end
     end
   end
 end

data/lib/method_found/simple_model.rb

@@ -0,0 +1,109 @@
+require "method_found"
+
+module MethodFound
+=begin
+
+Example class using MethodFound interceptors to implement attributes and change
+tracking. Symbols passed into constructor define patterns in interceptor
+modules to catch method calls and define methods on module as needed. New
+methods can be dynamically defined by calling any undefined method with a bang (!).
+
+This class is not included by default when requiring MethodFound, so you will need to explicitly require it with:
+
+  require "method_found/simple_model"
+
+@example Setting Attributes
+  post = MethodFound::SimpleModel.new(:title, :content)
+
+  post.title = "Method Found"
+  post.content = "Once upon a time..."
+
+  post.title
+  #=> "Method Found"
+
+  post.content
+  #=> "Once upon a time..."
+
+@example Dyanamically defining new attributes
+  post = MethodFound::SimpleModel.new
+
+  post.foo
+  #=> raises MethodNotFound error
+
+  post.foo!
+  #=> nil
+
+  post.foo = "my foo"
+  post.foo
+  #=> "my foo"
+
+@example Tracking changes
+  post = MethodFound::SimpleModel.new(:title)
+
+  post.title = "foo"
+  post.title_changed?
+  #=> false
+
+  post.title = "bar"
+  post.title_changed?
+  #=> true
+  post.title_was
+  #=> "foo"
+  post.title_changes
+  #=> ["bar", "foo"]
+
+=end
+  class SimpleModel
+    attr_reader :attribute_builder
+
+    # @param attribute_names [Symbol] One or more attribute names to define
+    #   interceptors for on model.
+    def initialize(*attribute_names)
+      @attributes = Hash.new { |h, k| h[k] = [] }
+
+      @attribute_builder = builder = Builder.new do
+        def define_missing(attribute_name)
+          intercept /\A(#{attribute_name})(=|\?)?\Z/.freeze do |_, matches, *arguments|
+            name  = matches[1]
+            value = @attributes[name].last
+
+            if matches[2] == "=".freeze
+              new_value = arguments[0]
+              @attributes[name].push(new_value) unless new_value == value
+            else
+              matches[2] == "?".freeze ? !!value : value
+            end
+          end
+
+          intercept /\A(reset_(#{attribute_name})|(#{attribute_name})_(changed\?|changes|was))\Z/.freeze do |_, matches|
+            if matches[1] == "reset_#{attribute_name}".freeze
+              !!@attributes.delete(matches[2])
+            else
+              changes = @attributes[matches[3]]
+              if matches[4] == "changes".freeze
+                changes.reverse
+              elsif matches[4] == "was".freeze
+                changes[-2]
+              else
+                changes.size > 1
+              end
+            end
+          end
+        end
+
+        intercept /\A(.+)\!\Z/ do |_, matches|
+          builder.define_missing matches[1]
+          singleton_class.include builder
+          @attributes[matches[1]].last
+        end
+      end
+      attribute_names.each { |name| builder.define_missing(name) }
+
+      singleton_class.include builder
+    end
+
+    def attributes
+      Hash[@attributes.map { |k, v| [k, v.last] }]
+    end
+  end
+end

data/lib/method_found/version.rb

@@ -1,3 +1,3 @@
 module MethodFound
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/method_found.rb

@@ -1,8 +1,11 @@
+require "securerandom"
+
 require "method_found/version"
+require "method_found/builder"
 require "method_found/interceptor"
 
 module MethodFound
   def self.new(*args, &block)
-    Interceptor.new(*args, &block)
+    Builder.new(*args, &block)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: method_found
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Chris Salzberg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-18 00:00:00.000000000 Z
+date: 2017-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,7 +71,9 @@ files:
 - bin/console
 - bin/setup
 - lib/method_found.rb
+- lib/method_found/builder.rb
 - lib/method_found/interceptor.rb
+- lib/method_found/simple_model.rb
 - lib/method_found/version.rb
 - method_found.gemspec
 homepage: https://github.com/shioyama/method_found