trailblazer-operation 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f87d954977f1411476bf2e2e5dfb93eb611fa285
+  data.tar.gz: 8faa3e771214751c0b5eca3c2546a24ef1ffe589
+SHA512:
+  metadata.gz: c401fdbdb86bee4af234a1a9cbc3cc08c7062dda7bc264eb2d899d3b8ee1ac463d8a3a0f76a9a9504e21ad7f3d4268d7cc74dadf2196910fdd2022923328f598
+  data.tar.gz: 4faa6d2eef74f061c2125952b618ac6eda7aad652153e3550c0d645bcc42dab78b54b039fe898d9518c4aa27b6bcb1d910cc2b6586028d6b40ff7397a55e0ff2

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+before_install:
+  - gem install bundler
+matrix:
+  include:
+    - rvm: 1.9.3
+      gemfile: "test/gemfiles/Gemfile.ruby-1.9"
+    - rvm: 2.1
+      gemfile: Gemfile
+    - rvm: 2.3.1
+      gemfile: Gemfile

data/CHANGES.md

@@ -0,0 +1,16 @@
+## 0.0.2
+
+* Works.
+
+
+## TODO:
+
+* test and assure it still works in ruby 1.9.
+
+
+res = Op.()
+res.auth { redirect_to "/login" }
+res.double ( flash[:error] = "Record exist" }
+res.success { redirect_to res.model.path }
+
+endpoint: new layer for presentation/reaction

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in trailblazer.gemspec
+gemspec
+
+gem "multi_json"
+
+gem "dry-auto_inject"
+gem "dry-matcher"
+
+gem "minitest-line"
+gem "benchmark-ips"
+# gem "pipetree", path: "../pipetree"

data/README.md

@@ -0,0 +1,3 @@
+## Goal
+
+* Make `Operation` an imutable object without having to expose @instance variables. This is now done via the Result object.

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.verbose = true
+
+  test_files = FileList['test/*_test.rb']
+
+  if RUBY_VERSION == "1.9.3"
+    test_files = test_files - %w{test/dry_container_test.rb}
+
+  end
+
+  puts test_files.inspect
+  test.test_files = test_files
+end

data/lib/trailblazer/operation.rb

@@ -0,0 +1,23 @@
+require "declarative" # FIXME: here?
+require "trailblazer/operation/skill"
+require "trailblazer/operation/pipetree"
+require "trailblazer/operation/generic"
+require "trailblazer/operation/stepable"
+
+module Trailblazer
+  # The Trailblazer-style operation.
+  # Note that you don't have to use our "opinionated" version with result object, skills, etc.
+  class Operation
+    extend Declarative::Heritage::Inherited
+    extend Declarative::Heritage::DSL
+
+    extend Skill::Accessors # ::[] and ::[]=
+
+    include Pipetree        # ::call, ::|
+    # we want the skill dependency-mechanism.
+    extend Skill::Call      # ::call
+
+    # we want the initializer and the ::call method.
+    include Generic         # #initialize, #call, #process.
+  end
+end

data/lib/trailblazer/operation/generic.rb

@@ -0,0 +1,12 @@
+module Trailblazer
+  # Generic initializer for the operation.
+  module Operation::Generic
+    def initialize(skills={})
+      @skills = skills
+    end
+
+    # dependency injection interface
+    extend Uber::Delegates
+    delegates :@skills, :[], :[]=
+  end
+end

data/lib/trailblazer/operation/pipetree.rb

@@ -0,0 +1,82 @@
+require "pipetree"
+require "pipetree/flow"
+require "trailblazer/operation/result"
+require "uber/option"
+
+class Trailblazer::Operation
+  New     = ->(klass, options)     { klass.new(options) }                   # returns operation instance.
+  Process = ->(operation, options) { operation.process(options["params"]) }
+
+  # http://trailblazer.to/gems/operation/2.0/pipetree.html
+  module Pipetree
+    def self.included(includer)
+      includer.extend ClassMethods # ::call, ::inititalize_pipetree!
+      includer.extend DSL          # ::|, ::> and friends.
+
+      includer.initialize_pipetree!
+      includer.>> New, name: "operation.new"
+    end
+
+    module ClassMethods
+      # Top-level, this method is called when you do Create.() and where
+      # all the fun starts, ends, and hopefully starts again.
+      def call(options)
+        pipe = self["pipetree"] # TODO: injectable? WTF? how cool is that?
+
+        last, operation = pipe.(self, options) # operation == self, usually.
+
+        Result.new(last == ::Pipetree::Flow::Right, operation)
+      end
+
+      # This method would be redundant if Ruby had a Class::finalize! method the way
+      # Dry.RB provides it. It has to be executed with every subclassing.
+      def initialize_pipetree!
+        heritage.record :initialize_pipetree!
+        self["pipetree"] = ::Pipetree::Flow[]
+      end
+    end
+
+    module DSL
+      # They all inherit.
+      def >>(*args); _insert(:>>, *args) end
+      def >(*args); _insert(:>, *args) end
+      def &(*args); _insert(:&, *args) end
+      def <(*args); _insert(:<, *args) end
+
+      # :private:
+      def _insert(operator, proc, options={})
+        heritage.record(:_insert, operator, proc, options)
+        self["pipetree"].send(operator, Uber::Option[proc], options) # ex: pipetree.> Validate, after: Model::Build
+      end
+
+      def ~(cfg)
+        heritage.record(:~, cfg)
+
+        self.|(cfg, inheriting: true) # FIXME: not sure if this is the final API.
+      end
+
+      def |(cfg, user_options={}) # sorry for the magic here, but still playing with the DSL.
+        if cfg.is_a?(Stepable) # e.g. Contract::Validate
+          import = Import.new(self, user_options)
+
+          return cfg.import!(self, import) &&
+            heritage.record(:|, cfg, user_options)
+        end
+
+        self.> cfg, user_options # calls heritage.record
+      end
+
+      # Try to abstract as much as possible from the imported module. This is for
+      # forward-compatibility.
+      Import = Struct.new(:operation, :user_options) do
+        def call(operator, step, options)
+          operation["pipetree"].send operator, step, options.merge(user_options)
+        end
+
+        def inheriting?
+          user_options[:inheriting]
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/operation/result.rb

@@ -0,0 +1,27 @@
+class Trailblazer::Operation
+  class Result
+    def initialize(success, data)
+      @success, @data = success, data
+    end
+
+    extend Uber::Delegates
+    delegates :@data, :[]
+
+    def success?
+      @success
+    end
+
+    def failure?
+      ! success?
+    end
+
+    # DISCUSS: the two methods below are more for testing.
+    def inspect
+      "<Result:#{success?} #{@data.inspect} >"
+    end
+
+    def slice(*keys)
+      keys.collect { |k| self[k] }
+    end
+  end
+end

data/lib/trailblazer/operation/skill.rb

@@ -0,0 +1,31 @@
+require "trailblazer/skill"
+require "uber/delegates"
+
+# Dependency ("skill") management for Operation.
+# Op::[]
+# Op::[]=
+# Writing, even with an existing name, will never mutate a container.
+# Op#[]
+# Op#[]=
+# Op.(params, { "constructor" => competences })
+class Trailblazer::Operation
+  module Skill
+    # The class-level skill container: Operation::[], ::[]=.
+    module Accessors
+      # :private:
+      def skills
+        @skills ||= {}
+      end
+
+      extend Uber::Delegates
+      delegates :skills, :[], :[]=
+    end
+
+    # Overrides Operation::call, creates the Skill hash and passes it to :call.
+    module Call
+      def call(params={}, options={}, *dependencies)
+        super Trailblazer::Skill.new(mutual={}, options.merge("params" => params), *dependencies, self.skills)
+      end
+    end
+  end
+end

data/lib/trailblazer/operation/stepable.rb

@@ -0,0 +1,17 @@
+class Trailblazer::Operation
+  module Stepable
+    Configuration = Struct.new(:mod, :args, :block) do
+      include Stepable # mark it, so that ::| thinks this is a step module.
+
+      def import!(operation, import)
+        mod.import!(operation, import, *args)
+      end
+    end
+
+    def [](*args, &block)
+      # When called like Builder["builder.crud"], create a proxy
+      # object and Pipeline::| calls #import! on it.
+      Configuration.new(self, args, block)
+    end
+  end
+end

data/lib/trailblazer/operation/version.rb

@@ -0,0 +1,7 @@
+module Trailblazer
+  # The Trailblazer-style operation.
+  # Note that you don't have to use our "opinionated" version with result object, skills, etc.
+  class Operation
+    VERSION = "0.0.2"
+  end
+end

data/lib/trailblazer/skill.rb

@@ -0,0 +1,39 @@
+# TODO: mark/make all but mutable_options as frozen.
+module Trailblazer
+  class Skill
+    def initialize(mutuable_options, *containers)
+      @mutuable_options = mutuable_options
+      @resolver         = Resolver.new(@mutuable_options, *containers)
+    end
+
+    def [](name)
+      @resolver[name]
+    end
+
+    def []=(name, value)
+      @mutuable_options[name] = value
+    end
+
+    # Look through a list of containers until you find the skill.
+    class Resolver
+    # alternative implementation:
+    # containers.reverse.each do |container| @mutuable_options.merge!(container) end
+    #
+    # benchmark, merging in #initialize vs. this resolver.
+    #                merge     39.678k (± 9.1%) i/s -    198.700k in   5.056653s
+    #             resolver     68.928k (± 6.4%) i/s -    342.836k in   5.001610s
+      def initialize(*containers)
+        @containers = containers
+      end
+
+      def [](name)
+        @containers.find { |container| container.key?(name) && (return container[name]) }
+      end
+    end
+
+    # private API.
+    def inspect
+      "<Skill #{@resolver.instance_variable_get(:@containers).collect { |c| c.inspect }.join(" ")}>"
+    end
+  end
+end

data/test/benchmark/skill_resolver_benchmark.rb

@@ -0,0 +1,43 @@
+require "trailblazer/operation"
+require "benchmark/ips"
+
+initialize_hash = {}
+10.times do |i|
+  initialize_hash["bla_#{i}"] = i
+end
+
+normal_container = {}
+50.times do |i|
+  normal_container["xbla_#{i}"] = i
+end
+
+
+Benchmark.ips do |x|
+  x.report(:merge) {
+    attrs = normal_container.merge(initialize_hash)
+    10.times do |i|
+      attrs["bla_8"]
+    end
+    10.times do |i|
+      attrs["xbla_1"]
+    end
+  }
+
+  x.report(:resolver) {
+    attrs = Trailblazer::Skill::Resolver.new(initialize_hash, normal_container)
+
+    10.times do |i|
+      attrs["bla_8"]
+    end
+    10.times do |i|
+      attrs["xbla_1"]
+    end
+  }
+end
+
+# Warming up --------------------------------------
+#                merge     3.974k i/100ms
+#             resolver     6.593k i/100ms
+# Calculating -------------------------------------
+#                merge     39.678k (± 9.1%) i/s -    198.700k in   5.056653s
+#             resolver     68.928k (± 6.4%) i/s -    342.836k in   5.001610s

data/test/call_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+# DISCUSS: do we need this test?
+class CallTest < Minitest::Spec
+  describe "::call" do
+    class Create < Trailblazer::Operation
+      def inspect
+        "#{@skills.inspect}"
+      end
+    end
+
+    it { Create.().must_be_instance_of Trailblazer::Operation::Result }
+
+    it { Create.({}).inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{}} {\"pipetree\"=>[>>operation.new]}> >} }
+    it { Create.(name: "Jacob").inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>>operation.new]}> >} }
+    it { Create.({ name: "Jacob" }, { policy: Object }).inspect.must_equal %{<Result:true <Skill {} {:policy=>Object, \"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>>operation.new]}> >} }
+
+    #---
+    # success?
+    class Update < Trailblazer::Operation
+      self.& ->(input, options) { input["params"] }, after: "operation.new"
+    end
+
+    it { Update.(true).success?.must_equal true }
+    it { Update.(false).success?.must_equal false }
+  end
+end
+

data/test/dry_container_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+require "dry/container"
+
+class DryContainerTest < Minitest::Spec
+  my_container = Dry::Container.new
+  my_container.register("user_repository", -> { Object })
+  my_container.namespace("contract") do
+    register("create") { Array }
+  end
+
+  class Create < Trailblazer::Operation
+  end
+
+  it { Create.({}, {}, my_container)["user_repository"].must_equal Object }
+  it { Create.({}, {}, my_container)["contract.create"].must_equal Array }
+  # also allows our own options PLUS containers.
+  it { Create.({}, { "model" => String }, my_container)["model"].must_equal String }
+  it { Create.({}, { "model" => String }, my_container)["user_repository"].must_equal Object }
+  it { Create.({}, { "user_repository" => Fixnum }, my_container)["user_repository"].must_equal Fixnum }
+end

data/test/gemfiles/Gemfile.ruby-1.9

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec path: "../../"

data/test/gemfiles/Gemfile.ruby-1.9.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: ../../
+  specs:
+    trailblazer-operation (2.0.0)
+      declarative
+      pipetree (>= 0.0.4, < 0.1.0)
+      uber (>= 0.1.0, < 0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    declarative (0.0.8)
+      uber (>= 0.0.15)
+    minitest (5.9.1)
+    pipetree (0.0.4)
+    rake (11.3.0)
+    uber (0.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  minitest
+  rake
+  trailblazer-operation!
+
+BUNDLED WITH
+   1.13.6

data/test/gemfiles/Gemfile.ruby-2.3

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gemspec path: "../../"
+
+gem "dry-auto_inject"
+gem "dry-matcher"

data/test/gemfiles/Gemfile.ruby-2.3.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: ../../
+  specs:
+    trailblazer-operation (2.0.0)
+      declarative
+      pipetree (>= 0.0.4, < 0.1.0)
+      uber (>= 0.1.0, < 0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.2)
+    declarative (0.0.8)
+      uber (>= 0.0.15)
+    dry-auto_inject (0.4.2)
+      dry-container (>= 0.3.4)
+    dry-configurable (0.3.0)
+      concurrent-ruby (~> 1.0)
+    dry-container (0.5.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-matcher (0.5.0)
+    minitest (5.9.1)
+    pipetree (0.0.4)
+    rake (11.3.0)
+    uber (0.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  dry-auto_inject
+  dry-matcher
+  minitest
+  rake
+  trailblazer-operation!
+
+BUNDLED WITH
+   1.12.5

data/test/inheritance_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class InheritanceTest < Minitest::Spec
+  Song = Struct.new(:id, :title, :length) do
+    def self.find_by(options); options[:id].nil? ? nil : new(options[:id]) end
+  end
+
+  class Create < Trailblazer::Operation
+    self["a"] = "A"
+    self["b"] = "B"
+    self["c"] = "D"
+
+    def self.class(*skills)
+      Class.new(Trailblazer::Operation). tap do |klass|
+        skills.each { |skill| klass.heritage.record(:[]=, skill, self[skill]) }
+      end
+    end
+  end
+
+  class Update < Create.class("a", "b")
+  end
+
+  it do
+    Update["a"].must_equal "A"
+    Update["b"].must_equal "B"
+    Update["c"].must_equal nil
+  end
+end

data/test/operation_skill_test.rb

@@ -0,0 +1,90 @@
+require "test_helper"
+
+class OperationSkillTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+  end
+
+  # no dependencies provided.
+  it { Create.()[:not_existent].must_equal nil }
+  # dependencies provided.
+  it { Create.({}, contract: Object)[:not_existent].must_equal nil }
+  it { Create.({}, contract: Object)[:contract].must_equal Object }
+end
+
+class OperationCompetenceTest < Minitest::Spec
+  Call = ->(input, options) { input.call }
+  # Operation#[]
+  # Operation#[]=
+  # arbitrary options can be saved via Op#[].
+  class Create < Trailblazer::Operation
+    self.> Call
+
+    def call(*)
+      self["drink"] = "Little Creatures"
+      self["drink"]
+    end
+  end
+
+  it { Create.()["drink"].must_equal "Little Creatures" }
+  # instance can override constructor options.
+  it { Create.({}, "drink" => "Four Pines")["drink"].must_equal "Little Creatures" }
+  # original hash doesn't get changed.
+  it do
+    Create.({}, hash = { "drink" => "Four Pines" })
+    hash.must_equal( { "drink" => "Four Pines" })
+  end
+
+
+  # Operation::[]
+  # Operation::[]=
+  class Update < Trailblazer::Operation
+    self.> Call
+
+    self["drink"] = "Beer"
+
+    def call(*)
+      self["drink"]
+    end
+  end
+
+  it { Update["drink"].must_equal "Beer" }
+
+  # class-level are available on instance-level via Op#[]
+  it { Update.()["drink"].must_equal "Beer" }
+
+  # runtime constructor options can override class-level.
+  it { Update.({}, "drink" => "Little Creatures")["drink"].must_equal "Little Creatures" }
+
+  # instance can override class-level
+  class Delete < Trailblazer::Operation
+    self.> Call
+
+    self["drink"] = "Beer"
+
+    def call(*)
+      self["drink"] = "Little Creatures"
+      self["drink"]
+    end
+  end
+
+  # Op#[]= can override class-level...
+  it { Delete.()["drink"].must_equal "Little Creatures" }
+  # ...but it doesn't change class-level.
+  it { Delete["drink"].must_equal "Beer" }
+
+  # we don't really need this test.
+  class Reward < Trailblazer::Operation
+    self["drink"] = "Beer"
+  end
+
+  it { Reward.()["drink"].must_equal "Beer" }
+end
+
+# {
+#   user_repository: ..,
+#   current_user: ..,
+# }
+
+
+# 1. initialize(params, {})
+# 2. extend AutoInject[] shouldn't override constructor but simply pass injected dependencies in second arg (by adding dependencies to hash).

data/test/pipetree_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class PipetreeTest < Minitest::Spec
+  module Validate
+    extend Trailblazer::Operation::Stepable
+
+    def self.import!(operation, pipe)
+      pipe.(:>, ->{ snippet }, name: "validate", before: "operation.new")
+    end
+  end
+
+  #---
+  # ::|
+  # without options
+  class Create < Trailblazer::Operation
+    self.| Validate[]
+  end
+
+  it { Create["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
+
+  # without any options or []
+  class New < Trailblazer::Operation
+    self.| Validate
+  end
+
+  it { New["pipetree"].inspect.must_equal %{[>validate,>>operation.new]} }
+
+  # with options
+  class Update < Trailblazer::Operation
+    self.| Validate, after: "operation.new"
+  end
+
+  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,>validate]} }
+
+  # with :symbol
+  class Delete < Trailblazer::Operation
+    self.| :call!
+
+    def call!(options)
+      self["x"] = options["params"]
+    end
+  end
+
+  it { Delete.("yo")["x"].must_equal "yo" }
+
+  # proc arguments
+  class Forward < Trailblazer::Operation
+    self.| ->(input, options) { puts "@@@@@ #{input.inspect}"; puts "@@@@@ #{options.inspect}" }
+  end
+
+  it { skip; Forward.({ id: 1 }) }
+
+  #---
+  # ::>, ::<, ::>>, :&
+  # with proc, method, callable.
+  class Right < Trailblazer::Operation
+    self.> ->(input, options) { options[">"] = options["params"][:id] }
+
+    self.> :method_name!
+    def method_name!(options); self["method_name!"] = options["params"][:id] end
+
+    class MyCallable
+      include Uber::Callable
+      def call(operation, options); operation["callable"] = options["params"][:id] end
+    end
+    self.> MyCallable.new
+  end
+
+  it { Right.( id: 1 ).slice(">", "method_name!", "callable").must_equal [1, 1, 1] }
+  it { Right["pipetree"].inspect.must_equal %{[>>operation.new,>self,>return,>#<PipetreeTest::Right::MyCallable:>]} }
+
+  #---
+  # inheritance
+  class Righter < Right
+    self.> ->(input, options) { options["righter"] = true }
+  end
+
+  it { Righter.( id: 1 ).slice(">", "method_name!", "callable", "righter").must_equal [1, 1, 1, true] }
+end
+
+
+# args: operation, skills

data/test/result_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+class ResultTest < Minitest::Spec
+  let (:success) { Trailblazer::Operation::Result.new(true, "x"=> String) }
+  it { success.success?.must_equal true }
+  it { success.failure?.must_equal false }
+  # it { success["success?"].must_equal true }
+  # it { success["failure?"].must_equal false }
+  it { success["x"].must_equal String }
+  it { success["not-existant"].must_equal nil }
+  it { success.slice("x").must_equal [String] }
+  it { success.inspect.must_equal %{<Result:true {\"x\"=>String} >} }
+
+  class Create < Trailblazer::Operation
+    self.> ->(input, options) { input.call }
+
+    def call(*)
+      self[:message] = "Result objects are actually quite handy!"
+    end
+  end
+
+  # #result[]= allows to set arbitrary k/v pairs.
+  it { Create.()[:message].must_equal "Result objects are actually quite handy!" }
+end

data/test/skill_test.rb

@@ -0,0 +1,61 @@
+require "test_helper"
+require "trailblazer/skill"
+
+class SkillTest < Minitest::Spec
+  describe "Skill" do
+    it do
+      class_level_container = {
+        "contract.class" => Object,
+        "model.class" => String
+      }
+
+      runtime_skills = {
+        "contract" => MyContract=Class.new,
+        "model.class" => Integer
+      }
+
+      mutable_options = {}
+
+      skill = Trailblazer::Skill.new(mutable_options, runtime_skills, class_level_container)
+
+      # non-existent key.
+      skill[:nope].must_equal nil
+
+      # from runtime.
+      skill["contract"].must_equal MyContract
+      # from compile-time.
+      skill["contract.class"].must_equal Object
+      # runtime supersedes compile-time.
+      skill["model.class"].must_equal Integer
+
+      skill["model.class"] = Fixnum
+      skill["model.class"].must_equal Fixnum
+
+      # add new tuple.
+      skill["user.current"] = "Todd"
+
+      # options we add get added to the hash.
+      mutable_options.inspect.must_equal %{{"model.class"=>Fixnum, "user.current"=>"Todd"}}
+      # original container don't get changed
+      class_level_container.inspect.must_equal %{{"contract.class"=>Object, "model.class"=>String}}
+      runtime_skills.inspect.must_equal %{{"contract"=>SkillTest::MyContract, "model.class"=>Integer}}
+
+      # setting false.
+      skill[:valid] = false
+      skill[:valid].must_equal false
+
+      # setting nil.
+      skill[:valid] = nil
+      skill[:valid].must_equal nil
+    end
+  end
+end
+# resolve: prefer @instance_attrs over competences
+#   or instace_atrt is competences
+
+# dependencies = { current_user: Runtime::User..., container: BLA }
+# dependencies[:current_user]
+# dependencies["user.create.contract"] # delegates to container, somehow.
+
+# Create.(params, dependencies) # not sure if op should build this runtime dependencies hash or if it comes from outside.
+

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require "minitest/autorun"
+require "trailblazer/operation"

data/trailblazer-operation.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'trailblazer/operation/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "trailblazer-operation"
+  spec.version       = Trailblazer::Operation::VERSION
+  spec.authors       = ["Nick Sutterer"]
+  spec.email         = ["apotonick@gmail.com"]
+  spec.description   = %q{Trailblazer's operation object.}
+  spec.summary       = %q{Trailblazer's operation object with dependency management and pipetree flow.}
+  spec.homepage      = "http://trailblazer.to"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+
+  spec.add_dependency "uber", ">= 0.1.0", "< 0.2.0"
+  spec.add_dependency "declarative"
+  spec.add_dependency "pipetree", ">= 0.0.4", "< 0.1.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+
+  spec.required_ruby_version = '>= 1.9.3'
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: trailblazer-operation
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Nick Sutterer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: uber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: declarative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pipetree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Trailblazer's operation object.
+email:
+- apotonick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/trailblazer/operation.rb
+- lib/trailblazer/operation/generic.rb
+- lib/trailblazer/operation/pipetree.rb
+- lib/trailblazer/operation/result.rb
+- lib/trailblazer/operation/skill.rb
+- lib/trailblazer/operation/stepable.rb
+- lib/trailblazer/operation/version.rb
+- lib/trailblazer/skill.rb
+- test/benchmark/skill_resolver_benchmark.rb
+- test/call_test.rb
+- test/dry_container_test.rb
+- test/gemfiles/Gemfile.ruby-1.9
+- test/gemfiles/Gemfile.ruby-1.9.lock
+- test/gemfiles/Gemfile.ruby-2.3
+- test/gemfiles/Gemfile.ruby-2.3.lock
+- test/inheritance_test.rb
+- test/operation_skill_test.rb
+- test/pipetree_test.rb
+- test/result_test.rb
+- test/skill_test.rb
+- test/test_helper.rb
+- trailblazer-operation.gemspec
+homepage: http://trailblazer.to
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.3
+signing_key: 
+specification_version: 4
+summary: Trailblazer's operation object with dependency management and pipetree flow.
+test_files:
+- test/benchmark/skill_resolver_benchmark.rb
+- test/call_test.rb
+- test/dry_container_test.rb
+- test/gemfiles/Gemfile.ruby-1.9
+- test/gemfiles/Gemfile.ruby-1.9.lock
+- test/gemfiles/Gemfile.ruby-2.3
+- test/gemfiles/Gemfile.ruby-2.3.lock
+- test/inheritance_test.rb
+- test/operation_skill_test.rb
+- test/pipetree_test.rb
+- test/result_test.rb
+- test/skill_test.rb
+- test/test_helper.rb