slayer 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e09fbfa409b97335f8476da1445d716025e0230
-  data.tar.gz: 8c3964b9a74d94d510681dde108d0acad83a8efb
+  metadata.gz: 324ed5c2712dfb7b91ab54d26035264be046c975
+  data.tar.gz: 9cbef2f5c7393d18d8323a19a12d94972e417806
 SHA512:
-  metadata.gz: 908f87de03974d652fb42acb9a9765b02872890cdb429f40d89eb578e9e0caff4655730e94f8c9b8f4e0805a93785bd3c367ca449ea15c622d467912b22e9b46
-  data.tar.gz: 6cbf9533c1e47a292446194a8b26163269258709abe89cb2a4777d2a7ccc6c72720ae6f594adab3959caecd1c7b07140b88acb0c4cf7ca65f3bcaa4d21795aaa
+  metadata.gz: 50c3825dce992223f71114a6f0db3aac21534e5d24332422549f687470a07acaf45e0750303e1cf66a4ee716c1e84c457a092bc7aa5ee68cdf6624abc409a20a
+  data.tar.gz: b86843b30033d24661fcb01a4572a3d8f16054b59ff1bcd1e422c5bed386f53d0f166a39ec6b532abf46c5331227899f4440220f03cd2bc6bc371912ec070d82

data/.rubocop.yml

@@ -1,7 +1,7 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.1
   Include:
     - 'lib/**/*.rb'
     - 'test/**/*.rb'

data/README.md

@@ -44,11 +44,88 @@ Or install it yourself as:
 $ gem install slayer
 ```
 
+## Rails Integration
+
+While Slayer is independent of any framework, we do offer a first-class integration with Ruby on Rails. To install the Rails extensions, add this line to your application's Gemfile:
+
+```ruby
+gem 'slayer_rails'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+And that's it. The integration provides a small handful of features that make your life easier when working with Ruby on Rails.
+
+### Form Validations
+
+With `slayer_rails`, `Slayer::Form` objects are automatically extended with `ActiveRecord` validations. You can use the same validations you would on your `ActiveRecord` models, but directly on your forms.
+
+### Form Creation
+
+With `slayer_rails` there are two new methods for instantiating `Slayer::Form` objects: `from_params` and `from_model`. These make it easier to populate forms with data while in your Rails controllers.
+
+Take the following example for a `FooController`:
+
+```ruby
+class FooController < ApplicationController
+  def new
+    @foo_form = FooForm.new
+  end
+
+  def edit
+    @foo = Foo.find(params[:id])
+    @foo_form = FooForm.from_model(@foo)
+  end
+
+  def create
+    @foo_form = FooForm.from_params(foo_params)
+  end
+
+  def update
+    @foo_form = FooForm.from_params(foo_params)
+  end
+
+  private
+
+    def foo_params
+      params.require(:foo).permit(:bar, :baz)
+    end
+end
+```
+
+### Transactions
+
+`Slayer::Command` and `Slayer::Service` objects are extended with access to `ActiveRecord` transactions. Anywhere in your `Command` or `Service` objects, you can execute a `transaction` block, which will let you bundle database interactions.
+
+```ruby
+class FooCommand < Slayer::Command
+  def call
+    transaction do
+      # => database interactions
+    end
+  end
+end
+```
+
+### Generators
+
+Use generators to make sure your `Slayer` objects are always in the right place. `slayer_rails` includes generators for `Slayer::Form`, `Slayer::Command`, and `Slayer::Service` objects.
+
+```sh
+$ bin/rails g slayer:form foo_form
+$ bin/rails g slayer:command foo_command
+$ bin/rails g slayer:service foo_service
+```
+
 ## Usage
 
 ### Commands
 
-Slayer Commands should implement `call`, which will `pass` or `fail` the service based on input. Commands return a `Slayer::Result` which has a predictable interface for determining `success?` or `failure?`, a `message`, and a `result` payload object.
+Slayer Commands should implement `call`, which will `pass` or `fail` the service based on input. Commands return a `Slayer::Result` which has a predictable interface for determining `success?` or `failure?`, a 'value' payload object, a 'status' value, and a user presentable `message`.
 
 ```ruby
 # A Command that passes when given the string "foo"
@@ -56,9 +133,9 @@ Slayer Commands should implement `call`, which will `pass` or `fail` the service
 class FooCommand < Slayer::Command
   def call(foo:)
     if foo == "foo"
-      pass! result: foo, message: "Passing FooCommand"
+      pass! value: foo, message: "Passing FooCommand"
     else
-      fail! result: foo, message: "Failing FooCommand"
+      fail! value: foo, message: "Failing FooCommand"
     end
   end
 end

data/lib/slayer/command.rb

@@ -56,14 +56,15 @@ module Slayer
     end
 
     # Fail the Command
-    def fail!(result:, status: :default, message: nil)
-      @result = Result.new(result, status, message)
+
+    def fail!(value: nil, status: :default, message: nil)
+      @result = Result.new(value, status, message)
       @result.fail!
     end
 
     # Pass the Command
-    def pass!(result:, status: :default, message: nil)
-      @result = Result.new(result, status, message)
+    def pass!(value: nil, status: :default, message: nil)
+      @result = Result.new(value, status, message)
     end
 
     # Call the command

data/lib/slayer/result_matcher.rb

@@ -195,23 +195,26 @@ module Slayer
     # @api private
     def execute_matching_block
       if @matching_block != false # nil should pass this test
-        @matching_block&.call(@result, @command) # explicit nil will not get called with
-                                                 # safe navigation (&.)
+        run_block(@matching_block)
       elsif @matching_all != false
-        @matching_all&.call(@result, @command)
+        run_block(@matching_all)
       elsif @default_block != false
-        @default_block&.call(@result, @command)
+        run_block(@default_block)
       elsif @default_all
-        @default_all&.call(@result, @command)
+        run_block(@default_all)
       end
     end
 
+    # Executes the ensure block if one exists.
+    # @api private
     def execute_ensure_block
-      # rubocop:disable Style/IfUnlessModifier
-      if @ensure_block != false # nil should pass this test
-        @ensure_block.call(@result, @command)
-      end
-      # rubocop:enable Style/IfUnlessModifier
+      run_block(@ensure_block) if @ensure_block != false # nil should pass this test
     end
+
+    private
+
+      def run_block(block)
+        block.call(@result.value, @result, @command) if block # explicit nil should fail this test
+      end
   end
 end

data/lib/slayer/version.rb

@@ -1,3 +1,3 @@
 module Slayer
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slayer
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Wyatt Kirby
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2017-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus