trailblazer-endpoint 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2223ccae09c1e72ad993d75dae43dbeb60d2194b924006caa44e606d0f41e162
-  data.tar.gz: c9a7580cef40249013d4069356edd3e260b820026101bea28c01f39e6d65935e
+  metadata.gz: a1f9924623a3e82ffce7398379c645bc0d6502e66d1d827231fb12b108e40978
+  data.tar.gz: 8a2f575d512c830e3ea29d2cff65ac8aed6f86cf75364a516102664c2928c928
 SHA512:
-  metadata.gz: 8f31213731d9bcd5267019ab3e5027e873d63cdf31cb0e418e48c70b0bf13ef3012c040deeb1a01fb171cb28aa9e1e64a5a0057218d9030679748c76ce57009e
-  data.tar.gz: 457aa56b0e109053568351a46fbc3f3dc487280e0937f88d2ed60297ee456078c64399422f6acb2ec7129c48c36db18aef406f257f17d43c0b60578e242043d7
+  metadata.gz: 9b817a46e644b31127385bcac23a5ec122a5bdd4cb9fd3a425f4d92a1be3d4e2fb35a70f28d13850902116a892bd445df3e4c795b895557bdf085de7505f2c71
+  data.tar.gz: fc0f421d1bcfa2c3ccf08f599ffa503c7d0cf7b8a64a387d88270ad68466e00f2cd79654b4a71ead8bf4425a231272b6ef6089dd5e5416d56f4961c7cba0f97d

data/CHANGES.md

@@ -1,3 +1,8 @@
+# 0.0.3
+
+* Introduce `Options`.
+* Introduce `Controller::DSL`.
+
 # 0.0.2
 
 The `:collaboration` and `:dictionary` options for `arguments_for` are now optional and figured out by `workflow`.

data/lib/trailblazer/endpoint.rb

@@ -76,7 +76,7 @@ module Trailblazer
     end
 
     #@ For WORKFLOW and operations. not sure this method will stay here.
-    def self.arguments_for(domain_ctx:, flow_options:, circuit_options: {}, **options)
+    def self.arguments_for(domain_ctx:, flow_options:, circuit_options: {}, **endpoint_options)
       domain_ctx      = Trailblazer::Context::IndifferentAccess.build(domain_ctx, {}, [domain_ctx, flow_options], circuit_options)
 
       [
@@ -89,7 +89,7 @@ module Trailblazer
               # encrypted_resume_data:          encrypted_resume_data,
 
               # cipher_key:                     cipher_key,
-              **options,
+              **endpoint_options,
           },
           flow_options
         ],
@@ -125,3 +125,6 @@ end
 
 require "trailblazer/endpoint/protocol"
 require "trailblazer/endpoint/adapter"
+require "trailblazer/endpoint/dsl"
+require "trailblazer/endpoint/controller"
+require "trailblazer/endpoint/options"

data/lib/trailblazer/endpoint/controller.rb

@@ -0,0 +1,7 @@
+module Trailblazer
+  class Endpoint
+    module Controller
+
+    end
+  end
+end

data/lib/trailblazer/endpoint/dsl.rb

@@ -0,0 +1,26 @@
+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)
+
+        def failure(&block)
+          self.failure_block = block
+          self
+        end
+
+        alias_method :Or, :failure
+
+        def protocol_failure(&block)
+          self.protocol_failure_block = block
+          self
+        end
+
+        # #call
+        def to_args
+          return args, {success_block: success_block, failure_block: failure_block, protocol_failure_block: protocol_failure_block}
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/endpoint/options.rb

@@ -0,0 +1,145 @@
+# TODO
+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)
+          options = {}
+
+          if inherit
+            options[:base_class] = instance_variable_get(:@normalizers)[directive_name] || Trailblazer::Activity::Path # FIXME
+          end
+
+          @normalizers[directive_name] = Trailblazer::Endpoint::Normalizer.Options(directive_name, *callables, **options) # DISCUSS: allow multiple calls?
+        end
+
+        def self.extended(extended) # TODO: let's hope this is only called once per hierachy :)
+          extended.instance_variable_set(:@normalizers, {})
+        end
+
+        module Inherit
+          def inherited(subclass)
+            super
+
+            subclass.instance_variable_set(:@normalizers, @normalizers.dup)
+          end
+        end
+      end
+
+      def options_for(directive_name, runtime_options)
+        normalizer = @normalizers[directive_name]
+
+        ctx = Trailblazer::Context::IndifferentAccess.build(runtime_options, {}, [{}, {}], {}) # FIXME: easier {::build}, please!
+
+        signal, (ctx, ) = Trailblazer::Developer.wtf?(normalizer, [ctx])
+
+        _, options = ctx.decompose
+        options
+      end
+    end
+
+    module Normalizer
+      def self.Options(directive_name, *callables, base_class: Trailblazer::Activity::Path)
+        normalizer = Class.new(base_class) do
+        end
+
+        Normalizer.add(normalizer, directive_name, callables)
+      end
+
+      def self.DefaultToEmptyHash(config_name)
+        -> (ctx, **) { ctx[config_name] ||= {} }
+      end
+
+      def self.add_normalizer!(target, normalizer, config)
+        normalizer = Normalizer.add(normalizer, target, config) # add configure steps for {subclass} to the _new_ normalizer.
+        target.instance_variable_set(:@normalizer, normalizer)
+        target.instance_variable_set(:@config, config)
+      end
+
+      class State < Module
+        def initialize(normalizer, config)
+          @normalizer = normalizer
+          @config = config
+        end
+
+        # called once when extended in {ApplicationController}.
+        def extended(extended)
+          super
+
+          extended.extend(Inherited)
+          Normalizer.add_normalizer!(extended, @normalizer, @config)
+        end
+
+      end
+      module Inherited
+        def inherited(subclass)
+          super
+
+          Normalizer.add_normalizer!(subclass, @normalizer, @config)
+        end
+      end
+
+      def self.add(normalizer, directive_name, options)
+        Class.new(normalizer) do
+          options.collect do |callable|
+            step task: Normalizer.CallDirective(callable, directive_name), id: "#{directive_name}=>#{callable}"
+          end
+        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
+
+          # ctx[option_name] = ctx[option_name].merge(config)
+          config.each do |k, v|
+            ctx[k] = v
+          end
+
+          return Trailblazer::Activity::Right, [ctx, flow_options]
+        }
+      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/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Endpoint
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/test/config_test.rb

@@ -0,0 +1,103 @@
+require "test_helper"
+
+require "trailblazer/endpoint/options"
+
+class ConfigTest < Minitest::Spec
+  Controller = Struct.new(:params)
+
+  it "what" do
+    ApplicationController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+
+  # inherits endpoint options from ApplicationController
+    ApeController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+  # defines its own domain options, none in ApplicationController
+    ApeController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
+
+    # 3-rd level, inherit everything from 2-nd level
+    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\"}}
+
+    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
+
+  class ApplicationController
+    def self.options_for_endpoint(ctx, **)
+      {
+        find_process_model: true,
+      }
+    end
+
+    def self.request_options(ctx, **)
+      {
+        request: true,
+      }
+    end
+
+    extend Trailblazer::Endpoint::Controller
+    directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+  end
+
+  class ApeController < ApplicationController
+    def self.options_for_domain_ctx(ctx, **)
+      {
+        current_user: "Yo",
+      }
+    end
+
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+  class ApeBabeController < ApeController
+    # def self.options_for_domain_ctx(ctx, **)
+    #   {policy: "Ehm"}
+    # end
+
+    # directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+  class BoringController < ApplicationController
+    def self.options_for_domain_ctx(ctx, **) {policy: "Ehm",} end
+    def self.options_for_endpoint(ctx, **)   {xml: "<XML",} end
+
+    directive :options_for_endpoint,   method(:options_for_endpoint) #, inherit: ApplicationController
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+  class OverridingController < BoringController
+    def self.options_for_domain_ctx(ctx, **)
+      {
+        redis: "Arrr",
+      }
+    end
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx), inherit: false
+  end
+end
+
+class RuntimeOptionsTest < Minitest::Spec
+  class ApplicationController
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        option: true,
+        params: controller[:params],
+      }
+    end
+
+  # You can access variables set prior to this options directive.
+    def self.request_options(ctx, controller:, params:, **)
+      {
+        my_params: params.inspect,
+        option: nil,
+      }
+    end
+
+    extend Trailblazer::Endpoint::Controller
+    directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+  end
+
+  it do
+    ApplicationController.options_for(:options_for_endpoint, controller: {params: {id: 1}}).inspect.must_equal %{{:option=>nil, :params=>{:id=>1}, :my_params=>\"{:id=>1}\"}}
+  end
+end

data/test/docs/controller_test.rb

@@ -1,92 +1,227 @@
 require "test_helper"
 
 class DocsControllerTest < Minitest::Spec
-  it "what" do
-    endpoint "view?" do |ctx|
-      # 200, success
-      return
+
+  class ApplicationController
+    def self.options_for_endpoint(ctx, **)
+      {
+        find_process_model: true,
+      }
     end
 
-    # 422
-    # but also 404 etc
-  end
+    def self.request_options(ctx, **)
+      {
+        request: true,
+      }
+    end
 
+    extend Trailblazer::Endpoint::Controller
+    directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
 
-  class Controller
-    def initialize(endpoint, activity)
-      @___activity = activity
-      @endpoint = endpoint
-      @seq      = []
+    def process(action_name, params:)
+      @params = params
+      send(action_name)
     end
 
-    def view(params)
-      endpoint "view?", params do |ctx|
-        @seq << :success
-        # 200, success
-        return
-      end
+    def render(text)
+      @render = text
+    end
+  end
 
-      @seq << :failure
-      # 422
-      # but also 404 etc
+  class ApeController < ApplicationController
+    def self.options_for_domain_ctx(ctx, **)
+      {
+        current_user: "Yo",
+      }
     end
 
-    def call(action, **params)
-      send(action, **params)
-      @seq
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+
+  class HtmlController < ApplicationController
+    private def endpoint_for(*)
+      protocol = Class.new(Trailblazer::Endpoint::Protocol) do
+        include T.def_steps(:authenticate, :policy)
+      end
+
+      endpoint =
+        Trailblazer::Endpoint.build(
+          domain_activity: Minitest::Spec.new(nil).activity, # FIXME
+          protocol: protocol,
+          adapter: Trailblazer::Endpoint::Adapter::Web,
+          scope_domain_ctx: false,
+
+      ) do
+        {Output(:not_found) => Track(:not_found)}
+      end
     end
 
-    private def endpoint(action, params, &block)
-      ctx = Trailblazer::Endpoint.advance_from_controller(@endpoint,
-        event_name:             "",
-        success_block: block,
-        failure_block: ->(*) { return },
-        protocol_failure_block: ->(*) { @seq << 401 and return },
+    private def advance_endpoint(options, &block)
+      endpoint = endpoint_for(options)
+
+      ctx = Trailblazer::Endpoint.advance_from_controller(
+
+        endpoint,
 
-        collaboration: @___activity,
-        domain_ctx: {},
-        success_id: "fixme",
+        # retrieve/compute options_for_domain_ctx and options_for_endpoint
+
+        domain_ctx: {seq: seq=[], current_user: "Yo", **@params},
         flow_options: {},
 
-        **params,
+        **options,
 
-      # DISCUSS: do we really like that fuzzy API? if yes, why do we need {additional_endpoint_options} or whatever it's called?
-        seq: @seq,
+        seq: seq,
+        current_user: "Yo",
+        **@params,
       )
     end
-  end
 
-  it "injected {return} interrupts the controller action" do
-    protocol = Class.new(Trailblazer::Endpoint::Protocol)do
-      include T.def_steps(:authenticate, :policy)
+    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 }
+
+      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}
     end
 
-    endpoint =
-      Trailblazer::Endpoint.build(
-        domain_activity: activity,
-        protocol: protocol,
-        adapter: Trailblazer::Endpoint::Adapter::Web,
-        scope_domain_ctx: false,
+    # all standard routes are user-defined
+    def view
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:current_user] + seq.inspect
 
-    ) do
-      {Output(:not_found) => Track(:not_found)}
+      end.failure do |ctx, seq:, **|
+        render "failure" + ctx[:current_user] + seq.inspect
+
+      end.protocol_failure do |ctx, seq:, **|
+        render "protocol_failure" + ctx[:current_user] + seq.inspect
+      end
     end
 
-  # 200
-    seq = Controller.new(endpoint, activity).call(:view)
-    seq.must_equal [:authenticate, :policy, :model, :validate, :success] # the {return} works.
+    # standard use-case: only success
+    def show
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:current_user] + seq.inspect
+      end
+    end
 
-  # 401
-    seq = Controller.new(endpoint, activity).call(:view, authenticate: false)
-    seq.must_equal [:authenticate, :policy, :model, :validate, :success]
-  end
+    # standard use case: {success} and {failure}
+    def update
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:current_user] + seq.inspect
+      end.Or do |ctx, seq:, **|
+        render "Fail!" + ctx[:current_user] + seq.inspect
+      end
+    end
+
+    def process(*)
+      dsl = super
+
+      options, block_options = dsl.to_args
+
+      advance_endpoint(**options, **block_options)
+
+      @render
+    end
+
+  end # HtmlController
 
   it "what" do
-    endpoint "view?" do |ctx|
-      # 200, success
-      return
-    end.Or() do |ctx|
-      # Only 422
+  # success
+    controller = HtmlController.new
+    controller.process(:view, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
+
+  # failure
+    controller = HtmlController.new
+    controller.process(:view, params: {validate: false}).must_equal %{failureYo[:authenticate, :policy, :model, :validate]}
+
+  # protocol_failure
+    controller = HtmlController.new
+    controller.process(:view, params: {authenticate: false}).must_equal %{protocol_failureYo[:authenticate]}
+  end
+
+  it "only success_block is user-defined" do
+  # success
+    controller = HtmlController.new
+    controller.process(:show, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
+
+  # failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:show, params: {validate: false}).must_equal [:authenticate, :policy, :model, :validate, :failure_block]
+
+  # protocol_failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:show, params: {authenticate: false}).must_equal [:authenticate, :protocol_failure_block]
+  end
+
+  it "success/Or" do
+  # success
+    controller = HtmlController.new
+    controller.process(:update, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
+
+  # failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:update, params: {validate: false}).must_equal %{Fail!Yo[:authenticate, :policy, :model, :validate]}
+
+  # protocol_failure
+    controller = HtmlController.new
+    # 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?"
+    end
+
+    # we add {:options_for_domain_ctx} manually
+    def download
+      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+    end
+
+    # override some settings from {endpoint_options}:
+    def new
+      endpoint "new?", find_process_model: false
     end
   end
+
+  class ControllerThatDoesntInherit
+    include Trailblazer::Endpoint::Controller
+
+    def options_for_domain_ctx
+      {
+        params: params
+      }
+    end
+
+    def options_for_endpoint
+
+    end
+
+    def view
+      endpoint "view?"
+    end
+
+    # we add {:options_for_domain_ctx} manually
+    def download
+      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+    end
+
+    # override some settings from {endpoint_options}:
+    def new
+      endpoint "new?", find_process_model: false
+    end
+  end
+
+  it "allows to get options without a bloody controller" do
+    MemoController.bla(params: params)
+  end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-10 00:00:00.000000000 Z
+date: 2020-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
@@ -102,6 +102,9 @@ files:
 - lib/trailblazer/endpoint.rb
 - lib/trailblazer/endpoint/adapter.rb
 - lib/trailblazer/endpoint/builder.rb
+- lib/trailblazer/endpoint/controller.rb
+- lib/trailblazer/endpoint/dsl.rb
+- lib/trailblazer/endpoint/options.rb
 - lib/trailblazer/endpoint/protocol.rb
 - lib/trailblazer/endpoint/rails.rb
 - lib/trailblazer/endpoint/version.rb
@@ -109,6 +112,7 @@ files:
 - test/adapter/representable_test.rb
 - test/adapter/web_test.rb
 - test/benchmark/skill_resolver_benchmark.rb
+- test/config_test.rb
 - test/docs/controller_test.rb
 - test/docs/endpoint_test.rb
 - test/endpoint_test.rb
@@ -177,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Endpoints handle authentication, policies, run your domain operation and
@@ -187,6 +191,7 @@ test_files:
 - test/adapter/representable_test.rb
 - test/adapter/web_test.rb
 - test/benchmark/skill_resolver_benchmark.rb
+- test/config_test.rb
 - test/docs/controller_test.rb
 - test/docs/endpoint_test.rb
 - test/endpoint_test.rb