trailblazer-endpoint 0.0.5 → 0.0.9

data/test/rails-app/app/controllers/songs_controller.rb

@@ -1,24 +1,267 @@
+#:endpoint
+#:or
+#:create
 class SongsController < ApplicationController::Web
-  endpoint("Create", domain_activity: Song::Operation::Create) do {} end # FIXME: we still need to provide an empty hash here if we want to override the not_found behavior.
+  endpoint Song::Operation::Create
 
-  # directive :options_for_domain_ctx, ->(ctx, **) { {seq: []} }
+#:endpoint end
+  def create
+    endpoint Song::Operation::Create do |ctx, current_user:, model:, **|
+      render html: cell(Song::Cell::Create, model, current_user: current_user)
+    end.Or do |ctx, contract:, **| # validation failure
+      render html: cell(Song::Cell::New, contract)
+    end
+  end
+#:create end
+
+#~oskip
+  class CreateOrController < SongsController
+#~oskip end
+  def create
+    endpoint Song::Operation::Create do |ctx, current_user:, model:, **|
+      render html: cell(Song::Cell::Create, model, current_user: current_user)
+    end.Or do |ctx, contract:, **| # validation failure
+      render json: contract.errors, status: 422
+    end
+  end
+end
+#:or end
+
+  def create_without_block
+    endpoint Song::Operation::Create
+  end
+
+  class CreateWithOptionsController < SongsController
+    #:create-options
+    def create
+      endpoint Song::Operation::Create, session: {user_id: 2} do |ctx, current_user:, model:, **|
+        render html: cell(Song::Cell::Create, model, current_user: current_user)
+      end
+    end
+    #:create-options end
+  end
+
+
+  class CreateWithOptionsForDomainCtxController < SongsController
+    #:domain_ctx
+    def create
+      endpoint Song::Operation::Create, options_for_domain_ctx: {params: {id: 999}} do |ctx, model:, **|
+        render html: cell(Song::Cell::Create, model)
+      end
+    end
+    #:domain_ctx end
+  end
+
+  class CreateEndpointCtxController < SongsController
+    #:endpoint_ctx
+    def create
+      endpoint Song::Operation::Create do |ctx, endpoint_ctx:, **|
+        render html: "Created", status: endpoint_ctx[:status]
+      end.Or do |ctx, **| # validation failure
+        #~empty
+        #~empty end
+      end
+    end
+    #:endpoint_ctx end
+  end
+
+  # end.Or do |ctx, endpoint_ctx:, **| # validation failure
+  #       render json: endpoint_ctx.keys, status: 422
+  #     end
+
+
+  class CreateWithProtocolFailureController < SongsController
+  #:protocol_failure
+  def create_with_protocol_failure
+    endpoint Song::Operation::Create do |ctx, **|
+      redirect_to dashboard_path
+    end.protocol_failure do |ctx, **|
+      render html: "wrong login, app crashed", status: 500
+    end
+  end
+  #:protocol_failure end
+  end
 
+  # {:process_model} is copied from {domain_ctx[:model]} via {#insert_copy_from_domain_ctx!}.
+  class Create1Controller < SongsController
   def create
-    endpoint "Create"
+    endpoint Song::Operation::Create do |ctx, endpoint_ctx:, **|
+      render html: endpoint_ctx[:process_model].inspect.html_safe
+    end
+  end
+  end
+
+
+  # endpoint_ctx
+  #   :resume_data
+  #   domain_ctx
+  #     :resume_data (copy)
+
+
+  # authenticate
+
+  # deserialize ==> {resume_data: {id: 1}}
+  # deserialize_process_model_id_from_resume_data
+
+  # find_process_model
+  # policy
+  # domain_activity
+
+  # serialize suspend_data and deserialize resume_data
+  class SerializeController < SongsController
+    endpoint Song::Operation::Create,
+      protocol: ApplicationController::Web::Protocol
+            # serialize: true
+
+    def self.options_for_block_options(ctx, **)
+      {
+        invoke: Trailblazer::Developer.method(:wtf?) # FIXME
+      }
+    end
+
+
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        cipher_key: Rails.application.config.cipher_key,
+
+        encrypted_resume_data: controller.params[:encrypted_resume_data],
+      }
+    end
+
+    directive :options_for_block_options, method(:options_for_block_options)
+    directive :options_for_endpoint, method(:options_for_endpoint)
+
+    def create
+      encrypted_value = Trailblazer::Workflow::Cipher.encrypt_value({}, cipher_key: cipher_key, value: JSON.dump({id: "findings received", class: Object}))
+
+      endpoint Song::Operation::Create, encrypted_resume_data: encrypted_value, process_model_from_resume_data: false do |ctx, current_user:, endpoint_ctx:, **|
+        render html: cell(Song::Cell::Create, model, current_user: current_user)
+      end.Or do |ctx, contract:, **| # validation failure
+        render html: cell(Song::Cell::New, contract)
+      end
+    end
+  end
+
+  # TODO: not really a doc test.
+# the entire deserialize cycle is skipped since we only use {:serialize}
+  class Serialize1Controller < SerializeController
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      serialize: true,
+      deserialize: true
+
+    def create
+      # {:model} and {:memory} are from the domain_ctx.
+      # {:encrypted_suspend_data} from endpoint.
+      endpoint "Create" do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end.Or do |ctx, **| # validation failure
+        render html: "xxx", status: 500
+      end
+    end
+  end
+
+    # TODO: not really a doc test.
+# ---------deserialize cycle is skipped.
+# we serialize {:remember}.
+  class Serialize2Controller < Serialize1Controller # "render confirm page"
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      step ->(ctx, **) { ctx[:suspend_data] = {remember: OpenStruct.new(id: 1), id: 9} }   # write to domain_ctx[:suspend_data]
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      serialize: true
+  end
+
+  # we can read from {:resume_data}
+  class Serialize3Controller < Serialize1Controller # "process submitted confirm page"
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      pass ->(ctx, **) { ctx[:memory] = ctx[:resume_data] }                           # read/process the suspended data
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      deserialize: true
+  end
+
+# find process_model via id in suspend/resume data (used to be called {process_model_from_resume_data})
+  class Serialize4Controller < Serialize1Controller
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      pass ->(ctx, **) { ctx[:memory] = ctx[:resume_data] }                           # read/process the suspended data
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      deserialize: true,
+      find_process_model: true,
+      deserialize_process_model_id_from_resume_data: true
+
+    def create
+      endpoint "Create", process_model_class: Song do |ctx, endpoint_ctx:, **|
+        render html: "#{endpoint_ctx[:process_model_id].inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
   end
 
-  def create_with_options
-    endpoint "Create", process_model: "yay!" do |ctx, model:, endpoint_ctx:, **|
-      # TODO test process_model
-      render json: [model, endpoint_ctx[:process_model]]
+  # find process_model from resume
+  # FIXME: what is the diff to Controller4?
+  class Serialize5Controller < Serialize1Controller
+    endpoint "Create",
+      domain_activity: Serialize4Controller::Create,
+      deserialize: true,
+      find_process_model: true,
+      deserialize_process_model_id_from_resume_data: true
+
+    def create
+      endpoint "Create", find_process_model: true, process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
     end
   end
 
-  def create_with_or
-    endpoint "Create" do |ctx, model:, **|
-      render json: {or: model}
-    end.Or do |ctx, model:, endpoint_ctx:, **|
-      render json: model, status: 422
+  # find process_model from action_options
+  class Serialize6Controller < Serialize1Controller
+    endpoint "Create",
+      domain_activity: Serialize4Controller::Create,
+      protocol: ApplicationController::Web::Protocol,
+      find_process_model: true
+
+    def create
+      endpoint "Create", find_process_model: true, process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+  end
+
+# Configure only {:find_process_model} and {:protocol}.
+  class Serialize7Controller < Serialize1Controller
+    endpoint find_process_model: true # generic setting for all endpoints in this controller.
+
+    endpoint "Create", # no need to specify {:find_process_model}
+      domain_activity: Serialize4Controller::Create
+
+    endpoint "New",
+      find_process_model: false,
+      domain_activity: Serialize4Controller::Create
+
+    def create
+      endpoint "Create", process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+
+    def new
+      endpoint "New", process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
     end
   end
 end

data/test/rails-app/app/models/song.rb

@@ -1,3 +1,6 @@
 class Song < Struct.new(:id)
-
+  def self.find_by(id: false)
+    return unless id
+    return Song.new(id)
+  end
 end

data/test/rails-app/app/models/user.rb

@@ -1,5 +1,7 @@
 class User < Struct.new(:id, :email)
-  def self.find_by(id:)
+  def self.find_by(id: false, email: false)
+    return User.new(1, "yogi@trb.to") if email == "yogi@trb.to"
     return User.new(id, "yogi@trb.to") if id.to_s == "1"
+    return User.new(id, "seuros@trb.to") if id.to_s == "2"
   end
 end

data/test/rails-app/config/application.rb

@@ -33,6 +33,6 @@ module RailsApp
     # Only loads a smaller set of middleware suitable for API only apps.
     # Middleware like session, flash, cookies can be added back manually.
     # Skip views, helpers and assets when generating a new resource.
-    config.api_only = true
+    config.api_only = false
   end
 end

data/test/rails-app/config/environments/test.rb

@@ -35,4 +35,6 @@ Rails.application.configure do
 
   # Raises error for missing translations.
   # config.action_view.raise_on_missing_translations = true
+
+  config.cipher_key = "e1e1cc87asdfasdfasdfasfdasdfasdfasvhnfvbdb" # FIXME: this usually happens via the new key mechanism in Rails 6
 end

data/test/rails-app/config/routes.rb

@@ -1,11 +1,29 @@
 Rails.application.routes.draw do
   # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
-  resources :songs
-  post "/songs/create_with_options", to: "songs#create_with_options"
-  post "/songs/create_with_or", to: "songs#create_with_or"
+  post "/songs/create_with_options", to: "songs_controller/create_with_options#create"
+  post "/songs/create_or", to: "songs_controller/create_or#create"
+  post "/songs/endpoint_ctx", to: "songs_controller/create_endpoint_ctx#create"
+  post "/songs/create_with_or", to: "songs#create"
+  post "/songs", to: "songs#create_without_block"
+  post "/songs/create_with_protocol_failure", to: "songs_controller/create_with_protocol_failure#create_with_protocol_failure"
+  post "/songs/create_with_options_for_domain_ctx", to: "songs_controller/create_with_options_for_domain_ctx#create"
+  post "/auth/sign_in", to: "auth#sign_in"
 
   post "/v1/songs", to: "api/v1/songs#create"
   get "/v1/songs/:id", to: "api/v1/songs#show"
 
   get "/v1/songs_with_options/:id", to: "api/v1/songs_controller/with_options#show"
+
+  get "/", to: "home#dashboard"
+
+  post "/songs/serialize", to: "songs_controller/serialize#create"
+  post "/songs/copy_from_domain_ctx", to: "songs_controller/create1#create"
+  post "/songs/serialize1", to: "songs_controller/serialize1#create"
+  post "/songs/serialize2", to: "songs_controller/serialize2#create"
+  post "/songs/serialize3", to: "songs_controller/serialize3#create"
+  post "/songs/serialize4", to: "songs_controller/serialize4#create"
+  post "/songs/serialize5", to: "songs_controller/serialize5#create"
+  post "/songs/serialize6", to: "songs_controller/serialize6#create"
+  post "/songs/serialize7", to: "songs_controller/serialize7#create"
+  post "/songs/serialize72", to: "songs_controller/serialize7#new"
 end

data/test/rails-app/test/controllers/api_songs_controller_test.rb

@@ -32,11 +32,13 @@ class ApiSongsControllerTest < ActionDispatch::IntegrationTest
   test "API interface" do
     yogi_jwt = jwt(1)
 
+  # default {success}
+    #:success
     post_json "/v1/songs", {id: 1}, yogi_jwt
 
-  # default {success}
     assert_response 200
     assert_equal "{\"id\":1}", response.body
+    #:success end
 
     # no proper input/params
     post_json "/v1/songs", {}, yogi_jwt
@@ -45,9 +47,11 @@ class ApiSongsControllerTest < ActionDispatch::IntegrationTest
     assert_equal "{\"errors\":{\"message\":\"The submitted data is invalid.\"}}", response.body
 
   # 401
-    post_json "/v1/songs", {authenticate: false}
+    #:not_authenticated
+    post_json "/v1/songs", {} # no token
     assert_response 401
     assert_equal "{\"errors\":{\"message\":\"Authentication credentials were not provided or are invalid.\"}}", response.body
+    #:not_authenticated end
 
   # 403
     post_json "/v1/songs", {id: 1, policy: false}, yogi_jwt

data/test/rails-app/test/controllers/songs_controller_test.rb

@@ -1,7 +1,18 @@
 require "test_helper"
 
 class SongsControllerTest < ActionDispatch::IntegrationTest
-  test "create 200" do
+  test "all possible outcomes with {Create}" do
+  # 401
+    post "/songs", params: {}
+    assert_response 401
+    assert_equal "", response.body
+
+  # sign in
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_equal 1, session[:user_id]
+    # follow_redirect!
+    assert_equal 1, session[:user_id]
+
     post "/songs", params: {id: 1}
   # default {success} block doesn't do anything
     assert_response 200
@@ -12,11 +23,6 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     assert_response 422
     assert_equal "", response.body
 
-  # 401
-    post "/songs", params: {authenticate: false}
-    assert_response 401
-    assert_equal "", response.body
-
   # 403
     post "/songs", params: {policy: false}
     assert_response 403
@@ -25,7 +31,7 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     post "/songs/create_with_options", params: {id: 1}
   # {success} block renders model
     assert_response 200
-    assert_equal "[\"1\",\"yay!\"]", response.body
+    assert_equal "<div>#<struct Song id=\"1\">#<struct User id=2, email=\"seuros@trb.to\"></div>\n", response.body
 
     post "/songs/create_with_options", params: {}
   # default {failure} block doesn't do anything
@@ -35,13 +41,122 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     post "/songs/create_with_or", params: {id: 1}
   # {success} block renders model
     assert_response 200
-    assert_equal "{\"or\":\"1\"}", response.body
+    assert_equal "<div>#<struct Song id=\"1\">#<struct User id=1, email=\"yogi@trb.to\"></div>\n", response.body
 
     post "/songs/create_with_or", params: {}
-  # default {failure} block doesn't do anything
+    assert_response 200
+    assert_equal %{<div>#<struct errors=nil></div>\n}, response.body
+
+  # Or { render status: 422 }
+    post "/songs/create_or", params: {}
     assert_response 422
-    assert_equal "null", response.body
+    assert_equal %{null}, response.body
+
+  # {:endpoint_ctx} is available in blocks
+    post "/songs/endpoint_ctx", params: {id: 1}
+    assert_response 200
+    assert_equal "Created", response.body
+    # assert_equal "[\"domain_ctx\",\"session\",\"controller\",\"config_source\",\"current_user\",\"domain_activity_return_signal\"]", response.body
+
+    # {:options_for_domain_ctx} overrides domain_ctx
+    post "/songs/create_with_options_for_domain_ctx", params: {id: 1} # params get overridden
+    assert_response 200
+    assert_equal "<div>#<struct Song id=999></div>\n", response.body
+  end
+
+  test "override protocol_failure" do
+    post "/songs/create_with_protocol_failure", params: {}
+    assert_response 500
+    assert_equal "wrong login, app crashed", response.body
+  end
+
+  test "serializing/deserializing/find_process_model_from_resume_data" do
+  # # 401
+  #   post "/songs/serialize/"
+  #   assert_response 401
+
+  # sign in
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_equal 1, session[:user_id]
+
+
+  # When {:encrypted_resume_data} is {nil} the entire deserialize cycle is skipped.
+  # Nothing gets serialized.
+  # This is considered an error since we're expecting resume data.
+    post "/songs/serialize1/", params: {} # encrypted_resume_data: nil
+    assert_response 500
+    assert_equal "xxx", response.body # DISCUSS: is this an application or a protocol error?
+
+  # Nothing deserialized, but {:remember} serialized
+  # "confirm_delete form"
+    post "/songs/serialize2/", params: {} # {:remember} serialized
+    assert_response 200
+    encrypted_string = "0109C4E535EDA2CCE8CD69E50C179F5950CC4A2A898504F951C995B6BCEAFE1DFAB02894854B96B9D11C23E25DB5FB03"
+    assert_equal "false/nil/#{encrypted_string}", response.body
+
+  # {:remember} deserialized
+  # "submit confirm_delete"
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize3/", params: {encrypted_resume_data: encrypted_string} # {:remember} serialized
+    assert_response 200
+    assert_equal "false/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+
+  # retrieve process_model via id in {:resume_data}
+  # we can see {endpoint_ctx[:process_model_id]}
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize4/", params: {encrypted_resume_data: encrypted_string}
+    assert_response 200
+    assert_equal "9/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+
+  # retrieve process_model via {:resume_data}'s serialized id.
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize5/", params: {encrypted_resume_data: encrypted_string}
+    assert_response 200
+    assert_equal "#<struct Song id=9>/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+    # model not found
+    post "/songs/serialize5/", params: {encrypted_resume_data: "36C61CCE30E6CFDE637DF0DA9257CC49"}
+    assert_response 404
+    assert_equal "", response.body
+
+  # find model without serialize from params, no serialized stuff passed
+  # DISCUSS: this could be a different test
+    post "/songs/serialize6/", params: {id: 1}
+    assert_response 200
+    assert_equal "#<struct Song id=\"1\">/#<struct Song id=\"1\">/", response.body
+    # model not found
+    post "/songs/serialize6/", params: {id: nil}
+    assert_response 404
+    assert_equal "", response.body
+
+  # {find_process_model: true} set on controller level, for all endpoints.
+    post "/songs/serialize7/", params: {id: 1}
+    assert_response 200
+    assert_equal "#<struct Song id=\"1\">/#<struct Song id=\"1\">/", response.body
+  # {find_process_model: false} overrides controller setting
+    post "/songs/serialize72/", params: {id: 1}
+    assert_response 200
+    assert_equal "false/false/", response.body
+
+
+# {#insert_copy_from_domain_ctx!} provides {:process_model}
+    post "/songs/copy_from_domain_ctx", params: {id: 1}
+    assert_response 200
+    assert_equal %{#<struct Song id="1">}, response.body
+  end
+
+  test "sign_in" do
+  # wrong credentials
+    post "/auth/sign_in", params: {}
+    assert_response 401
+    assert_equal "", response.body
+    assert_nil session[:user_id]
 
+  # valid signin
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_response 302
+    # assert_equal "", response.body
+    assert_equal 1, session[:user_id]
+    assert_redirected_to "/"
   end
 end
 

data/trailblazer-endpoint.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["apotonick@gmail.com"]
   spec.description   = %q{Endpoints handle authentication, policies, run your domain operation and set up the rendering.}
   spec.summary       = %q{Endpoints handle authentication, policies, run your domain operation and set up the rendering.}
-  spec.homepage      = "http://trailblazer.to/gems/operation/endpoint.html"
+  spec.homepage      = "http://trailblazer.to/"
   spec.license       = "LGPL-3.0"
 
   spec.files         = `git ls-files`.split($/)
@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.3.0", "< 0.4.0"
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.4.0", "< 0.5.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.9
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-09 00:00:00.000000000 Z
+date: 2021-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,9 @@ files:
 - lib/trailblazer/endpoint/dsl.rb
 - lib/trailblazer/endpoint/options.rb
 - lib/trailblazer/endpoint/protocol.rb
+- lib/trailblazer/endpoint/protocol/cipher.rb
+- lib/trailblazer/endpoint/protocol/controller.rb
+- lib/trailblazer/endpoint/protocol/find_process_model.rb
 - lib/trailblazer/endpoint/rails.rb
 - lib/trailblazer/endpoint/version.rb
 - test/adapter/api_test.rb
@@ -129,13 +132,19 @@ files:
 - test/rails-app/app/concepts/auth/jwt.rb
 - test/rails-app/app/concepts/auth/operation/authenticate.rb
 - test/rails-app/app/concepts/auth/operation/policy.rb
+- test/rails-app/app/concepts/song/cell/create.rb
+- test/rails-app/app/concepts/song/cell/new.rb
 - test/rails-app/app/concepts/song/operation/create.rb
 - test/rails-app/app/concepts/song/operation/show.rb
 - test/rails-app/app/concepts/song/representer.rb
+- test/rails-app/app/concepts/song/view/create.erb
+- test/rails-app/app/concepts/song/view/new.erb
 - test/rails-app/app/controllers/api/v1/songs_controller.rb
 - test/rails-app/app/controllers/application_controller.rb
 - test/rails-app/app/controllers/application_controller/api.rb
 - test/rails-app/app/controllers/application_controller/web.rb
+- test/rails-app/app/controllers/auth_controller.rb
+- test/rails-app/app/controllers/home_controller.rb
 - test/rails-app/app/controllers/songs_controller.rb
 - test/rails-app/app/models/application_record.rb
 - test/rails-app/app/models/concerns/.keep
@@ -178,7 +187,7 @@ files:
 - test/rails-app/tmp/.keep
 - test/test_helper.rb
 - trailblazer-endpoint.gemspec
-homepage: http://trailblazer.to/gems/operation/endpoint.html
+homepage: http://trailblazer.to/
 licenses:
 - LGPL-3.0
 metadata: {}
@@ -197,8 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Endpoints handle authentication, policies, run your domain operation and
@@ -222,13 +230,19 @@ test_files:
 - test/rails-app/app/concepts/auth/jwt.rb
 - test/rails-app/app/concepts/auth/operation/authenticate.rb
 - test/rails-app/app/concepts/auth/operation/policy.rb
+- test/rails-app/app/concepts/song/cell/create.rb
+- test/rails-app/app/concepts/song/cell/new.rb
 - test/rails-app/app/concepts/song/operation/create.rb
 - test/rails-app/app/concepts/song/operation/show.rb
 - test/rails-app/app/concepts/song/representer.rb
+- test/rails-app/app/concepts/song/view/create.erb
+- test/rails-app/app/concepts/song/view/new.erb
 - test/rails-app/app/controllers/api/v1/songs_controller.rb
 - test/rails-app/app/controllers/application_controller.rb
 - test/rails-app/app/controllers/application_controller/api.rb
 - test/rails-app/app/controllers/application_controller/web.rb
+- test/rails-app/app/controllers/auth_controller.rb
+- test/rails-app/app/controllers/home_controller.rb
 - test/rails-app/app/controllers/songs_controller.rb
 - test/rails-app/app/models/application_record.rb
 - test/rails-app/app/models/concerns/.keep