trailblazer 0.0.1 → 0.1.0

data/lib/trailblazer/operation/responder.rb

@@ -0,0 +1,24 @@
+module Trailblazer::Operation::Responder
+  # TODO: test me.
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def model_name
+      model_class.model_name
+    end
+  end
+
+  extend Forwardable
+  def_delegators :@model, :to_param, :destroyed?, :persisted?
+
+  def errors
+    return [] if @valid
+    [1]
+  end
+
+  def to_json(*)
+    self.class.representer_class.new(model).to_json
+  end
+end

data/lib/trailblazer/operation/uploaded_file.rb

@@ -0,0 +1,77 @@
+require 'trailblazer/operation'
+require 'action_dispatch/http/upload'
+require 'tempfile'
+
+module Trailblazer
+  # TODO: document:
+  # to_hash
+  # from_hash
+  # initialize/tmp_dir
+  class Operation::UploadedFile
+    def initialize(uploaded, options={})
+      @uploaded = uploaded
+      @options  = options
+      @tmp_dir  = options[:tmp_dir]
+    end
+
+    def to_hash
+      path = persist!
+
+      hash = {
+        :filename       => @uploaded.original_filename,
+        :type           => @uploaded.content_type,
+        :tempfile_path  => path
+      }
+
+      cleanup!
+
+      hash
+    end
+
+    # Returns a ActionDispatch::Http::UploadedFile as if the upload was in the same request.
+    def self.from_hash(hash)
+      suffix = File.extname(hash[:filename])
+
+      # we need to create a Tempfile to make Http::UploadedFile work.
+      tmp  = Tempfile.new(["bla", suffix]) # always force file suffix to avoid problems with imagemagick etc.
+      file = File.open(hash[:tempfile_path])# doesn't close automatically :( # fixme: introduce strategy (Tempfile:=>slow, File:=> hopefully less memory footprint)
+      tmp.write(file.read) # DISCUSS: We need Tempfile.new(<File>) to avoid this slow and memory-consuming mechanics.
+
+      file.close # TODO: can we test that?
+      File.unlink(file)
+
+      ActionDispatch::Http::UploadedFile.new(hash.merge(:tempfile => tmp))
+    end
+
+  private
+    attr_reader :tmp_dir
+
+     # convert Tempfile from Rails upload into persistent "temp" file so it is available in workers.
+    def persist!
+      path = @uploaded.path # original Tempfile path (from Rails).
+      path = path_with_tmp_dir(path)
+
+      path = path + "_trailblazer_upload"
+
+      FileUtils.mv(@uploaded.path, path) # move Rails upload file into persistent `path`.
+      path
+    end
+
+    def path_with_tmp_dir(path)
+      return path unless tmp_dir # if tmp_dir set, create path in it.
+
+      @with_tmp_dir = Tempfile.new(File.basename(path), tmp_dir)
+      @with_tmp_dir.path # use Tempfile to create nested dirs (os-dependent.)
+    end
+
+    def delete!(file)
+      file.close
+      file.unlink # the Rails uploaded file is already unlinked since moved.
+    end
+
+    def cleanup!
+      delete!(@uploaded.tempfile) if @uploaded.respond_to?(:tempfile) # this is Rails' uploaded file, not sure if we need to do that. in 3.2, we don't have UploadedFile#close, yet.
+      delete!(@with_tmp_dir) if @with_tmp_dir # we used that file to create a tmp file path below tmp_dir.
+    end
+  end
+end

data/lib/trailblazer/operation/worker.rb

@@ -0,0 +1,96 @@
+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
+  module Worker
+    def self.included(base)
+      base.send(:include, Sidekiq::Worker) # TODO: this will work with any bg gem.
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def run(params)
+        if background?
+          return perform_async(serializable(params))
+        end
+
+        new.run(params)
+      end
+
+    private
+      def background? # TODO: make configurable.
+        true
+        # if Rails.env == "production" or Rails.env == "staging"
+      end
+
+      def serializable(params)
+        params # this is where we convert file uloads into Trailblazer::UploadedFile, etc. soon.
+      end
+    end
+
+
+    # called from Sidekiq.
+    def perform(params)
+      # the serialized params hash from Sidekiq contains a Op::UploadedFile hash.
+
+      # the following code is basically what happens in a controller.
+      # this is a bug in Rails, it doesn't work without requiring as/hash/ina
+      # params = ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(params) # TODO: this might make it ultra-slow as Reform converts it back to strings.
+      params = params.with_indifferent_access
+
+      run(deserializable(params))
+    end
+
+  private
+    def deserializable(params)
+      params # this is where we convert file uloads into Trailblazer::UploadedFile, etc. soon.
+    end
+
+
+    # Overrides ::serializable and #deserializable and handles file properties from the Contract schema.
+    module FileMarshaller
+      # NOTE: this is WIP and the implementation will be more understandable and performant soon.
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+
+    private
+      module ClassMethods
+        def file_marshaller_representer
+          @file_marshaller_representer ||= contract_class.schema.apply do |dfn|
+            dfn.delete!(:prepare)
+
+            dfn.merge!(
+              :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.
+            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
+            )
+          end
+        end
+
+        def serializable(params)
+          file_marshaller_representer.new(params).to_hash
+        end
+      end
+
+      # todo: do with_indifferent_access in #deserialize and call super here.
+      def deserializable(hash)
+        # self.class.file_marshaller_representer.new({}).extend(Representable::Debug).from_hash(hash)
+        self.class.file_marshaller_representer.new({}.with_indifferent_access).from_hash(hash)
+      end
+    end
+  end
+end

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/crud_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+require 'trailblazer/operation'
+
+class CrudTest < MiniTest::Spec
+  Song = Struct.new(:title, :id) do
+    class << self
+      attr_accessor :find_result # TODO: eventually, replace with AR test.
+
+      def find(id)
+        find_result
+      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
+
+
+  # creates model for you.
+  it { CreateOperation[song: {title: "Blue Rondo a la Turk"}].model.title.must_equal "Blue Rondo a la Turk" }
+  # exposes #model.
+  it { CreateOperation[song: {title: "Blue Rondo a la Turk"}].model.must_be_instance_of Song }
+
+  class ModifyingCreateOperation < CreateOperation
+    def process(params)
+      model.instance_eval { def genre; "Punkrock"; end }
+
+      validate(params[:song]) do |f|
+        f.sync
+      end
+    end
+  end
+
+  # lets you modify model.
+  it { ModifyingCreateOperation[song: {title: "Blue Rondo a la Turk"}].model.title.must_equal "Blue Rondo a la Turk" }
+  it { ModifyingCreateOperation[song: {title: "Blue Rondo a la Turk"}].model.genre.must_equal "Punkrock" }
+
+  # Update
+  class UpdateOperation < CreateOperation
+    action :update
+  end
+
+  # finds model and updates.
+  it do
+    song = CreateOperation[song: {title: "Anchor End"}].model
+    Song.find_result = song
+
+    UpdateOperation[id: song.id, song: {title: "The Rip"}].model.title.must_equal "The Rip"
+    song.title.must_equal "The Rip"
+  end
+
+  # Find == Update
+  class FindOperation < CreateOperation
+    action :find
+  end
+
+  # finds model and updates.
+  it do
+    song = CreateOperation[song: {title: "Anchor End"}].model
+    Song.find_result = song
+
+    FindOperation[id: song.id, song: {title: "The Rip"}].model.title.must_equal "The Rip"
+    song.title.must_equal "The Rip"
+  end
+
+
+  class DefaultCreateOperation < Trailblazer::Operation
+    include CRUD
+    model Song
+
+    def process(params)
+      self
+    end
+  end
+
+  # uses :create as default if not set via ::action.
+  it { DefaultCreateOperation[{}].model.must_equal Song.new }
+
+  # model Song, :action
+  class ModelUpdateOperation < CreateOperation
+    model Song, :update
+  end
+
+  # allows ::model, :action.
+  it do
+    Song.find_result = song = Song.new
+    ModelUpdateOperation[{id: 1, song: {title: "Mercy Day For Mr. Vengeance"}}].model.must_equal song
+  end
+
+  # no call to ::model raises error.
+  class NoModelOperation < Trailblazer::Operation
+    include CRUD
+
+    def process(params)
+      self
+    end
+  end
+
+  # uses :create as default if not set via ::action.
+  it { assert_raises(RuntimeError){ NoModelOperation[{}] } }
+end

data/test/operation_test.rb

@@ -0,0 +1,334 @@
+require 'test_helper'
+
+module Comparable
+  # only used for test.
+  def ==(b)
+    self.class == b.class
+  end
+end
+
+
+class OperationRunTest < MiniTest::Spec
+  class Operation < Trailblazer::Operation
+    # allow providing your own contract.
+    self.contract_class = class Contract
+      def initialize(*)
+      end
+      def validate(params)
+        return false if params == false # used in ::[] with exception test.
+        "local #{params}"
+      end
+
+      def errors
+        Struct.new(:to_s).new("Op just calls #to_s on Errors!")
+      end
+
+      include Comparable
+      self
+    end
+
+    def process(params)
+      model = Object
+      validate(params, model)
+    end
+  end
+
+  let (:operation) { Operation.new.extend(Comparable) }
+
+  # contract is inferred from self::contract_class.
+  it { Operation.run(true).must_equal ["local true", operation] }
+
+  # return operation when ::call
+  it { Operation.call(true).must_equal operation }
+  it { Operation[true].must_equal operation }
+
+  # ::[] raises exception when invalid.
+  it do
+    exception = assert_raises(Trailblazer::Operation::InvalidContract) { Operation[false] }
+    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] }
+
+  # ::run with block returns operation.
+  # valid executes block.
+  it "block" do
+    outcome = nil
+    res = Operation.run(true) do
+      outcome = "true"
+    end
+
+    outcome.must_equal "true" # block was executed.
+    res.must_equal operation
+  end
+
+  # invalid doesn't execute block.
+  it "block, invalid" do
+    outcome = nil
+    res = Operation.run(false) do
+      outcome = "true"
+    end
+
+    outcome.must_equal nil # block was _not_ executed.
+    res.must_equal operation
+  end
+
+  # block yields operation
+  it do
+    outcome = nil
+    res = Operation.run(true) do |op|
+      outcome = op
+    end
+
+    outcome.must_equal operation # block was executed.
+    res.must_equal operation
+  end
+
+  # Operation#contract returns @contract
+  let (:contract)  { Operation::Contract.new }
+  it { Operation[true].contract.must_equal contract }
+end
+
+
+class OperationTest < MiniTest::Spec
+  class Operation < Trailblazer::Operation
+    def process(params)
+      validate(Object, params)
+    end
+  end
+
+  # 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.
+  class OperationWithoutValidateCall < Trailblazer::Operation
+    def process(params)
+      params || invalid!(params)
+    end
+  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
+
+  # #validate yields contract when valid
+  class OperationWithValidateBlock < Trailblazer::Operation
+    self.contract_class = class Contract
+      def initialize(*)
+      end
+
+      def validate(params)
+        params
+      end
+      self
+    end
+
+    def process(params)
+      validate(params, Object.new) do |c|
+        @secret_contract = c
+      end
+    end
+
+    attr_reader :secret_contract
+  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) }
+
+  # 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
+    self.contract_class = class Contract
+      def initialize(*)
+      end
+      def validate(params)
+        params
+      end
+      self
+    end
+
+    def process(params)
+      validate(params, Object) do
+        return 1
+      end
+      2
+    end
+  end
+
+  it { OperationUsingReturnInValidate.run(true).must_equal [true, 1] }
+  it { OperationUsingReturnInValidate.run(false).must_equal [false, 2] }
+
+
+  # unlimited arguments for ::run and friends.
+  class OperationReceivingLottaArguments < Trailblazer::Operation
+    def process(model, params)
+      [model, params]
+    end
+  end
+
+  it { OperationReceivingLottaArguments.run(Object, {}).must_equal([true, [Object, {}]]) }
+
+
+  # TODO: experimental.
+  # ::present to avoid running #validate.
+  class ContractOnlyOperation < Trailblazer::Operation
+    self.contract_class = class Contract
+      def initialize(model)
+        @_model = model
+      end
+      attr_reader :_model
+      self
+    end
+
+    def process(params)
+      @object = Object # arbitrary init code.
+
+      validate(params, Object) do
+        raise "this should not be run."
+      end
+    end
+  end
+
+  it { ContractOnlyOperation.present({}).contract._model.must_equal Object }
+
+end
+
+class OperationBuilderTest < MiniTest::Spec
+  class Operation < Trailblazer::Operation
+    def process(params)
+      "operation"
+    end
+
+    class Sub < self
+      def process(params)
+        "sub:operation"
+      end
+    end
+
+    builds do |params|
+      Sub if params[:sub]
+    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" }
+end
+
+# ::contract builds Reform::Form class
+class OperationInheritanceTest < MiniTest::Spec
+  class Operation < Trailblazer::Operation
+    contract do
+      property :title
+      property :band
+
+      # TODO/DISCUSS: this is needed in order to "handle" the anon forms. but in Trb, that
+      # doesn't really matter as AM is automatically included?
+      def self.name
+        "Song"
+      end
+    end
+
+    class JSON < self
+      # inherit Contract
+      contract do
+        property :genre, validates: {presence: true}
+        property :band, virtual: true
+      end
+    end
+  end
+
+  # inherits subclassed Contract.
+  it { Operation.contract_class.wont_equal Operation::JSON.contract_class }
+
+  it do
+    form = Operation.contract_class.new(OpenStruct.new)
+    form.validate({})#.must_equal true
+    form.errors.to_s.must_equal "{}"
+
+    form = Operation::JSON.contract_class.new(OpenStruct.new)
+    form.validate({})#.must_equal true
+    form.errors.to_s.must_equal "{:genre=>[\"can't be blank\"]}"
+  end
+
+  # allows overriding options
+  it do
+    form = Operation::JSON.contract_class.new(song = OpenStruct.new)
+    form.validate({genre: "Punkrock", band: "Osker"}).must_equal true
+    form.sync
+
+    song.genre.must_equal "Punkrock"
+    song.band.must_equal nil
+  end
+end