trailblazer-future 2.1.0.rc1

data/lib/trailblazer/v2_1/rails/cell.rb

@@ -0,0 +1,22 @@
+module Trailblazer::V2_1::Rails::Controller::Cell
+  private # rubocop:disable Lint/UselessAccessModifier
+
+  module Render
+    def render(cell = nil, options = {}, *, &block)
+      return super unless cell.kind_of?(::Cell::ViewModel)
+
+      render_cell(cell, options)
+    end
+
+    def render_cell(cell, options)
+      options = options.reverse_merge(layout: true)
+
+      # render the cell.
+      content = cell.()
+
+      render({html: content}.merge(options))
+    end
+  end
+
+  include Render unless method_defined?(:render_cell)
+end

data/lib/trailblazer/v2_1/rails/controller.rb

@@ -0,0 +1,66 @@
+module Trailblazer::V2_1::Rails
+  module Controller
+    def run_v21(operation, *dependencies)
+      result = if Rails.application.config.trailblazer.enable_tracing
+                 _run_operation_v21(operation, :trace, *dependencies).tap { |r| _operation_trace(r) }
+               else
+                 _run_operation_v21(operation, :call, *dependencies)
+               end
+
+      _assign_trb_ivars(result)
+
+      yield(result) if result.success? && block_given?
+
+      @_result = result
+    end
+
+    alias run run_v21 unless method_defined?(:run)
+
+    private
+
+    # Override to tweak params. Not recommended.
+    # Use a deserializer instead.
+    def _run_params(params)
+      params
+    end
+
+    # This is where we can inject Dry.RB containers and the like via dependencies.
+    def _run_runtime_options(ctx = {}, *dependencies)
+      [_run_options(ctx), *dependencies]
+    end
+
+    # Override this to inject dependencies such as "current_user"
+    # into the runtime options.
+    def _run_options(ctx)
+      ctx
+    end
+
+    def _run_operation_v21(operation, call_method, *dependencies)
+      operation.send(
+        call_method,
+        {params: _run_params(self.params)}.merge(*_run_runtime_options(*dependencies)) # rubocop:disable Style/RedundantSelf
+      )
+    end
+
+    def _operation_trace(result)
+      puts result.wtf?
+    end
+
+    def _assign_trb_ivars(result)
+      @model = result[:model]
+      @form  = _wrap_with_trb_form(result["contract.default"], @model.class)
+    end
+
+    def _wrap_with_trb_form(form, model)
+      Trailblazer::V2_1::Rails::Form.new(form, model)
+    end
+
+    module Result
+      def result
+        @_result
+      end
+    end
+
+    include Result
+  end
+end

data/lib/trailblazer/v2_1/rails/form.rb

@@ -0,0 +1,21 @@
+module Trailblazer::V2_1
+  class Rails::Form < SimpleDelegator
+    def initialize(delegated, model_class)
+      super(delegated)
+      @model_class = model_class
+    end
+
+    def self.name
+      # for whatever reason, validations climb up the inheritance tree and require _every_ class to have a name (4.1).
+      "Reform::Form"
+    end
+
+    def model_name
+      ::ActiveModel::Name.new(self, nil, @model_class.to_s.camelize)
+    end
+
+    def to_model
+      self
+    end
+  end
+end

data/lib/trailblazer/v2_1/rails/railtie.rb

@@ -0,0 +1,31 @@
+require "rails/railtie"
+require "trailblazer/v2_1/loader"
+require "trailblazer/v2_1/rails/railtie/extend_application_controller"
+require "trailblazer/v2_1/rails/railtie/loader"
+
+module Trailblazer::V2_1
+  class Railtie < ::Rails::Railtie
+    config.trailblazer = ActiveSupport::OrderedOptions.new
+    ## Accept also an Array of controllers
+    config.trailblazer.application_controller ||= 'ActionController::Base'
+    config.trailblazer.enable_loader ||= true
+    config.trailblazer.use_loader ||= true # TODO: remove with next release
+    config.trailblazer.enable_tracing ||= false
+
+    include Loader
+    include ExtendApplicationController
+
+    private
+
+    def reloader_class
+      # Rails 5.0.0.rc1 says:
+      # DEPRECATION WARNING: to_prepare is deprecated and will be removed from Rails 5.1
+      # (use ActiveSupport::Reloader.to_prepare instead)
+      if Gem.loaded_specs['activesupport'].version >= Gem::Version.new('5')
+        ActiveSupport::Reloader
+      else
+        ActionDispatch::Reloader
+      end
+    end
+  end
+end

data/lib/trailblazer/v2_1/rails/railtie/extend_application_controller.rb

@@ -0,0 +1,28 @@
+require "active_support/concern"
+
+module Trailblazer::V2_1
+  class Railtie < ::Rails::Railtie
+    module ExtendApplicationController
+      extend ActiveSupport::Concern
+
+      included do
+        initializer "trailblazer.application_controller", before: "finisher_hook" do
+          reloader_class.to_prepare do
+            ActiveSupport.on_load(:action_controller) do |app|
+              Trailblazer::V2_1::Railtie.extend_application_controller!(app)
+            end
+          end
+        end
+
+        def extend_application_controller!(app)
+          controllers = Array(::Rails.application.config.trailblazer.application_controller).map(&:to_s)
+          if controllers.include? app.to_s
+            app.send :include, Trailblazer::V2_1::Rails::Controller
+            app.send :include, Trailblazer::V2_1::Rails::Controller::Cell if defined?(::Cell)
+          end
+          app
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/v2_1/rails/railtie/loader.rb

@@ -0,0 +1,58 @@
+require "active_support/concern"
+
+module Trailblazer::V2_1
+  class Railtie < ::Rails::Railtie
+    module Loader
+      extend ActiveSupport::Concern
+
+      included do # rubocop:disable Metrics/BlockLength
+        def self.load_concepts(app)
+          load_for(app)
+
+          engines.each { |engine| load_for(engine) }
+        end
+
+        def self.engines
+          ::Rails.application.railties.select { |tie| tie.is_a?(::Rails::Engine) }
+        end
+
+        def self.load_for(app)
+          Trailblazer::V2_1::Loader.new.(prepend: AllModelFiles, root: app.root) { |file| require_dependency(file) }
+        end
+
+        # Prepend model file, before the concept files like operation.rb get loaded.
+        ModelFile = lambda do |input, options|
+          model = "app/models/#{options[:name]}.rb"
+          File.exist?(model) ? [model] + input : input
+        end
+
+        # Load all model files before any TRB files.
+        AllModelFiles = lambda do |input, options|
+          Dir.glob("#{options[:root]}/app/models/**/*.rb").sort + input
+        end
+
+        # This is to autoload Operation::Dispatch, etc. I'm simply assuming people find this helpful in Rails.
+        initializer "trailblazer.library_autoloading" do
+        end
+
+        # thank you, http://stackoverflow.com/a/17573888/465070
+        initializer "trailblazer.install", after: "reform.form_extensions" do |app|
+          # the trb autoloading has to be run after initializers have been loaded, so we can tweak inclusion of features in
+          # initializers.
+
+          # TODO: remove me in the next version!
+          if config.trailblazer.use_loader.to_s.present?
+            warn "DEPRECATION WARNING [trailblazer-rails]: please use config.trailblazer.enable_loader" \
+                 " to enable/disable the loader. config.trailblazer.use_loader will be removed from version > 2.1.6"
+          end
+
+          if config.trailblazer.enable_loader || config.trailblazer.use_loader
+            reloader_class.to_prepare do
+              Trailblazer::V2_1::Railtie.load_concepts(app)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/v2_1/rails/test/integration.rb

@@ -0,0 +1,6 @@
+require "minitest/rails/capybara" # loads Capybara, etc.
+
+module Trailblazer::V2_1::Test
+  class Integration < Capybara::Rails::TestCase
+  end
+end

data/lib/trailblazer/v2_1/versions.txt

@@ -0,0 +1,7 @@
+'trailblazer' => 'v2.1.0.rc1'
+'trailblazer-activity' => 'v0.7.1'
+'trailblazer-context' => 'v0.1.2'
+'trailblazer-macro' => 'v2.1.0.rc1'
+'trailblazer-macro-contract' => 'v2.1.0.rc1'
+'trailblazer-operation' => 'v0.4.1'
+'trailblazer-rails' => 'v2.1.6'

data/test/rails5.0/.gitignore

@@ -0,0 +1,17 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*
+!/log/.keep
+/tmp

data/test/rails5.0/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+# Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
+gem 'rails', '~> 5.0.0'
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3'
+# Use SCSS for stylesheets
+
+gem "trailblazer"
+gem "trailblazer-future", path: '../../../trailblazer-future'
+gem "trailblazer-rails"
+
+gem "minitest-rails-capybara"
+
+gem "trailblazer-cells"
+gem "cells-rails"
+gem "cells-erb"
+
+gem "minitest-line"
+
+gem "reform-rails"

data/test/rails5.0/Rakefile

@@ -0,0 +1,3 @@
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/test/rails5.0/app/concepts/artist/cell/dashboard.rb

@@ -0,0 +1,7 @@
+module Artist::Cell
+  class Dashboard < Trailblazer::Cell
+    def theme
+      options[:theme]
+    end
+  end
+end

data/test/rails5.0/app/concepts/artist/cell/show.rb

@@ -0,0 +1,4 @@
+module Artist::Cell
+  class Show < Trailblazer::Cell
+  end
+end

data/test/rails5.0/app/concepts/artist/view/dashboard.erb

@@ -0,0 +1,4 @@
+<h1 theme="<%= theme %>">
+  <%= model.title %>
+</h1>
+<%= link_to artists_path %>

data/test/rails5.0/app/concepts/artist/view/show.erb

@@ -0,0 +1 @@
+<p><%= model["model"].inspect %>,<%= model["contract.default"].class.superclass %>,<%= options[:song].inspect %></p>

data/test/rails5.0/app/concepts/params/operation/with_args.rb

@@ -0,0 +1,5 @@
+module Params
+  class WithArgs < Trailblazer::Operation
+    step ->(options) { options["x"] = %{#{options["params"].to_h} #{options["current_user"] }} }
+  end
+end

data/test/rails5.0/app/concepts/song/contract/form.rb

@@ -0,0 +1,6 @@
+module Song::Contract
+  class Form < Reform::Form
+    property :id
+    property :title
+  end
+end

data/test/rails5.0/app/concepts/song/operation/create.rb

@@ -0,0 +1,15 @@
+class Song::New < Trailblazer::Operation
+  step Model( Song, :new )
+  step Contract::Build(constant: Song::Contract::Form)
+  step :set_current_user!
+
+  def set_current_user!(_options, model:, current_user:, **)
+    model.user_name = current_user
+  end
+end
+
+class Song::Create < Trailblazer::Operation
+  step Nested( Song::New )
+  step Contract::Validate()
+  step Contract::Persist()
+end

data/test/rails5.0/app/concepts/song/operation/show.rb

@@ -0,0 +1,3 @@
+class Song::Show < Trailblazer::Operation
+  step Model( Song, :new )
+end

data/test/rails5.0/app/concepts/song/operation/update.rb

@@ -0,0 +1,15 @@
+class Song::Update < Trailblazer::V2_1::Operation
+  class Present < Trailblazer::V2_1::Operation
+    step Model(Song, :find_by)
+    step Contract::Build(constant: Song::Contract::Form)
+    step Policy::Guard(:policy)
+
+    def policy(_options, model:, current_user:, **)
+      model.user_name == current_user
+    end
+  end
+
+  step Nested(Present)
+  step Contract::Validate()
+  step Contract::Persist()
+end

data/test/rails5.0/app/controllers/application_controller.rb

@@ -0,0 +1,46 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+
+  def run(operation, params=self.params, *dependencies)
+    if operation < Trailblazer::Operation
+      super
+    else
+      result = operation.({params: _run_params(self.params) }.merge(*_run_runtime_options(*dependencies)))
+
+      @model = result[:model]
+      @form  = Rails::Form.new( result[ "contract.default" ], @model.class )
+
+      yield(result) if result.success? && block_given?
+
+      @_result = result
+    end
+  end
+
+  private
+
+  def _run_options(options)
+    options.merge("current_user" => "user_name" )
+  end
+
+  class Rails::Form < SimpleDelegator
+    def initialize(delegated, model_class)
+      super(delegated)
+      @model_class = model_class
+    end
+
+    def self.name
+      # for whatever reason, validations climb up the inheritance tree and require _every_ class to have a name (4.1).
+      "Reform::Form"
+    end
+
+    def model_name
+      ::ActiveModel::Name.new(self, nil, @model_class.to_s.camelize)
+    end
+
+    def to_model
+      self
+    end
+  end
+end

data/test/rails5.0/app/controllers/args_controller.rb

@@ -0,0 +1,5 @@
+class ArgsController < ApplicationController
+  def with_args
+    run Params::WithArgs, { fake: "bla" }, "current_user" => Module
+  end
+end

data/test/rails5.0/app/controllers/artists_controller.rb

@@ -0,0 +1,24 @@
+class ArtistsController < ApplicationController
+  def dashboard
+    model = Struct.new(:title).new("Dashboard")
+    render cell( Artist::Cell::Dashboard, model, theme: "cute" )
+  end
+
+  def widget
+    model = Struct.new(:title).new("Dashboard")
+    render cell( Artist::Cell::Dashboard, model ), layout: false
+  end
+
+  include Trailblazer::Rails::Controller::Result
+
+  def with_expose
+    run Song::New
+    render cell( Artist::Cell::Show, result )
+    # render cell( Artist::Cell::Show, expose(search: @search, %w{model contract.default}) )
+  end
+
+  def with_expose_and_args
+    run Song::New
+    render cell( Artist::Cell::Show, result, song: @model )
+  end
+end