business_pipeline 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fffa062373cea0a470d7c9f8c35843f95448c3c9c31fdbdf5be11c57f8c937e0
+  data.tar.gz: 720225822fa786111bdd11e3abf54fdcc1388a1baca3dd8c8c94e45db11230a4
+SHA512:
+  metadata.gz: f1d1e38de02437aff15fedf896e8f3020b74ae95f9ddbe6d2abec26efc35158ace21841348dc3f504a799e22d5ca4158a64d14b755d19226e4b4c39b4a2631ac
+  data.tar.gz: c41e391563e1d73dbb7a4fc54e5f3b143d1c388caee4c51f3dae09b9e6500bdae4633914e8a5cc25944834f3ae5c978ce6838075289a3bdba2e0f97fb5eb64ff

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/examples.txt

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,87 @@
+AllCops:
+  TargetRubyVersion: 2.5.3
+
+Layout/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+
+# Layout/FirstParameterIndentation:
+#   Exclude:
+#     - 'spec/**/*_spec.rb'
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Layout/MultilineMethodCallBraceLayout:
+  EnforcedStyle: same_line
+
+Layout/MultilineMethodDefinitionBraceLayout:
+  EnforcedStyle: same_line
+
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+  IndentationWidth: 2
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/LineLength:
+  Exclude:
+    - 'spec/**/*_spec.rb'
+  Max: 90
+
+Naming/PredicateName:
+  NamePrefixBlacklist:
+    - is_
+
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - 'bin/**'
+
+# Style/MultilineBlockChain:
+#   Enabled: false
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  '{}'
+    '%i': '[]'
+    '%q': '{}'
+    '%Q': '{}'
+    '%r': '{}'
+    '%s': '{}'
+    '%w': '[]'
+    '%W': '[]'
+    '%x': '{}'
+
+Style/RegexpLiteral:
+  EnforcedStyle: mixed
+
+Style/SignalException:
+  EnforcedStyle: semantic
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Style/YodaCondition:
+  EnforcedStyle: equality_operators_only

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+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.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at scourtois_github@cubyx.fr. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in business_pipeline.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: .
+  specs:
+    business_pipeline (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    ffi (1.10.0)
+    formatador (0.2.5)
+    guard (2.15.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    jaro_winkler (1.5.1)
+    json (2.1.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.13)
+    method_source (0.9.2)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parallel (1.12.1)
+    parser (2.5.1.2)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.60.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.0)
+    ruby_dep (1.5.0)
+    shellany (0.0.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    thor (0.20.3)
+    unicode-display_width (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  business_pipeline!
+  guard-rspec (~> 4.7)
+  rake (~> 10.0)
+  rspec (~> 3.6)
+  rubocop (~> 0.60.0)
+  simplecov (~> 0.16.1)
+
+BUNDLED WITH
+   1.17.2

data/Guardfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: 'bundle exec rspec', all_after_pass: true do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Simon Courtois
+
+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,445 @@
+# BusinessPipeline
+
+BusinessPipeline (BP) aim is to help organize your app's logic in a generic way. You define business bricks that you can then plug together to build more eveolved pipelines.
+
+While it was developed with Rails in mind, BP has no dependency upon it and can be used to organize pretty much any Ruby code.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'business_pipeline'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install business_pipeline
+
+## A touch of generic
+
+Let's say you build an API using Rails. Would you agree that most of the time, CRUD actions look pretty much alike?
+
+If your answer is "yes" or "yes but…" BusinessPipeline might be a good fit for you! What if you could write a single process to list resources in a Rails application? Wouldn't it be cool to have a generic code that can adapt to most if not all of your use-cases?
+
+BusinessPipeline has been extracted from applications that did just that. And if you were wondering, no those apps weren't 15-minute blogs 😁.
+
+A typical _index_ process would look like:
+
+```ruby
+module Processes
+  class Index < ApplicationProcess
+    step Steps::FetchAll
+    step Steps::Sort
+    step Steps::Paginate
+  end
+end
+```
+
+This may look like a trivial example but the power of this simplicity resides in how generic the Steps of your Process are.
+
+We'll start be looking at the basics of working with BusinessPipeline and then move on to how you could leverage its power in a Rails application.
+
+## Basic usage
+
+### Defining a Process
+
+Let's start from the very beginning and define a very focused business process:
+
+```ruby
+class UsersIndexProcess
+  include BusinessPipeline::Process
+
+  step FetchAllUsers
+  step SortUsers
+  step PaginateUsers
+end
+```
+
+### Defining Steps
+
+So far so good. Now let write the Steps that our process uses:
+
+```ruby
+class FetchAllUsers
+  include BusinessPipeline::Step
+
+  def call
+    context.users = User.all
+  end
+end
+
+class SortUsers
+  include BusinessPipeline::Step
+
+def call
+    context.users = context.users.order(context.sort)
+  end
+end
+
+class PaginateUsers
+  include BusinessPipeline::Step
+
+def call
+    context.users = context.user.page(context.page)
+  end
+end
+```
+
+Before we call our process, let's take a look at what we've got.
+
+### Nested processes
+
+A Process is actually a super-Step. This means that a Process can call another Process like any other Step.
+
+```ruby
+class UsersIndexProcess
+  include BusinessPipeline::Process
+
+  step ::IndexProcess
+  step UsersCustomStep
+end
+```
+
+In some occasions that may be a handy solution but you shouldn't need it most of the time.
+
+### Context
+
+The first thing that you see is that every Step interacts with something called `context`.
+
+This `context` is a _bag-of-data_ that is passed from one Step to another. It can be used as an object, just like we did with `context.users` but you can also use it like a Hash if necessary so here `context[:users]` would also work fine.
+
+```ruby
+context.value = 42
+
+context.value    # => 42
+context['value'] # => 42
+context[:value]  # => 42
+```
+
+In our `SortUsers` and `PaginateUsers` Steps we used values from our _context_ that weren't define so far. We'll see how they came to be when looking at how to call a Process.
+
+### Calling a Process
+
+When calling a Process, you can provide an initial _context_ by passing a Hash as argument:
+
+```ruby
+UsersIndex.new.call(page: 1, sort: { created_at: :desc })
+```
+
+You can then use this initial _context_ in all your Steps.
+
+A Process returns the modified _context_ at the end of its execution. You can interrogate this _context_ to know if everything went according to plan:
+
+```ruby
+result = UsersIndex.new.call(page: 1, sort: { created_at: :desc })
+
+result.success? # => true
+result.failure? # => false
+result.users # => …sorted and paginated list of users…
+```
+
+## Going generic
+
+So far we've written very narrow focused Processes and Steps but can we rewrite this code so that it becomes generic? Let's see how!
+
+### Process config
+
+Before we get started we need to first take a look at a Process' initialization. It actually accepts a Hash that will act somewhat like `context` but should contain data that _define_ the Process as opposed to `context` that is more related to the _execution_ of the Process.
+
+```ruby
+process = IndexProcess.new(collection_name: 'users', model_class: User)
+process.call(page: 1, sort: { created_at: :desc })
+```
+
+### Generic Steps
+
+Now that we initialized our Process with a _config_ let's change our Process' code and our Steps.
+
+```ruby
+class IndexProcess
+  include BusinessPipeline::Process
+
+  step FetchAll
+  step Sort
+  step Paginate
+end
+```
+
+So far all we did is remove the `User` part of our class names, now we need to modify the code they contain to be indeed generic.
+
+```ruby
+class FetchAll
+  include BusinessPipeline::Step
+
+  def call
+    collection_name = config.collection_name
+    model_class  = config.model_class
+
+    context[collection_name] = model_class.all
+  end
+end
+
+class Sort
+  include BusinessPipeline::Step
+
+  def call
+    collection_name = config.collection_name
+
+    context[collection_name] = context[collection_name].order(context.sort)
+  end
+end
+
+class Paginate
+  include BusinessPipeline::Step
+
+  def call
+    collection_name = config.collection_name
+
+    context[collection_name] = context[collection_name].page(context.page)
+  end
+end
+```
+
+And done! Not bad actually. We leveraged the information passed to the Process config to be able to reuse our Steps for any type of resource.
+
+## Hooks
+
+More often than not, you will want to implement things that are not quiet part of the business process per se, but are necessary for its good execution nonetheless. That's where _hooks_ come in handy.
+
+_If you're used to Rails, hooks act like `around_action`, `before_action` and `after_action`._
+
+Hooks can be defined on Processes and Steps alike. They accept blocks, method names or classes:
+
+```ruby
+class IndexProcess
+  include BusinessPipeline::Process
+
+  around do |process, context, config|
+    puts "Calling process: #{process.class}"
+    puts "Config is: #{config.inspect}"
+
+    puts "Context before call is: #{context.inspect}"
+
+    process.call
+
+    puts "Context after call is: #{context.inspect}"
+  end
+
+  before :some_method
+
+  after SomeAwesomeClass
+
+  private def some_method(context, config)
+
+  end
+end
+```
+
+### Hooks execution order
+
+Execution of _around_ hooks will always be the first one. Then the _before_ hooks and to finish the _after_ ones. So writing the following Process
+
+```ruby
+class IndexProcess
+  include BusinessPipeline::Process
+
+  around do |process|
+    puts 'AROUND 1 START'
+    process.call
+    puts 'AROUND 1 END'
+  end
+
+  before { puts 'BEFORE 1' }
+  before { puts 'BEFORE 2' }
+
+  around do |process|
+    puts 'AROUND 2 START'
+    process.call
+    puts 'AROUND 2 END'
+  end
+
+  after { puts 'AFTER 1' }
+  after { puts 'AFTER 2' }
+end
+```
+
+Would result in the following output:
+
+```
+AROUND 1 START
+AROUND 2 START
+BEFORE 1
+BEFORE 2
+AFTER 1
+AFTER 2
+AROUND 2 END
+AROUND 1 END
+```
+
+### Hooks inheritence
+
+If you inherit from a Process, your new class will inherit the hooks from its parent Process. This is especially useful when you want to centralize specific behaviors across all Processes.
+
+If for instance you wanted to wrap every Process in a transaction (which would be a good idea by the way :wink:), you can define it this way:
+
+```ruby
+class TransactionWrapping
+  def call(process, context, config)
+    ActiveRecord::Base.transaction { process.call }
+  end
+end
+
+class ApplicationProcess
+  include BusinessPipeline::Process
+
+  around TransactionWrapping
+end
+
+class IndexProcess < ApplicationProcess
+  # …
+end
+```
+
+Calling your `IndexProcess` will wrap it in a SQL transaction :heart_eyes:.
+
+## Process config configuration
+
+If you go generic all the way, you may end-up with interesting Steps like this:
+
+```ruby
+class ExtractAttribute
+  include BusinessPipeline::Step
+
+  def call
+    attribute_name = config.attribute_name
+    expose_as = config.expose_as
+    source = config.source
+
+    context[expose_as] = context[source].public_send(attribute_name)
+  end
+end
+```
+
+If for instance you have a `user` in your _context_ and you wanted to expose its `email` attribute as `user_email` the _config_ needed for this to happen would be:
+
+```ruby
+{ source: :user, attribute_name: :email, expose_as: :user_email }
+```
+
+And the whole Step to translate to
+
+```ruby
+class ExtractAttribute
+  include BusinessPipeline::Step
+
+  def call
+    context.user_email = context.user.email
+  end
+end
+```
+
+Now what happens if you need to call this generic step for several attributes?
+
+Luckily, you can override the Process' _config_ when using a Step and this override will only be active for this specific Step:
+
+```ruby
+class SomeUserProcess < ApplicationProcess
+  step FindUser
+
+  step ExtractAttribute do
+    source :user
+    attribute_name :email
+    expose_as :user_email
+  end
+
+  step ExtractAttribute do
+    source :user
+    attribute_name :lastname
+    expose_as :user_lastname
+  end
+end
+```
+
+At the end of the Process' execution, the context will contain `user_email` and `user_lastname` with the corresponding values.
+
+## Returning early
+
+Very often you may need to stop the execution of a Process. This can happen for two reasons: an error or an early success.
+
+### Errors
+
+If you want to stop the process execution because a situation makes it impossible to continue, you can leverage the `fail!` method.
+
+```ruby
+class DataCheck
+  include BusinessPipeline::Step
+
+  def call
+    context.continue == 'yes' || fail!(error: 'Continue is not set to yes')
+  end
+end
+
+class CheckingProcess
+  include BusinessPipeline::Process
+
+  step DataCheck
+end
+```
+
+Calling `context.fail!` will stop the execution and merge the information you give it to the _context_.
+
+```ruby
+result = CheckingProcess.new.call(continue: 'no')
+
+result.success? # => false
+result.failure? # => true
+result.error    # => 'Continue is not set to yes'
+```
+
+### Early success
+
+Sometimes, you may want to stop the execution of a Process because of an early success. That's what the `succeed!` method is for.
+
+For instance if you want to have a _find or create_ behavior you could implement it this way:
+
+```ruby
+class UserCreationProcess
+  include BusinessPipeline::Process
+
+  step FindUser
+  step CreateUser
+  step SendAccountConfirmationEmail
+end
+
+class FindUser
+  include BusinessPipeline::Step
+
+  def call
+    user = User.find(context.user_id)
+    succeed!(user: user) if user
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/simonc/business_pipeline. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the BusinessPipeline project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/simonc/business_pipeline/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+task default: :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'business_pipeline'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+cat > .git/hooks/pre-commit <<EOF
+#!/usr/bin/env sh
+
+unset GIT_DIR
+
+bundle exec rubocop -D
+if [ \$? -eq 1 ]; then exit 1; fi
+EOF
+
+chmod +x .git/hooks/pre-commit

data/business_pipeline.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'business_pipeline/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'business_pipeline'
+  spec.version       = BusinessPipeline::VERSION
+  spec.authors       = ['Simon Courtois']
+  spec.email         = ['scourtois_github@cubyx.fr']
+
+  spec.summary       = 'A new business pipeline architecture for Rails applications'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'guard-rspec', '~> 4.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'rubocop', '~> 0.60.0'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
+end

data/lib/bp.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'business_pipeline'
+
+BP = BusinessPipeline

data/lib/business_pipeline.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'business_pipeline/process'
+require 'business_pipeline/step'
+require 'business_pipeline/version'
+
+# BusinessPipeline provides a new organisation for your Rails application.
+module BusinessPipeline
+end

data/lib/business_pipeline/config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module BusinessPipeline
+  class Config < OpenStruct
+    def initialize(hash = nil, &block)
+      super(hash)
+      instance_eval(&block) if block
+    end
+
+    def fetch(key)
+      value = self[key.to_sym]
+
+      return value unless value.nil?
+      return yield(key) if block_given?
+
+      fail KeyError, key
+    end
+
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(meth, *args, &block)
+      if args.size.zero? || meth.to_s.end_with?('=')
+        super
+      else
+        self[meth] = args.first
+      end
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+
+    attr_reader :data
+    private :data
+  end
+end

data/lib/business_pipeline/context.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module BusinessPipeline
+  class Context < OpenStruct
+    def self.build(context = {})
+      context.is_a?(self) ? context : new(context)
+    end
+
+    def initialize(*)
+      super
+      @failure = false
+    end
+
+    def fail
+      @failure = true
+    end
+
+    def fail!(additional_context = {})
+      update!(additional_context)
+      self.fail
+      throw :early_stop, self
+    end
+
+    def failure?
+      !!@failure
+    end
+
+    def succeed!(additional_context = {})
+      update!(additional_context)
+      throw :early_stop, self
+    end
+
+    def success?
+      !failure?
+    end
+
+    private def update!(context)
+      context.each { |key, value| modifiable[key.to_sym] = value }
+    end
+  end
+end

data/lib/business_pipeline/hooks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module BusinessPipeline
+  module Hooks
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def add_hooks(*new_hooks, type: __callee__, &block)
+        hooks[type] += [*new_hooks, block].compact.map do |hook|
+          hook.respond_to?(:new) ? hook.new : hook
+        end
+      end
+      alias_method :after, :add_hooks
+      alias_method :around, :add_hooks
+      alias_method :before, :add_hooks
+
+      def hooks
+        @hooks ||= { after: [], around: [], before: [] }
+      end
+    end
+
+    private def run_around_hooks(&block)
+      around_hooks = self.class.hooks[:around]
+
+      around_hooks
+        .reverse
+        .inject(block) { |chain, hook| proc { run_hook(hook, chain) } }
+        .call
+    end
+
+    private def with_hooks
+      run_around_hooks do
+        run_hooks :before
+        yield
+        run_hooks :after
+      end
+    end
+
+    private def run_hooks(type)
+      self.class.hooks[type].each { |hook| run_hook(hook) }
+    end
+
+    private def run_hook(hook, *args)
+      hook = method(hook) if hook.is_a?(Symbol)
+      hook.call(*args, context, config)
+    end
+  end
+end

data/lib/business_pipeline/process.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'business_pipeline/config'
+
+module BusinessPipeline
+  module Process
+    def self.included(base)
+      base.class_eval do
+        include BusinessPipeline::Step
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      def call
+        self.class.steps.each do |step_class, block|
+          step_config = BusinessPipeline::Config.new(config, &block)
+          step = step_class.new(step_config)
+          step.perform(context)
+        end
+      end
+
+      def perform(context = {})
+        config._processes ||= []
+        config._processes << self
+
+        config._processes.one? ? catch(:early_stop) { super } : super
+      ensure
+        config._processes.pop
+      end
+    end
+
+    module ClassMethods
+      def step(step_class, &block)
+        steps << [step_class, block]
+      end
+
+      def steps
+        @steps ||= []
+      end
+    end
+  end
+end

data/lib/business_pipeline/step.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'business_pipeline/config'
+require 'business_pipeline/context'
+require 'business_pipeline/hooks'
+
+module BusinessPipeline
+  module Step
+    def self.included(base)
+      base.class_eval do
+        include Hooks
+
+        attr_reader :context
+        private :context
+
+        attr_reader :config
+        private :config
+
+        def self.inherited(child_class)
+          child_class.instance_variable_set(:@hooks, hooks)
+        end
+      end
+    end
+
+    def initialize(config = {})
+      @config = BusinessPipeline::Config.new(config)
+    end
+
+    def call
+      fail NotImplementedError
+    end
+
+    def fail!(additional_context = {})
+      context.fail!(additional_context)
+    end
+
+    def perform(context = {})
+      @context = BusinessPipeline::Context.build(context)
+      with_hooks { call }
+      @context
+    end
+
+    def succeed!(additional_context = {})
+      context.succeed!(additional_context)
+    end
+  end
+end

data/lib/business_pipeline/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BusinessPipeline
+  VERSION = -'0.1.0'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: business_pipeline
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Simon Courtois
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.60.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.60.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+description: 
+email:
+- scourtois_github@cubyx.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- business_pipeline.gemspec
+- lib/bp.rb
+- lib/business_pipeline.rb
+- lib/business_pipeline/config.rb
+- lib/business_pipeline/context.rb
+- lib/business_pipeline/hooks.rb
+- lib/business_pipeline/process.rb
+- lib/business_pipeline/step.rb
+- lib/business_pipeline/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.7.6
+signing_key: 
+specification_version: 4
+summary: A new business pipeline architecture for Rails applications
+test_files: []