carry_out 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 978f0d178d3f9163e0c712bbb6d9d15a2dc73331
-  data.tar.gz: 025b60557fca2bc67a66e2ece60d00482ac66dd5
+  metadata.gz: 85928342e0fda93fadd48a0609af90372244b406
+  data.tar.gz: 50a55f7b851ae3363d1f8ff3a9bccae4720c0963
 SHA512:
-  metadata.gz: 060aff17ad5c6426f1d62fdde246e3360416064e582d5dcadb40d2b49f7b5007259880d56bd690b85106c96b634d614f1d8dcf3c83bafae4b102e095ad90fb20
-  data.tar.gz: e705734c5a0ddcfec23612af8053bc93ebb5f05c6c72a63defe0043ded55379e398acbfef4cc7f3e4dafb29b6fedd802d01b055117ab8d9019f1b294e344c108
+  metadata.gz: bb251b2ce082f94ede7d254a57a6973a1f609c775951e1390dc8105fa14d007bb17a54c7849f51f8f540e9cf293e556137a167d6c9f0dc656f20f9d545d6c122
+  data.tar.gz: 84f8722a4a273fd1b9ad0e5ce15fb608ba1f66a99681cc2aad81be3c2dee41c5657a313639d3f80fad1ede719c8825219303ce89d3a465453e58987d274a52c5

data/README.md

@@ -1,6 +1,6 @@
 # CarryOut
 
-CarryOut connects units of logic into workflows.  Each unit can extend the DSL with parameter methods.  Artifacts and errors are collected as the workflow executes and are returned in a result bundle upon completion.
+CarryOut runs isolated units of logic in a series.  Each unit can extend the DSL with methods for passing input parameters.  Artifacts and errors are collected as the series executes and are returned in a result bundle upon completion.
 
 [![Gem Version](https://badge.fury.io/rb/carry_out.svg)](https://badge.fury.io/rb/carry_out) [![Build Status](https://travis-ci.org/ryanfields/carry_out.svg?branch=master)](https://travis-ci.org/ryanfields/carry_out) [![Coverage Status](https://coveralls.io/repos/github/ryanfields/carry_out/badge.svg?branch=master)](https://coveralls.io/github/ryanfields/carry_out?branch=master) [![Code Climate](https://codeclimate.com/github/ryanfields/carry_out/badges/gpa.svg)](https://codeclimate.com/github/ryanfields/carry_out)
 
@@ -25,7 +25,7 @@ Or install it yourself as:
 Execution units extend CarryOut::Unit and should implement ```CarryOut::Unit#execute(result)```.
 ```ruby
 class SayHello < CarryOut::Unit
-  def execute(result)
+  def call
     puts "Hello, World!"
   end
 end
@@ -33,16 +33,18 @@ end
 
 CarryOut can then be used to create an execution plan using the unit.
 ```ruby
-plan = CarryOut.will(SayHello)
+plan = CarryOut.plan do
+  call SayHello
+end
 ```
 
 Run the plan using:
 ```
-result = plan.execute
+result = plan.call
 ```
 
 ### Parameters
-Execution units can be passed parameters statically during plan creation, or dynamically via a block.
+Execution units can be passed parameters statically during plan creation, or dynamically via a block.  There is also a special `context` method that will be explained futher down in this document.
 
 #### parameter
 
@@ -51,7 +53,7 @@ Redefine the example above to greet someone by name:
 class SayHello < CarryOut::Unit
   parameter :to, :name
     
-  def execute(result)
+  def call
     puts "Hello, #{@name}!"
   end
 end
@@ -59,15 +61,19 @@ end
 
 Define the plan as:
 ```ruby
-plan = CarryOut
-  .will(SayHello)
-  .to("Ryan")
-    
+plan = CarryOut.plan do
+  call SayHello do
+    to "World"
+  end
+end
+
 # or
 
-plan = CarryOut
-  .will(SayHello)
-  .to { "Ryan" }
+plan = CarryOut do
+  call SayHello do
+    to { "World" }
+  end
+end
 ```
 
 And execute the same way as above.
@@ -79,18 +85,19 @@ Appending parameters will convert the value of an existing parameter to an array
 ```ruby
 class SayHello < CarryOut::Unit
   parameter :to, :names
-  appending_parameter :and, :names
+  appending_parameter :and_to, :names
 
-  def execute
+  def call
     puts "Hello, #{@names}.join(", ")}!"
   end
 end
 
-plan = CarryOut
-  .will(SayHello)
-  .to("John")
-  .and("Jane")
-  .and("Ryan")
+plan = CarryOut.plan do
+  call SayHello do
+    to "John"
+    and_to "Jane"
+  end
+end
 ```
 
 Unlike `parameter`, `appending_parameter` must provide both a method name and an instance variable name.
@@ -105,218 +112,148 @@ A unit may wish to provide the syntactic sugar while ensuring the underlying ins
 
 Plan executions return a `CarryOut::Result` object that contains any artifacts returned by units (in `Result#artifacts`), along with any errors raised (in `Result#errors`).  If `errors` is empty, `Result#success?` will return `true`.
 
-References via `CarryOut#get` or via blocks can be used to pass result artifacts on to subsequent execution units in the plan.
+The result context can be accessed via the `context` method when creating a plan.
 
 ```ruby
 class AddToCart < CarryOut::Unit
   parameter :items
     
-  def execute(result)
-    result.add :contents, @items
-  end
+  def call; @items; end
 end
 
 class CalculateSubtotal < CarryOut::Unit
   parameters :items
     
-  def execut(result)
-    subtotal = items.inject { |sum, item| sum + item.price }
-    result.add :subtotal, subtotal
+  def call
+    items.inject { |sum, item| sum + item.price }
   end
 end
 ```
 ```ruby
-plan = CarryOut
-  .will(AddToCart, as: :cart)
-  .items([ item1, item2, item3])
-  .then(CalculateSubtotal, as: :invoice)
-  .items(CarryOut.get(:cart, :contents) 
-  # or .items { |refs| refs[:cart][:contents] }
-
-plan.execute do |result|
-  puts "Subtotal: #{result.artifacts[:invoice][:subtotal]}"
+plan = CarryOut.plan do
+  call AddToCart do
+    items [ item1, item2, item3 ]
+    return_as :cart
+  end
+  
+  then_call CalculateSubtotal do
+    items context(:cart)
+    # or: items { context(:cart) }
+    return_as :subtotal
+  end
 end
+
+result = plan.call
+puts "Subtotal: #{result.artifacts[:subtotal]}"
 ```
 
 ### Initial Artifacts
 
-`Plan#execute` accepts a hash that will seed the initial result artifacts.
+`Plan#call` accepts a hash that will seed the initial result context.
 
 ```ruby
-plan = CarryOut
-  .will(SayHello)
-  .to(CarryOut.get(:name))
+plan = CarryOut.plan do
+  call AddToCart do
+    items context(:items)
+  end
+end
 
-plan.execute(name: 'John')
+plan.call(items: [ item1, item2, item3 ])
 ```
 
-### Wrapping Execution
+### Altering a returned value
 
-Plan execution can be wrapped for purposes such as ensuring files get closed or to run the plan inside a database transaction.  Wrapping also provides an alternative mechanism for injecting initial artifacts into the plan result.
-
-If `Plan#execute` is passed an initial artifact hash, and a wrapper injects an artifact hash, the two will be merged.  The wrapper hash will get priority.
+It should be considered preferable to encapsulate all logic inside units and always append to the context.  However, it may be more pragmatic in some circumstances to make minor changes to a returned value as it is being returned.  This can be achieved by providing a block to `return_as`.
 
 ```ruby
-class FileContext
-  def initialize(file_path)
-    @file_path = file_path
-  end
-  
-  def execute
-    File.open(@file_path, "r") do |f|
-      yield file: f
-    end
+plan = CarryOut.plan do
+  call EchoName do
+    name 'john'
+    return_as (:name) { |result| result.capitalize }
   end
 end
-
-plan = CarryOut
-  .within(FileContext.new("path/to/file"))  # Expects instance, not class
-  .will(DoAThing)
-  .with_file(CarryOut.get(:file))
 ```
 
-The wrapping context can also be a block.
-
-```ruby
-plan = CarryOut
-  .within { |proc| ActiveRecordBase.transaction { proc.call } }
-  .will(CreateModel)
-```
-
-When using a block, `proc.call` can be used to seed the references hash in the same manner as `yield` in the first example.
-
-Wrapper contexts will always be applied to an entire plan.  If a plan has multiple phases that need to be wrapped in different contexts, it is better to create multiple plans and embed them together in a larger plan as shown below.
-
 ### Embedding Plans
 
-A plan can be used in place of a `CarryOut::Unit`.  This allows plans to be reused as part of larger strategies.
+A plan can be used in place of a `CarryOut::Unit`.  This allows plans to be reused as part of larger series.  Compositing plans can also help when dealing with optional series.
 
 ```ruby
-say_hello = CarryOut.will(SayHello)
+say_hello = CarryOut.plan { call SayHello }
 
-plan = CarryOut
-  .will(DisplayBanner)
-  .then(say_hello)
+plan = CarryOut do
+  call DisplayBanner
+  then_call SayHello
+end
 ```
 
-Passing a plan to `#then` works similar to passing a `CarryOut::Unit` class or instance.  If the `as` option is added, the inner plan's result artifacts will be added to the outer plan's result at the specified key.
+Passing a plan to `call` works similar to passing a `CarryOut::Unit` class or instance.  A block can be included in order to specify a `return_as` directive.  The resulting artifact hash will be stored under the name given to `return_as`.
 
-**One caveat to be aware of**:  There is no way to specify initial artifacts for an embedded plan.  If an embedded plan depends on an external context, `CarryOut#within` is sufficient to work around this limitation.  However, there is currently no way for an inner plan to access an outer plan's artifacts.  This is considered a bug and will be fixed in a future release.
+An embedded plan will receive the current result context as its initial context.
+
+**Caveat**
+Errors for embedded plans will be stored at the top level of `Result#errors`.  The `return_as` label for embedded plans is not factored into the label path for errors.  As a result, it can be tricky to determine whether an error was set by the outer plan or an embedded plan.  This is a known bug and will be fixed in a future release.
 
 ### Conditional Units
 
-Use the `if` or `unless` directive to conditionally execute a unit.
+Use the `only_when` or `except_when` directives to conditionally execute a unit.  
 
 ```ruby
-plan = CarryOut
-  .will(SayHello)
-  .if { |refs| refs[:audible] }
-  # or .if(CarryOut.get(:audible))
+plan = CarryOut.plan do
+  call SayHello
+    only_when context(:audible)
+  end
+end
 ```
 
 ```ruby
-plan = CarryOut
-  .will(SayHello)
-  .unless { |refs| refs[:silenced] }
-  # or .unless(CarryOut.get(:silenced))
-```
-
-### Magic Directives (Experimental)
-
-*This feature is highly experimental.  It has not been thoroughly tested in larger application environments like Rails and is not yet guaranteed to remain part of this gem.*
-
-CarryOut provides some magic methods that can improve the readability of a plan.  These rely on a search strategy to find classes by name.  A very limited strategy is provided out-of-the-box.  This strategy accepts an array of modules and will only find classes that are direct children of any of the provided modules.  The first match gets priority.
-
-```ruby
-CarryOut.defaults = {
-  search: [ MyModule1 ]
-}
+plan = CarryOut.plan do
+  call SayHello
+  except_when context(:silenced)
+end
 ```
 
-If the default strategy is insufficient (and it most likely will be), a custom strategy can be provided as a lambda/Proc.  For example, a strategy that works in Rails is to put the following in an initializer:
+These directives can be given blocks if more complex conditional logic is needed.  As with parameter blocks, the `context` method is available inside the block.
 
-```ruby
-CarryOut.defaults = {
-  search: -> (name) { name.constantize }
-}
-```
+### Magic Unit Methods
 
-#### will\_, then\_, and within\_ Directives
+CarryOut provides some magic to translate unit classes into method names that can replace the `call Class` syntax.  This feature relies on a search strategy to find classes by name.  A very limited strategy is provided out-of-the-box.  This strategy accepts an array of modules and will only find classes that are direct children of any of the provided modules.  The first match gets priority.
 
-The magic versions of `will`, `then`, and `within` will use the configured search strategy to convert the remaning portion of the directive into a class reference.
+Assuming `MyModule1` contains definitions for units `DisplayBanner` and `SayHello`:
 
-Using the default strategy as configured above:
 ```ruby
-module MyModule1
-  class SayHello
-    def execute; puts "Hello!"; end
-  end
+CarryOut.configure do
+  search [ MyModule1 ]
 end
 
-plan = CarryOut.will_say_hello
-```
-
-#### returning\_as\_ Directive
-
-The magic `returning_as_` directive is an alternative to passing the `as:` option to a `will`/`then` directive.  The remainder of the directive becomes the key symbol into which the unit's return value will be stored.
-
-```ruby
-plan = CarryOut
-  .will_receive_message
-    .returning_as_message
-  .then_log
-    .message(CarryOut.get(:message))
+plan = CarryOut.plan do
+  display_banner { with_text "This is my banner." }
+  say_hello { to "World" }
+end
 ```
 
-#### result\_of\_ Directive
-
-The magic `result_of_` directive is available within blocks passed to parameter methods.  The remainder of the directive becomes the context key symbol from which the value will be retreived.
+If the default strategy is insufficient (and it most likely will be), a custom strategy can be provided as a lambda/Proc.  For example, a strategy that works in Rails is to put the following in an initializer:
 
 ```ruby
-plan = CarryOut
-  .will_receive_message
-    .returning_as_message
-  .then_log
-    .message { result_of_message }
-    # instead of .message(CarryOut.get(:message)
-    # or .message { |refs| refs.message }
+CarryOut.configure do
+  search -> (name) { name.constantize }
+end
 ```
 
-#### Example using all available magic
+## Configuration
+The CarryOut global can be configured using `CarryOut#configure`.  It accepts a block containing configuration directives.  At the moment, the only directive is the `search` option described above.
 
-While a contrived example, the following illustrates the improved readability of a plan when using the magic directives.
-
-```ruby
-plan = CarryOut
-  .within_order_transaction
-    .will_order_bagel
-      .flavored('everything')
-      .toasted
-      .topped_with('butter')
-      .and('strawberry cream cheese')
-      .returning_as_bagel
-    .then_order_coffee
-      .with_cream
-      .and_sugar
-      .returning_as_coffee
-    .then_calculate_order_total
-      .for { result_of_bagel }
-      .and { result_of_coffee }
-    .then_swipe_credit_card
-      .returning_as_cc
-    .then_pay
-      .with_credit_card { result_of_cc }
-```
+If more than one configuration of CarryOut is needed, the `CarryOut#with_configuration` method can be used to obtain a configured instance of CarryOut.  At the moment, this method accepts a hash of configuration options.  *This will change in a future release, in which this method will be called just like the configure method.*  This method returns an instance that operates just like the CarryOut global, but uses the provided configuration options when creating and running plans.
 
 ## Motivation
 
 I've been trying to keep my Rails controllers clean, but I prefer to avoid shoving inter-model business logic inside database models.  The recommendation I most frequently run into is to move that kind of logic into something akin to service objects.  I like that idea, but I want to keep my services small and composable, and I want to separate the "what" from the "how" of my logic.
 
-CarryOut is designed to be a consistent layer of glue between single-purpose or "simple-purpose" units of business logic.  CarryOut describes what needs to be done and what inputs are to be used.  The units themselves worry about how to perform the actual work.  These units tend to have names that describe their intent.  They remain small and easier to test.  What ends up in my controllers is a process description that that can be comprehended at a glance and remains fairly agnostic to the underlying details of my chosen ORM, job queue, message queue, etc.
+CarryOut is designed to be a consistent layer of glue between single-purpose or "simple-purpose" units of business logic.  CarryOut describes what needs to be done and which inputs are to be used.  The units themselves worry about how to perform the actual work.  These units tend to have names that describe their intent.  They remain small and easier to test in isolation.  What ends up in my controllers is a process description that that can be comprehended at a glance and remains fairly agnostic to the underlying details of my chosen ORM, job queue, message queue, etc.
 
-I'm building up CarryOut alongside a new Rails application, but my intent is for CarryOut to remain just as useful outside of Rails.  At present, it isn't bound in any way to things like ActiveRecord.  If those sorts of bindings emerge, I'll provide an add-on gem or an alternate require.
+I'm building up CarryOut alongside a new Rails application, but my intent is for CarryOut to remain just as useful outside of Rails.  At present, it is not bound in any way to ActiveRecord.  If those sorts of bindings emerge, I intend to provide an add-on gem or an alternate require.
 
-CarryOut's workflows don't support asynchronous execution units yet.  The workflows can't branch or loop.  These are features I hope to provide in the future.  Feature requests are welcome.
+A CarryOut series is synchronous.  Support for asynchronous execution is desired, but not yet planned for a future release.  A series can not loop.  Branching is achievable in a round-about way through the `only_when` and `except_when` conditionals, but this becomes hard to follow in complex plans.  If you find frequent need of complex branching and looping, a full workflow engine might be a better choice than CarryOut.
 
 ## Development
 

data/carry_out.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "simplecov", "~> 0.12.0"
   spec.add_development_dependency "coveralls", "~> 0.8"
 
   if RUBY_VERSION < '2.0'

data/lib/carry_out/configurator.rb

@@ -0,0 +1,11 @@
+module CarryOut
+  class Configurator
+    def initialize(options)
+      @options = options
+    end
+
+    def search(path)
+      @options[:search] = [ path ].flatten(1)
+    end
+  end
+end

data/lib/carry_out/plan/guard.rb

@@ -0,0 +1,22 @@
+require 'carry_out/plan/guard_context'
+
+module CarryOut
+  module Plan
+    class Guard
+      def initialize(proc, options = {})
+        @proc = proc
+        invert(options[:invert])
+      end
+
+      def call(context = {})
+        result = GuardContext.new(context).instance_exec(context, &@proc)
+        result = !result if @invert
+        result
+      end
+
+      def invert(is_inverted = true)
+        @invert = !!is_inverted
+      end
+    end
+  end
+end

data/lib/carry_out/plan/guard_context.rb

@@ -0,0 +1,13 @@
+module CarryOut
+  module Plan
+    class GuardContext
+      def initialize(context = {})
+        @context = context
+      end
+
+      def context(*args)
+        args.inject(@context) { |c, k| c.nil? ? nil : c[k] }
+      end
+    end
+  end
+end

data/lib/carry_out/plan/node.rb

@@ -0,0 +1,71 @@
+require "carry_out/plan/guard"
+require "carry_out/plan/node_result"
+
+module CarryOut
+  module Plan
+    class Node
+      attr_accessor :action
+      attr_accessor :connects_to
+      attr_reader :guarded_by
+      attr_accessor :returns_as
+      attr_accessor :return_transform
+
+      def initialize(action = nil)
+        @action = action
+        @messages = []
+      end
+
+      def call(context = {})
+        return NodeResult.new unless @action
+        return unless guard(context)
+
+        result = @action.call do |a|
+          @messages.map do |m|
+            value = m[:source]
+            
+            if value.respond_to?(:call)
+              value = GuardContext.new(context).instance_exec(context, &value)
+            end
+
+            a.send(m[:method], value)
+          end
+        end
+        
+        result = return_transform.call(result) unless return_transform.nil?
+
+        NodeResult.new(result)
+      end
+
+      def guard_with(guard)
+        guard = guard.respond_to?(:call) ? guard : Proc.new { guard }
+        guarded_by.push Guard.new(guard)
+      end
+
+      def guard_with_inverse(guard)
+        guard_with(guard)
+        guarded_by.last.invert
+      end
+
+      def guarded_by
+        @guarded_by ||= []
+      end
+
+      def method_missing(method, *args, &block)
+        if respond_to?(method)
+          @messages.push({ method: method, source: block || (args.length == 0 ? true : args.first) })
+        else
+          raise NoMethodError, "undefined method `#{method}' for #{@action}"
+        end
+      end
+
+      def respond_to?(method, private = false)
+        (@action && @action.respond_to?(:has_parameter?) && @action.has_parameter?(method)) || super
+      end
+
+      private
+        def guard(context = {})
+          guarded_by.empty? || guarded_by.all? { |g| g.call(context) }
+        end
+    end
+  end
+end

data/lib/carry_out/plan/node_context.rb

@@ -0,0 +1,40 @@
+module CarryOut
+  module Plan
+    class NodeContext
+      def initialize(node)
+        @node = node
+      end
+
+      def action
+        self
+      end
+
+      def context(*args)
+        -> (context) do
+          args.inject(context) { |c, k| c.nil? ? nil : c[k] }
+        end
+      end
+
+      def only_when(value = nil, &block)
+        @node.guard_with(value || block)
+      end
+
+      def except_when(value = nil, &block)
+        @node.guard_with_inverse(value || block)
+      end
+
+      def method_missing(method, *args, &block)
+        @node.send(method, *args, &block)
+      end
+
+      def respond_to?(method)
+        @node.respond_to?(method)
+      end
+
+      def return_as(key, &block)
+        @node.returns_as = key
+        @node.return_transform = block unless block.nil?
+      end
+    end
+  end
+end

data/lib/carry_out/plan/node_result.rb

@@ -0,0 +1,11 @@
+module CarryOut
+  module Plan
+    class NodeResult
+      attr_reader :value
+
+      def initialize(value = nil)
+        @value = value
+      end
+    end
+  end
+end

data/lib/carry_out/plan_builder.rb

@@ -0,0 +1,70 @@
+require "carry_out/plan/node"
+require "carry_out/plan/node_context"
+
+module CarryOut
+  class PlanBuilder
+    def initialize(options = {}, &block)
+      @plan = Plan::Node.new
+      @wrapper = nil
+      @constant_resolver = [ options[:search] ].flatten(1)
+
+      configure_node(@plan, &block) if block
+    end
+
+    attr_reader :plan
+
+    def self.build(options = {}, &block)
+      builder = PlanBuilder.new(options)
+      builder.instance_eval(&block)
+      builder.plan
+    end
+
+    def call(unit = nil, &block)
+      unit = find_object(unit) if unit.is_a?(Symbol) || unit.is_a?(String)
+      node = Plan::Node.new(unit)
+
+      configure_node(node, &block) if block
+      current_node.connects_to = node
+      self.current_node = node
+
+      node
+    end
+
+    alias_method :then_call, :call
+
+    def method_missing(method, *args, &block)
+      obj = find_object(method)
+
+      if obj
+        call(method, &block)
+      else
+        super
+      end
+    end
+
+    private
+      attr_writer :current_node
+
+      def configure_node(node, &block)
+        Plan::NodeContext.new(node).instance_eval(&block)
+      end
+
+      def current_node
+        @current_node ||= @plan
+      end
+
+      def find_object(name)
+        constant_name = name.to_s.split('_').map { |w| w.capitalize }.join('')
+
+        @constant_resolver.inject(nil) do |obj, m|
+          return obj if obj
+
+          if m.respond_to?(:call)
+            m.call(constant_name)
+          else
+            m.const_get(constant_name) rescue nil
+          end
+        end
+      end
+  end
+end

data/lib/carry_out/plan_runner.rb

@@ -0,0 +1,34 @@
+module CarryOut
+  class PlanRunner
+    def self.run(plan, context = {})
+      PlanRunner.new.run(plan, context)
+    end
+
+    def run(plan, context = {})
+      Result.new(context).tap do |plan_result|
+        node = plan
+
+        until node.nil?
+          node_result = nil
+
+          begin
+            node_result = node.call(plan_result.artifacts)
+
+            if node_result.kind_of?(Plan::NodeResult) && node.returns_as
+              plan_result.add(node.returns_as, node_result.value)
+
+              if node_result.value.kind_of?(CarryOut::Result) && !node_result.value.success?
+                break
+              end
+            end
+
+            node = node.connects_to
+          rescue StandardError => error
+            plan_result.add (node.returns_as || :base), CarryOut::Error.new(error.message, error)
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carry_out/result.rb

@@ -10,6 +10,10 @@ module CarryOut
         add_error(group, object)
       elsif object.kind_of?(Result)
         add(group, object.to_hash)
+        
+        object.errors.each do |g, errors|
+          errors.each { |e| add(g,e) }
+        end
       elsif object.kind_of?(Hash)
         artifacts[group] ||= {}
         object.each { |k,v| artifacts[group][k] = v }

data/lib/carry_out/unit.rb

@@ -1,7 +1,18 @@
 module CarryOut
   class Unit
     
-    def execute
+    def call
+      raise "Expected #{self.class} to define #{self.class}#call" unless self.class == Unit
+    end
+
+    def self.call(&block)
+      unit = self.new
+      yield unit if block
+      unit.call
+    end
+
+    def self.has_parameter?(method)
+      self.instance_methods.include?(method)
     end
 
     def self.appending_parameter(method_name, var)

data/lib/carry_out/version.rb

@@ -1,3 +1,3 @@
 module CarryOut
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/lib/carry_out.rb

@@ -1,69 +1,40 @@
-require "carry_out/version"
+require 'carry_out/version'
 
-require "carry_out/context"
-require "carry_out/error"
-require "carry_out/plan"
-require "carry_out/plan_node"
-require "carry_out/reference"
-require "carry_out/result"
-require "carry_out/unit"
-require "carry_out/unit_error"
+require 'carry_out/configurator'
+require 'carry_out/error'
+require 'carry_out/result'
+require 'carry_out/unit'
 
-module CarryOut
-  MATCH_CONTINUATION_METHOD = /^will_/
-  MATCH_WITHIN_METHOD = /^within_/
+require 'carry_out/plan_builder'
+require 'carry_out/plan_runner'
 
-  class ConfiguredCarryOut
+module CarryOut
+  class ConfiguredInstance
     def initialize(options = {})
-      @config = options
-    end
-
-    def get(*args)
-      Reference.new(*args)
-    end
-
-    def method_missing(method, *args, &block)
-      if MATCH_CONTINUATION_METHOD =~ method
-        create_plan.send(method, *args, &block)
-      elsif MATCH_WITHIN_METHOD =~ method
-        create_plan.send(method, *args, &block)
-      else
-        super
-      end
+      @options = Hash.new
+      @options[:search] = options[:search] if options.has_key?(:search)
     end
 
-    def will(*args)
-      create_plan.will(*args)
+    def plan(options = {}, &block)
+      CarryOut.plan(Hash.new.merge(@options).merge(options), &block) 
     end
-
-    def within(wrapper = nil, &block)
-      create_plan(within: wrapper || block)
-    end
-
-    private
-      def create_plan(options = {})
-        Plan.new(nil, @config.merge(options))
-      end
-  end
-
-  def self.configured_with(options = {})
-    ConfiguredCarryOut.new(options)
   end
 
-  def self.defaults=(options = {})
-    @default_options = options
-    @default_carry_out = nil
+  def self.configure(&block)
+    Configurator.new(configuration).instance_eval(&block)
   end
 
-  def self.method_missing(method, *args, &block)
-    default_carry_out.send(method, *args, &block)
+  def self.plan(options = {}, &block)
+    merged_options = Hash.new.merge(configuration).merge(options)
+    plan = PlanBuilder.build(merged_options, &block)
+    -> (context = nil) { PlanRunner.run(plan, context) }
   end
 
-  def self.default_options
-    @default_options ||= Hash.new
+  def self.configuration
+    @configuration ||= {}
   end
 
-  def self.default_carry_out
-    @default_carry_out ||= ConfiguredCarryOut.new(default_options)
+  def self.with_configuration(options = {})
+    ConfiguredInstance.new(options)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carry_out
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Fields
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-27 00:00:00.000000000 Z
+date: 2017-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -88,14 +102,17 @@ files:
 - bin/setup
 - carry_out.gemspec
 - lib/carry_out.rb
-- lib/carry_out/context.rb
+- lib/carry_out/configurator.rb
 - lib/carry_out/error.rb
-- lib/carry_out/plan.rb
-- lib/carry_out/plan_node.rb
-- lib/carry_out/reference.rb
+- lib/carry_out/plan/guard.rb
+- lib/carry_out/plan/guard_context.rb
+- lib/carry_out/plan/node.rb
+- lib/carry_out/plan/node_context.rb
+- lib/carry_out/plan/node_result.rb
+- lib/carry_out/plan_builder.rb
+- lib/carry_out/plan_runner.rb
 - lib/carry_out/result.rb
 - lib/carry_out/unit.rb
-- lib/carry_out/unit_error.rb
 - lib/carry_out/version.rb
 homepage: https://github.com/ryanfields/carry_out
 licenses:

data/lib/carry_out/context.rb

@@ -1,17 +0,0 @@
-module CarryOut
-  class Context
-    MATCH_RESULT_METHOD = /^result_of_(.+)/
-
-    def initialize(context)
-      @context = context
-    end
-
-    def method_missing(method, *args, &block)
-      if MATCH_RESULT_METHOD =~ method && args.empty? && block.nil?
-        @context[$1.to_sym]
-      else
-        super
-      end
-    end
-  end
-end

data/lib/carry_out/plan.rb

@@ -1,165 +0,0 @@
-module CarryOut
-  class Plan
-    MATCH_CONTINUATION_METHOD = /^(?:will|then)_(.+)/
-    MATCH_CONTEXT_METHOD = /^within_(.+)/
-    MATCH_RETURNING_METHOD = /^returning_as_(.+)/
-
-    def initialize(unit = nil, options = {})
-      @nodes = {}
-      @node_meta = {}
-      @previously_added_node = nil
-      @wrapper = options[:within]
-      @search = options[:search] || []
-
-      self.then(unit, options) unless unit.nil?
-    end
-
-    def execute(context = nil, &block)
-      if @wrapper
-        if @wrapper.respond_to?(:execute)
-          @wrapper.execute do |wrapper_context|
-            execute_internal(Result.new(context, wrapper_context), &block)
-          end
-        else
-          @wrapper.call(Proc.new { |wrapper_context|
-            execute_internal(Result.new(context, wrapper_context), &block)
-          })
-        end
-      else
-        execute_internal(Result.new(context), &block)
-      end
-    end
-
-    def if(reference = nil, &block)
-      raise NoMethodError("Conditional execution must be applied to a unit") unless @previously_added_node
-
-      guards = node_meta(@previously_added_node)[:guards] ||= []
-      guards << (reference || block)
-
-      self
-    end
-
-    def will(*args)
-      self.then(*args)
-    end
-
-    def then(unit = nil, options = {})
-      add_node(PlanNode.new(unit), options[:as]) unless unit.nil?
-      self
-    end
-
-    def unless(reference = nil, &block)
-      self.if { |refs| !self.instance_exec(refs, &(reference || block)) }
-      
-      self
-    end
-
-    def method_missing(method, *args, &block)
-      if MATCH_CONTINUATION_METHOD =~ method
-        obj = find_object($1)
-        return super if obj.nil?
-        self.then(obj, *args, &block)
-      elsif MATCH_CONTEXT_METHOD =~ method
-        obj = find_object($1)
-        return super if obj.nil?
-        @wrapper = obj.new
-        self
-      elsif @previously_added_node
-        if MATCH_RETURNING_METHOD =~ method
-          node_meta(@previously_added_node)[:as] = $1.to_sym
-        else
-          @previously_added_node.send(method, *args, &block)
-        end
-        self
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      (@previously_added_node && @previously_added_node.respond_to?(method)) || super
-    end
-
-    private
-      def add_node(node, as = nil)
-        id = generate_node_name
-
-        if @previously_added_node.nil?
-          @initial_node_key = id
-        else
-          @previously_added_node.next = id
-        end
-
-        @nodes[id] = node
-        @node_meta[id] = { as: as }
-        @previously_added_node = node
-
-        id
-      end
-
-      def execute_internal(result = Result.new, &block)
-        id = @initial_node_key
-
-        until (node = @nodes[id]).nil? do
-          execute_node(node, result) if guard_node(node, result.artifacts)
-          break unless result.success?
-          id = node.next
-        end
-
-        unless block.nil?
-          block.call(result)
-        end
-
-        result
-      end
-
-      def execute_node(node, result)
-        meta = node_meta(node)
-        publish_to = meta[:as]
-
-        begin
-          node_result = node.execute(result.artifacts)
-          result.add(publish_to, node_result) unless publish_to.nil?
-        rescue UnitError => error
-          result.add(publish_to || key_for_node(node), CarryOut::Error.new(error.error.message, error.error))
-        end
-      end
-
-      def find_object(name)
-        constant_name = name.to_s.split('_').map { |w| w.capitalize }.join('')
-
-        if @search.respond_to?(:call)
-          @search.call(constant_name)
-        else
-          containing_module = @search.find { |m| m.const_get(constant_name) rescue nil }
-          containing_module.const_get(constant_name) unless containing_module.nil?
-        end
-      end
-
-      def generate_node_name
-        id = @next_node_id ||= 1
-        @next_node_id += 1
-        "node_#{id}".to_sym
-      end
-
-      def guard_node(node, artifacts)
-        context = Context.new(artifacts)
-        guards = node_meta(node)[:guards]
-        guards.nil? || guards.map do |guard|
-          if guard.kind_of?(CarryOut::Reference)
-            reference_proc = -> (refs) { guard.call(refs) }
-          end
-
-          context.instance_exec(artifacts, &(reference_proc || guard))
-        end.all?
-      end
-
-      def key_for_node(node)
-        @nodes.key(node)
-      end
-
-      def node_meta(node)
-        @node_meta[key_for_node(node)]
-      end
-  end
-end

data/lib/carry_out/plan_node.rb

@@ -1,68 +0,0 @@
-module CarryOut
-  class PlanNode
-    attr_reader :next
-
-    def initialize(klass = nil)
-      @unitClass = klass
-      @messages = []
-    end
-
-    def method_missing(method, *args, &block)
-      if is_parameter_method?(*args, &block)
-        append_message(method, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      @unitClass.instance_methods.include?(method) || super
-    end
-
-    def execute(context)
-      unit = @unitClass.respond_to?(:execute) ? @unitClass : @unitClass.new
-
-      @messages.each do |message|
-        arg =
-          if message[:block]
-            Context.new(context).instance_exec(context, &message[:block])
-          else
-            message[:argument]
-          end
-
-        unit.send(message[:method], arg)
-      end
-
-      begin
-        unit.execute
-      rescue StandardError => error
-        raise UnitError.new(error)
-      end
-    end
-
-    def next=(value)
-      @next = value.to_sym
-    end
-
-    private
-      def append_message(method, *args, &block)
-        if !args.first.nil? && !block.nil?
-          raise ArgumentError.new("Arguments, references, and blocks are mutually exclusive")
-        end
-
-        if @unitClass.instance_methods.include?(method)
-          if args.first.kind_of?(Reference)
-            @messages << { method: method, block: -> (refs) { args.first.call(refs) } }
-          else
-            @messages << { method: method, argument: args.first || true, block: block }
-          end
-        else
-          raise NoMethodError.new("#{@unitClass} instances do not respond to `#{method}'", method, *args)
-        end
-      end
-      
-      def is_parameter_method?(*args, &block)
-        args.length <= 1 || (args.length == 0 && !block.nil?)
-      end
-  end
-end

data/lib/carry_out/reference.rb

@@ -1,22 +0,0 @@
-module CarryOut
-  class Reference
-
-    def initialize(*args)
-      @key_path = args
-    end
-
-    def call(context)
-      result = context
-      @key_path.each do |key|
-        if context.respond_to?(:has_key?) && context.has_key?(key)
-          result = context[key]
-        else
-          result = nil
-          break
-        end
-      end
-
-      result
-    end
-  end
-end

data/lib/carry_out/unit_error.rb

@@ -1,9 +0,0 @@
-module CarryOut
-  class UnitError < StandardError
-    attr_reader :error
-
-    def initialize(error)
-      @error = error
-    end
-  end
-end