glue_gun 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd223260a00a383841134a2a305ac1cecb9b16ce
+  data.tar.gz: 1aae3df283792b7ee46f804f042dac2170f0bb6b
+SHA512:
+  metadata.gz: 37589b55c665a7caaa9aa5419ee5f50e63aa4b6d6e313534c0ba56b7f1f2bf29837d50546f292fee56f18d81ac3560092f8a3651b9ae479d9473c05f3560972f
+  data.tar.gz: b64200cb444cd4cefb3c1b3c3f7af3a3bc535d8e0aa8a0ca9d3f6fd8ccf2766d76d92f339f162ffb1d628420f08940318dcccc600ee080925f2b9a3e926eeec9

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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in naught.gemspec
+gemspec
+
+group :test do
+  gem 'ruby_gntp'
+  gem 'coveralls', require: false
+  gem 'debugger'
+end

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/glue_gun/config_builder/commands/.rb$})  { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('spec/support/*')  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  # Uncomment next line if Gemfile contain `gemspec' command
+  watch(/^.+\.gemspec/)
+end
+
+notification :gntp

data/LICENSE.txt

@@ -0,0 +1,17 @@
+##########################################################################
+# glue_gun
+#
+# Copyright © 2013 University of Notre Dame
+# Additional copyright may be held by others, as reflected in the commit history.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,82 @@
+# GlueGun
+
+A tool for connecting parts of your application at configuration time.
+
+## But why?
+
+This is part thought experiment, as I wanted to explore pluginable builders.
+This is perhaps needed for working with lots of potentially inter-related Rails engines; Thank you [Project Hydra](https://projecthydra.org).
+
+## Why might this be helpful?
+
+Given that you have an application that is based on a Rails engine or multiple Rails engines.
+When you want to decorate the behavior of one of the engines
+...And don't want to fork the repository
+...And don't have an easy means of submitting a pull request
+Then you may need Glue Gun
+
+## How to think about this?
+
+Imagine that you want Rails to report each and every time an action in one of the engines is called.
+Because of Ruby you can do it relatively easily; Classes can be reopened.
+However, is it critical that you application do the reporting?
+Should you always have that overhead in your tests?
+
+My hope is that with GlueGun you can declare how your various pieces interact together.
+By declaring those interactions, you also have a chance to greater isolate your tests.
+And by that, I mean in the future I intend for GlueGun to be disabled for your tests, unless you specifically want the test to enable all of the hot glue.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'glue_gun'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install glue_gun
+
+## Usage
+
+    $before = []
+    $after = []
+
+    class Book
+      def read; end
+    end
+
+    GlueGun do |config|
+      config.after_method(Book, :read) << lambda { |object|
+        $before << object
+      }
+
+      config.after_method(Book, :read) << lambda { |object|
+        $after << [:read,object]
+      }
+    end
+
+    GlueGun.configure!
+
+    book = Book.new
+    book.read
+    $before == [book]
+    $after == [[:read, book]]
+
+## Todo
+
+* Document the plugin architecture.
+* Create a rails generator for a new before_method hook
+* Create a rails generator for a new after_method hook
+* Create a command for controllers. In theory, after method is adequate for controllers if you always check the status. However, there may be more domain specific details for controller actions.
+
+## 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 @@
+require "bundler/gem_tasks"

data/glue_gun.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'glue_gun/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "glue_gun"
+  spec.version       = GlueGun::VERSION
+  spec.authors       = [
+    "Jeremy Friesen"
+  ]
+  spec.email         = [
+    "jeremy.n.friesen@gmail.com"
+  ]
+  spec.description   = <<-EOF
+  A tool for connecting parts of your application at configuration time.
+  Part thought experiment, part useful, part extensible via plugins.
+  EOF
+  spec.summary       = %q{A tool for connecting parts of your application at configuration time.}
+  spec.homepage      = "https://github.com/jeremyf/glue_gun"
+  spec.license       = "APACHE2"
+
+  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 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'guard-bundler'
+  spec.add_development_dependency 'guard-livereload'
+
+end

data/lib/glue_gun.rb

@@ -0,0 +1,21 @@
+require "glue_gun/version"
+
+module GlueGun
+  module_function
+  def configuration=(object)
+    @configuration = object
+  end
+  def configuration
+    @configuration
+  end
+  def configure!
+    configuration.configure!
+  end
+end
+
+def GlueGun(config = GlueGun::ConfigBuilder.new(GlueGun))
+  yield(config) if block_given?
+  GlueGun.configuration = config
+end
+
+require 'glue_gun/config_builder'

data/lib/glue_gun/config_builder.rb

@@ -0,0 +1,50 @@
+require 'glue_gun/config_builder/commands'
+module GlueGun
+  class ConfigBuilder
+    attr_reader :operations
+    def initialize(context)
+      @context = context
+    end
+
+    def method_missing(method_name, *args, &block)
+      command_name = command_name_for_method(method_name)
+      if Commands.const_defined?(command_name)
+        command_class = Commands.const_get(command_name)
+        command_class.new(self, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private=false)
+      command_name = command_name_for_method(method_name)
+      Commands.const_defined?(command_name) || super
+    rescue NameError
+      super
+    end
+
+    def configure!
+      deferred_commands.each { |commands| commands.call }
+    end
+
+    def cached_command(*args)
+      if cached_value = deferred_commands.detect {|command| command == args }
+        cached_value
+      else
+        command = yield
+        deferred_commands << command
+        command
+      end
+    end
+
+    private
+
+      def command_name_for_method(method_name)
+        method_name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }
+      end
+
+      def deferred_commands
+        @deferred_commands ||= []
+      end
+  end
+end

data/lib/glue_gun/config_builder/command.rb

@@ -0,0 +1,29 @@
+module GlueGun
+  class ConfigBuilder
+    class Command
+      def self.new(builder, *args)
+        builder.cached_command(*args) {
+          super
+        }
+      end
+
+      def initialize(builder)
+        @builder = builder
+        @wrappers = []
+      end
+
+      attr_reader :wrappers
+      protected :wrappers
+      def <<(wrapper)
+        @wrappers += Array(wrapper)
+      end
+
+
+      def call
+        raise NotImplementedError,
+          "Method #call should be overriden in child classes"
+      end
+
+    end
+  end
+end

data/lib/glue_gun/config_builder/commands.rb

@@ -0,0 +1,8 @@
+module GlueGun
+  class ConfigBuilder
+    module Commands
+    end
+  end
+end
+
+Dir[File.expand_path("../commands/*.rb", __FILE__)].each { |f| puts f; require f }

data/lib/glue_gun/config_builder/commands/after_method.rb

@@ -0,0 +1,30 @@
+require 'glue_gun/config_builder/command'
+module GlueGun
+  class ConfigBuilder
+    module Commands
+      class AfterMethod < GlueGun::ConfigBuilder::Command
+
+        attr_reader :klass, :method_name
+        def initialize(builder, klass, method_name)
+          @klass = klass
+          @method_name = method_name
+          super(builder)
+        end
+
+        def call
+          klass.module_exec(method_name, method_to_wrap, wrappers) { |name, method, procs|
+            define_method(name) { |*args, &block|
+              returing_value = method.bind(self).call(*args, &block)
+              procs.each {|proc| proc.call(self) }
+              returing_value
+            }
+          }
+        end
+        private
+          def method_to_wrap
+            klass.instance_method(method_name)
+          end
+      end
+    end
+  end
+end

data/lib/glue_gun/config_builder/commands/before_method.rb

@@ -0,0 +1,29 @@
+require 'glue_gun/config_builder/command'
+module GlueGun
+  class ConfigBuilder
+    module Commands
+      class BeforeMethod < GlueGun::ConfigBuilder::Command
+
+        attr_reader :klass, :method_name
+        def initialize(builder, klass, method_name)
+          @klass = klass
+          @method_name = method_name
+          super(builder)
+        end
+
+        def call
+          klass.module_exec(method_name, method_to_wrap, wrappers) { |name, method, procs|
+            define_method(name) { |*args, &block|
+              procs.each {|proc| proc.call(self) }
+              method.bind(self).call(*args, &block)
+            }
+          }
+        end
+        private
+          def method_to_wrap
+            klass.instance_method(method_name)
+          end
+      end
+    end
+  end
+end

data/lib/glue_gun/version.rb

@@ -0,0 +1,3 @@
+module GlueGun
+  VERSION = "0.0.2"
+end

data/spec/lib/glue_gun.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe GlueGun do
+
+  let(:klass) {
+    Class.new {
+      def foo; end
+    }
+  }
+end

data/spec/lib/glue_gun/config_builder/command_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module GlueGun
+  describe ConfigBuilder::Command do
+    it 'is abstract' do
+      command = ConfigBuilder::Command.new(ConfigBuilder.new(nil))
+      expect{command.call}.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/glue_gun/config_builder/commands/after_method_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+describe GlueGun do
+  describe 'after_method' do
+    let(:klass) {
+      Class.new {
+        def initialize
+          @counter = 0
+        end
+        attr_reader :counter
+        def foo
+          @counter += 1
+        end
+      }
+    }
+    before(:each) do
+      $receiver = []
+      $other_receiver = []
+      GlueGun do |config|
+        config.after_method(klass, :foo) << lambda { |object|
+          $receiver << object
+        }
+
+        config.after_method(klass, :foo) << lambda { |object|
+          $other_receiver << 1
+        }
+      end
+    end
+    let(:klass_instance) { klass.new }
+
+    it 'runs the configuration block when method is called' do
+      GlueGun.configure!
+      expect {
+        expect {
+          klass_instance.foo
+        }.to change { $other_receiver }.from([]).to([1])
+      }.to change { $receiver }.from([]).to([klass_instance])
+      expect(klass_instance.counter).to eq(1)
+    end
+
+    it 'does not apply configuration until configurator is configured!' do
+      expect {
+        expect {
+          klass_instance.foo
+        }.to_not change { $other_receiver }
+      }.to_not change { $receiver }
+      expect(klass_instance.counter).to eq(1)
+    end
+  end
+end

data/spec/lib/glue_gun/config_builder/commands/before_method_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+describe GlueGun do
+  describe 'before_method command' do
+    let(:klass) {
+      Class.new {
+        def initialize
+          @counter = 0
+        end
+        attr_reader :counter
+        def foo
+          @counter += 1
+        end
+      }
+    }
+    before(:each) do
+      $receiver = []
+      $other_receiver = []
+      GlueGun do |config|
+        config.before_method(klass, :foo) << lambda { |object|
+          $receiver << object
+        }
+
+        config.before_method(klass, :foo) << lambda { |object|
+          $other_receiver << 1
+        }
+      end
+    end
+    let(:klass_instance) { klass.new }
+
+    it 'runs the configuration block when method is called' do
+      GlueGun.configure!
+      expect {
+        expect {
+          klass_instance.foo
+        }.to change { $other_receiver }.from([]).to([1])
+      }.to change { $receiver }.from([]).to([klass_instance])
+      expect(klass_instance.counter).to eq(1)
+    end
+
+    it 'does not apply configuration until configurator is configured!' do
+      expect {
+        expect {
+          klass_instance.foo
+        }.to_not change { $other_receiver }
+      }.to_not change { $receiver }
+      expect(klass_instance.counter).to eq(1)
+    end
+  end
+end

data/spec/lib/glue_gun/config_builder_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module GlueGun
+  class ConfigBuilder
+    module Commands
+      class TestCommand
+      end
+    end
+  end
+
+  describe ConfigBuilder do
+
+    let(:container) { double }
+    subject { GlueGun::ConfigBuilder.new(container) }
+
+    it 'responds to commands defined in ConfigBuilder::Commands' do
+      expect(subject).to respond_to(:test_command)
+    end
+
+    it 'translates method calls into command invocations including arguments' do
+      test_command = double
+      ConfigBuilder::Commands::TestCommand.should_receive(:new).
+        with(subject, "foo", 42).
+        and_return(test_command)
+      expect(subject.test_command("foo", 42)).to eq(test_command)
+    end
+
+    it 'handles missing non-command missing methods normally' do
+      expect(subject).not_to respond_to(:nonexistant_method)
+      expect{subject.nonexistent_method}.to raise_error(NoMethodError)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+GEM_ROOT = File.expand_path("../../", __FILE__)
+$:.unshift File.join(GEM_ROOT, "lib")
+
+require 'glue_gun'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: glue_gun
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jeremy Friesen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-31 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: guard
+  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: guard-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: guard-bundler
+  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: guard-livereload
+  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: |2
+    A tool for connecting parts of your application at configuration time.
+    Part thought experiment, part useful, part extensible via plugins.
+email:
+- jeremy.n.friesen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- glue_gun.gemspec
+- lib/glue_gun.rb
+- lib/glue_gun/config_builder.rb
+- lib/glue_gun/config_builder/command.rb
+- lib/glue_gun/config_builder/commands.rb
+- lib/glue_gun/config_builder/commands/after_method.rb
+- lib/glue_gun/config_builder/commands/before_method.rb
+- lib/glue_gun/version.rb
+- spec/lib/glue_gun.rb
+- spec/lib/glue_gun/config_builder/command_spec.rb
+- spec/lib/glue_gun/config_builder/commands/after_method_spec.rb
+- spec/lib/glue_gun/config_builder/commands/before_method_spec.rb
+- spec/lib/glue_gun/config_builder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jeremyf/glue_gun
+licenses:
+- APACHE2
+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: A tool for connecting parts of your application at configuration time.
+test_files:
+- spec/lib/glue_gun.rb
+- spec/lib/glue_gun/config_builder/command_spec.rb
+- spec/lib/glue_gun/config_builder/commands/after_method_spec.rb
+- spec/lib/glue_gun/config_builder/commands/before_method_spec.rb
+- spec/lib/glue_gun/config_builder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: