solid_use_case 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2623d1e04af22ee51de1e4746582707b9c5229d2
-  data.tar.gz: 7f9546142427b3e95209b807d3f55107f6c18057
+  metadata.gz: 6ddf3a778dbf1eb61bc2f63319813267790aa806
+  data.tar.gz: 11b3e39668ca2ca7502255f90999eb2b8181753e
 SHA512:
-  metadata.gz: 878297f0a78c9f4b558a2a18daf8358c12320aa031bf6268f0e311ff411280e55e73e66ecd5f24680604aa11bb80f95e86e1e4db24d0b27be45be67d9bf42957
-  data.tar.gz: 1ad7e0f4eeebb337bc12ab21723185d939ec78171f3bba1cd5f43c31624a83fc11c1dacb5f87d124f7aaef8626a8a93c4ab2b42b5dbd14ad1b3d3979db9314b1
+  metadata.gz: 9c6177ff65b30961fce7808ecce96401259926075f8d55340767efc6ff104180728e00365fce5044a24dbf4413b8ae08a8df65229e604e61366f98930c57d589
+  data.tar.gz: 77ff94dd60cb46f013ae170e92863c1c60f027d8dd74817676b644f6385863ac71039f7353c1e7c7cc799691b1bc273ad6838089823acea803a46b04d67def49

data/README.md

@@ -6,7 +6,7 @@
 
 Add this line to your application's Gemfile:
 
-    gem 'solid_use_case', '~> 2.0.1'
+    gem 'solid_use_case', '~> 2.0.2'
 
 And then execute:
 
@@ -93,6 +93,47 @@ class UsersController < ApplicationController
 end
 ```
 
+## Control Flow Helpers
+
+`check_exists` (alias `maybe_continue`) allows you to implicitly return a failure when a value is nil:
+
+```ruby
+# NOTE: The following assumes that #post_comment returns a Success or Failure
+video = Video.find_by_id(params[:video_id])
+check_exists(video).and_then { post_comment(params) }
+
+# NOTE: The following assumes that #find_tag and #create_tag both return a Success or Failure
+check_exists(Tag.find_by(name: tag)).or_else { create_tag(tag) }.and_then { ... }
+
+# If you wanted, you could refactor the above to use a method:
+def find_tag(name)
+  maybe_continue(Tag.find_by(name: name))
+end
+
+# Then, elsewhere...
+find_tag(tag)
+.or_else { create_tag(tag) }
+.and_then do |active_record_tag|
+  # At this point you can safely assume you have a tag :)
+end
+```
+
+`attempt` allows you to catch an exception. It's useful when you want to attempt something that might fail, but don't want to write all that exception-handling boilerplate.
+
+`attempt` also **auto-wraps your values**; in other words, the inner code does **not** have to return a success or failure.
+
+For example, a Stripe API call:
+
+```ruby
+# Goal: Only charge customer if he/she exists
+attempt {
+  Stripe::Customer.retrieve(some_id)
+}
+.and_then do |stripe_customer|
+  stripe_customer.charge(...)
+end
+```
+
 ## RSpec Matchers
 
 If you're using RSpec, Solid Use Case provides some helpful matchers for testing.

data/lib/solid_use_case/composable.rb

@@ -32,11 +32,26 @@ module SolidUseCase
     # Helpers #
     # # # # # #
 
+    def check_exists(val, error=:not_found)
+      if val.nil?
+        fail(error)
+      else
+        continue(val)
+      end
+    end
+
+    def attempt
+      attempt_all do
+        try { yield }
+      end
+    end
+
     def fail(type, data={})
       data[:type] = type
       Failure(ErrorStruct.new(data))
     end
 
+    alias :maybe_continue :check_exists
     alias :continue :Success
   end
 end

data/lib/solid_use_case/version.rb

@@ -1,3 +1,3 @@
 module SolidUseCase
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/spec/control_flow_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe "Control Flow Helpers" do
+
+  describe '#check_exists' do
+    class FloodGate
+      include SolidUseCase::Composable
+
+      def basic(input)
+        check_exists(input).and_then {|x| Success(x * 2) }
+      end
+
+      def alias(input)
+        maybe_continue(input)
+      end
+
+      def custom_error(input, err)
+        check_exists(input, err)
+      end
+    end
+
+    it "stops when the value is nil" do
+      result = FloodGate.new.basic(nil)
+      expect(result).to fail_with(:not_found)
+    end
+
+    it "continues when the value is not nil" do
+      result = FloodGate.new.basic(17)
+      expect(result).to be_a_success
+      expect(result.value).to eq 34
+    end
+
+    it "has an alias" do
+      result = FloodGate.new.basic(17)
+      expect(result).to be_a_success
+      expect(result.value).to eq 34
+    end
+
+    it "allows a custom error" do
+      result = FloodGate.new.custom_error(nil, :my_error)
+      expect(result).to fail_with(:my_error)
+    end
+  end
+
+  describe '#attempt' do
+    class Bubble
+      include SolidUseCase::Composable
+
+      def pop1
+        attempt { "pop!" }
+      end
+
+      def pop2
+        attempt { raise NoMethodError.new("oops") }
+      end
+    end
+
+    it "succeeds when no exceptions happen" do
+      expect(Bubble.new.pop1).to be_a_success
+    end
+
+    it "catches exceptions" do
+      result = Bubble.new.pop2
+      expect(result).to_not be_a_success
+      expect(result.value).to be_a NoMethodError
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_use_case
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Gilbert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-10 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deterministic
@@ -89,6 +89,7 @@ files:
 - lib/solid_use_case/version.rb
 - solid_use_case.gemspec
 - spec/composable_spec.rb
+- spec/control_flow_spec.rb
 - spec/rspec_matchers_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mindeavor/solid_use_case
@@ -117,6 +118,7 @@ specification_version: 4
 summary: A flexible UseCase pattern that works *with* your workflow, not against it.
 test_files:
 - spec/composable_spec.rb
+- spec/control_flow_spec.rb
 - spec/rspec_matchers_spec.rb
 - spec/spec_helper.rb
 has_rdoc: