trailblazer 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 706f11d67b247409077b6cf7dd236ee0cbb67490
-  data.tar.gz: 02c05af733cceef4436e35f018a71e667ef45db5
+  metadata.gz: f2618bcea766e5192fadaa575315a4ad04170654
+  data.tar.gz: fe623b65e42ac232f9bc0ec45a723b5fa5da70e2
 SHA512:
-  metadata.gz: 389626ff14345d9a37ca9159ecce584233d74ccb09248f34eb09a332af95bf9457b13dcf653a8579d23bc45ee92e778f8c19218665167c768e8b8961f4ef4dfb
-  data.tar.gz: 5ec3b0a491cf5a56159f79463a15f88971ef53ef9e72984d9c2a3aec627fdbefd8c2de58eeed9e5cfc3a6747e2f7e59d4635bf1a9e736c7f6f586eef6617243e
+  metadata.gz: befbbee9f37e868da73002c26ce09b91f609ee0e1ded07ffc976dc56cd4440cfa23609911939394c48427d7e9a69bcf28839404a2fb411584d6215b11f79f8c2
+  data.tar.gz: e132220e955dc8b0338584b3fc1055d9abacd2100308277829cbf51bfa6b0ecb5bf2a605c7759bb9a36a191ac9985fe514c4a581ede512cd003a74728928c6e6

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 1.0.1
+
+* Treat `:js` requests as non-document, too.
+* `Controller#form` now returns the form object and not the operation.
+* In `Controller`, `#form`, `#present`, `#run` and `#respond` now all have the same API: `run(constant, options)`. If you want to pass a custom params hash, use `run Comment::Create, params: {..}`.
+
 # 1.0.0
 
 * All Rails-relevant files are now in the `trailblazer-rails` gem. You have to include it should you be in a Rails environment.

data/README.md

@@ -18,13 +18,13 @@ _Trailblazer is a thin layer on top of Rails. It gently enforces encapsulation,
 
 Trailblazer is designed to handle different contexts like user roles by applying [inheritance](#inheritance) between and [composing](#composing) of operations, form objects, policies, representers and callbacks.
 
-
+Wanna see some code? Jump [right here](#controllers)!
 
 ## Mission
 
 While _Trailblazer_ offers you abstraction layers for all aspects of Ruby On Rails, it does _not_ missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.
 
-Trailblazer is all about structure. It helps re-organize existing code into smaller components where different concerns are handled in separated classes. Forms go into form objects, views are object-oriented MVC controllers, the business logic happens in dedicated domain objects backed by completely decoupled persistence objects.
+Trailblazer is all about structure. It helps re-organize existing code into smaller components where different concerns are handled in separated classes.
 
 Again, you can pick which layers you want. Trailblazer doesn't impose technical implementations, it offers mature solutions for recurring problems in all types of Rails applications.
 
@@ -61,75 +61,80 @@ The opposite is the case: Controller, view and model become lean endpoints for H
 
 ## Routing
 
-Trailblazer uses Rails routing to map URLs to controllers (we will add simplifications to routing soon).
+Trailblazer uses Rails routing to map URLs to controllers, because it works.
+
+```ruby
+Rails.application.routes.draw do
+  resources :comments
+end
+```
 
 ## Controllers
 
-Controllers are lean endpoints for HTTP. They differentiate between request formats like HTML or JSON and do not contain any business logic. Actions immediately dispatch to an operation.
+Controllers are lean endpoints for HTTP. They do not contain any business logic. Actions immediately dispatch to an operation.
 
 ```ruby
 class CommentsController < ApplicationController
   def create
-    Comment::Create.(params)
+    run Comment::Create # Comment::Create is an operation class.
   end
 ```
 
-This can be simplified using the `run` method and allows you a simple conditional to handle failing operations.
+The `#run` method invokes the operation. It allows you to run a conditional block of logic if the operation was successful.
 
 ```ruby
 class CommentsController < ApplicationController
   def create
     run Comment::Create do |op|
-      return redirect_to(comment_path op.model) # success.
+      return redirect_to(comment_path op.model) # success!
     end
 
-    render :new # re-render form.
+    render :new # invalid. re-render form.
   end
 ```
 
-Again, the controller only knows how to dispatch to the operation and what to do for success and invalid processing. While business affairs (e.g. logging or rollbacks) are to be handled in the operation, the controller invokes rendering or redirecting.
+Again, the controller only dispatchs to the operation and handles successful/invalid processing on the HTTP level. For instance by redirecting, setting flash messages, or signing in a user.
 
-## Operation
+[Learn more.](http://trailblazerb.org/gems/operation/controller.html)
 
-The [API is documented here](http://trailblazerb.org/gems/operation/api.html).
+## Operation
 
-Operations encapsulate business logic and are the heart of a Trailblazer architecture. One operation per high-level domain _function_ is used. Different formats or environments are handled in subclasses. Operations don't know about HTTP or the environment.
+Operations encapsulate business logic and are the heart of a Trailblazer architecture.
 
-An operation is not just a monolithic replacement for your business code. An operation is a simple orchestrator between the form object, models and your business code.
+Operations don't know about HTTP or the environment. You could use an operation in Rails, Lotus, or Roda, it wouldn't know. This makes them an ideal replacement for test factories.
 
-You don't have to use the form/contract if you don't want it.
+An operation is not just a monolithic replacement for your business code. It's a simple orchestrator between the form object, models and your business code.
 
 ```ruby
-class Comment < ActiveRecord::Base
-  class Create < Trailblazer::Operation
-    def process(params)
-      # do whatever you feel like.
-    end
+class Comment::Create < Trailblazer::Operation
+  def process(params)
+    # do whatever you feel like.
   end
 end
 ```
 
 Operations only need to implement `#process` which receives the params from the caller.
 
+[Learn more.](http://trailblazerb.org/gems/operation)
+
 ## Validations
 
-Operations usually have a form object which is simply a `Reform::Form` class. All the [API documented in Reform](https://github.com/apotonick/reform) can be applied and used.
+In Trailblazer, an operation (usually) has a form object which is simply a `Reform::Form` class. All the [API documented in Reform](https://github.com/apotonick/reform) can be applied and used.
 
 The operation makes use of the form object using the `#validate` method.
 
 ```ruby
-class Comment < ActiveRecord::Base
-  class Create < Trailblazer::Operation
-    contract do
-      property :body, validates: {presence: true}
-    end
+class Comment::Create < Trailblazer::Operation
+  contract do
+    # this is a Reform::Form class!
+    property :body, validates: {presence: true}
+  end
 
-    def process(params)
-      @model = Comment.new
+  def process(params)
+    @model = Comment.new
 
-      validate(params[:comment], @model) do |f|
-        f.save
-      end
+    validate(params[:comment], @model) do |f|
+      f.save
     end
   end
 end
@@ -137,59 +142,43 @@ end
 
 The contract (aka _form_) is defined in the `::contract` block. You can implement nested forms, default values, validations, and everything else Reform provides.
 
-In case of a valid form the block for `#validate` is invoked. It receives the populated form object. You can use the form to save data or write your own logic. This is where your business logic is implemented, and in turn could be an invocation of service objects or organizers.
-
-Technically speaking, what really happens in `Operation#validate` is the following.
-
-```ruby
-contract_class.new(@model).validate(params[:comment])
-```
-
-This is a familiar work-flow from Reform. Validation does _not_ touch the model.
+In the `#process` method you can define your business logic.
 
-
-
-
-If you prefer keeping your forms in separate classes or even files, you're free to do so.
-
-```ruby
-class Create < Trailblazer::Operation
-  self.contract_class = MyCommentForm
-```
+[Learn more.](http://trailblazerb.org/gems/operation/api.html)
 
 ## Callbacks
 
 Post-processing logic (also known as _callbacks_) is configured in operations.
 
-Following the schema of your contract, you can define callbacks for events tracked by the form's twin.
+Callbacks can be defined in groups. They use the form object's state tracking to find out whether they should be run.
 
 ```ruby
-class Create < Trailblazer::Operation
+class Comment::Create < Trailblazer::Operation
   callback(:after_save) do
-    on_change :upload_file, property: :file
-
-    property :user do
-      on_create :notify_user!
-    end
+    on_change :markdownize_body! # this is only run when the form object has changed.
   end
 ```
 
-The _Imperative Callback_ pattern then allows you to call this _callback group_ wherever you need it.
+Callbacks are never triggered automatically, you have to invoke them! This is called _Imperative Callback_.
 
 ```ruby
-class Create < Trailblazer::Operation
-
+class Comment::Create < Trailblazer::Operation
   def process(params)
     validate(params) do
       contract.save
-      dispatch!(:after_save)
+      dispatch!(:after_save) # run markdownize_body!, but only if form changed.
     end
   end
+
+  def markdownize_body!(comment)
+    comment.body = Markdownize.(comment.body)
+  end
 end
 ```
 
 No magical triggering of unwanted logic anymore, but explicit invocations where you want it.
 
+[Learn more.](http://trailblazerb.org/gems/operation/callback.html)
 
 ## Models
 
@@ -198,10 +187,8 @@ Models for persistence can be implemented using any ORM you fancy, for instance
 In Trailblazer, models are completely empty. They solely contain associations and finders. No business logic is allowed in models.
 
 ```ruby
-class Thing < ActiveRecord::Base
-  has_many :comments, -> { order(created_at: :desc) }
-  has_many :users, through: :authorships
-  has_many :authorships
+class Comment < ActiveRecord::Base
+  belongs_to :thing
 
   scope :latest, lambda { all.limit(9).order("id DESC") }
 end
@@ -211,14 +198,12 @@ Only operations and views/cells can access models directly.
 
 ## Policies
 
-The full documentation for [Policy is here](http://trailblazerb.org/gems/operation/policy.html).
-
 You can abort running an operation using a policy. "[Pundit](https://github.com/elabs/pundit)-style" policy classes define the rules.
 
 ```ruby
-class Thing::Policy
-  def initialize(user, thing)
-    @user, @thing = user, thing
+class Comment::Policy
+  def initialize(user, comment)
+    @user, @comment = user, comment
   end
 
   def create?
@@ -230,31 +215,15 @@ end
 The rule is enabled via the `::policy` call.
 
 ```ruby
-class Thing::Create < Trailblazer::Operation
+class Comment::Create < Trailblazer::Operation
   include Policy
 
-  policy Thing::Policy, :create?
+  policy Comment::Policy, :create?
 ```
 
 The policy is evaluated in `#setup!`, raises an exception if `false` and suppresses running `#process`.
 
-```ruby
-Thing::Create.(current_user: User.find(1), thing: {}) # raises exception.
-```
-
-You can query the `policy` object at any point in your operation without raising an exception.
-
-To [use policies in your builders](http://trailblazerb.org/gems/operation/builder#resolver.html), please read the documentation.
-
-```ruby
-class Thing::Create < Trailblazer::Operation
-  include Resolver
-
-  builder-> (model, policy, params) do
-    return Admin if policy.admin?
-    return SignedIn if params[:current_user]
-  end
-```
+[Learn more.](http://trailblazerb.org/gems/operation/policy.html)
 
 ## Views
 
@@ -262,304 +231,63 @@ View rendering can happen using the controller as known from Rails. This is abso
 
 More complex UI logic happens in _View Models_ as found in [Cells](https://github.com/apotonick/cells). View models also replace helpers.
 
-
-## Representers
-
-Operations can use representers from [Roar](https://github.com/apotonick/roar) to serialize and parse JSON and XML documents for APIs.
-
-Representers can be inferred automatically from your contract, then may be refined, e.g. with hypermedia or a format like `JSON-API`.
-
-```ruby
-class Create < Trailblazer::Operation
-
-  representer do
-    # inherited :body
-    include Roar::JSON::HAL
-
-    link(:self) { comment_path(represented.id) }
-  end
-```
-
-The operation can then parse incoming JSON documents in `validate` and render a document via `to_json`. The full [documentation is here](http://trailblazerb.org/gems/operation/representer.html) or in the [Trailblazer book](https://leanpub.com/trailblazer), chapter _Hypermedia APIs_.
-
-## Tests
-
-Subject to tests are mainly _Operation_s and _View Model_s, as they encapsulate endpoint behavior of your app. As a nice side effect, factories are replaced by simple _Operation_ calls.
-
-
-
-## Overview
-
-Trailblazer is a collection of mature gems that have been developed over the past 10 years and are used in thousands of production apps.
-
-Using the different layers is completely optional and up to you: Both Cells and Reform can be excluded from your stack if you wish so.
-
-## Controller API
-
-[Learn more](http://trailblazerb.org/gems/operation/controller.html)
-
-Trailblazer provides four methods to present and invoke operations. But before that, you need to include the `Controller` module.
+The operation's form object can be rendered in views, too.
 
 ```ruby
 class CommentsController < ApplicationController
-  include Trailblazer::Operation::Controller
-```
-
-### Running an operation
-
-If you do not intend to maintain different request formats, the easiest is to use `#run` to process incoming data using an operation.
-
-```ruby
-def create
-  run Comment::Create
-end
-```
-
-This will simply run `Comment::Create[params]`.
-
-
-
-
-
-----
-
-It's up to the operation's builder to decide which class to instantiate.
-
-```ruby
-class Create < Trailblazer::Operation
-  builds do |params|
-    JSON if params[:format] == "json"
+  def new
+    form Comment::Create # will assign the form object to @form.
   end
-end
 ```
 
-[Note that this will soon be provided with a module.]
-
-
-## Operation API
+Since Reform objects can be passed to form builders, you can use the operation to render and process the form!
 
-### Call style
-
-The simplest way of running an operation is the _call style_.
-
-```ruby
-op = Comment::Create.(params)
+```haml
+= simple_form_for @form do |f|
+  = f.input :body
 ```
 
-The call style runs the operation and return the operation instance, only.
-
-In case of an invalid operation, this will raise an exception.
-
-### Run style
-
-The _run style_ will do the same as call, but won't raise an exception in case of an invalid result. Instead, it returns result _and_ the operation instance.
-
-```ruby
-result, op = Comment::Create.run(params)
-```
-
-Additionally, it accepts a block that's only run for a valid state.
-
-```ruby
-Comment::Create.run(params) do |op|
-  # only run when valid.
-end
-```
-
-### Inheritance
-
-Operations fully support inheritance and will copy the contract, the callback groups and any methods from the original operation class.
-
-```ruby
-class Create < Trailblazer::Operation
-  contract do
-    property :title
-  end
 
-  callback(:before_save) do
-    on_change :notify!
-  end
-
-  def notify!(*)
-  end
-end
-```
-
-This happens with normal Ruby inheritance.
-
-```ruby
-class Update < Create
-  # inherited:
-  # contract
-  # callback(:before_save)
-  # def notify!(*)
-end
-```
-
-You can customize callback groups and contracts using the `:inherit` option, add and remove properties or add methods.
-
-[Learn more](http://trailblazerb.org/gems/operation/inheritance.html)
-
-### Modules
-
-In case inheritance is not enough for you, use modules to share common functionality.
-
-```ruby
-module ExtendedCreate
-  include Trailblazer::Operation::Module
-
-  contract do
-    property :id
-  end
-
-  callback do
-    on_update :update!
-  end
-
-  def update!(song)
-    # do something
-  end
-end
-```
-
-Modules can be included and will simply run the declarations in the including class.
-
-```ruby
-class Create::Admin < Create
-  include ExtendedCreate
-
-  # contract has :title and :id now.
-```
-
-Modules are often used to modify an existing operation for admin or signed-in roles.
-
-[Learn more](http://trailblazerb.org/gems/operation/inheritance.html)
-
-
-## Form API
-
-Usually, an operation has a form object.
-
-```ruby
-class Create < Trailblazer::Operation
-  contract do
-    property :body
-    validates :body: presence: true, length: {max: 160}
-  end
-```
-
-A `::contract` block simply opens a new Reform class for you.
-
-```ruby
-contract do #=> Class.new(Reform::Form) do
-```
-
-This allows using Reform's API in the block.
-
-When inheriting, the block is `class_eval`ed in the inherited class' context and allows adding, removing and customizing the sub contract.
-
-### CRUD Semantics
-
-You can make Trailblazer find and create models for you using the `Model` module.
-
-```ruby
-require 'trailblazer/operation/model'
-
-class Comment < ActiveRecord::Base
-  class Create < Trailblazer::Operation
-    include Model
-    model Comment, :create
-
-    contract do
-      # ..
-    end
-
-    def process(params)
-      validate(params[:comment]) do |f|
-        f.save
-      end
-    end
-  end
-end
-```
-
-You have to tell `Model` the model class and what action to implement using `::model`.
-
-Note how you do not have to pass the `@model` to validate anymore. Also, the `@model` gets created automatically and is accessible using `Operation#model`.
-
-In inherited operations, you can override the action, only, using `::action`.
-
-```ruby
-class Update < Create
-  action :update
-end
-```
-
-Another action is `:find` (which is currently doing the same as `:update`) to find a model by using `params[:id]`.
-
-
-### Normalizing params
-
-Override `#setup_params!` to add or remove values to params before the operation is run.
-
-```ruby
-class Create < Trailblazer::Operation
-  def process(params)
-    params #=> {show_all: true, admin: true, .. }
-  end
-
-  private
-    def setup_params!(params)
-      params.merge!(show_all: true) if params[:admin]
-    end
-  end
-end
-```
-
-This centralizes params normalization and doesn't require you to do that manually in `#process`.
-
-### Collections
-
-Operations can also be used to present (and soon to process) collections of objects, e.g. for an `Index` operation. This is [documented here](http://trailblazerb.org/gems/operation/collection.html).
+## Representers
 
-### Background Processing
+Operations can use representers from [Roar](https://github.com/apotonick/roar) to serialize and parse JSON and XML documents for APIs.
 
-To run an operation in Sidekiq (ActiveJob-support coming!) all you need to do is include the `Worker` module.
+Representers can be inferred automatically from your contract, then may be refined, e.g. with hypermedia or a format like `JSON-API`.
 
 ```ruby
-require 'trailblazer/operation/worker'
-
-class Comment::Image::Crop < Trailblazer::Operation
-  include Worker
+class Comment::Create < Trailblazer::Operation
+  representer do
+    # inherited :body
+    include Roar::JSON::HAL
 
-  def process(params)
-    # will be run asynchronously.
+    link(:self) { comment_path(represented.id) }
   end
-end
 ```
 
+The operation can then parse incoming JSON documents in `validate` and render a document via `to_json`.
 
-### Worker::FileMarshaller: needs representable 2.1.1 (.schema)
-
+[Learn more.](http://trailblazerb.org/gems/operation/representer.html)
 
-### Testing Operations
-
-## Autoloading
+## Tests
 
-Use our autoloading if you dislike explicit requires.
+In Trailblazer, you only have operation unit tests and integration smoke tests to test the operation/controller wiring.
 
-You can just add
+Operations completely replace the need for leaky factories.
 
 ```ruby
-require "trailblazer/autoloading"
+describe Comment::Update do
+  let(:comment) { Comment::Create.(comment: {body: "[That](http://trailblazerb.org)!"}) }
 ```
 
-to `config/initializers/trailblazer.rb` and implementation classes like `Operation` will be automatically loaded.
+## More
 
-## Operation Autoloading
+Trailblazer has many more architectural features such as
 
-If you structure your CRUD operations using the `app/concepts/*/crud.rb` file layout we use in the book, the `crud.rb` files are not gonna be found by Rails automatically. It is a good idea to enable CRUD autoloading.
+* Polymorphic builders and operations
+* Inheritance and composition support
+* Polymorphic views
 
+Check the project website and the book.
 
 ## Installation
 
@@ -573,40 +301,11 @@ gem "cells"
 
 Cells is _not_ required per default! Add it if you use it, which is highly recommended.
 
-A few quirks are required at the moment as Rails autoloading is giving us a hard time. The setup of an app [is documented here](https://github.com/apotonick/gemgem-trbrb/wiki/Things-You-Should-Know).
-
-## Undocumented Features
-
-(Please don't read this section!)
-
-
-
-### Named Controller Instance Variables
-
-If you want to include named instance variables for you views you must include another ActiveRecord specific module.
-
-```ruby
-require 'trailblazer/operation/controller/active_record'
-
-class ApplicationController < ActionController::Base
-  include Trailblazer::Operation::Controller
-  include Trailblazer::Operation::Controller::ActiveRecord
-end
-```
-
-This will setup a named instance variable of your operation's model, for example `@song`.
-
 ## The Book
 
 ![](https://raw.githubusercontent.com/apotonick/trailblazer/master/doc/trb.jpg)
 
-Please buy my book [Trailblazer - A new architecture for Rails](https://leanpub.com/trailblazer) and [let me know](http://twitter.com/apotonick) what you think! I am still working on the book but keep adding new chapters every other week. It will be about 300 pages and we're developing a real, full-blown Rails/Trb application.
+Please buy it: [Trailblazer - A new architecture for Rails](https://leanpub.com/trailblazer).
 
 The [demo application](https://github.com/apotonick/gemgem-trbrb) implements what we discuss in the book.
 
-## Why?
-
-* Grouping code, views and assets by concepts increases the **maintainability** of your apps. Developers will find their way faster into your structure as the file layout is more intuitive.
-* Finding bugs gets less frustrating as encapsulated layers allow **testing components** in total isolation. Once you know your form and your view are ok, it must be the parsing code.
-* The reusability of code increases drastically as Trailblazer gently pushes you towards encapsulation. No more redundant helpers but clean inheritance.
-* No more surprises from ActiveRecord's massive API. The separation between persistence and domain automatically results in smaller, less destructive APIs for your models.

data/lib/trailblazer/autoloading.rb

@@ -1,3 +1,7 @@
+Trailblazer.class_eval do
+  autoload :NotAuthorizedError, "trailblazer/operation/policy"
+end
+
 Trailblazer::Operation.class_eval do
   autoload :Controller, "trailblazer/operation/controller"
   autoload :Model,      "trailblazer/operation/model"

data/lib/trailblazer/endpoint.rb

@@ -12,7 +12,7 @@ module Trailblazer
 
     def call
       document_body! if document_request?
-      yield # Create.run(params)
+      yield @params# Create.run(params)
     end
 
   private

data/lib/trailblazer/operation.rb

@@ -137,7 +137,7 @@ module Trailblazer
       result
     end
 
-    # When using Op::[], an invalid contract will raise an exception.
+    # When using Op.(), an invalid contract will raise an exception.
     def raise!(contract)
       raise InvalidContract.new(contract.errors.to_s) if @options[:raise_on_invalid]
     end

data/lib/trailblazer/operation/controller.rb

@@ -5,13 +5,13 @@ private
   def form(*args)
     operation!(*args).tap do |op|
       op.contract.prepopulate! # equals to @form.prepopulate!
-    end
+    end.contract
   end
 
   # Provides the operation instance, model and contract without running #process.
   # Returns the operation.
-  def present(operation_class, params=self.params)
-    operation!(operation_class, params, skip_form: true)
+  def present(operation_class, options={})
+    operation!(operation_class, skip_form: true)
   end
 
   def collection(*args)
@@ -20,8 +20,8 @@ private
     end
   end
 
-  def run(operation_class, params=self.params, &block)
-    res, op = operation_for!(operation_class, params) { operation_class.run(params) }
+  def run(operation_class, options={}, &block)
+    res, op = operation_for!(operation_class, options) { |params| operation_class.run(params) }
 
     yield op if res and block_given?
 
@@ -29,8 +29,9 @@ private
   end
 
   # The block passed to #respond is always run, regardless of the validity result.
-  def respond(operation_class, options={}, params=self.params, &block)
-    res, op   = operation_for!(operation_class, params, options) { operation_class.run(params) }
+  def respond(operation_class, options={}, &block)
+    options[:___dont_deprecate] = 1 # TODO: remove in 1.1.
+    res, op   = operation_for!(operation_class, options) { |params| operation_class.run(params) }
     namespace = options.delete(:namespace) || []
 
     return respond_with *namespace, op, options if not block_given?
@@ -38,8 +39,8 @@ private
   end
 
 private
-  def operation!(operation_class, params=self.params, options={}) # or #model or #setup.
-    res, op = operation_for!(operation_class, params, options) { [true, operation_class.present(params)] }
+  def operation!(operation_class, options={}) # or #model or #setup.
+    res, op = operation_for!(operation_class, options) { |params| [true, operation_class.present(params)] }
     op
   end
 
@@ -47,9 +48,13 @@ private
   end
 
   # Normalizes parameters and invokes the operation (including its builders).
-  def operation_for!(operation_class, params, options={}, &block)
-    # Per default, only treat :html as non-document.
-    options[:is_document] ||= request.format == :html ? false : true
+  def operation_for!(operation_class, options, &block)
+    options = deprecate_positional_params_argument!(options)
+
+    # Per default, only treat :html and js as non-document.
+    default_options = {is_document: ![:html, :js].include?(request.format.to_sym)}
+    options = default_options.merge(options)
+    params  = options.delete(:params) || self.params # TODO: test params: parameter properly in all 4 methods.
 
     process_params!(params)
     res, op = Trailblazer::Endpoint.new(operation_class, params, request, options).(&block)
@@ -58,6 +63,19 @@ private
     [res, op]
   end
 
+  def deprecate_positional_params_argument!(options) # TODO: remove in 1.1.
+    return options if options.has_key?(:skip_form)
+    return options if options.has_key?(:is_document)
+    return options if options.has_key?(:params)
+    return options if options.has_key?(:namespace)
+    return options if options.has_key?(:___dont_deprecate)
+    return options if options.size == 0
+
+    warn "[Trailblazer] The positional params argument for #run, #present, #form and #respond is deprecated and will be removed in 1.1.
+Please provide a custom params via `run Comment::Create, params: {..}` and have a nice day."
+    {params: options}
+  end
+
   def setup_operation_instance_variables!(operation, options)
     @operation = operation
     @model     = operation.model

data/lib/trailblazer/operation/representer.rb

@@ -33,6 +33,7 @@ module Trailblazer::Operation::Representer
         options_from:     :deserializer, # use :instance etc. in deserializer.
         superclass:       Representable::Decorator,
         representer_from: lambda { |inline| inline.representer_class },
+        exclude_options:  [:default, :populator] # TODO: test with populator: in an operation.
       )
     end
   end

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2015-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -237,4 +237,3 @@ test_files:
 - test/representer_test.rb
 - test/rollback_test.rb
 - test/test_helper.rb
-has_rdoc: