hexagonal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0361915ddc3f4bcb10417c531a291b3f8857c164
+  data.tar.gz: 1389a24a48796d96a529b2fe84fbf17c7ccbc834
+SHA512:
+  metadata.gz: 883666b54d38b6033bede7a5baf99f5603e9e2b5d482d819edc92a635b0ece9e9f8a505d719268bae96b02d91b5df8e6ae7e4eca0cf23a09df995246efb51c3b
+  data.tar.gz: 1ba10dcff07734983eebc13dcfd566f00e2d7ba0a691cf5eaed332c9032490628bf7d764e1449dc14f5935a1cdf4d250494f26faf8b50b1252ce06a823abb3d8

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 hexagonal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Matt Beedle
+
+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,367 @@
+# Hexagonal
+
+A simple gem to provide structure and guidance for writing hexagonal ruby
+applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hexagonal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hexagonal
+
+## Why?!?!
+
+Rails applications are usually really fast to build at the beginning, but due to
+high coupling, as they mature they begin to calcify. Eventually adding any new
+features and fixing bugs becomes a pain. Developers get caught in callback hell.
+Nothing can be tested in isolation. Test suites take >10 minutes to run. This is
+also sometimes true of non-Rails Ruby apps. Some people will suggest that Rails
+Engines are a better solution for breaking up complexity. I say that engines and
+Hexagonal can be used together. Engines don't solve the problem of domain
+objects being tightly coupled to the database and often to each other through
+callbacks for example.
+
+Hexagonal is an abstraction of the way that I've been building my latest Ruby
+applications. It's inspired by [Matt Wynne](http://www.confreaks.com/videos/977-goruco2012-hexagonal-rails),
+[Brandur](https://brandur.org/mediator), [grouper](http://eng.joingrouper.com/blog/2014/03/03/rails-the-missing-parts-interactors),
+[agileplanner](https://www.agileplannerapp.com/blog/building-agile-planner/refactoring-with-hexagonal-rails),
+[Victor Savkins](http://victorsavkin.com/post/42542190528/hexagonal-architecture-for-rails-developers)
+and many discussions with [@soulim](https://github.com/soulim).
+Hexagonal provides base classes for everything required to build a small
+modular, Ruby application. See Structure section below.
+
+## Usage
+
+When using Rails, the following generators are available. When not using Rails,
+please see the examples folder for how to extend the provided classes
+correctly.
+
+### Generate a resource
+This will generate a repository, policy, mediators and runners for all CRUD
+actions for a specified resource.
+```
+rails generate hexagonal:resource [RESOURCE_NAME]
+```
+
+### Generate a repository
+```
+rails generate hexagonal:repository [REPOSITORY_NAME]
+```
+
+### Generate a runner
+```
+rails generate hexagonal:runner [RUNNER_NAME]
+```
+
+### Generate a mediator
+```
+rails generate hexagonal:mediator [MEDIATOR_NAME]
+```
+
+### Generate a policy
+```
+rails generate hexaganal:policy [POLICY_NAME]
+```
+
+### Generate a worker
+```
+rails generate hexagonal:worker [WORKER_NAME]
+```
+
+### Generate a job
+```
+rails generate hexagonal:job [JOB_NAME]
+```
+
+### Generate a decorator
+```
+rails generate hexagonal:decorator [MODEL_NAME]
+```
+
+## Structure
+
+Here is the basic app structure along with some implementation examples.
+Not all of these objects need to inherited/extended from Hexagonal. Services,
+Jobs and Workers are not planned to be part of the gem.
+
+### Runners (app/runners)
+These are my own creation. They are responsible for model materialization,
+authorization (authentication still happens in the controller) and running
+ parameter validation
+
+```ruby
+class CreateJobRunner < Hexagonal::Runners::CreateRunner
+  private
+
+  def form
+    @form ||= JobForm.new(attributes)
+  end
+
+  def mediator
+    @mediator ||= CreateJobMediator.new(user, form.attributes)
+  end
+end
+```
+
+### Mediators (app/mediators)
+A [Mediator](http://en.wikipedia.org/wiki/Mediator_pattern) is a design
+pattern encapsulating how a set of objects interact
+The mediators take care of saving/updating/deleting/etc and calling out
+to workers (for longer jobs, like looking up social media data)
+or jobs (for shorter jobs, like sending email)
+
+```ruby
+class CreateJobMediator < Hexagonal::Mediators::CreateMediator
+  def target
+    @target ||= Job.new(attributes)
+  end
+
+  private
+
+  def default_attributes
+    { created_by_id: user.id, account_id: user.account_id }
+  end
+
+  def repository
+    @repository ||= JobRepository.new
+  end
+end
+```
+
+### Forms (app/forms)
+These contain parameter validation logic.
+
+```ruby
+class JobForm
+  include Hexagonal::Form
+
+  attribute :title, String
+  attribute :remote_working_allowed, Boolean, default: true
+
+  validates :title, presence: true
+end
+```
+
+### Decorators (app/decorators)
+These are used to add an object-oriented presentation layer. Decorators use the
+[draper gem](https://github.com/drapergem/draper).
+
+```ruby
+class JobDecorator < Draper::Decorator
+  decorates :job
+
+  delegate_all
+
+  def address
+    [street, city, country].compact.join(', ')
+  end
+end
+```
+
+### Workers (app/workers)
+Sidekiq workers to handle longer running tasks (to avoid slow requests).
+The workers themselves have barely any code inside. They just materialize any
+models required and then call the required service.
+
+```ruby
+class ContactImportWorker
+  include Sidekiq::Worker
+
+  def perform(user_id)
+    User.find(user_id).tap do |user|
+      ContactImportService.new(user).call
+    end
+  end
+end
+```
+
+### Jobs (app/jobs)
+Sucker Punch jobs. Sucker punch handles background tasks in a single process
+using asynchronous Ruby. It's good for keeping costs down on heroku.
+I find sidekiq to [generally be overkill](http://brandonhilkert.com/blog/why-i-wrote-the-sucker-punch-gem/)
+for most tasks (email sending for example). Sucker Punch workers are the same as
+Sidekiq workers. Just materialize models and call the correct service
+
+```ruby
+class SignupConfirmationJob
+  include SuckerPunch::Job
+
+  def perform(user)
+    UserMailer.signup_confirmation(user).deliver
+  end
+end
+```
+
+### Services (app/services)
+When the app needs to interact with any third party service then a service
+object is used. They are called either from workers or mediators. They handle
+the details of things like email sending, lookup up social media data,
+importing/syncing contacts, polling IMAP, etc.
+
+```ruby
+class ContactImportService
+  def initialize(user)
+    @user = user
+  end
+
+  def call
+    # some complex logic to pull contacts from social media
+  end
+end
+```
+
+### Responses (app/responses)
+These handle responding to the client. They are almost all just simple
+delegators that help me to avoid duplicating code in controllers.
+
+```ruby
+class CreateResponse < SimpleDelegator
+  def created_successfully(object)
+    respond_with object
+  end
+
+  def creation_failed(object)
+    render :errors, object.errors.as_json
+  end
+end
+```
+
+### Repositories (app/repositories)
+Used to access the database. I'm trying to gradually decouple the app completely
+from ActiveRecord. It keeps the queries private instead of leaking storage API
+details into the app.
+
+```ruby
+class JobRepository
+  include Hexagonal::Repository
+
+  def find_by_creator_id(creator_id)
+    adapter.where(creator_id: creator_id)
+  end
+end
+```
+
+### Adapters (app/adapters)
+Adapters communicate between specific storage implementations and repositories.
+So far there is only an ActiveRecordAdapter. When I comes time to switch to
+something else, perhaps sequel, then I will just need to define a new adapter
+and plug it into the base repository. Adapters also need to define a Unit Of
+Work in order to be able to roll back groups of changes. With SQL this is just a
+wrapper around a Transaction.
+
+### Errors (app/errors)
+These define business specific errors rather than just using the standard ones.
+Also map database specific errors to business ones so that the database can be
+switched out easily.
+
+### Policies (app/policies)
+These handle authorization.
+
+```ruby
+class JobPolicy
+  def initialize(user, job)
+    @user = user
+    @job = job
+  end
+
+  def delete?
+    job.created_by == user
+  end
+
+  private
+
+  attr_reader :user, :job
+end
+```
+
+## Example
+
+Here is an example Rails API controller using hexagonal
+```ruby
+class JobsController < ApplicationController::Base
+  before_filter :authenticate_user!
+
+  def index
+    filter_runner.run
+  end
+
+  def show
+    find_runner.run
+  end
+
+  def create
+    create_runner.run
+  end
+
+  def update
+    update_runner.run
+  end
+
+  def destroy
+    delete_runner.run
+  end
+
+  private
+
+  def find_runner
+    FindJobRunner.new(find_one_response, current_user, params[:id])
+  end
+
+  def find_one_response
+    FindOneResponse.new(self)
+  end
+
+  def filter_runner
+    FilterJobsRunner.new(find_all_response, current_user, params)
+  end
+
+  def create_runner
+    CreateJobRunner.new(create_response, current_user, params[:job])
+  end
+
+  def create_response
+    CreateResponse.new(self)
+  end
+
+  def update_runner
+    UpdateJobRunner
+      .new(update_response, current_user, params[:id], params[:job])
+  end
+
+  def update_response
+    UpdateResponse.new(self)
+  end
+
+  def delete_runner
+    DeleteRunner.new(delete_response, current_user, params[:id])
+  end
+
+  def delete_response
+    DeleteResponse.new(self)
+  end
+end
+```
+
+## Supported Rubies
+2.0.x, 2.1.x, JRuby 1.7.x
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/hexagonal/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
+
+## Alternatives
+- [hexx](https://github.com/nepalez/hexx)

data/Rakefile

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

data/hexagonal.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hexagonal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hexagonal"
+  spec.version       = Hexagonal::VERSION
+  spec.authors       = ["Matt Beedle"]
+  spec.email         = ["mattbeedle@googlemail.com"]
+  spec.summary       = %q{A simple gem for building hexagonal Ruby applications}
+  spec.description   = %q{A simple gem for building hexagonal Ruby applications}
+  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_runtime_dependency 'activerecord'
+  spec.add_runtime_dependency 'activesupport'
+
+  spec.add_development_dependency 'bogus'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/hexagonal.rb

@@ -0,0 +1,11 @@
+require 'hexagonal/version'
+
+require 'hexagonal/adapters'
+require 'hexagonal/errors'
+require 'hexagonal/mediators'
+require 'hexagonal/repository'
+require 'hexagonal/runners'
+
+module Hexagonal
+  # Your code goes here...
+end

data/lib/hexagonal/adapters.rb

@@ -0,0 +1 @@
+require_relative 'adapters/active_record_adapter'

data/lib/hexagonal/adapters/active_record_adapter.rb

@@ -0,0 +1,65 @@
+module Hexagonal
+  module Adapters
+    class ActiveRecordAdapter
+      include ActiveSupport::Rescuable
+
+      pattr_initialize :persistence
+
+      rescue_from ActiveRecord::RecordNotFound,   with: :record_not_found
+      rescue_from ActiveRecord::StatementInvalid, with: :statement_invalid
+
+      def find(id)
+        persistence.find id
+      rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      def save(object)
+        object.save
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      def save!(object)
+        object.save!
+        object
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      def destroy(object)
+        object.destroy
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      def query(&block)
+        yield(persistence)
+      rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      def unit_of_work
+        @unit_of_work ||=
+          Hexagonal::Adapters::ActiveRecordAdapter::UnitOfWork.new
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        persistence.send(method_sym, *arguments, &block)
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
+        rescue_with_handler(e)
+      end
+
+      private
+
+      def record_not_found(exception)
+        fail Hexagonal::Errors::RecordNotFoundException, exception, caller
+      end
+
+      def statement_invalid(exception)
+        fail Hexagonal::Errors::StatementInvalidException, exception, caller
+      end
+
+    end
+  end
+end

data/lib/hexagonal/adapters/active_record_adapter/unit_of_work.rb

@@ -0,0 +1,11 @@
+module Hexagonal
+  module Adapters
+    module ActiveRecordAdapter
+      class UnitOfWork
+        def run(&block)
+          ActiveRecord::Base.transaction { yield }
+        end
+      end
+    end
+  end
+end

data/lib/hexagonal/errors.rb

@@ -0,0 +1,2 @@
+require_relative 'errors/record_invalid_exception'
+require_relative 'errors/unauthorized_exception'

data/lib/hexagonal/errors/record_invalid_exception.rb

@@ -0,0 +1,6 @@
+module Hexagonal
+  module Errors
+    class RecordInvalidException < ActiveRecord::RecordInvalid
+    end
+  end
+end

data/lib/hexagonal/errors/unauthorized_exception.rb

@@ -0,0 +1,6 @@
+module Hexagonal
+  module Errors
+    class UnauthorizedException < StandardError
+    end
+  end
+end

data/lib/hexagonal/mediators.rb

@@ -0,0 +1,2 @@
+require_relative 'mediators/create_mediator'
+require_relative 'mediators/delete_mediator'

data/lib/hexagonal/mediators/create_mediator.rb

@@ -0,0 +1,26 @@
+module Hexagonal
+  module Mediators
+    class CreateMediator
+      pattr_initialize :user, :attributes
+
+      attr_writer :repository
+
+      def initialize(user, attributes)
+        @user       = user
+        @attributes = attributes.merge(default_attributes)
+      end
+
+      def call
+        repository.save! target
+      end
+
+      private
+
+      attr_reader :attributes, :repository
+
+      def default_attributes
+        {}
+      end
+    end
+  end
+end

data/lib/hexagonal/mediators/delete_mediator.rb

@@ -0,0 +1,17 @@
+module Hexagonal
+  module Mediators
+    class DeleteMediator
+      pattr_initialize :user, :target
+
+      attr_writer :repository
+
+      def call
+        repository.destroy target
+      end
+
+      private
+
+      attr_reader :repository
+    end
+  end
+end

data/lib/hexagonal/repository.rb

@@ -0,0 +1,35 @@
+module Hexagonal
+  class Repository
+    attr_writer :database_klass, :adapter
+
+    def all
+      adapter.all
+    end
+
+    def find(id)
+      adapter.find id
+    end
+
+    def save(object)
+      adapter.save(object)
+    end
+
+    def save!(object)
+      adapter.save!(object)
+    end
+
+    def destroy(object)
+      adapter.destroy(object)
+    end
+
+    def unit_of_work
+      adapter.unit_of_work
+    end
+
+    private
+
+    def adapter
+      @adapter ||= Hexagonal::Adapters::ActiveRecordAdapter.new(database_klass)
+    end
+  end
+end

data/lib/hexagonal/responses.rb

@@ -0,0 +1,3 @@
+require_relative 'responses/create_response'
+require_relative 'responses/delete_response'
+require_relative 'responses/find_all_response'

data/lib/hexagonal/responses/create_response.rb

@@ -0,0 +1,13 @@
+module Hexagonal
+  module Responses
+    class CreateResponse
+      def created_successfully(object)
+        present object.class.to_s.underscore.to_sym, object
+      end
+
+      def creation_failed(exception)
+        error!({ errors: exception.record.errors }, 422)
+      end
+    end
+  end
+end

data/lib/hexagonal/responses/delete_response.rb

@@ -0,0 +1,13 @@
+module Hexagonal
+  module Responses
+    class DeleteResponse < SimpleDelegator
+      def deleted_successfully(object)
+        status 204
+      end
+
+      def unauthorized(exception)
+        error!({ message: exception.message }, 401)
+      end
+    end
+  end
+end

data/lib/hexagonal/responses/find_all_response.rb

@@ -0,0 +1,33 @@
+module Hexagonal
+  module Responses
+    class FindAllResponse
+      delegate :error!, :garner, :pagination, :present, to: :target
+
+      def initialize(target, key, paginated: false, cache_method: nil)
+        @target       = target
+        @key          = key
+        @paginated    = paginated
+        @cache_method = cache_method
+      end
+
+      def found(objects)
+        garner.bind(cache_key(objects)) do
+          present(key, objects).as_json
+          present(:meta, pagination(objects)).as_json if paginated
+        end
+      end
+
+      def invalid(exception)
+        error!({ errors: exception.record.errors }, 422)
+      end
+
+      private
+
+      attr_reader :cache_method, :key, :paginated, :target
+
+      def cache_key(objects)
+        cache_method ? objects.send(cache_method) : objects
+      end
+    end
+  end
+end

data/lib/hexagonal/runners.rb

@@ -0,0 +1,3 @@
+require_relative 'runners/create_runner'
+require_relative 'runners/delete_runner'
+require_relative 'runners/filter_runner'

data/lib/hexagonal/runners/create_runner.rb

@@ -0,0 +1,32 @@
+module Hexagonal
+  module Runners
+    class Hexagonal::Runners::CreateRunner
+      pattr_initialize :listener, :user, :attributes
+
+      delegate :created_successfully, :creation_failed, to: :listener
+      delegate :target,                                 to: :mediator
+
+      attr_writer :form
+
+      def run
+        validate!
+        create!
+      rescue Hexagonal::Errors::RecordInvalidException => ex
+        creation_failed(ex)
+      end
+
+      private
+
+      def create!
+        mediator.call
+        created_successfully(target)
+      end
+
+      def validate!
+        unless form.valid?
+          fail Hexagonal::Errors::RecordInvalidException, form, caller
+        end
+      end
+    end
+  end
+end

data/lib/hexagonal/runners/delete_runner.rb

@@ -0,0 +1,37 @@
+module Hexagonal
+  module Runners
+    class DeleteRunner
+      pattr_initialize :listener, :user, :id
+
+      delegate :unauthorized, :deleted_successfully, to: :listener
+
+      attr_writer :policy, :repository
+
+      def run
+        authorize!
+        delete!
+        deleted_successfully target
+      rescue Hexagonal::Errors::UnauthorizedException => ex
+        unauthorized(ex)
+      end
+
+      private
+
+      def authorize!
+        fail! unless policy.delete?
+      end
+
+      def fail!
+        fail Hexagonal::Errors::UnauthorizedException, 'Unauthorized', caller
+      end
+
+      def delete!
+        mediator.call
+      end
+
+      def target
+        @target ||= repository.find id
+      end
+    end
+  end
+end

data/lib/hexagonal/runners/filter_runner.rb

@@ -0,0 +1,36 @@
+module Hexagonal
+  module Runners
+    class FilterRunner
+      attr_writer :form, :repository
+
+      delegate :found, :invalid, to: :listener
+
+      def initialize(listener, user, attributes = nil)
+        @listener   = listener
+        @user       = user
+        @attributes = attributes
+      end
+
+      def run
+        validate! if attributes
+        found items
+      rescue Hexagonal::Errors::RecordInvalidException => ex
+        invalid ex
+      end
+
+      private
+
+      attr_reader :listener, :user, :attributes
+
+      def items
+        @items ||= repository.filter_for_user(user, form.attributes)
+      end
+
+      def validate!
+        unless form.valid?
+          fail Hexagonal::Errors::RecordInvalidException, form, caller
+        end
+      end
+    end
+  end
+end

data/lib/hexagonal/version.rb

@@ -0,0 +1,3 @@
+module Hexagonal
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: hexagonal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matt Beedle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bogus
+  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: 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'
+description: A simple gem for building hexagonal Ruby applications
+email:
+- mattbeedle@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hexagonal.gemspec
+- lib/hexagonal.rb
+- lib/hexagonal/adapters.rb
+- lib/hexagonal/adapters/active_record_adapter.rb
+- lib/hexagonal/adapters/active_record_adapter/unit_of_work.rb
+- lib/hexagonal/errors.rb
+- lib/hexagonal/errors/record_invalid_exception.rb
+- lib/hexagonal/errors/unauthorized_exception.rb
+- lib/hexagonal/mediators.rb
+- lib/hexagonal/mediators/create_mediator.rb
+- lib/hexagonal/mediators/delete_mediator.rb
+- lib/hexagonal/repository.rb
+- lib/hexagonal/responses.rb
+- lib/hexagonal/responses/create_response.rb
+- lib/hexagonal/responses/delete_response.rb
+- lib/hexagonal/responses/find_all_response.rb
+- lib/hexagonal/runners.rb
+- lib/hexagonal/runners/create_runner.rb
+- lib/hexagonal/runners/delete_runner.rb
+- lib/hexagonal/runners/filter_runner.rb
+- lib/hexagonal/version.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.2.2
+signing_key: 
+specification_version: 4
+summary: A simple gem for building hexagonal Ruby applications
+test_files: []