trailblazer 1.1.2 → 2.0.0.beta1

data/Rakefile

@@ -5,6 +5,25 @@ task :default => [:test]
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
-  test.test_files = FileList['test/**/*_test.rb']
+  # test.test_files = FileList['test/**/*_test.rb']
+  test_files = FileList[%w{
+    test/operation/guard_test.rb
+    test/operation/pundit_test.rb
+    test/operation/builder_test.rb
+    test/operation/model_test.rb
+    test/operation/contract_test.rb
+    test/operation/persist_test.rb
+    test/operation/callback_test.rb
+    test/operation/resolver_test.rb
+    test/operation/dsl/contract_test.rb
+
+    test/docs/*_test.rb
+    }]
+
+  if RUBY_VERSION == "1.9.3"
+    test_files = test_files - %w{test/docs/dry_test.rb test/docs/auto_inject_test.rb}
+  end
+
+  test.test_files = test_files
   test.verbose = true
-end
+end

data/draft-1.2.rb

@@ -0,0 +1,7 @@
+representer :deserializer, Representer::Create (do)
+  or
+Op.(representer.deserializer.class: Representer::Create)
+
+
+representer!(name)
+  @options[representer.deserializer.class] || self.class[representer.deserializer.class]

data/lib/trailblazer.rb

@@ -1,7 +1,20 @@
 require "trailblazer/operation"
+require "trailblazer/operation/pipetree"
+
+require "trailblazer/dsl"
 require "trailblazer/version"
-require "uber/inheritable_attr"
 
-module Trailblazer
-  # Your code goes here...
-end
+require "trailblazer/operation/builder"
+require "trailblazer/operation/model"
+require "trailblazer/operation/contract"
+require "trailblazer/operation/validate"
+require "trailblazer/operation/representer"
+require "trailblazer/operation/present"
+require "trailblazer/operation/policy"
+require "trailblazer/operation/pundit"
+require "trailblazer/operation/guard"
+require "trailblazer/operation/persist"
+# require "trailblazer/operation/callback"
+require "trailblazer/operation/nested"
+require "trailblazer/operation/wrap"
+require "trailblazer/operation/rescue"

data/lib/trailblazer/dsl.rb

@@ -0,0 +1,47 @@
+module Trailblazer
+  module DSL
+    # Boring DSL code that allows to set a skill class, or define it ad-hoc using a block.
+    # passing a constant always wipes out the existing class.
+    #
+    # Used in Contract, Representer, Callback, ..
+    class Build
+      # options[:prefix]
+      # options[:class]
+      # options[:container]
+
+      # Currently, adds .class only to classes. this could break builder instances?
+
+      def call(options, name=nil, constant=nil, dsl_block, &block)
+        # contract MyForm
+        if name.is_a?(Class)
+          constant = name
+          name     = :default
+        end
+
+        is_instance = !(constant.kind_of?(Class) || dsl_block) # i don't like this magic too much, but since it's the only DSL method in TRB, it should be ok. # DISCUSS: options[:is_instance]
+
+        path = path_name(options[:prefix], name, is_instance ? nil : "class") # "contract.default.class"
+
+        if is_instance
+          skill = constant
+        else
+          extended = options[:container][path] # Operation["contract.default.class"]
+          extended = yield extended if extended && block_given?
+
+          # only extend an existing skill class when NO constant was passed.
+          constant = (extended || options[:class]) if constant.nil?# && block_given?
+
+          skill = Class.new(constant)
+          skill.class_eval(&dsl_block) if dsl_block
+        end
+
+        [path, skill]
+      end
+
+    private
+      def path_name(prefix, name, suffix)
+        [prefix, name, suffix].compact.join(".") # "contract.class" for default, otherwise "contract.params.class" etc.
+      end
+    end
+  end
+end

data/lib/trailblazer/operation/auto_inject.rb

@@ -0,0 +1,47 @@
+require "dry/auto_inject"
+
+class Trailblazer::Operation
+  # Thanks, @timriley! <3
+  # https://gist.github.com/timriley/d314a58da9784912159006e208ba8ea9
+  module AutoInject
+    class InjectStrategy < Module
+      ClassMethods = Class.new(Module)
+
+      attr_reader :container
+      attr_reader :dependency_map
+      attr_reader :class_mod
+
+      def initialize(container, *dependency_names)
+        @container = container
+        @dependency_map = Dry::AutoInject::DependencyMap.new(*dependency_names)
+        @class_mod = ClassMethods.new
+      end
+
+      def included(klass)
+        define_call
+
+        klass.singleton_class.prepend @class_mod
+
+        super
+      end
+
+      private
+
+      def define_call
+        class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+          define_method :call do |params={}, options={}, *dependencies|
+            options_with_deps = dependency_map.to_h.each_with_object({}) { |(name, identifier), obj|
+              obj[name] = options[name] || container[identifier]
+            }.merge(options)
+
+            super(params, options_with_deps, *dependencies)
+          end
+        end
+      end
+    end
+  end
+
+  def self.AutoInject(container)
+    Dry::AutoInject(container, strategies: {default: AutoInject::InjectStrategy})
+  end
+end

data/lib/trailblazer/operation/builder.rb

@@ -1,26 +1,26 @@
 require "uber/builder"
 
-# Allows to add builders via ::builds.
-module Trailblazer::Operation::Builder
-  def self.extended(extender)
-    extender.send(:include, Uber::Builder)
-  end
+# http://trailblazer.to/gems/operation/2.0/builder.html
+class Trailblazer::Operation
+  module Builder
+    def self.import!(operation, import, user_builder)
+      import.(:>>, user_builder,
+        name:   "builder.call",
+        before: "operation.new")
 
-  def builder_class
-    @builders
-  end
+      false # suppress inheritance. dislike. FIXME at some point.
+    end
 
-  def builder_class=(constant)
-    @builders = constant
-  end
+    # Include this when you want the ::builds DSL.
+    def self.included(includer)
+      includer.extend DSL # ::builds, ::builders
+      includer.| includer.Builder( includer.builders ) # pass class Builders object to our ::import!.
+    end
 
-private
-  # Runs the builders for this operation class to figure out the actual class.
-  def build_operation_class(*args)
-    class_builder(self).(*args) # Uber::Builder::class_builder(context)
+    DSL = Uber::Builder::DSL
   end
 
-  def build_operation(params, options={})
-    build_operation_class(params).new(params, options)
+  def self.Builder(*args, &block)
+    [ Builder, args, block ]
   end
-end
+end

data/lib/trailblazer/operation/callback.rb

@@ -1,53 +1,46 @@
 require "declarative"
 require "disposable/callback"
 
-module Trailblazer::Operation::Callback
-  def self.included(base)
-    base.extend ClassMethods
-
-    base.extend Declarative::Heritage::Inherited
-    base.extend Declarative::Heritage::DSL
-  end
-
-  def callback!(name=:default, options={ operation: self, contract: contract, params: @params }) # FIXME: test options.
-    config  = self.class.callbacks.fetch(name) # TODO: test exception
-    group   = config[:group].new(contract)
-
-    options[:context] ||= (config[:context] == :operation ? self : group)
-    group.(options)
+# Needs #[], #[]= skill dependency.
+class Trailblazer::Operation
+  module Callback
+    def self.import!(operation, import, group)
+      import.(:&, ->(input, options) { input.callback!(group) },
+        name: "callback.#{group}")
+
+      operation.send :include, self
+    end
 
-    invocations[name] = group
-  end
+    def callback!(name=:default, options=self) # FIXME: test options.
+      config  = self["callback.#{name}.class"] || raise #.fetch(name) # TODO: test exception
+      group   = config[:group].new(self["contract.default"])
 
-  def dispatch!(*args, &block)
-    callback!(*args, &block)
-  end
+      options[:context] ||= (config[:context] == :operation ? self : group)
+      group.(options)
 
-  def invocations
-    @invocations ||= {}
-  end
-
-  module ClassMethods
-    def callbacks
-      @callbacks ||= {}
+      invocations[name] = group
     end
 
-    def callback(name=:default, constant=nil, &block)
-      return callbacks[name][:group] unless constant or block_given?
-
-      add_callback(name, constant, &block)
+    def invocations
+      @invocations ||= {}
     end
 
-  private
-    def add_callback(name, constant, &block)
-      heritage.record(:add_callback, name, constant, &block)
+    module DSL
+      def callback(name=:default, constant=nil, &block)
+        heritage.record(:callback, name, constant, &block)
 
-      callbacks[name] ||= {
-        group:   Class.new(constant || Disposable::Callback::Group),
-        context: constant ? nil : :operation # `context: :operation` when the callback is inline. `context: group` otherwise.
-      }
+        # FIXME: make this nicer. we want to extend same-named callback groups.
+        # TODO: allow the same with contract, or better, test it!
+        extended = self["callback.#{name}.class"] && self["callback.#{name}.class"]
 
-      callbacks[name][:group].class_eval(&block) if block_given?
+        path, group_class = Trailblazer::DSL::Build.new.({ prefix: :callback, class: Disposable::Callback::Group, container: self }, name, constant, block) { |extended| extended[:group] }
+
+        self[path] = { group: group_class, context: constant ? nil : :operation }
+      end
     end
   end
+
+  def self.Callback(*args, &block)
+    [ Callback, args, block ]
+  end
 end

data/lib/trailblazer/operation/contract.rb

@@ -0,0 +1,46 @@
+# Best practices for using contract.
+#
+# * inject contract instance via constructor to #contract
+# * allow contract setup and memo via #contract(model, options)
+# * allow implicit automatic setup via #contract and class.contract_class
+#
+# Needs Operation#model.
+# Needs #[], #[]= skill dependency.
+module Trailblazer::Operation::Contract
+  module Build
+    # bla build contract at runtime.
+    def self.build_contract!(operation, options, name:"default", constant:nil, builder: nil)
+      # TODO: we could probably clean this up a bit at some point.
+      contract_class = constant || options["contract.#{name}.class"]
+      model          = operation["model"] # FIXME: model.default
+
+      return operation["contract.#{name}"] = Uber::Option[builder].(operation, constant: contract_class, model: model) if builder
+
+      operation["contract.#{name}"] = contract_class.new(model)
+    end
+
+    def self.import!(operation, import, **args)
+      import.(:>, ->(operation, options) { build_contract!(operation, options, **args) },
+        name: "contract.build")
+    end
+  end
+
+  def self.Build(*args, &block)
+    [ Build, args, block ]
+  end
+
+  module DSL
+    # This is the class level DSL method.
+    #   Op.contract #=> returns contract class
+    #   Op.contract do .. end # defines contract
+    #   Op.contract CommentForm # copies (and subclasses) external contract.
+    #   Op.contract CommentForm do .. end # copies and extends contract.
+    def contract(name=:default, constant=nil, base: Reform::Form, &block)
+      heritage.record(:contract, name, constant, &block)
+
+      path, form_class = Trailblazer::DSL::Build.new.({ prefix: :contract, class: base, container: self }, name, constant, block)
+
+      self[path] = form_class
+    end
+  end # Contract
+end

data/lib/trailblazer/operation/controller.rb

@@ -1,19 +1,17 @@
-require "trailblazer/endpoint"
-
 module Trailblazer::Operation::Controller
 private
   def form(operation_class, options={})
-    res, op, options = operation!(operation_class, options)
-    op.contract.prepopulate!(options) # equals to @form.prepopulate!
+    res, options = operation_for!(operation_class, options) { |params| { operation: operation_class.present(params) } }
+    res.contract.prepopulate!(options) # equals to @form.prepopulate!
 
-    op.contract
+    res.contract
   end
 
   # Provides the operation instance, model and contract without running #process.
   # Returns the operation.
   def present(operation_class, options={})
-    res, op = operation!(operation_class, options.merge(skip_form: true))
-    op
+    res, options = operation_for!(operation_class, options.merge(skip_form: true)) { |params| { operation: operation_class.present(params) } }
+    res # FIXME.
   end
 
   def collection(*args)
@@ -23,11 +21,11 @@ private
   end
 
   def run(operation_class, options={}, &block)
-    res, op = operation_for!(operation_class, options) { |params| operation_class.run(params) }
+    res = operation_for!(operation_class, options) { |params| operation_class.(params) }
 
-    yield op if res and block_given?
+    yield res if res[:valid] and block_given?
 
-    op
+    res # FIXME.
   end
 
   # The block passed to #respond is always run, regardless of the validity result.
@@ -40,33 +38,53 @@ private
   end
 
 private
-  def operation!(operation_class, options={}) # or #model or #setup.
-    operation_for!(operation_class, options) { |params| [true, operation_class.present(params)] }
-  end
-
   def process_params!(params)
   end
 
-  # Override and return arbitrary params object.
-  def params!(params)
-    params
-  end
-
   # Normalizes parameters and invokes the operation (including its builders).
   def operation_for!(operation_class, options, &block)
     params = options[:params] || self.params # TODO: test params: parameter properly in all 4 methods.
-    params = params!(params)
     process_params!(params) # deprecate or rename to #setup_params!
 
-    res, op = Trailblazer::Endpoint.new(operation_class, params, request, options).(&block)
-    setup_operation_instance_variables!(op, options)
+    res = Endpoint.new(operation_class, params, request, options).(&block)
+    setup_operation_instance_variables!(res, options)
+
+    [res, options.merge(params: params)]
+  end
 
-    [res, op, options.merge(params: params)]
+  def setup_operation_instance_variables!(result, options)
+    @operation = result # FIXME: remove!
+    @model     = result["model"]
+    @form      = result["contract"] unless options[:skip_form]
   end
 
-  def setup_operation_instance_variables!(operation, options)
-    @operation = operation
-    @model     = operation.model
-    @form      = operation.contract unless options[:skip_form]
+  # Encapsulates HTTP-specific logic needed before running an operation.
+  # Right now, all this does is #document_body! which figures out whether or not to pass the request body
+  # into params, so the operation can use a representer to deserialize the original document.
+  # To be used in Hanami, Roda, Rails, etc.
+  class Endpoint
+    def initialize(operation_class, params, request, options)
+      @operation_class = operation_class
+      @params          = params
+      @request         = request
+      @is_document     = options[:is_document]
+    end
+
+    def call
+      document_body! if @is_document
+      yield @params# Create.run(params)
+    end
+
+  private
+    attr_reader :params, :operation_class, :request
+
+    def document_body!
+      # this is what happens:
+      # respond_with Comment::Update::JSON.run(params.merge(comment: request.body.string))
+      concept_name = operation_class.model_class.to_s.underscore # this could be renamed to ::concept_class soon.
+      request_body = request.body.respond_to?(:string) ? request.body.string : request.body.read
+
+      params.merge!(concept_name => request_body)
+    end
   end
 end