method_found 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 54697c45ed4ce6071e6c36e15b8aa1a7ec0a2ace
-  data.tar.gz: 366c25aaff318c8033e51ebff45c6415c5c32651
+SHA256:
+  metadata.gz: 95397b45051b6b4b33b65a371f9115455f7006398d726678bd045e6a3bb32f5b
+  data.tar.gz: b4cd923223329c88bd1c3e3ce2281f14975a44ecd2c99711251626cc62c3b0e4
 SHA512:
-  metadata.gz: d78c7e39e4eb121df39f2f9f0b6c68c21cc0b1465bde81220b38bfa74b6d5d032e3f311fcfaf389d5eb40daccd81567d43b1c3c42f2ff749e435db1fc8a24ae1
-  data.tar.gz: 9f3a8ef4238dcd2575dd5a55992835ac77033f5a4739db70f7b1624632e7ba4916d5cd4142aede903ed70d9cc9d342ff208d6161e494573c1b4714dfff10c3c2
+  metadata.gz: b0d3e0960d80193f87d0d690cd18081caae5a10fdbcd85a9cd85c914a2b65c7192ec4a6ada6cb5f1f57bb0bb8c489dddf9edc233bb1fc63d2e3fb078684fdd4d
+  data.tar.gz: 8a7acaa4dffeb0a638dfb7e47449c5e8820530d3958149ac69abbb2186c6d9d907529e47b78e3d3b40ae15a77d8603b3b5445d67a3b6eec21aecee24252997ef

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.1'
+gem 'method_found', '~> 0.1.6'
 ```
 
 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.rb

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

data/lib/method_found/attribute_interceptor.rb

@@ -0,0 +1,91 @@
+require "method_found"
+
+module MethodFound
+=begin
+
+Class defining prefix, suffix and affix methods to a class for a given
+attribute name or set of attribute names.
+
+@example
+  class Person < Struct.new(:attributes)
+    include MethodFound::AttributeInterceptor.new
+    include MethodFound::AttributeInterceptor.new(suffix: '=')
+    include MethodFound::AttributeInterceptor.new(suffix: '_contrived?')
+    include MethodFound::AttributeInterceptor.new(prefix: 'clear_')
+    include MethodFound::AttributeInterceptor.new(prefix: 'reset_', suffix: '_to_default!')
+
+    def initialize(attributes = {})
+      super(attributes)
+    end
+
+    private
+
+    def attribute_contrived?(attr)
+      true
+    end
+
+    def clear_attribute(attr)
+      send("#{attr}=", nil)
+    end
+
+    def reset_attribute_to_default!(attr)
+      send("#{attr}=", 'Default Name')
+    end
+
+    def attribute(attr)
+      attributes[attr]
+    end
+
+    def attribute=(attr, value)
+      attributes[attr] = value
+    end
+  end
+=end
+  class AttributeInterceptor < Interceptor
+    def initialize(prefix: '', suffix: '')
+      @regex = /\A(?:#{Regexp.escape(prefix)})(.*)(?:#{Regexp.escape(suffix)})\z/
+      @method_missing_target = method_missing_target = "#{prefix}attribute#{suffix}"
+      @method_name = "#{prefix}%s#{suffix}"
+
+      super to_proc do |_, attr_name, *args, &block|
+        send(method_missing_target, attr_name, *args, &block)
+      end
+    end
+
+    def define_attribute_methods(*attr_names)
+      handler = @method_missing_target
+      attr_names.each do |attr_name|
+        define_method method_name(attr_name) do |*arguments, &block|
+          send(handler, attr_name, *arguments, &block)
+        end
+      end
+    end
+
+    def alias_attribute(new_name, old_name)
+      handler = method_name(old_name)
+      define_method method_name(new_name) do |*arguments, &block|
+        send(handler, *arguments, &block)
+      end
+    end
+
+    def to_proc
+      regex = @regex
+      proc do |method_name|
+        (matches = regex.match(method_name)) &&
+          (method_name != :attributes) &&
+          respond_to?(:attributes) &&
+          (attributes.keys & matches.captures).first
+      end
+    end
+
+    def inspect
+      "<#{self.class.name}: #{@regex.inspect}>"
+    end
+
+    private
+
+    def method_name(attr_name)
+      @method_name % attr_name
+    end
+  end
+end

data/lib/method_found/attribute_methods.rb

@@ -0,0 +1,79 @@
+require "method_found/attribute_interceptor"
+
+module MethodFound
+=begin
+
+Re-implementation of ActiveModel::AttributeMethods from Rails using
+{MethodFound::Interceptor} modules instead of class variables.
+
+@example
+  class Person < Struct.new(:attributes)
+    include MethodFound::AttributeMethods
+
+    attribute_method_suffix ''
+    attribute_method_suffix '='
+    attribute_method_suffix '_contrived?'
+    attribute_method_prefix 'clear_'
+    attribute_method_affix  prefix: 'reset_', suffix: '_to_default!'
+
+    define_attribute_methods :name
+
+    def initialize(attributes = {})
+      super(attributes)
+    end
+
+    private
+
+    def attribute_contrived?(attr)
+      true
+    end
+
+    def clear_attribute(attr)
+      send("#{attr}=", nil)
+    end
+
+    def reset_attribute_to_default!(attr)
+      send("#{attr}=", 'Default Name')
+    end
+
+    def attribute(attr)
+      attributes[attr]
+    end
+
+    def attribute=(attr, value)
+      attributes[attr] = value
+    end
+  end
+
+=end
+  module AttributeMethods
+    def self.included(base)
+      base.include(AttributeInterceptor.new)
+      base.instance_eval do
+        def attribute_method_prefix(*prefixes)
+          prefixes.each { |prefix| include AttributeInterceptor.new(prefix: prefix) }
+        end
+
+        def attribute_method_suffix(*suffixes)
+          suffixes.each { |suffix| include AttributeInterceptor.new(suffix: suffix) }
+        end
+
+        def attribute_method_affix(*affixes)
+          affixes.each { |affix| include AttributeInterceptor.new(prefix: affix[:prefix], suffix: affix[:suffix]) }
+        end
+
+        def define_attribute_methods(*attr_names)
+          ancestors.each do |ancestor|
+            ancestor.define_attribute_methods(*attr_names) if ancestor.is_a?(AttributeInterceptor)
+          end
+        end
+
+        def alias_attribute(new_name, old_name)
+          ancestors.each do |ancestor|
+            ancestor.alias_attribute(new_name, old_name) if ancestor.is_a?(AttributeInterceptor)
+          end
+        end
+      end
+    end
+  end
+end

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
+      @interceptors = []
+      super
+    end
+
+    def intercept(*args, &block)
+      @interceptors.push(interceptor = Interceptor.new(*args, &block))
+      include interceptor
+    end
+  end
+end

data/lib/method_found/interceptor.rb

@@ -1,22 +1,91 @@
 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
-    def initialize(regex, &intercept_block)
+    attr_reader :matcher
+
+    # 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
+
+    # 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, self)
+          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, self)
+          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}: #{matcher.inspect}>"
+    end
+
+    private
+
+    def cache_method(method_name, matches)
+      intercept_method, matcher = @intercept_method, @matcher
+      define_method method_name do |*arguments, &block|
+        if matcher.proc? && !(matches = matcher.match(method_name, self))
+          return super(*arguments, &block)
+        end
+        arguments = [matches, *arguments] unless method(intercept_method).arity == 1
+        send(intercept_method, method_name, *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, context)
+        if matcher.is_a?(Regexp)
+          matcher.match(method_name)
+        elsif matcher.respond_to?(:call)
+          context.instance_exec(method_name, &matcher)
+        else
+          (matcher.to_sym == method_name)
+        end
+      end
+
+      def proc?
+        matcher.is_a?(Proc)
       end
 
-      define_method :inspect do
-        klass = self.class
-        name  = klass.name || klass.inspect
-        "#<#{name}: #{regex.inspect}>"
+      def inspect
+        matcher.inspect
       end
     end
   end

data/lib/method_found/version.rb

@@ -1,3 +1,3 @@
 module MethodFound
-  VERSION = "0.1.1"
+  VERSION = "0.1.6"
 end

data/method_found.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 12.3"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: method_found
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Chris Salzberg
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-04-17 00:00:00.000000000 Z
+date: 2020-12-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description:
 email:
 - chris@dejimata.com
 executables: []
@@ -71,6 +57,9 @@ files:
 - bin/console
 - bin/setup
 - lib/method_found.rb
+- lib/method_found/attribute_interceptor.rb
+- lib/method_found/attribute_methods.rb
+- lib/method_found/builder.rb
 - lib/method_found/interceptor.rb
 - lib/method_found/version.rb
 - method_found.gemspec
@@ -78,7 +67,7 @@ homepage: https://github.com/shioyama/method_found
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -93,9 +82,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: Gem to intercept method_missing calls and do something useful.
 test_files: []