trailblazer 0.2.2 → 0.3.0

data/Rakefile

@@ -1,15 +1,23 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-task :default => [:test]
+task :default => [:build]
+default_task = Rake::Task[:build]
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
   test.test_files = FileList['test/*_test.rb']
   test.verbose = true
 end
 
+# this how the rails test must be run: BUNDLE_GEMFILE=gemfiles/Gemfile.rails bundle exec rake rails
 Rake::TestTask.new(:rails) do |test|
   test.libs << 'test/rails'
   test.test_files = FileList['test/rails/*_test.rb']
   test.verbose = true
-end
+end
+
+rails_task = Rake::Task["rails"]
+test_task = Rake::Task["test"]
+default_task.enhance { test_task.invoke }
+default_task.enhance { rails_task.invoke }

data/gemfiles/Gemfile.rails.lock

@@ -1,15 +1,18 @@
 PATH
   remote: ../
   specs:
-    trailblazer (0.1.1)
+    trailblazer (0.2.2)
       actionpack (>= 3.0.0)
-      reform (~> 1.2.0)
-      representable (>= 2.1.1, < 2.2.0)
+      reform (>= 1.2.0)
       uber (>= 0.0.10)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    actionmailer (4.1.1)
+      actionpack (= 4.1.1)
+      actionview (= 4.1.1)
+      mail (~> 2.5.4)
     actionpack (4.1.1)
       actionview (= 4.1.1)
       activesupport (= 4.1.1)
@@ -44,14 +47,29 @@ GEM
     hitimes (1.2.2)
     i18n (0.6.11)
     json (1.8.1)
-    mini_portile (0.6.1)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.25.1)
+    mini_portile (0.6.2)
     minitest (5.4.2)
-    multi_json (1.10.1)
-    nokogiri (1.6.4.1)
+    multi_json (1.11.0)
+    nokogiri (1.6.6.2)
       mini_portile (~> 0.6.0)
+    polyglot (0.3.5)
     rack (1.5.2)
     rack-test (0.6.2)
       rack (>= 1.0)
+    rails (4.1.1)
+      actionmailer (= 4.1.1)
+      actionpack (= 4.1.1)
+      actionview (= 4.1.1)
+      activemodel (= 4.1.1)
+      activerecord (= 4.1.1)
+      activesupport (= 4.1.1)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.1.1)
+      sprockets-rails (~> 2.0)
     railties (4.1.1)
       actionpack (= 4.1.1)
       activesupport (= 4.1.1)
@@ -61,39 +79,52 @@ GEM
     redis (3.1.0)
     redis-namespace (1.5.1)
       redis (~> 3.0, >= 3.0.4)
-    reform (1.2.1)
+    reform (1.2.6)
       activemodel
       disposable (~> 0.0.5)
       representable (~> 2.1.0)
-      uber (~> 0.0.8)
-    representable (2.1.3)
+      uber (~> 0.0.11)
+    representable (2.1.8)
       multi_json
       nokogiri
       uber (~> 0.0.7)
+    responders (1.1.2)
+      railties (>= 3.2, < 4.2)
     sidekiq (3.1.4)
       celluloid (>= 0.15.2)
       connection_pool (>= 2.0.0)
       json
       redis (>= 3.0.6)
       redis-namespace (>= 1.3.1)
+    sprockets (3.1.0)
+      rack (~> 1.0)
+    sprockets-rails (2.3.1)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
     sqlite3 (1.3.9)
     thor (0.19.1)
     thread_safe (0.3.4)
     timers (4.0.1)
       hitimes
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
-    uber (0.0.11)
+    uber (0.0.13)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   activerecord
-  bundler (~> 1.3)
+  bundler
   minitest
+  rails
   railties
   rake
+  responders
   sidekiq (~> 3.1.0)
   sqlite3
   trailblazer!

data/lib/trailblazer/autoloading.rb

@@ -1,5 +1,6 @@
 Trailblazer::Operation.class_eval do
-  autoload :Controller, 'trailblazer/operation/controller'
-  autoload :Responder,  'trailblazer/operation/responder'
-  autoload :CRUD,       'trailblazer/operation/crud'
+  autoload :Controller, "trailblazer/operation/controller"
+  autoload :Responder,  "trailblazer/operation/responder"
+  autoload :CRUD,       "trailblazer/operation/crud"
+  autoload :Collection, "trailblazer/operation/collection"
 end

data/lib/trailblazer/endpoint.rb

@@ -0,0 +1,40 @@
+module Trailblazer
+  # To be used in Lotus, Roda, Rails, etc.
+  class Endpoint
+    def initialize(controller, operation_class, params, request, config)
+      @controller = controller
+      @operation_class = operation_class
+      @params  = params
+      @request = request
+      @config  = config
+    end
+
+    def call
+      @controller.send(:process_params!, params) # FIXME.
+
+      document_body! if document_request?
+
+      res, operation = yield # Create.run(params)
+      @controller.send(:setup_operation_instance_variables!, operation)
+
+      [res, operation] # DISCUSS: do we need result here? or can we just go pick op.valid?
+    end
+
+  private
+    attr_reader :params, :operation_class, :request, :controller
+
+    def document_request?
+      # request.format == :html
+      @config[:document_formats][request.format.to_sym]
+    end
+
+    def document_body!
+      # this is what happens:
+      # respond_with Comment::Update::JSON.run(params.merge(comment: request.body.string))
+      concept_name = operation_class.model_class.to_s.underscore # this could be renamed to ::concept_class soon.
+      request_body = request.body.respond_to?(:string) ? request.body.string : request.body.read
+
+      params.merge!(concept_name => request_body)
+    end
+  end
+end

data/lib/trailblazer/operation.rb

@@ -33,11 +33,11 @@ module Trailblazer
       # ::call only returns the Operation instance (or whatever was returned from #validate).
       # This is useful in tests or in irb, e.g. when using Op as a factory and you already know it's valid.
       def call(*params)
-        build_operation_class(*params).new(:raise_on_invalid => true).run(*params).last
+        build_operation_class(*params).new(raise_on_invalid: true).run(*params).last
       end
-      alias_method :[], :call
+      alias_method :[], :call # TODO: deprecate #[] in favor of .().
 
-      # Runs #process without validate and returns the form object.
+      # Runs #setup! and returns the form object.
       def present(*params)
         build_operation_class(*params).new.present(*params)
       end
@@ -56,7 +56,6 @@ module Trailblazer
 
     def initialize(options={})
       @valid            = true
-      # DISCUSS: use reverse_merge here?
       @raise_on_invalid = options[:raise_on_invalid] || false
     end
 
@@ -64,7 +63,9 @@ module Trailblazer
     def run(*params)
       setup!(*params) # where do we assign/find the model?
 
-      [process(*params), valid?].reverse
+      process(*params)
+
+      [valid?, self]
     end
 
     def present(*params)
@@ -75,6 +76,7 @@ module Trailblazer
     end
 
     attr_reader :contract
+    attr_reader :model
 
     def errors
       contract.errors
@@ -103,16 +105,20 @@ module Trailblazer
     def setup_params!(*params)
     end
 
-    def validate(params, model, contract_class=nil) # NOT to be overridden?!! it creates Result for us.
+    def validate(params, model, contract_class=nil)
       @contract = contract_for(contract_class, model)
 
-      if @valid = contract.validate(params)
+      if @valid = validate_contract(params)
         yield contract if block_given?
       else
         raise!(contract)
       end
 
-      self
+      @valid
+    end
+
+    def validate_contract(params)
+      contract.validate(params)
     end
 
     def invalid!(result=self)
@@ -137,6 +143,7 @@ module Trailblazer
 end
 
 require 'trailblazer/operation/crud'
+require "trailblazer/operation/dispatch"
 
 # run
 #   setup

data/lib/trailblazer/operation/collection.rb

@@ -0,0 +1,7 @@
+module Trailblazer::Operation::Collection
+  # Collection does not produce a contract.
+  def present(*params)
+    setup!(*params)
+    self
+  end
+end

data/lib/trailblazer/operation/controller.rb

@@ -1,6 +1,6 @@
-module Trailblazer::Operation::Controller
-  # TODO: test me.
+require "trailblazer/endpoint"
 
+module Trailblazer::Operation::Controller
 private
   def form(operation_class, params=self.params) # consider private.
     process_params!(params)
@@ -23,6 +23,14 @@ private
     # TODO: implement respond(present: true)
   end
 
+  def collection(operation_class, params=self.params)
+    # TODO: merge with #present.
+    res, op = operation!(operation_class, params) { [true, operation_class.present(params)] }
+    @collection = @model
+
+    yield op if block_given?
+  end
+
   # full-on Op[]
   # Note: this is not documented on purpose as this concept is experimental. I don't like it too much and prefer
   # returns in the valid block.
@@ -47,37 +55,37 @@ private
   end
 
   # The block passed to #respond is always run, regardless of the validity result.
-  def respond(operation_class, params=self.params, &block)
+  def respond(operation_class, params=self.params, respond_options = {}, &block)
     res, op = operation!(operation_class, params) { operation_class.run(params) }
 
-    return respond_with op if not block_given?
-    respond_with op, &Proc.new { |formats| block.call(op, formats) } if block_given?
+    return respond_with op, respond_options if not block_given?
+    respond_with op, respond_options, &Proc.new { |formats| block.call(op, formats) } if block_given?
   end
 
   def process_params!(params)
   end
 
   # Normalizes parameters and invokes the operation (including its builders).
-  def operation!(operation_class, params)
-    process_params!(params)
-
-    unless request.format == :html
-      # this is what happens:
-      # respond_with Comment::Update::JSON.run(params.merge(comment: request.body.string))
-      concept_name = operation_class.model_class.to_s.underscore # this could be renamed to ::concept_class soon.
-      request_body = request.body.respond_to?(:string) ? request.body.string : request.body.read
-
-      params.merge!(concept_name => request_body)
-    end
+  def operation!(operation_class, params, &block)
+    Trailblazer::Endpoint.new(self, operation_class, params, request, self.class._operation).(&block)
+  end
 
-    res, @operation = yield # Create.run(params)
-    setup_operation_instance_variables!
+  def setup_operation_instance_variables!(operation)
+    @operation = operation
+    @form      = operation.contract
+    @model     = operation.model
+  end
 
-    [res, @operation] # DISCUSS: do we need result here? or can we just go pick op.valid?
+  def self.included(includer)
+    includer.extend Uber::InheritableAttr
+    includer.inheritable_attr :_operation
+    includer._operation = {document_formats: {}}
+    includer.extend ClassMethods
   end
 
-  def setup_operation_instance_variables!
-    @form = @operation.contract
-    @model = @operation.model
+  module ClassMethods
+    def operation(options)
+      _operation[:document_formats][options[:document_formats]] = true
+    end
   end
 end

data/lib/trailblazer/operation/controller/active_record.rb

@@ -1,12 +1,16 @@
 # Assigns an additional instance variable for +@model+ named after the model's table name (e.g. @comment).
 module Trailblazer::Operation::Controller::ActiveRecord
 private
-  def setup_operation_instance_variables!
+  def setup_operation_instance_variables!(operation)
     super
     instance_variable_set(:"@#{operation_model_name}", @model)
   end
 
   def operation_model_name
-    @model.class.table_name.singularize
+    # set the right variable name if collection
+    if @operation.is_a?(Trailblazer::Operation::Collection)
+      return @model.model.table_name.split(".").last
+    end
+    @model.class.table_name.split(".").last.singularize
   end
 end

data/lib/trailblazer/operation/crud.rb

@@ -3,8 +3,6 @@ module Trailblazer
     # The CRUD module will automatically create/find models for the configured +action+.
     # It adds a public  +Operation#model+ reader to access the model (after performing).
     module CRUD
-      attr_reader :model
-
       module Included
         def included(base)
           base.extend Uber::InheritableAttr
@@ -39,8 +37,8 @@ module Trailblazer
 
 
       # #validate no longer accepts a model since this module instantiates it for you.
-      def validate(params, *args)
-        super(params, @model, *args)
+      def validate(params, model=self.model, *args)
+        super(params, model, *args)
       end
 
     private
@@ -81,4 +79,4 @@ module Trailblazer
       end
     end
   end
-end
+end

data/lib/trailblazer/operation/dispatch.rb

@@ -0,0 +1,29 @@
+require "disposable/callback"
+
+module Trailblazer::Operation::Dispatch
+  def dispatch!(name=:default)
+    group = self.class.callbacks[name].new(contract)
+    group.(context: self)
+
+    invocations[name] = group
+  end
+
+  def invocations
+    @invocations ||= {}
+  end
+
+
+  module ClassMethods
+    def callback(name=:default, *args, &block)
+      callbacks[name] ||= Class.new(Disposable::Callback::Group).extend(Representable::Cloneable)
+      callbacks[name].class_eval(&block)
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.extend Uber::InheritableAttr
+    base.inheritable_attr :callbacks
+    base.callbacks = Representable::Cloneable::Hash.new
+  end
+end

data/lib/trailblazer/operation/representer.rb

@@ -1,18 +1,54 @@
+# Including this will change the way deserialization in #validate works.
+#
+# Instead of treating params as a hash and letting the form object deserialize it,
+# a representer will be infered from the contract. This representer is then passed as
+# deserializer into Form#validate.
+#
+# TODO: so far, we only support JSON, but it's two lines to change to support any kind of format.
 module Trailblazer::Operation::Representer
   def self.included(base)
     base.extend Uber::InheritableAttr
-    base.inheritable_attr :representer_class
-    # TODO: allow representer without contract?!
+    base.inheritable_attr :_representer_class
     base.extend ClassMethods
   end
 
   module ClassMethods
     def representer(&block)
-      build_representer_class.class_eval(&block)
+      representer_class.class_eval(&block)
     end
 
-    def build_representer_class
-      representer_class || self.representer_class= Class.new(contract_class.schema)
+    def representer_class
+      self._representer_class ||= infer_representer_class
+    end
+
+    def representer_class=(constant)
+      self._representer_class = constant
+    end
+
+    def infer_representer_class
+      Disposable::Twin::Schema.from(contract_class,
+        include:          [Representable::JSON],
+        options_from:     :deserializer, # use :instance etc. in deserializer.
+        superclass:       Representable::Decorator,
+        representer_from: lambda { |inline| inline.representer_class },
+      )
+    end
+  end
+
+
+private
+  def validate_contract(params)
+    # use the inferred representer from the contract for deserialization in #validate.
+    contract.validate(params) do |document|
+      self.class.representer_class.new(contract).from_json(document)
+    end
+  end
+
+
+  module Rendering
+    def to_json(*)
+      self.class.representer_class.new(contract).to_json
     end
   end
+  include Rendering
 end