trailblazer-endpoint 0.0.4 → 0.0.5

data/lib/trailblazer/endpoint/dsl.rb

@@ -2,7 +2,7 @@ module Trailblazer
   class Endpoint
     module DSL
       # Run before the endpoint is invoked. This collects the blocks from the controller.
-      class Runtime < Struct.new(:args, :success_block, :failure_block, :protocol_failure_block)
+      class Runtime < Struct.new(:options, :success_block, :failure_block, :protocol_failure_block)
 
         def failure(&block)
           self.failure_block = block
@@ -17,8 +17,11 @@ module Trailblazer
         end
 
         # #call
-        def to_args
-          return args, {success_block: success_block, failure_block: failure_block, protocol_failure_block: protocol_failure_block}
+        def to_args(default_block_options)
+          return options,
+            success_block:          success_block || default_block_options[:success_block],
+            failure_block:          failure_block || default_block_options[:failure_block],
+            protocol_failure_block: protocol_failure_block || default_block_options[:protocol_failure_block]
         end
       end
     end

data/lib/trailblazer/endpoint/options.rb

@@ -1,28 +1,7 @@
-# TODO
+# DISCUSS: the generic inheritance/Options logic might be extracted to trailblazer-config or something.
+#          it is completely independent and could be helpful for many other configurations.
 module Trailblazer
   class Endpoint
-    def self.Normalizer(target:, options:)
-      normalizer = Class.new(Trailblazer::Activity::Railway) do
-        # inject an empty {} for all options.
-        # options.collect do |(method_name => option)|
-        #   step Normalizer.DefaultToEmptyHash(config_name), id: :"default_#{config_name}"
-        # end
-      end
-
-      Normalizer::State.new(normalizer, options)
-    end
-
-    def self.Normalizer___(options, base_class: Trailblazer::Activity::Path)
-      normalizer = Class.new(base_class) do
-        # inject an empty {} for all options.
-        # options.collect do |(method_name => option)|
-        #   step Normalizer.DefaultToEmptyHash(config_name), id: :"default_#{config_name}"
-        # end
-      end
-
-      Normalizer.add(normalizer, nil, options)
-    end
-
     module Options
       module DSL
         def directive(directive_name, *callables, inherit: superclass)
@@ -35,6 +14,7 @@ module Trailblazer
           @normalizers[directive_name] = Trailblazer::Endpoint::Normalizer.Options(directive_name, *callables, **options) # DISCUSS: allow multiple calls?
         end
 
+        # Called in {Endpoint::Controller}.
         def self.extended(extended) # TODO: let's hope this is only called once per hierachy :)
           extended.instance_variable_set(:@normalizers, {})
         end
@@ -49,7 +29,7 @@ module Trailblazer
       end
 
       def options_for(directive_name, runtime_options)
-        normalizer = @normalizers[directive_name]
+        normalizer = @normalizers.fetch(directive_name)
 
         ctx = Trailblazer::Context(runtime_options, {})
 
@@ -59,7 +39,15 @@ module Trailblazer
         _, options = ctx.decompose
         options
       end
-    end
+
+
+      # Merge {merged} into {hash}, but only keys that exist in {hash}.
+      def self.merge_with(merged, hash)
+        keys = hash.keys
+        merged = keys.collect { |key| merged.key?(key) ? [key, merged[key]] : nil }.compact.to_h
+        hash.merge(merged)
+      end
+    end # Options
 
     module Normalizer
       def self.Options(directive_name, *callables, base_class: Trailblazer::Activity::Path)
@@ -110,16 +98,6 @@ module Trailblazer
         end
       end
 
-      def self.CallDirectiveMethod(target, config_name)
-        ->((ctx, flow_options), *) {
-          config = target.send(config_name, ctx, **ctx) # e.g. ApplicationController.options_for_endpoint
-
-          ctx[config_name] = ctx[config_name].merge(config)
-
-          return Trailblazer::Activity::Right, [ctx, flow_options]
-        }
-      end
-
       def self.CallDirective(callable, option_name)
         ->((ctx, flow_options), *) {
           config = callable.(ctx, **ctx) # e.g. ApplicationController.options_for_endpoint
@@ -133,14 +111,5 @@ module Trailblazer
         }
       end
     end # Normalizer
-
-    module Controller
-      def self.extended(extended)
-        extended.extend Trailblazer::Endpoint::Options::DSL
-        extended.extend Trailblazer::Endpoint::Options::DSL::Inherit
-        extended.extend Trailblazer::Endpoint::Options
-      end
-    end # Controller
-
   end
 end

data/lib/trailblazer/endpoint/protocol.rb

@@ -1,3 +1,5 @@
+require "trailblazer/activity/dsl/linear"
+
 module Trailblazer
   class Endpoint
     # The {Protocol} implements auth*, and calls the domain OP/WF.
@@ -16,13 +18,8 @@ module Trailblazer
       class Noop < Trailblazer::Activity::Railway
       end
 
-      class Failure < Trailblazer::Activity::End # DISCUSS: move to Act::Railway?
-        # class Authentication < Failure
-        # end
-      end
-
       def self._Path(semantic:, &block) # DISCUSS: the problem with Path currently is https://github.com/trailblazer/trailblazer-activity-dsl-linear/issues/27
-        Path(track_color: semantic, end_id: "End.#{semantic}", end_task: Failure.new(semantic: semantic), &block)
+        Path(track_color: semantic, end_id: "End.#{semantic}", end_task: Activity::End.new(semantic: semantic), &block)
       end
 
       step :authenticate, Output(:failure) => _Path(semantic: :not_authenticated) do
@@ -43,8 +40,8 @@ module Trailblazer
       # termini for the Adapter this is the only way to get it working right now.
       # FIXME: is this really the only way to add an {End} to all this?
       @state.update_sequence do |sequence:, **|
-        sequence = Activity::Path::DSL.append_end(sequence, task: Failure.new(semantic: :not_found), magnetic_to: :not_found, id: "End.not_found")
-        sequence = Activity::Path::DSL.append_end(sequence, task: Failure.new(semantic: :invalid_data), magnetic_to: :invalid_data, id: "End.invalid_data")
+        sequence = Activity::Path::DSL.append_end(sequence, task: Activity::End.new(semantic: :not_found), magnetic_to: :not_found, id: "End.not_found")
+        sequence = Activity::Path::DSL.append_end(sequence, task: Activity::End.new(semantic: :invalid_data), magnetic_to: :invalid_data, id: "End.invalid_data")
 
         recompile_activity!(sequence)
 

data/lib/trailblazer/endpoint/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Endpoint
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/test/adapter/api_test.rb

@@ -12,14 +12,13 @@ class AdapterAPITest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter:  Trailblazer::Endpoint::Adapter::API,
         scope_domain_ctx: false,
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
   # success
     assert_route endpoint, {}, :authenticate, :policy, :model, :validate, :success, status: 200
+  # created, when passing 201
+    assert_route endpoint, {success_status: 201}, :authenticate, :policy, :model, :validate, :success, status: 201
   # authentication error
     assert_route endpoint, {authenticate: false}, :authenticate, :fail_fast, status: 401           # fail_fast == protocol error
   # policy error
@@ -47,12 +46,8 @@ class AdapterAPITest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter: adapter,
         scope_domain_ctx: false,
-
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
     class TestErrors < Struct.new(:message)
       def ==(b)

data/test/adapter/web_test.rb

@@ -19,11 +19,8 @@ class AdapterWebTest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter:  Trailblazer::Endpoint::Adapter::Web,
         scope_domain_ctx: false,
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
   # success
     assert_route(endpoint, {}, :authenticate, :policy, :model, :validate, :success)

data/test/config_test.rb

@@ -17,12 +17,22 @@ class ConfigTest < Minitest::Spec
     ApeBabeController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
     ApeBabeController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
 
+    # 4t-h level, also inherit everything from 2-nd level
+    ApeBabeKidController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+    ApeBabeKidController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
+
     BoringController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true, :xml=>"<XML"}}
     BoringController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:policy=>\"Ehm\"}}
 
     OverridingController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:redis=>\"Arrr\"}}
   end
 
+  it "raises helpful exception with unknown directive" do
+    assert_raises KeyError do
+      ApplicationController.options_for(:unknown_options, {})
+    end
+  end
+
   class ApplicationController
     def self.options_for_endpoint(ctx, **)
       {
@@ -58,6 +68,10 @@ class ConfigTest < Minitest::Spec
     # directive :options_for_domain_ctx, method(:options_for_domain_ctx)
   end
 
+  class ApeBabeKidController < ApeController
+
+  end
+
   class BoringController < ApplicationController
     def self.options_for_domain_ctx(ctx, **) {policy: "Ehm",} end
     def self.options_for_endpoint(ctx, **)   {xml: "<XML",} end
@@ -101,3 +115,14 @@ class RuntimeOptionsTest < Minitest::Spec
     ApplicationController.options_for(:options_for_endpoint, controller: {params: {id: 1}}).inspect.must_equal %{{:option=>nil, :params=>{:id=>1}, :my_params=>\"{:id=>1}\"}}
   end
 end
+
+class OptionsTest < Minitest::Spec
+  # Options#merge_with
+  it "works with empty {merged}" do
+    Trailblazer::Endpoint::Options.merge_with({}, {a: 1, b: 2}).inspect.must_equal %{{:a=>1, :b=>2}}
+  end
+
+  it "keys in merged have precedence, but unknown {merged} keys are discarded" do
+    Trailblazer::Endpoint::Options.merge_with({a: 3, d: 4}, {a: 1, b: 2}).inspect.must_equal %{{:a=>3, :b=>2}}
+  end
+end

data/test/docs/controller_test.rb

@@ -1,11 +1,11 @@
 require "test_helper"
 
 class DocsControllerTest < Minitest::Spec
-
   class ApplicationController
-    def self.options_for_endpoint(ctx, **)
+    def self.options_for_endpoint(ctx, controller:, **)
       {
         find_process_model: true,
+        **controller.instance_variable_get(:@params)[:params],
       }
     end
 
@@ -15,30 +15,52 @@ class DocsControllerTest < Minitest::Spec
       }
     end
 
+    def self.options_for_flow_options(ctx, **)
+      {
+      }
+    end
+
+    def self.options_for_block_options(ctx, controller:, **)
+      {
+        success_block:          ->(ctx, seq:, **) { controller.instance_exec { render seq << :success_block } },
+        failure_block:          ->(ctx, seq:, **) { controller.instance_exec { render seq << :failure_block } },
+        protocol_failure_block: ->(ctx, seq:, **) { controller.instance_exec { render seq << :protocol_failure_block } }
+      }
+    end
+
+
     extend Trailblazer::Endpoint::Controller
+
+    # include Trailblazer::Endpoint::Controller::InstanceMethods      # {#endpoint_for}
+    include Trailblazer::Endpoint::Controller::InstanceMethods::DSL # {#endpoint}
+
+    include Trailblazer::Endpoint::Controller::Rails
+    include Trailblazer::Endpoint::Controller::Rails::Process
+
     directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+    directive :options_for_flow_options, method(:options_for_flow_options)
+    directive :options_for_block_options, method(:options_for_block_options)
 
-    def process(action_name, params:)
+    def process(action_name, **params)
       @params = params
-      send(action_name)
+      send_action(action_name)
+      @render
     end
 
     def render(text)
       @render = text
     end
-  end
 
-  class ApeController < ApplicationController
-    def self.options_for_domain_ctx(ctx, **)
-      {
-        current_user: "Yo",
-      }
+
+
+
+    Protocol = Class.new(Trailblazer::Endpoint::Protocol) do
+      include T.def_steps(:authenticate, :policy)
     end
 
-    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web, domain_ctx_filter: Trailblazer::Endpoint.domain_ctx_filter([:current_user, :process_model]), scope_domain_ctx: true
   end
 
-
   class HtmlController < ApplicationController
     private def endpoint_for(*)
       protocol = Class.new(Trailblazer::Endpoint::Protocol) do
@@ -50,46 +72,31 @@ class DocsControllerTest < Minitest::Spec
           domain_activity: Minitest::Spec.new(nil).activity, # FIXME
           protocol: protocol,
           adapter: Trailblazer::Endpoint::Adapter::Web,
-          scope_domain_ctx: false,
+          scope_domain_ctx: true,
 
       ) do
         {Output(:not_found) => Track(:not_found)}
       end
     end
 
-    private def advance_endpoint(options, &block)
-      endpoint = endpoint_for(options)
-
-      ctx = Trailblazer::Endpoint.advance_from_controller(
-
-        endpoint,
-
-        # retrieve/compute options_for_domain_ctx and options_for_endpoint
-
-        domain_ctx: {seq: seq=[], current_user: "Yo", **@params},
-        flow_options: {},
-
-        **options,
-
-        seq: seq,
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
         current_user: "Yo",
-        **@params,
-      )
+        seq: seq,
+        **controller.instance_variable_get(:@params)[:params],
+      }
     end
 
-    private def _endpoint(action, params: {}, &block)
-      success_block =          ->(ctx, seq:, **) { render seq << :success_block }
-      failure_block =          ->(ctx, seq:, **) { render seq << :failure_block }
-      protocol_failure_block = ->(ctx, seq:, **) { render seq << :protocol_failure_block }
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
 
-      dsl = Trailblazer::Endpoint::DSL::Runtime.new({action: action, params: params}, block || success_block, failure_block, protocol_failure_block) # provides #Or etc, is returned to {Controller#call}
+    private def _endpoint(action, seq: [], &block)
+      endpoint(action, seq: seq, &block)
     end
 
     # all standard routes are user-defined
     def view
       _endpoint "view?" do |ctx, seq:, **|
         render "success" + ctx[:current_user] + seq.inspect
-
       end.failure do |ctx, seq:, **|
         render "failure" + ctx[:current_user] + seq.inspect
 
@@ -114,16 +121,6 @@ class DocsControllerTest < Minitest::Spec
       end
     end
 
-    def process(*)
-      dsl = super
-
-      options, block_options = dsl.to_args
-
-      advance_endpoint(**options, **block_options)
-
-      @render
-    end
-
   end # HtmlController
 
   it "what" do
@@ -171,57 +168,147 @@ class DocsControllerTest < Minitest::Spec
     # from controller-default
     controller.process(:update, params: {authenticate: false}).must_equal [:authenticate, :protocol_failure_block]
   end
-end
 
-class ControllerOptionsTest < Minitest::Spec
-  class Controller
-    include Trailblazer::Endpoint::Controller
 
-    def view
-      endpoint "view?"
+# Test if {domain_ctx} is automatically wrapped via Context() so that we can use string-keys.
+# TODO: test if aliases etc are properly passed.
+  class OptionsController < HtmlController
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
+        "contract.params" => Object, # string-key should usually break if not wrapped
+      }
     end
 
-    # we add {:options_for_domain_ctx} manually
-    def download
-      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        current_user: "Yogi",
+        process_model: Class,
+      }
     end
 
-    # override some settings from {endpoint_options}:
-    def new
-      endpoint "new?", find_process_model: false
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    directive :options_for_endpoint, method(:options_for_endpoint), inherit: false
+
+    def view
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx["contract.params"].to_s + seq.inspect
+      end
     end
+  end # OptionsController
+
+  it "allows string keys in {domain_ctx} since it gets automatically Ctx()-wrapped" do
+    controller = OptionsController.new
+    controller.process(:view, params: {}).must_equal %{successObject[:authenticate, :policy, :model, :validate]}
   end
 
-  class ControllerThatDoesntInherit
-    include Trailblazer::Endpoint::Controller
 
-    def options_for_domain_ctx
+# copy from {endpoint_ctx} to {domain_ctx}
+  class DomainContextController < ApplicationController
+    private def _endpoint(action, seq: [], **options, &block)
+      endpoint(action, seq: seq, **options, &block)
+    end
+
+    Activity = Class.new(Trailblazer::Activity::Railway) do
+      step :check
+
+      def check(ctx, current_user:, seq:, process_model:, **)
+        seq << :check
+        ctx[:message] = "#{current_user} / #{process_model}"
+      end
+    end
+
+    endpoint "view?", domain_activity: Activity
+    endpoint "show?", domain_activity: Activity
+
+
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
       {
-        params: params
+        seq: seq,
       }
     end
 
-    def options_for_endpoint
-
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        current_user: "Yogi",
+        process_model: Class,
+        something: true,
+      }
     end
 
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    directive :options_for_endpoint, method(:options_for_endpoint), inherit: false
+
     def view
-      endpoint "view?"
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:message].to_s + seq.inspect
+      end
     end
 
-    # we add {:options_for_domain_ctx} manually
-    def download
-      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+    def show
+      # override existing domain_ctx
+      # make options here available in steps
+      _endpoint "show?", options_for_domain_ctx: {params: {id: 1}, seq: []} do |ctx, seq:, params:, **|
+        render "success" + ctx[:message].to_s + seq.inspect + params.inspect
+      end
     end
 
-    # override some settings from {endpoint_options}:
-    def new
-      endpoint "new?", find_process_model: false
+    def create
+      # add endpoint_options
+      _endpoint "show?", policy: false do |ctx, seq:, params:, **|
+        render "success" + ctx[:message].to_s + seq.inspect + params.inspect
+      end
     end
+
+    # todo: test overriding endp options
+      # _endpoint "show?", params: {id: 1}, process_model: "it's me!" do |ctx, seq:, params:, process_model:, **|
+  end # DomainContextController
+
+  it "{:current_user} and {:process_model} are made available in {domain_ctx}" do
+    controller = DomainContextController.new
+    controller.process(:view, params: {}).must_equal %{successYogi / Class[:authenticate, :policy, :check]}
+  end
+
+  it "{:seq} is overridden, {:params} made available, in {domain_ctx}" do
+    controller = DomainContextController.new
+    # note that {seq} is not shared anymore
+    controller.process(:show, params: {}).must_equal %{successYogi / Class[:check]{:id=>1}}
   end
 
-  it "allows to get options without a bloody controller" do
-    MemoController.bla(params: params)
+  it "allows passing {endpoint_options} directly" do
+    controller = DomainContextController.new
+    controller.process(:create, params: {}).must_equal [:authenticate, :policy, :protocol_failure_block]
+  end
+
+
+# Test without DSL
+  class BasicController
+    extend Trailblazer::Endpoint::Controller
+
+    directive :options_for_block_options, Trailblazer::Endpoint::Controller.method(:options_for_block_options)
+
+    def endpoint(name, &block)
+      action_options = {seq: []}
+
+      Trailblazer::Endpoint::Controller.advance_endpoint_for_controller(endpoint: endpoint_for(name), block_options: self.class.options_for(:options_for_block_options, {controller: self}), config_source: self.class, **action_options)
+    end
+
+    def head(status)
+      @status = status
+    end
+  end
+
+  class RodaController < BasicController
+    endpoint("show?", protocol: ApplicationController::Protocol, adapter: Trailblazer::Endpoint::Adapter::Web, domain_activity: Class.new(Trailblazer::Activity::Railway) { def save(*); true; end; step :save })
+
+    def show
+      endpoint "show?"
+      @status
+    end
+  end
+
+  it "what" do
+    RodaController.new.show.must_equal 200
   end
 end
 
+