trailblazer 0.2.2 → 0.3.0

data/lib/trailblazer/operation/responder.rb

@@ -18,7 +18,7 @@ module Trailblazer::Operation::Responder
     [1]
   end
 
-  def to_json(*)
-    self.class.representer_class.new(model).to_json
+  def to_model
+    @model
   end
 end

data/lib/trailblazer/operation/uploaded_file.rb

@@ -18,9 +18,9 @@ module Trailblazer
       path = persist!
 
       hash = {
-        :filename       => @uploaded.original_filename,
-        :type           => @uploaded.content_type,
-        :tempfile_path  => path
+        filename: @uploaded.original_filename,
+        type: @uploaded.content_type,
+        tempfile_path: path
       }
 
       cleanup!
@@ -40,7 +40,7 @@ module Trailblazer
       file.close # TODO: can we test that?
       File.unlink(file)
 
-      ActionDispatch::Http::UploadedFile.new(hash.merge(:tempfile => tmp))
+      ActionDispatch::Http::UploadedFile.new(hash.merge(tempfile: tmp))
     end
 
   private

data/lib/trailblazer/operation/worker.rb

@@ -1,10 +1,10 @@
 require 'sidekiq/worker'
-# require 'active_support/hash_with_indifferent_access'
 require 'active_support/core_ext/hash/indifferent_access'
 
 
 class Trailblazer::Operation
   # only kicks in when Operation::run, #run will still do it real-time
+  # Works with Reform 2, only.
   module Worker
     def self.included(base)
       base.send(:include, Sidekiq::Worker) # TODO: this will work with any bg gem.
@@ -61,22 +61,20 @@ class Trailblazer::Operation
     private
       module ClassMethods
         def file_marshaller_representer
-          @file_marshaller_representer ||= contract_class.schema.apply do |dfn|
-            dfn.delete!(:prepare)
-
+          @file_marshaller_representer ||= contract_class.schema(include: [Representable::Hash]).apply do |dfn|
             dfn.merge!(
-              :getter => lambda { |*| self[dfn.name.to_sym] },
-              :setter => lambda { |fragment, *| self[dfn.name.to_s] = fragment }
+              getter: lambda { |*| self[dfn.name.to_sym] },
+              setter: lambda { |fragment, *| self[dfn.name.to_s] = fragment }
             ) # FIXME: allow both sym and str.
 
-            dfn.merge!(:class => Hash) and next if dfn[:form] # nested properties need a class for deserialization.
+            dfn.merge!(class: Hash) and next if dfn[:form] or dfn[:twin] # nested properties need a class for deserialization.
             next unless dfn[:file]
 
             # TODO: where do we set /tmp/uploads?
             dfn.merge!(
-              :serialize   => lambda { |file, *| Trailblazer::Operation::UploadedFile.new(file, :tmp_dir => "/tmp/uploads").to_hash },
-              :deserialize => lambda { |object, hash, *| Trailblazer::Operation::UploadedFile.from_hash(hash) },
-              :class       => Hash
+              serialize: lambda { |file, *| Trailblazer::Operation::UploadedFile.new(file, tmp_dir: "/tmp/uploads").to_hash },
+              deserialize: lambda { |object, hash, *| Trailblazer::Operation::UploadedFile.from_hash(hash) },
+              class: Hash
             )
           end
         end

data/lib/trailblazer/rails/railtie.rb

@@ -1,6 +1,6 @@
 module Trailblazer
   class Railtie < Rails::Railtie
-    def self.autoload_crud_operations(app)
+    def self.autoload_operations(app)
       Dir.glob("app/concepts/**/crud.rb") do |f|
         path  = f.sub("app/concepts/", "")
         model = path.sub("/crud.rb", "")
@@ -10,16 +10,19 @@ module Trailblazer
       end
     end
 
+    def self.autoload_cells(app)
+      Dir.glob("app/concepts/**/*cell.rb") do |f|
+        require_dependency "#{app.root}/#{f}" # load app/concepts/{concept}/cell.rb.
+      end
+    end
+
     # thank you, http://stackoverflow.com/a/17573888/465070
     initializer 'trailblazer.install', after: :load_config_initializers do |app|
       # the trb autoloading has to be run after initializers have been loaded, so we can tweak inclusion of features in
       # initializers.
-      if Rails.configuration.cache_classes
-        Trailblazer::Railtie.autoload_crud_operations(app)
-      else
-        ActionDispatch::Reloader.to_prepare do
-          Trailblazer::Railtie.autoload_crud_operations(app)
-        end
+      ActionDispatch::Reloader.to_prepare do
+        Trailblazer::Railtie.autoload_operations(app)
+        Trailblazer::Railtie.autoload_cells(app)
       end
     end
   end

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/test/collection_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+require "trailblazer/operation/collection"
+
+class CollectionTest < MiniTest::Spec
+  Song = Struct.new(:title, :id) do
+    class << self
+      attr_accessor :all_records
+
+      def all
+        all_records
+      end
+    end
+  end
+
+
+  class CreateOperation < Trailblazer::Operation
+    include CRUD
+    model Song
+    action :create
+
+    contract do
+      property :title
+      validates :title, presence: true
+    end
+
+    def process(params)
+      validate(params[:song]) do |f|
+        f.sync
+      end
+    end
+  end
+
+  class FetchCollectionOperation < CreateOperation
+    include Trailblazer::Operation::Collection
+
+    model Song
+
+    contract do
+      property :title
+    end
+
+    def model!(params)
+      Song.all
+    end
+  end
+
+  # ::present.
+  it do
+    Song.all_records = [
+      CreateOperation.(song: {title: "Blue Rondo a la Turk"}).model,
+      CreateOperation.(song: {title: "Mercy Day For Mr. Vengeance"}).model
+    ]
+    op = FetchCollectionOperation.present(user_id: 0)
+    op.model.must_equal Song.all_records
+  end
+end

data/test/crud_test.rb

@@ -5,6 +5,7 @@ class CrudTest < MiniTest::Spec
   Song = Struct.new(:title, :id) do
     class << self
       attr_accessor :find_result # TODO: eventually, replace with AR test.
+      attr_accessor :all_records
 
       def find(id)
         find_result
@@ -102,6 +103,7 @@ class CrudTest < MiniTest::Spec
   end
 
 
+
   # Op#setup_model!
   class SetupModelOperation < CreateOperation
     def setup_model!(params)
@@ -141,4 +143,24 @@ class CrudTest < MiniTest::Spec
   end
 
   it { ContractKnowsModelNameOperation.present(song: {title: "Direct Hit"}).contract.class.model_name.to_s.must_equal "CrudTest::Song" }
-end
+
+
+  # allow passing validate(params, model, contract_class)
+  class OperationWithPrivateContract < Trailblazer::Operation
+    include CRUD
+    model Song
+
+    class Contract < Reform::Form
+      property :title
+    end
+
+    def process(params)
+      validate(params[:song], model, Contract) do |f|
+        f.sync
+      end
+    end
+  end
+
+  # uses private Contract class.
+  it { OperationWithPrivateContract.(song: {title: "Blue Rondo a la Turk"}).model.title.must_equal "Blue Rondo a la Turk" }
+end

data/test/dispatch_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+# callbacks are tested in Disposable::Callback::Group.
+class OperationCallbackTest < MiniTest::Spec
+  Song = Struct.new(:name)
+
+  class Create < Trailblazer::Operation
+    include Dispatch
+
+    contract do
+      property :name
+    end
+
+    callback do
+      on_change :notify_me!
+      on_change :notify_you!
+    end
+
+    # TODO: always dispatch, pass params.
+
+    def process(params)
+      @model = Song.new
+
+      validate(params, @model) do
+        dispatch!
+      end
+    end
+
+    def dispatched
+      @dispatched ||= []
+    end
+
+  private
+    def notify_me!(*)
+      dispatched << :notify_me!
+    end
+
+    def notify_you!(*)
+      dispatched << :notify_you!
+    end
+  end
+
+
+  class Update < Create
+    # TODO: allow skipping groups.
+    # skip_dispatch :notify_me!
+
+    callback do
+      remove! :on_change, :notify_me!
+    end
+  end
+
+
+  it "invokes all callbacks" do
+    op = Create.({"name"=>"Keep On Running"})
+    op.dispatched.must_equal [:notify_me!, :notify_you!]
+  end
+
+  it "does not invoke removed callbacks" do
+    op = Update.({"name"=>"Keep On Running"})
+    op.dispatched.must_equal [:notify_you!]
+  end
+end

data/test/operation_test.rb

@@ -1,27 +1,45 @@
-require 'test_helper'
+require "test_helper"
 
-module Comparable
-  # only used for test.
-  def ==(b)
-    self.class == b.class
+module Inspect
+  def inspect
+    "<#{self.class.to_s.split("::").last} @model=#{@model}>"
   end
+  alias_method :to_s, :inspect
 end
 
 class OperationSetupParamsTest < MiniTest::Spec
   class OperationSetupParam < Trailblazer::Operation
     def process(params)
-      params
+      @model = params
     end
 
     def setup_params!(params)
       params.merge!(garrett: "Rocks!")
     end
+
+    include Inspect
   end
 
-  let (:operation) { OperationSetupParam.new }
-  it { OperationSetupParam.run({valid: true}).must_equal [true, {valid: true, garrett: "Rocks!"}] }
+  # allows you changing params in #setup_params!.
+  it { OperationSetupParam.run({valid: true}).to_s.must_equal "[true, <OperationSetupParam @model={:valid=>true, :garrett=>\"Rocks!\"}>]" }
 end
 
+# Operation#model.
+class OperationModelTest < MiniTest::Spec
+  class Operation < Trailblazer::Operation
+    def process(params)
+    end
+
+    def model!(params)
+      params
+    end
+  end
+
+  # #model.
+  it { Operation.(Object).model.must_equal Object }
+end
+
+
 class OperationRunTest < MiniTest::Spec
   class Operation < Trailblazer::Operation
     # allow providing your own contract.
@@ -29,15 +47,13 @@ class OperationRunTest < MiniTest::Spec
       def initialize(*)
       end
       def validate(params)
-        return false if params == false # used in ::[] with exception test.
-        "local #{params}"
+        return true if params == "yes, true"
+        false
       end
 
       def errors
         Struct.new(:to_s).new("Op just calls #to_s on Errors!")
       end
-
-      include Comparable
       self
     end
 
@@ -45,68 +61,66 @@ class OperationRunTest < MiniTest::Spec
       model = Object
       validate(params, model)
     end
-  end
 
-  let (:operation) { Operation.new.extend(Comparable) }
+    include Inspect
+  end
 
   # contract is inferred from self::contract_class.
-  it { Operation.run(true).must_equal ["local true", operation] }
+  # ::run returns result set when run without block.
+  it { Operation.run("not true").to_s.must_equal %{[false, <Operation @model=>]} }
+  it { Operation.run("yes, true").to_s.must_equal %{[true, <Operation @model=>]} }
 
-  # return operation when ::call
-  it { Operation.call(true).must_equal operation }
-  it { Operation.(true).must_equal operation }
-  # #[] is alias for .()
-  it { Operation[true].must_equal operation }
-
-  # ::[] raises exception when invalid.
+  # ::call raises exception when invalid.
   it do
-    exception = assert_raises(Trailblazer::Operation::InvalidContract) { Operation[false] }
+    exception = assert_raises(Trailblazer::Operation::InvalidContract) { Operation.("not true") }
     exception.message.must_equal "Op just calls #to_s on Errors!"
   end
 
-  # ::run without block returns result set.
-  it { Operation.run(true).must_equal  ["local true", operation] }
-  it { Operation.run(false).must_equal [false, operation] }
+  # return operation when ::call
+  it { Operation.("yes, true").to_s.must_equal %{<Operation @model=>} }
+  # #[] is alias for .()
+  it { Operation["yes, true"].to_s.must_equal %{<Operation @model=>} }
+
 
   # ::run with block returns operation.
   # valid executes block.
   it "block" do
     outcome = nil
-    res = Operation.run(true) do
+    res = Operation.run("yes, true") do
       outcome = "true"
     end
 
     outcome.must_equal "true" # block was executed.
-    res.must_equal operation
+    res.to_s.must_equal %{<Operation @model=>}
   end
 
   # invalid doesn't execute block.
   it "block, invalid" do
     outcome = nil
-    res = Operation.run(false) do
+    res = Operation.run("no, not true, false") do
       outcome = "true"
     end
 
     outcome.must_equal nil # block was _not_ executed.
-    res.must_equal operation
+    res.to_s.must_equal %{<Operation @model=>}
   end
 
   # block yields operation
   it do
     outcome = nil
-    res = Operation.run(true) do |op|
+    res = Operation.run("yes, true") do |op|
       outcome = op
     end
 
-    outcome.must_equal operation # block was executed.
-    res.must_equal operation
+    outcome.to_s.must_equal %{<Operation @model=>} # block was executed.
+    res.to_s.must_equal %{<Operation @model=>}
   end
 
-  # Operation#contract returns @contract
-  let (:contract)  { Operation::Contract.new }
-  it { Operation.(true).contract.must_equal contract }
+  # # Operation#contract returns @contract
+  it { Operation.("yes, true").contract.class.to_s.must_equal "OperationRunTest::Operation::Contract" }
 end
 
+
 class OperationTest < MiniTest::Spec
   class Operation < Trailblazer::Operation
     def process(params)
@@ -117,36 +131,20 @@ class OperationTest < MiniTest::Spec
   # contract is retrieved from ::contract_class.
   it { assert_raises(NoMethodError) { Operation.run({}) } } # TODO: if you call #validate without defining a contract, the error is quite cryptic.
 
-  # no #process method defined.
-  # DISCUSS: not sure if we need that.
-  # class OperationWithoutProcessMethod < Trailblazer::Operation
-  # end
-
-  # it { OperationWithoutProcessMethod[{}].must_be_kind_of OperationWithoutProcessMethod }
-
-  # #process and no validate.
+  # test #invalid!
   class OperationWithoutValidateCall < Trailblazer::Operation
     def process(params)
       params || invalid!(params)
     end
+
+    include Inspect
   end
 
   # ::run
-  it { OperationWithoutValidateCall.run(Object).must_equal [true, Object] }
-  # ::[]
-  it { OperationWithoutValidateCall.(Object).must_equal(Object) }
-  # ::run with invalid!
-  it { OperationWithoutValidateCall.run(nil).must_equal [false, nil] }
-  # ::run with block, invalid
-  it do
-    OperationWithoutValidateCall.run(false) { @outcome = "true" }.must_equal false
-    @outcome.must_equal nil
-  end
-  # ::run with block, valid
-  it do
-    OperationWithoutValidateCall.run(true) { @outcome = "true" }.must_equal true
-    @outcome.must_equal "true"
-  end
+  it { OperationWithoutValidateCall.run(true).to_s.must_equal %{[true, <OperationWithoutValidateCall @model=>]} }
+  # invalid.
+  it { OperationWithoutValidateCall.run(false).to_s.must_equal %{[false, <OperationWithoutValidateCall @model=>]} }
+
 
   # #validate yields contract when valid
   class OperationWithValidateBlock < Trailblazer::Operation
@@ -162,7 +160,7 @@ class OperationTest < MiniTest::Spec
 
     def process(params)
       validate(params, Object.new) do |c|
-        @secret_contract = c
+        @secret_contract = c.class
       end
     end
 
@@ -170,58 +168,15 @@ class OperationTest < MiniTest::Spec
   end
 
   it { OperationWithValidateBlock.run(false).last.secret_contract.must_equal nil }
-  it('zzz') { OperationWithValidateBlock.(true).secret_contract.must_equal OperationWithValidateBlock.contract_class.new.extend(Comparable) }
+  it { OperationWithValidateBlock.(true).secret_contract.must_equal OperationWithValidateBlock::Contract }
 
-  # manually setting @valid
-  class OperationWithManualValid < Trailblazer::Operation
-    def process(params)
-      @valid = false
-      params
-    end
-  end
-
-  # ::run
-  it { OperationWithManualValid.run(Object).must_equal [false, Object] }
-  # ::[]
-  it { OperationWithManualValid.(Object).must_equal(Object) }
-
-  # re-assign params
-  class OperationReassigningParams < Trailblazer::Operation
-    def process(params)
-      params = params[:title]
-      params
-    end
-  end
 
-  # ::run
-  it { OperationReassigningParams.run({:title => "Day Like This"}).must_equal [true, "Day Like This"] }
-
-  # #invalid!(result)
-  class OperationCallingInvalid < Trailblazer::Operation
-    def process(params)
-      return 1 if params
-      invalid!(2)
-    end
-  end
-
-  it { OperationCallingInvalid.run(true).must_equal [true, 1] }
-  it { OperationCallingInvalid.run(nil).must_equal [false, 2] }
-
-  # #invalid! without result defaults to operation instance.
-  class OperationCallingInvalidWithoutResult < Trailblazer::Operation
-    include Comparable
-    def process(params)
-      invalid!
-    end
-  end
-
-  it { OperationCallingInvalidWithoutResult.run(true).must_equal [false, OperationCallingInvalidWithoutResult.new] }
-
-  # calling return from #validate block leaves result true.
-  class OperationUsingReturnInValidate < Trailblazer::Operation
+  # test validate wit if/else
+  class OperationWithValidateAndIf < Trailblazer::Operation
     self.contract_class = class Contract
       def initialize(*)
       end
+
       def validate(params)
         params
       end
@@ -229,24 +184,31 @@ class OperationTest < MiniTest::Spec
     end
 
     def process(params)
-      validate(params, Object) do
-        return 1
+      if validate(params, Object.new)
+        @secret_contract = contract.class
+      else
+        @secret_contract = "so wrong!"
       end
-      2
     end
+
+    attr_reader :secret_contract
   end
 
-  it { OperationUsingReturnInValidate.run(true).must_equal [true, 1] }
-  it { OperationUsingReturnInValidate.run(false).must_equal [false, 2] }
+  it { OperationWithValidateAndIf.run(false).last.secret_contract.must_equal "so wrong!" }
+  it { OperationWithValidateAndIf.(true).secret_contract.must_equal OperationWithValidateAndIf::Contract }
+
+
+
 
   # unlimited arguments for ::run and friends.
   class OperationReceivingLottaArguments < Trailblazer::Operation
     def process(model, params)
-      [model, params]
+      @model = [model, params]
     end
+    include Inspect
   end
 
-  it { OperationReceivingLottaArguments.run(Object, {}).must_equal([true, [Object, {}]]) }
+  it { OperationReceivingLottaArguments.run(Object, {}).to_s.must_equal %{[true, <OperationReceivingLottaArguments @model=[Object, {}]>]} }
 
   # ::present only runs #setup! which runs #model!.
   class ContractOnlyOperation < Trailblazer::Operation
@@ -270,16 +232,13 @@ class OperationTest < MiniTest::Spec
   it { ContractOnlyOperation.present({}).contract._model.must_equal Object }
 end
 
+
 class OperationBuilderTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
+  class ParentOperation < Trailblazer::Operation
     def process(params)
-      "operation"
     end
 
     class Sub < self
-      def process(params)
-        "sub:operation"
-      end
     end
 
     builds do |params|
@@ -287,13 +246,13 @@ class OperationBuilderTest < MiniTest::Spec
     end
   end
 
-  it { Operation.run({}).last.must_equal "operation" }
-  it { Operation.run({sub: true}).last.must_equal "sub:operation" }
-
-  it { Operation.({}).must_equal "operation" }
-  it { Operation.({sub: true}).must_equal "sub:operation" }
+  it { ParentOperation.run({}).last.class.must_equal ParentOperation }
+  it { ParentOperation.run({sub: true}).last.class.must_equal ParentOperation::Sub }
+  it { ParentOperation.({}).class.must_equal ParentOperation }
+  it { ParentOperation.({sub: true}).class.must_equal ParentOperation::Sub }
 end
 
+
 # ::contract builds Reform::Form class
 class OperationInheritanceTest < MiniTest::Spec
   class Operation < Trailblazer::Operation
@@ -357,4 +316,4 @@ class OperationErrorsTest < MiniTest::Spec
     res, op = Operation.run({})
     op.errors.to_s.must_equal "{:title=>[\"can't be blank\"]}"
   end
-end
+end