carry_out 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48df2d9a646c48893cc2224a4167d522dd2c8e81
-  data.tar.gz: e928043f8032caccc5af2f111d31d8f94a348b26
+  metadata.gz: 15539f051ef8fbb7bde23ab9027e1a309b318eb6
+  data.tar.gz: 75df54ddbd00851be278a80faaa350e2483ad0c5
 SHA512:
-  metadata.gz: 2de51be35be58f48b5c02269631e6b731a5b61057c6f29b9c7cc3edf260a82aeee71b31a2c999b09ea412de6b125349a2b053d6d9a1c2f651b4536ee37596f8a
-  data.tar.gz: 86e7ad493a8175f7e426a6bd0b69d919d9f1ba8d633cc3cad86eef9734d7ba3890e3fad5c4cf9614130b091d2a85f2dade390f3fc91e5b1a422791c625f7e86d
+  metadata.gz: c9df9545f0b391a1f31471ecbc1b85a4f5257fd9399144c75d55643cb787620ac7486dc46de7ee297877779a975b7b3a1817ac14ad62b31172895f9a851c581c
+  data.tar.gz: 33bcc7bc1820b9c2dbd2bd8a084f6a8168d145e854d6ee50ad0fd0ae370ce8a8255ba0a361dadc97201b277353a5b6f1b1d283063d75935f7a3edac6702593dd

data/README.md

@@ -221,6 +221,53 @@ plan = CarryOut
   # 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 ]
+}
+```
+
+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
+CarryOut.defaults = {
+  search: -> (name) { name.constantize }
+}
+```
+
+#### Magic will\_, then\_, and within\_
+
+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.
+
+Using the default strategy as configured above:
+```ruby
+module MyModule1
+  class SayHello
+    def execute; puts "Hello!"; end
+  end
+end
+
+plan = CarryOut.will_say_hello
+```
+
+#### Magic returning\_as\_
+
+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))
+```
+
 ## 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.

data/carry_out.gemspec

@@ -24,10 +24,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '~> 2.0'
+  spec.required_ruby_version = '>= 1.9.3'
 
   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 "coveralls"
+  spec.add_development_dependency "coveralls", "~> 0.8"
+
+  if RUBY_VERSION < '2.0'
+    spec.add_development_dependency "tins", "~> 1.6.0"
+  end
 end

data/lib/carry_out/plan.rb

@@ -1,15 +1,17 @@
 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] || []
 
-      unless unit.nil?
-        self.then(unit, options)
-      end
+      self.then(unit, options) unless unit.nil?
     end
 
     def execute(context = nil, &block)
@@ -41,8 +43,8 @@ module CarryOut
       self.then(*args)
     end
 
-    def then(unit, options = {})
-      add_node(PlanNode.new(unit), options[:as])
+    def then(unit = nil, options = {})
+      add_node(PlanNode.new(unit), options[:as]) unless unit.nil?
       self
     end
 
@@ -53,8 +55,21 @@ module CarryOut
     end
 
     def method_missing(method, *args, &block)
-      if @previously_added_node
-        @previously_added_node.send(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
@@ -106,7 +121,18 @@ module CarryOut
           node_result = node.execute(result.artifacts)
           result.add(publish_to, node_result) unless publish_to.nil?
         rescue UnitError => error
-          result.add(publish_to || id, CarryOut::Error.new(error.error.message, error.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
 
@@ -121,8 +147,12 @@ module CarryOut
         guards.nil? || guards.map { |guard| guard.call(artifacts) }.all?
       end
 
+      def key_for_node(node)
+        @nodes.key(node)
+      end
+
       def node_meta(node)
-        @node_meta[@nodes.key(node)]
+        @node_meta[key_for_node(node)]
       end
   end
 end

data/lib/carry_out/version.rb

@@ -1,3 +1,3 @@
 module CarryOut
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/lib/carry_out.rb

@@ -9,15 +9,61 @@ require "carry_out/unit"
 require "carry_out/unit_error"
 
 module CarryOut
-  def self.get(*args)
-    Reference.new(*args)
+  MATCH_CONTINUATION_METHOD = /^will_/
+  MATCH_WITHIN_METHOD = /^within_/
+
+  class ConfiguredCarryOut
+    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
+    end
+
+    def will(*args)
+      create_plan.will(*args)
+    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.will(*args)
-    Plan.new(*args)
+  def self.defaults=(options = {})
+    @default_options = options
+    @default_carry_out = nil
   end
 
-  def self.within(unit = nil, &block)
-    Plan.new(nil, within: unit || block)
+  def self.method_missing(method, *args, &block)
+    default_carry_out.send(method, *args, &block)
   end
+
+  private
+    def self.default_options
+      @default_options ||= Hash.new
+    end
+
+    def self.default_carry_out
+      @default_carry_out ||= ConfiguredCarryOut.new(default_options)
+    end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carry_out
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Ryan Fields
@@ -56,16 +56,16 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 description: |2
       CarryOut connects units of logic into workflows.  Each unit can extend
       the DSL with parameter methods.  Artifacts and errors are collected as
@@ -106,9 +106,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="