implements 0.0.2

data/.githooks/pre-commit/run-ruby-appraiser

@@ -0,0 +1,17 @@
+#!/bin/bash
+echo -e "\033[0;36mRuby Appraiser: running\033[0m"
+bundle exec ruby-appraiser --all --mode=staged
+result_code=$?
+if [ $result_code -gt "0" ]; then
+  echo -en "\033[0;31m" # RED
+  echo "[✘] Ruby Appraiser found newly-created defects and "
+  echo "    has blocked your commit."
+  echo "    Fix the defects and commit again."
+  echo "    To bypass, commit again with --no-verify."
+  echo -en "\033[0m" # RESET
+  exit $result_code
+else
+  echo -en "\033[0;32m" # GREEN
+  echo "[✔] Ruby Appraiser ok"
+  echo -en "\033[0m" #RESET
+fi

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/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+script: "bundle exec rake spec"
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,7 @@
+# encoding: utf-8
+source 'https://rubygems.org'
+
+gem 'activesupport', require: false
+
+# Specify your gem's dependencies in implements.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Biesemeyer
+
+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,173 @@
+# Implements
+
+`Implements` is a tool for building modular libraries and tools as
+interfaces, for implementing those interfaces, and ensuring that
+consumers are able to load the best available implementation at
+runtime.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'implements'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install implements
+
+## Usage
+
+`Implements` was created as a dependency of my [redis-copy][] gem, which
+provides multiple implementations of each of multiple interfaces in order to
+provide support for new features in redis, while falling back gracefully
+(sometimes multiple steps) to less-optimal implementations when
+the underlying support is not present.
+
+[redis-copy]: https://github.com/yaauie/redis-copy
+
+The goal of the `implements` gem in particular is to provide an implementation
+registry that is attached to the interface, and can be used to provide
+the best-possible implementation for a given scenario. It also allows
+third-party libraries to provide their own implementations of an interface
+without having to touch the library that contains their upstream interface.
+
+Below you will find a simplified example:
+
+``` ruby
+require 'implements/global'
+
+module RedisCopy
+  module KeyEmitter
+    extend Implements::Interface
+
+    # @param redis_connection [Object]
+    # @return [void]
+    def intialize(redis_connection)
+      @redis = redis_connection
+    end
+
+    # @param keys [String] - ('*') a glob-ish pattern
+    # @return [Enumerable<String>]
+    def keys(pattern = '*')
+      raise NotImplementedError
+    end
+
+    # ...
+
+    class Default
+      implements KeyEmitter
+
+      def keys(pattern = '*')
+        @redis.keys(pattern)
+      end
+    end
+
+    class Scanner
+      # note how a block is given to `implements`.
+      # this block is called with the class' initialize arguments
+      # to determine whether or not this implementation is compatible
+      # with the input and its state before initializing the object.
+      implements KeyEmitter do |redis_connection|
+        bin_version = Gem::Version.new(redis_connection.info['redis_version'])
+        bin_requirement = Gem::Requirement.new('>= 2.7.105')
+
+        break false unless bin_requirement.satisfied_by?(bin_version)
+
+        redis_connection.respond_to?(:scan_each)
+      end
+
+      def keys(pattern = '*')
+        @redis.scan_each(match: pattern, count: 1000)
+      end
+    end
+  end
+end
+```
+
+The consumer of this interface, then, can get the best available implementation,
+given their environment and the object(s) passed to `#initialize`, without
+having to know anything about the implementations themselves:
+
+``` ruby
+source_redis = Redis.new(port: 9736) # a scanner-compatible redis process (>= 2.7.105)
+key_emitter = RedisCopy::KeyEmitter.implementation.new(source_redis)
+# => <RedisCopy::KeyEmitter::Scanner: ... >
+key_emitter.keys('schedule:*').to_enum
+# => <Enumerator ...>
+
+source_redis = Redis.new(port: 9737) # a scanner-incompatible redis process (< 2.7.105)
+key_emitter = RedisCopy::KeyEmitter.implementation.new(source_redis)
+# => <RedisCopy::KeyEmitter::Default: ... >
+key_emitter.keys('schedule:*').to_enum
+# => <Enumerator ...>
+```
+
+The consumer can choose to favor a particular implementation by name:
+
+``` ruby
+key_emitter = RedisCopy::KeyEmitter.implementation(:scanner).new(source_redis)
+# => <RedisCopy::KeyEmitter::Scanner: ... >
+```
+
+And if a compatible implementation cannot be found, an appropriate exception
+is raised:
+
+``` ruby
+key_emitter = RedisCopy::KeyEmitter.implementation(:scanner).new(source_redis)
+# Implements::implementation::NotFound: no compatible implementation for RedisCopy::KeyEmitter>
+```
+
+The implementation finder assumes that implementations loaded later are
+somehow better than those loaded before them, but a consumer can specify
+first preference and fallback groups:
+
+``` ruby
+key_emitter = RedisCopy::KeyEmitter.implementation(:scanner, :auto).new(source_redis)
+# => <RedisCopy::KeyEmitter::Default: ... >
+```
+
+And implementations can be added which are not in the auto load-order and have
+to be explicitly asked for:
+
+``` ruby
+# Like this insane whack-a-mole implementation,
+# Which we wouldn't want anyone to accidentally use:
+class RedisCopy::KeyEmitter::WhackAMole
+  Implements RedisCopy::KeyEmitter, auto: false
+
+  def keys(pattern = '*')
+    return enum_for(__method__, pattern) unless block_given?
+    while(key = redis.randomkey)
+      yield key if glob_match?(pattern, key)
+    end
+  end
+
+  # ...
+end
+```
+
+``` ruby
+key_emitter = RedisCopy::KeyEmitter.implementation(:whack_a_mole).new(source_redis)
+# => <RedisCopy::KeyEmitter::WhackAMole: ... >
+# But it doesn't come back unless you ask for it.
+key_emitter = RedisCopy::KeyEmitter.implementation.new(source_redis)
+# => <RedisCopy::KeyEmitter::Scanner: ... >
+```
+
+# TODO:
+
+ - Provide tools for testing *all* implementations of an interface.
+ - Finalize syntax for the check. A block alone is convenient, but not clear.
+ - Finalize scope of check. Allocate and instance_exec? Run all as hooks before `#initialize`?
+
+## 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,8 @@
+# encoding: utf-8
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.verbose = true
+end

data/implements.gemspec

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'implements/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'implements'
+  spec.version       = Implements::VERSION
+  spec.authors       = ['Ryan Biesemeyer']
+  spec.email         = ['ryan@simplymeasured.com']
+  spec.summary       = 'A tool for building and implementing interfaces.'
+  spec.description   = <<-EODESC.gsub(/^[\w]+/, ' ').squeeze
+    Implements is a tool for building modular libraries and tools as
+    interfaces, for implementing those interfaces, and ensuring that
+    consumers are able to load the best available implementation at
+    runtime.
+  EODESC
+  spec.homepage      = 'https://github.com/yaauie/implements'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency     'activesupport'
+
+  spec.add_development_dependency 'bundler', '~> 1.3', '>= 1.3.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+
+
+  # code quality
+  spec.add_development_dependency 'ruby-appraiser-reek'
+  spec.add_development_dependency 'ruby-appraiser-rubocop'
+end

data/lib/implements.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+require 'implements/version'
+require 'implements/interface'
+require 'implements/implementation'

data/lib/implements/global.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require 'implements'
+
+# Add functionality to Class, which enables us to use
+# `Implements::Implementation`'s ::implements method
+# without having to pre-extend the class.
+class Class
+  def implements(*args, &block)
+    return super if defined?(super)
+
+    extend(Implements::Implementation)
+    send(__method__, *args, &block)
+  end
+  private :implements
+end

data/lib/implements/implementation.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'active_support/inflector'
+
+require_relative 'implementation/registry'
+
+module Implements
+  # Implementation: mix into your implementations
+  module Implementation
+    # An exception raised when an implementation cannot be found.
+    NotFound = Class.new(NotImplementedError)
+
+    private
+
+    # @api public
+    # @param iface [Module(Implements::Interface)]
+    # @param options [Hash{Symbol => Object}] - ({}) optional options hash
+    # @option options [Boolean] :auto - (true) whether to include this
+    #   implementation in the interface's default search
+    # @option options [String] :as - The canonical name for this
+    #   implementation, must be unique across all implementations.
+    # @option options [#to_s, Array<#to_s>] :groups - one or more named tags
+    #   for this implementation, used for matching in Interface#implementation.
+    #
+    # If given, the block will be usde to determine the compatibility of this
+    # interface with the arguments that would be passed to the implementation's
+    # #initialize method.
+    # @yieldparam (@see self#initialize)
+    # @yieldreturn [Boolean]
+    #
+    # @return [void]
+    # @raises [TypeError] unless iface is a Implements::Interface Module
+    def implements(iface, options = {}, &block)
+      unless iface.instance_of?(Module)  && iface.kind_of?(Interface)
+        fail(TypeError, 'Argument must be a Implements::Interface Module')
+      end
+
+      params = {}
+      params[:name] = options.fetch(:as) if options.key?(:as)
+      groups = []
+      groups << :default unless block_given?
+      groups << :auto if options.fetch(:auto, true)
+      params[:groups] = groups
+
+      iface.register_implementation(self, params, &block)
+
+      include iface
+    end
+
+    # @api private
+    def self.extended(klass)
+      unless klass.instance_of?(Class)
+        fail(TypeError, "expected Class, got #{klass.class}")
+      end
+    end
+
+    # @api private
+    def self.included(base)
+      base && fail(ScriptError, "#{self} supports only extend, not include.")
+    end
+  end
+end

data/lib/implements/implementation/registry.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'set'
+
+module Implements
+  module Implementation
+    # A registry of implementations, held by an interface.
+    # @api private
+    class Registry
+      # @api private
+      # @param interface [Interface]
+      def initialize(interface)
+        @interface = interface
+        @elements = []
+      end
+      attr_reader :interface
+
+      # Returns an enumerator of elements matching the given selectors,
+      # in the order specified; this is used by {Finder#find}.
+      # @param selectors [#to_s, Array<#to_s>] - one or more selectors
+      # @return [Enumerator<Element>]
+      def elements(selectors)
+        Enumerator.new do |yielder|
+          yielded = Set.new
+          Array(selectors).product(@elements) do |selector, element|
+            next unless element.match?(selector)
+            yielder << element if yielded.add?(element)
+          end
+        end
+      end
+
+      # @api private
+      # @return [Array<String>]
+      def list_names
+        @elements.map(&:name).compact
+      end
+
+      # @api private
+      # @param implementation [Implementation]
+      # @param options [Hash{Symbol=>Object}] (see: Element#initialize)
+      # @param check [#call, nil]
+      def register(implementation, options, check)
+        @elements.unshift Element.new(self, implementation, options, check)
+      end
+    end
+  end
+end
+
+require_relative 'registry/element'
+require_relative 'registry/finder'

data/lib/implements/implementation/registry/element.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Implements
+  # An Element in a Registry
+  # @api private
+  class Implementation::Registry::Element
+    # @api private
+    # @param registry [Implementation::Registry]
+    # @param implementation [Implementation]
+    # @param options [Hash{Symbol=>Object}]
+    # @param check [#call, nil]
+    def initialize(registry, implementation, options, check)
+      @registry = registry
+      @implementation = implementation
+      @options = options
+      @check = check
+    end
+    attr_reader :implementation
+
+    # @api private
+    # @param selector [#===]
+    # @return [Boolean]
+    def match?(selector)
+      selector = selector.to_s if selector.kind_of?(Symbol)
+      selector = selector.dasherize if selector.kind_of?(String)
+      groups.map(&:to_s).any? { |group| selector === group }
+    end
+
+    # Check the implementation agains the args that would be used
+    # to instantiate it.
+    # @api private
+    # @params *args [Array<Object>]
+    # @return [Boolean]
+    def check?(*args)
+      return true unless @check
+      @check.call(*args)
+    end
+
+    # @api private
+    # @return [String]
+    def name
+      groups.first
+    end
+
+    private
+
+    # @api private
+    # @return [Array<String>]
+    def groups
+      @groups ||= [@options[:name],
+                   implementation_descriptors,
+                   @options[:groups]].flatten.compact.map(&:to_s)
+    end
+
+    # @api private
+    # @return [Array<String>]
+    def implementation_descriptors
+      desc = []
+      desc << (name = @implementation.name)
+      desc << (name && name.sub(/^(::)?#{@registry.interface}::/, ''))
+      desc.compact.map(&:underscore).map(&:dasherize).reverse
+    end
+  end
+end

data/lib/implements/implementation/registry/finder.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Implements
+  # A Finder, plumbed to a Registry.
+  # @api private
+  class Implementation::Registry::Finder
+    # @api private
+    # @param registry [Implementation::Registry]
+    # @param selectors [Array<#===>] Typically an array of strings
+    def initialize(registry, selectors)
+      @registry = registry
+      @selectors = selectors
+    end
+
+    # Returns an instance of the @registry.interface that supports the given
+    # arguments.
+    # @api private
+    def new(*args, &block)
+      implementation = find(*args)
+      implementation.new(*args, &block)
+    end
+
+    # Find a suitable implementation of the given interface,
+    # given the args that would be passed to its #initialize
+    # and our selectors
+    # @api private
+    def find(*args)
+      @registry.elements(@selectors).each do |config|
+        next unless config.check?(*args)
+        return config.implementation
+      end
+
+      fail(Implementation::NotFound,
+           "no compatible implementation for #{inspect}")
+    end
+
+    # @api private
+    def inspect
+      "<#{@registry.interface}::implementation(#{@selectors.join(', ')})>"
+    end
+  end
+end

data/lib/implements/interface.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Implements
+  # Interface: mix into your interfaces.
+  module Interface
+    # Used to find a suitable implementation
+    # @api public
+    # @param [*selectors] zero or more selectors to use for finding an
+    #   implementation of this interface. If none is given, :auto is assumed.
+    # @return [Implementation::Registry::Finder]
+    def implementation(*selectors)
+      selectors << :auto if selectors.empty?
+      Implementation::Registry::Finder.new(@implementations, selectors)
+    end
+
+    # Returns a list of implementations by resolvable name.
+    # @api public
+    # @return [Array<String>]
+    def list_implementation_names
+      @implementations.list_names.map(&:to_s).uniq
+    end
+
+    # Find an instantiate a suitable implementation on auto mode
+    # @see Implementation::Registry::Find#new
+    # @api public
+    def new(*args, &block)
+      implementation(:auto).new(*args, &block)
+    end
+
+    # @api private
+    # Used by Implementation#implements
+    # @param implements (see Registry#register)
+    # @param options (see Registry#register)
+    # @param &block (see Registry#register)
+    # @return (see Registry#register)
+    def register_implementation(implementation, options, &block)
+      @implementations.register(implementation, options, block)
+    end
+
+    # Bad things happen when used improperly. Make it harder to get it wrong.
+    # @api private
+    def self.included(base)
+      base && fail(ScriptError, "#{self} supports only extend, not include.")
+    end
+
+    # Set up the interface.
+    # @param base [Module]
+    # @api private
+    def self.extended(base)
+      unless base.instance_of?(Module)
+        fail(TypeError, "expected Module, got #{base.class}")
+      end
+
+      base.instance_variable_set(:@implementations,
+                                 Implementation::Registry.new(base))
+    end
+  end
+end

data/lib/implements/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# @see ../implements.rb
+module Implements
+  # Implements is Semantically Versioned.
+  # @see http://semver.org
+  VERSION = '0.0.2'
+end

data/spec/implements_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+
+describe Implements do
+  context 'On a Widget interface' do
+    let!(:interface) do
+      interface = Module.new do
+        extend Implements::Interface
+
+        def initialize(number)
+          @number = number
+        end
+
+        def wobble() :interface end
+      end
+
+      stub_const('::Widget', interface)
+      def Widget.inspect() 'Widget' end
+
+      interface
+    end
+
+    context 'with two conditional & one default implementations' do
+      # order and registry matters, so define the implementations
+      # with let! to ensure they are run and memoized before the
+      # example is run.
+      let!(:default_implementation) do
+        Class.new do
+          extend(Implements::Implementation)
+          implements ::Widget
+        end
+      end
+      let!(:small_implementation) do
+        Class.new do
+          extend(Implements::Implementation)
+          implements ::Widget, as: :small do |number|
+            number < 10
+          end
+          def wobble() :small end
+        end
+      end
+      let!(:large_implementation) do
+        Class.new do
+          extend(Implements::Implementation)
+          implements ::Widget, as: :large do |number|
+            number >= 1_000_000
+          end
+          def wobble() :large end
+        end
+      end
+      let!(:odd_implementation) do
+        Class.new do
+          extend(Implements::Implementation)
+          implements ::Widget, as: :odd do |number|
+            number.odd?
+          end
+          def wobble() :odd end
+        end
+      end
+
+      context 'Interface#new' do
+        let(:result) { interface.new(input) }
+        subject { result }
+
+        context 'matching the large implementation' do
+          let(:input) { 10_000_000 }
+          it 'should return the large implementation' do
+            expect(result).to be_an_instance_of large_implementation
+          end
+          it { should be_a Widget }
+          its(:wobble) { should be :large } # ensure proper inheritance
+        end
+
+        context 'matching the small implementation' do
+          let(:input) { 2 }
+          it 'should return the small implementation' do
+            expect(result).to be_an_instance_of small_implementation
+          end
+          it { should be_a Widget }
+          its(:wobble) { should be :small } # ensure proper inheritance
+        end
+
+        context 'matching neither small nor large' do
+          let(:input) { 1_000 }
+          it 'should return the default implementation' do
+            expect(result).to be_an_instance_of default_implementation
+          end
+          it { should be_a Widget }
+          its(:wobble) { should be :interface } # ensure proper inheritance
+        end
+
+        context '#implementation.new' do
+          let(:result) { interface.implementation(*selectors).new(input) }
+          subject { result }
+          context 'specifying the large implementation' do
+            let(:selectors) { [:large] }
+            context 'not matching the large implementation' do
+              let(:input) { 2 }
+              it 'should raise an appropriate exception' do
+                expect do
+                  result
+                end.to raise_error Implements::Implementation::NotFound
+              end
+            end
+            context 'matching the large implementation' do
+              let(:input) { 10_000_000 }
+              it 'should return the large implementation' do
+                expect(result).to be_an_instance_of large_implementation
+              end
+            end
+          end
+          context 'specifying the small implementation' do
+            let(:selectors) { [:small] }
+            context 'not matching the small implementation' do
+              let(:input) { 1_000_000 }
+              it 'should raise an appropriate exception' do
+                expect do
+                  result
+                end.to raise_error Implements::Implementation::NotFound
+              end
+            end
+            context 'matching the small implementation' do
+              let(:input) { 2 }
+              it 'should return the small implementation' do
+                expect(result).to be_an_instance_of small_implementation
+              end
+            end
+          end
+          context 'when multiple implementations match' do
+            let(:input) { 7 }
+            context 'specifying the small or odd implementation' do
+              let(:selectors) { [:small, :odd] }
+              it 'should favor small' do
+                expect(result).to be_an_instance_of small_implementation
+              end
+            end
+            context 'specifying the odd or small implementation' do
+              let(:selectors) { [:odd, :small] }
+              it 'should favor odd' do
+                expect(result).to be_an_instance_of odd_implementation
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'with no implementations' do
+      context 'Interface#new' do
+        let(:result) { interface.new(input) }
+        subject { result }
+
+        let(:input) { 1_000 }
+        it 'should raise an appropriate exception' do
+          expect { result }.to raise_error Implements::Implementation::NotFound
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'implements'

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: implements
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Biesemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: ruby-appraiser-reek
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-appraiser-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! " Implements is a tol for building modular libraries and tols as\n
+  interfaces, for implementing those interfaces, and ensuring that\n consumers are
+  able to load the best available implementation at\n runtime.\n"
+email:
+- ryan@simplymeasured.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .githooks/pre-commit/run-ruby-appraiser
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- implements.gemspec
+- lib/implements.rb
+- lib/implements/global.rb
+- lib/implements/implementation.rb
+- lib/implements/implementation/registry.rb
+- lib/implements/implementation/registry/element.rb
+- lib/implements/implementation/registry/finder.rb
+- lib/implements/interface.rb
+- lib/implements/version.rb
+- spec/implements_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/yaauie/implements
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A tool for building and implementing interfaces.
+test_files:
+- spec/implements_spec.rb
+- spec/spec_helper.rb
+has_rdoc: