porch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4465a58cd1f427a90f98c0fe4287da4a95a591c
+  data.tar.gz: 3c9117fc73b0f17b88e1a6d6a44a3c549269886a
+SHA512:
+  metadata.gz: 283ed8cbacd23252b660d4f64cd538851b1f15463f3b3e84534cc8eb260b721018a1cc6a9c6c0eec0816763811c6ce8dfbfbafe64a10c5fa1404b283d0fc2686
+  data.tar.gz: 0809d2abafa5631ac04752b8dcc0c21864e364b38be31fe1068a4a33a7a44d2513beb491ce0422bea66325644f882092028c2ac4d6b75111c944a1b8f5b188a2

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at jamie@brilliantfantastic.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    porch (0.1.0)
+      dry-validation (~> 0.10.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.4)
+    diff-lcs (1.2.5)
+    dry-configurable (0.5.0)
+      concurrent-ruby (~> 1.0)
+    dry-container (0.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.2.3)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.2.0)
+    dry-logic (0.4.0)
+      dry-container (~> 0.2, >= 0.2.6)
+      dry-core (~> 0.1)
+      dry-equalizer (~> 0.2)
+    dry-types (0.9.3)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1)
+      dry-container (~> 0.3)
+      dry-core (~> 0.2, >= 0.2.1)
+      dry-equalizer (~> 0.2)
+      dry-logic (~> 0.4, >= 0.4.0)
+      inflecto (~> 0.0.0, >= 0.0.2)
+    dry-validation (0.10.4)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+      dry-container (~> 0.2, >= 0.2.8)
+      dry-core (~> 0.2, >= 0.2.1)
+      dry-equalizer (~> 0.2)
+      dry-logic (~> 0.4, >= 0.4.0)
+      dry-types (~> 0.9, >= 0.9.0)
+    inflecto (0.0.2)
+    rake (10.0.4)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12.0)
+  porch!
+  rake (~> 10.0.0)
+  rspec (~> 3.5.0)
+
+BUNDLED WITH
+   1.12.5

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Jamie Wright
+
+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,286 @@
+Porch
+======
+
+[ ![Codeship Status for jwright/porch](https://app.codeship.com/projects/8780ad70-b5ae-0134-fb0d-62cbe9f5cc84/status?branch=master)](https://app.codeship.com/projects/194128)
+
+A simple service layer pattern for plain old Ruby objects.
+
+## DESCRIPTION
+
+Yeah, yeah, yeah. Keep yer controllers skinny they always tell us. This is a lot easier to say than do in many cases. Our controllers are supposed to create that user, send them an invitation email, block them from access until they authenticate their email address, etc.
+
+Porch allows you to move the code into a series of steps that execute simple methods on itself or within simple PORO objects.
+
+This was inspired by [LightService](https://github.com/adomokos/light-service) and the middleware chain by [Sidekiq](https://github.com/mperham/sidekiq).
+
+## USAGE
+
+### Installation
+
+```
+gem install porch
+```
+
+### Getting started
+
+Your service object is simply a series of steps.
+
+```
+# app/services/registers_user.rb
+
+require "porch"
+
+module Services
+  class RegistersUser
+    include Porch::Organizer
+
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def register
+      with(attributes) do |chain|
+        chain.add CreateUser
+        chain.add SendWelcomeEmail
+        chain.add CreateBillingCustomer
+      end
+    end
+  end
+end
+```
+
+You can then use your service in your controllers with the result that it returns from the chain.
+
+```
+# app/controllers/users_controller.rb
+
+class UsersController < ApplicationController
+  def create
+    result = Services::RegistersUser.new(params[:user]).register
+
+    if result.success?
+      redirect_to dashboard_path(result.user), notice: "Welcome #{result.user.name}."
+    else
+      flash[:error] = result.message
+      render :new
+    end
+  end
+end
+```
+
+### Defining steps or actions
+
+You can define steps as classes and include some nice helper methods. (COMING SOON)
+
+```
+# app/services/steps/create_user.rb
+
+require "porch"
+
+class CreateUser
+  include Porch::Step
+
+  params do
+    required(:email).filled(type?: :str, format?: RegEx.email_address)
+    required(:password).filled(type?: :str, min_size?: 8)
+  end
+
+  def call(context)
+    context.user = User.create email: context.email, password: context.password
+    context.fail! context.user.errors unless context.user.valid?
+  end
+end
+```
+
+You can define steps as PORO classes that respond to a call method.
+
+```
+# app/services/create_billing_customer.rb
+
+require "stripe"
+
+class CreateBillingCustomer
+  def call(context)
+    customer = Stripe::Customer.create email: context.email
+    User.find_by_email(context.email).update_attributes(billing_id: customer.id)
+  end
+end
+```
+
+You can define steps as blocks on the organizer
+
+```
+# app/services/registers_user.rb
+
+require "porch"
+
+module Services
+  class RegistersUser
+    include Porch::Organizer
+
+    # ...
+
+    def register
+      with(attributes) do |chain|
+        # ...
+        chain.add :send_welcome_email do |context|
+          UserMailer.welcome(context.user).deliver_later
+        end
+        # ...
+      end
+    end
+  end
+end
+```
+
+You can define steps as methods on the organizer.
+
+```
+# app/services/registers_user.rb
+
+require "porch"
+
+module Services
+  class RegistersUser
+    include Porch::Organizer
+
+    # ...
+
+    def register
+      with(attributes) do |chain|
+        # ...
+        chain.add :send_welcome_email
+        # ...
+      end
+    end
+
+    private
+
+    def send_welcome_email(context)
+      UserMailer.welcome(context.user).deliver_later
+    end
+  end
+end
+```
+
+### Failing the chain
+
+At any step, you can set the `Porch::Context` as a failure which will stop processing the remaining steps and set the `Context` as a failed context with an optional message.
+
+```
+class RegistersUser
+  include Porch::Organizer
+
+  # ...
+
+  def register
+    with(attributes) do |chain|
+      # ...
+      chain.add :send_welcome_email
+      # ...
+    end
+  end
+
+  private
+
+  def send_welcome_email(context)
+    context.fail! "Better luck next time!" if some_failure_condition?
+    UserMailer.welcome(context.user).deliver_later
+  end
+end
+
+result = RegistersUser.new(email: "test@example.com").register
+if result.failure?
+  puts result.message # => "Better luck next time!"
+end
+```
+
+### Skipping steps
+
+At any step, you can skip the remaining actions in the organizer. This stops the running of the remaining actions but the `Porch::Context` will still return a successful `Porch::Context`.
+
+```
+class RegistersUser
+  include Porch::Organizer
+
+  # ...
+
+  def register
+    with(attributes) do |chain|
+      # ...
+      chain.add :save_user
+      # ...
+    end
+  end
+
+  private
+
+  def save_user(context)
+    User.create context
+    context.skip_remaining! if sending_emails_disabled?
+  end
+end
+
+result = RegistersUser.new(email: "test@example.com").register
+result.success? # => true
+```
+
+### Validating the context
+
+Porch comes with multiple ways that you can validate each step is setup correctly. It uses the DSL provided by [dry-validation](http://dry-rb.org/gems/dry-validation/).
+
+Several helper methods are included in the `Porch::Context` to guard against an invalid `Porch::Context`.
+
+`Porch::Context#guard` can be used and if the validation fails, the `Context` will skip the remaining actions.
+
+```
+class SomeStep
+  def call(context)
+    context.guard { required(:email) }
+    # The rest of the action will not be performed and the rest of the actions will be
+    # skipped if the guard fails
+  end
+end
+```
+
+`Porch::Context#guard!` (with a bang(!)) can be used and if the validation fails, the `Context` will be marked as a failure. The failure message for the `Context` will be set to be a comma-seperated list of the context errors that failed.
+
+```
+class SomeStep
+  def call(context)
+    context.guard! { required(:email) }
+    # The rest of the action will not be performed and the rest of the actions will be
+    # skipped and the action will be marked as failed if the guard fails
+  end
+end
+```
+
+At any point, you can use the `Porch::GuardRail::Guard` helper method to validate any hash (including the `Porch::Context`).
+
+```
+hash = { email: "test@example" }
+result = Porch::GuardRail::Guard.new(hash).against { required(:email).value(format?: RegEx::Email) }
+result.success? # => false
+result.errors # => { email: ["is invalid"] }
+```
+
+## CONTRIBUTING
+
+1. Clone the repository `git clone https://github.com/jwright/porch`
+1. Create a feature branch `git checkout -b my-awesome-feature`
+1. Codez!
+1. Commit your changes (small commits please)
+1. Push your new branch `git push origin my-awesome-feature`
+1. Create a pull request `hub pull-request -b jwright:master -h jwright:my-awesome-feature`
+
+## RELEASING A NEW GEM
+
+1. Bump the VERSION in `lib/porch/version.rb`
+1. Commit changes and push to GitHub
+1. run `bundle exec rake release`
+
+## LICENSE
+
+This project is licensed under the [MIT License](LICENSE.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/porch/context.rb

@@ -0,0 +1,71 @@
+require "porch/guard_rail"
+
+module Porch
+  class Context < Hash
+    include Porch::GuardRail
+
+    attr_reader :message
+
+    def initialize(context={}, success=true)
+      @message = nil
+      @success = success
+      @skip_remaining = false
+      deep_duplicate(context)
+    end
+
+    def deep_dup
+      self.class.new(self, self.success?)
+    end
+
+    def fail!(message="")
+      @message = message
+      @success = false
+      throw :stop_current_step_execution, self
+    end
+
+    def failure?
+      !success?
+    end
+
+    def guard(&block)
+      result = super
+      skip_remaining! if result.failure?
+      result
+    end
+
+    def guard!(&block)
+      result = guard &block
+      fail!(HumanError.new(result.errors).message) if result.failure?
+      result
+    end
+
+    def method_missing(name, *args, &block)
+      return fetch(name) if key?(name)
+      super
+    end
+
+    def skip_remaining?
+      !!@skip_remaining
+    end
+
+    def skip_remaining!(skip_current=false)
+      @skip_remaining = true
+      throw :stop_current_step_execution, self if skip_current
+    end
+
+    def success?
+      @success
+    end
+
+    def stop_processing?
+      failure? || skip_remaining?
+    end
+
+    private
+
+    def deep_duplicate(context)
+      (context || {}).to_hash.each { |k, v| self[k] = v }
+      self
+    end
+  end
+end

data/lib/porch/core_ext/string.rb

@@ -0,0 +1,55 @@
+module Porch
+  module CoreExt
+    class String
+      CAPITALIZE_SEPARATOR = ' '.freeze
+      CLASSIFY_SEPARATOR  = '_'.freeze
+      NAMESPACE_SEPARATOR = '::'.freeze
+      UNDERSCORE_DIVISION_TARGET = '\1_\2'.freeze
+      UNDERSCORE_SEPARATOR = '/'.freeze
+
+      def initialize(string)
+        @string = string.to_s
+      end
+
+      def capitalize
+        head, *tail = underscore.split(CLASSIFY_SEPARATOR)
+
+        self.class.new tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR)
+      end
+
+      def gsub(pattern, replacement=nil, &blk)
+        if block_given?
+          string.gsub(pattern, &blk)
+        else
+          string.gsub(pattern, replacement)
+        end
+      end
+
+      def split(pattern, limit=0)
+        string.split(pattern, limit)
+      end
+
+      def to_s
+        string
+      end
+
+      def underscore
+        new_string = gsub(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
+        new_string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
+        new_string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
+        new_string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+        new_string.downcase!
+        self.class.new new_string
+      end
+
+      def ==(other)
+        to_s == other
+      end
+      alias eql? ==
+
+      private
+
+      attr_reader :string
+    end
+  end
+end

data/lib/porch/core_ext.rb

@@ -0,0 +1 @@
+require_relative "core_ext/string"

data/lib/porch/errors/invalid_step_type_error.rb

@@ -0,0 +1,10 @@
+module Porch
+  class InvalidStepTypeError < RuntimeError
+    attr_reader :step
+
+    def initialize(step)
+      @step = step
+      super "Step type #{step.class.name} is not handled"
+    end
+  end
+end

data/lib/porch/errors.rb

@@ -0,0 +1 @@
+require_relative "errors/invalid_step_type_error"

data/lib/porch/executable_step_decorator.rb

@@ -0,0 +1,35 @@
+require_relative "step_decorators/class_step_decorator"
+require_relative "step_decorators/method_step_decorator"
+require_relative "step_decorators/proc_step_decorator"
+
+module Porch
+  class ExecutableStepDecorator
+    attr_reader :decorated_step
+
+    def step
+      decorated_step.step
+    end
+
+    def initialize(step, organizer)
+      @decorated_step = decorate step, organizer
+    end
+
+    def execute(context)
+      catch :stop_current_step_execution do
+        decorated_step.execute context
+      end
+    end
+
+    def self.registered_decorators
+      [ClassStepDecorator, MethodStepDecorator, ProcStepDecorator].freeze
+    end
+
+    private
+
+    def decorate(step, organizer)
+      decorator = self.class.registered_decorators.find { |d| d.decorates?(step) }
+      raise InvalidStepTypeError.new(step) if decorator.nil?
+      decorator.new(step, organizer)
+    end
+  end
+end

data/lib/porch/guard_rail/guard.rb

@@ -0,0 +1,18 @@
+require "dry-validation"
+
+module Porch
+  module GuardRail
+    class Guard
+      attr_reader :guarded_object
+
+      def initialize(guarded_object)
+        @guarded_object = guarded_object
+      end
+
+      def against(&block)
+        schema = Dry::Validation.Schema &block
+        schema.call guarded_object
+      end
+    end
+  end
+end

data/lib/porch/guard_rail.rb

@@ -0,0 +1,9 @@
+require_relative "guard_rail/guard"
+
+module Porch
+  module GuardRail
+    def guard(&block)
+      Guard.new(self).against(&block)
+    end
+  end
+end

data/lib/porch/human_error.rb

@@ -0,0 +1,43 @@
+module Porch
+  class HumanError
+    attr_accessor :seperator
+    attr_reader :errors
+
+    def initialize(errors, seperator=", ")
+      @errors = errors
+      @seperator = seperator
+    end
+
+    def message
+      collect_messages(errors).join(seperator)
+    end
+
+    private
+
+    def collect_messages(error_hash, attribute_prefix=nil)
+      error_hash.collect do |attribute, descriptions|
+        if descriptions.is_a? Hash
+          collect_messages descriptions, attribute
+        else
+          append_message attribute_prefix, attribute, descriptions
+        end
+      end
+    end
+
+    def append_message(attribute_prefix, attribute, descriptions)
+      append_descriptions(humanize(attribute_prefix, attribute), descriptions)
+    end
+
+    def append_descriptions(attribute, descriptions)
+      descriptions.collect { |description| "#{attribute} #{description}" }.join(seperator)
+    end
+
+    def humanize(attribute_prefix, attribute)
+      capitalize("#{attribute_prefix} #{attribute}".lstrip)
+    end
+
+    def capitalize(string)
+      CoreExt::String.new(string).capitalize
+    end
+  end
+end

data/lib/porch/organizer.rb

@@ -0,0 +1,14 @@
+module Porch
+  module Organizer
+    attr_reader :context
+
+    def with(parameters={})
+      @context = Context.new parameters
+
+      chain = StepChain.new(self)
+      yield chain if block_given?
+
+      chain.execute context
+    end
+  end
+end

data/lib/porch/step_chain.rb

@@ -0,0 +1,31 @@
+module Porch
+  class StepChain
+    attr_reader :organizer, :steps
+
+    def initialize(organizer)
+      @organizer = organizer
+      @steps = []
+    end
+
+    def add(step=nil, &block)
+      step = block if block_given?
+      steps << ExecutableStepDecorator.new(step, organizer)
+    end
+
+    def insert(index, step=nil, &block)
+      step = block if block_given?
+      steps.insert index, ExecutableStepDecorator.new(step, organizer)
+    end
+
+    def remove(step)
+      @steps.delete_if { |decorated_step| decorated_step.step == step }
+    end
+
+    def execute(context)
+      ctx = Context.new context
+      steps.map do |step|
+        ctx = step.execute ctx unless ctx.stop_processing?
+      end.last || ctx
+    end
+  end
+end

data/lib/porch/step_decorators/class_step_decorator.rb

@@ -0,0 +1,19 @@
+module Porch
+  class ClassStepDecorator
+    attr_reader :step
+
+    def initialize(step, _organizer)
+      @step = step
+    end
+
+    def execute(context)
+      ctx = Context.new(context)
+      step.new.call ctx
+      ctx
+    end
+
+    def self.decorates?(step)
+      step.is_a? Class
+    end
+  end
+end

data/lib/porch/step_decorators/method_step_decorator.rb

@@ -0,0 +1,20 @@
+module Porch
+  class MethodStepDecorator
+    attr_reader :organizer, :step
+
+    def initialize(step, organizer)
+      @step = step
+      @organizer = organizer
+    end
+
+    def execute(context)
+      ctx = Context.new(context)
+      organizer.send step, ctx
+      ctx
+    end
+
+    def self.decorates?(step)
+      step.is_a?(Symbol) || step.is_a?(String)
+    end
+  end
+end

data/lib/porch/step_decorators/proc_step_decorator.rb

@@ -0,0 +1,19 @@
+module Porch
+  class ProcStepDecorator
+    attr_reader :step
+
+    def initialize(step, _organizer)
+      @step = step
+    end
+
+    def execute(context)
+      ctx = Context.new(context)
+      step.call ctx
+      ctx
+    end
+
+    def self.decorates?(step)
+      step.is_a? Proc
+    end
+  end
+end

data/lib/porch/version.rb

@@ -0,0 +1,3 @@
+module Porch
+  VERSION = "0.1.0"
+end

data/lib/porch.rb

@@ -0,0 +1,12 @@
+require "porch/context"
+require "porch/core_ext"
+require "porch/errors"
+require "porch/executable_step_decorator"
+require "porch/human_error"
+require "porch/guard_rail"
+require "porch/organizer"
+require "porch/step_chain"
+require "porch/version"
+
+module Porch
+end

data/porch.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "porch/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "porch"
+  spec.version       = Porch::VERSION
+  spec.authors       = ["Jamie Wright"]
+  spec.email         = ["jamie@brilliantfantastic.com"]
+
+  spec.summary       = "A simple service layer pattern for plain old Ruby objects."
+  spec.description   = %q{Porch allows you to move the code into a series of steps that execute simple methods on itself or within simple PORO objects.}
+  spec.homepage      = "https://github.com/jwright/porch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dry-validation", "~> 0.10.4"
+
+  spec.add_development_dependency "bundler", "~> 1.12.0"
+  spec.add_development_dependency "rake", "~> 10.0.0"
+  spec.add_development_dependency "rspec", "~> 3.5.0"
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: porch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jamie Wright
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+description: Porch allows you to move the code into a series of steps that execute
+  simple methods on itself or within simple PORO objects.
+email:
+- jamie@brilliantfantastic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/porch.rb
+- lib/porch/context.rb
+- lib/porch/core_ext.rb
+- lib/porch/core_ext/string.rb
+- lib/porch/errors.rb
+- lib/porch/errors/invalid_step_type_error.rb
+- lib/porch/executable_step_decorator.rb
+- lib/porch/guard_rail.rb
+- lib/porch/guard_rail/guard.rb
+- lib/porch/human_error.rb
+- lib/porch/organizer.rb
+- lib/porch/step_chain.rb
+- lib/porch/step_decorators/class_step_decorator.rb
+- lib/porch/step_decorators/method_step_decorator.rb
+- lib/porch/step_decorators/proc_step_decorator.rb
+- lib/porch/version.rb
+- porch.gemspec
+homepage: https://github.com/jwright/porch
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A simple service layer pattern for plain old Ruby objects.
+test_files: []