response_state 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 582d7c3101becc563d9c0696000bc50ab4d3646c
-  data.tar.gz: 67cb929a24c3261d6e3c1bc9adf5677d2ae5785e
+  metadata.gz: 49640a1d8e13c04e6904e1672de5233b74e10577
+  data.tar.gz: 5ecc66ed44412cedb76b30afc5b8021d1d2ef96d
 SHA512:
-  metadata.gz: 1bfae51a4b1628e3726a16217cb254abbe0cafcebb142f09920d0b8d2b3ddc8f2e9df2e3607ff22550137f735cf910454d7bc64693a06e3e4a6f80a96ec26939
-  data.tar.gz: 97eb8d8a09ea753479fb470ca659e50a64872f0a5b01e86c8749d2480f116cd921ea33ecdf686a67f7a5c2270698d6ddd59bec8ebd87d2cc8b060b1235b10a04
+  metadata.gz: 5104ca4e50e10cf325155e4c6e5108f353a8dd91a7a2dfd0e7775b7054def88814ec3b9dd27dac8fbdbeef61a2fdb6392fa1b01d0bb58a47f8adab96b8892bab
+  data.tar.gz: dfcc5f13dd9c9b6d8fa60ce39363d2a4f7fece15c17888ea2bcdca0f9158dcda349e2786e4e473a3405ed276003240d69bb26069fd93f87438696d5ed6c6a4f5

data/README.md

@@ -24,44 +24,60 @@ Create a service class and subclass ResponseState::Service.
 
 ```ruby
 class MyService < ResponseState::Service
+  response_states :success, :failure
+
   def initialize(param)
     @param = param
   end
 
   def call(&block)
     # do some work
-    yield send_state(:success)
+    yield send_state :success
   end
 end
 ```
 
-You must implement a `call` method.
-Your call method should yield with a `ResponseState::Response`.
-The response can be generated with a helper method `send_state` in your service class.
+You must implement a `call` method. You must also indicated the valid response states
+using the `response_states` class macro method.
 
-You can optionally declare and restrict the set of valid states for your service's responses.
-The service will use this set of states when generating the response with the `send_state` method.
+Your call method should yield with a call to `send_state` which will create a `ResponseState::Response`.
 
-```ruby
-class MyService < ResponseState::Service
-  response_states :success, :failure
+The `send_state` method takes at a minimum a symbol representing the state. It optionally can also
+take a message and a context. The message by convention should be a string but there are no restrictions.
+The context can be any object. An error will be raised if a state is specified that is not in the list
+of valid response states.
 
-  def call(&block)
-    # do some work
-    yield send_state(:success)
-  end
+### Your service API
+
+Your service can now be used as such:
+
+```ruby
+MyService.('Some param') do |response|
+  response.success { puts 'I was successful.' }
+  response.failure { puts 'I failed.' }
 end
 ```
 
+You can optionally ensure all states have been handled by placing a call
+to `unhandled_states` at the end of your response block. This will yield an array of
+unhandled states to the given block if there are any unhandled states.
+
+```ruby
+MyService.('Some param') do |response|
+  response.success { puts 'I was successful.' }
+  response.failure { puts 'I failed.' }
+  response.unhandled_states { |states| raise "You didn't handle #{states.join(', ')}" }
+end
+```
 
-### Response
+### ResponseState::Response
 
 A `ResponseState::Response` can take up to 4 arguments but must at least have the first argument which is the state of the response. In addition it can take a message, a context, and a set of valid states. The message by convention should
 be a string but there are no restrictions. The context can be any object. The valid states should be an array of symbols
 that are the allowed states. An exception will be thrown if initialized with a type of response that is not in the valid states if a set of valid states was specified.
 
 ```ruby
-response = Response.new(:success, 'You win!', {an_important_value: 'some value'})
+response = Response.new(:success, 'You win!', {an_important_value: 'some value'}, [:success, :failure])
 response.type    # :success
 response.message # 'You win!'
 response.context  # {an_important_value: 'some value'}
@@ -93,30 +109,6 @@ response.foo { puts 'Not going to work' }
 # exception => NoMethodError: undefined method `foo'
 ```
 
-### Your service API
-
-Your service can now be used as such:
-
-```ruby
-MyService.('Some param') do |response|
-  response.success { puts 'I was successful.' }
-  response.failure { puts 'I failed.' }
-end
-```
-
-If your service or the response itself restrict the response to a specific set
-of states, you can ensure all states have been handled by placing a call
-to `unhandled_states` at the end of your response block. This will yield an array of
-unhandled states to the given block if there are any unhandled states.
-
-```ruby
-MyService.('Some param') do |response|
-  response.success { puts 'I was successful.' }
-  response.failure { puts 'I failed.' }
-  response.unhandled_states { |states| raise "You didn't handle #{states.join(', ')}" }
-end
-```
-
 ## Contributing
 
 1. Fork it

data/lib/response_state/response.rb

@@ -4,7 +4,7 @@ module ResponseState
 
     def initialize(state, message=nil, context=nil, valid_states=nil)
       @valid_states = Array(valid_states || self.class.class_valid_states)
-      raise "Invalid state of response: #{state}" unless (@valid_states.empty? || @valid_states.include?(state))
+      raise "Invalid state of response: #{state}" unless  @valid_states.include? state
       @state = state
       @context = context
       @message = message
@@ -20,7 +20,6 @@ module ResponseState
     end
 
     def unhandled_states
-      return if valid_states.empty?
       yield uncalled_states unless uncalled_states.empty?
       nil
     end
@@ -30,19 +29,15 @@ module ResponseState
     end
 
     def method_missing(method, *args, &block)
-      if valid_state? method
-        called_states << method unless called_states.include? method
-        yield if method == state
-        nil
-      else
-        super
-      end
+      return super unless valid_state? method
+      called_states << method unless called_states.include? method
+      yield if method == state
+      nil
     end
 
     private
 
     def valid_state?(call_state)
-      return true if valid_states.empty?
       return true if valid_states.include? call_state
       raise "Invalid state: #{call_state}"
     end

data/lib/response_state/service.rb

@@ -14,7 +14,7 @@ module ResponseState
     end
 
     def call(&block)
-      yield send_state(:unimplemented, "A ResponseState::Service should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponseState::Response object.\n")
+      fail NotImplementedError, "A ResponseState::Service should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponseState::Response object.\n"
     end
 
     def send_state(state, message=nil, context=nil, valid_states=nil)

data/lib/response_state/version.rb

@@ -1,3 +1,3 @@
 module ResponseState
-  VERSION = "0.3.0"
+  VERSION = '0.4.0'
 end

data/spec/features/full_example_spec.rb

@@ -1,10 +1,8 @@
 require 'spec_helper'
-
-class MyResponse < ResponseState::Response
-  valid_states :success, :failure
-end
+require 'ostruct'
 
 class MyService < ResponseState::Service
+  response_states :success, :failure
   attr_reader :object, :pass
 
   def initialize(object, pass)
@@ -20,11 +18,11 @@ class MyService < ResponseState::Service
 
   def success_response
     return unless pass
-    MyResponse.new(:success, 'Yay! It works.', object)
+    send_state :success, 'Yay! It works.', object
   end
 
   def failure_response
-    MyResponse.new(:failure, 'Boo! It failed.')
+    send_state :failure, 'Boo! It failed.'
   end
 end
 

data/spec/lib/response_state/response_spec.rb

@@ -2,8 +2,11 @@ require 'spec_helper'
 
 module ResponseState
   describe Response do
-    subject(:response) { Response.new(state) }
+    subject(:response) { Response.new(state, message, context, valid_states) }
     let(:state) { :success }
+    let(:message) { nil }
+    let(:context) { nil }
+    let(:valid_states) { [:success, :failure] }
     before { Response.instance_variable_set :@class_valid_states, nil }
 
     it 'yields when sent :success with a state of :success' do
@@ -15,19 +18,16 @@ module ResponseState
     end
 
     context 'when initialized with a message' do
-      subject(:response) { Response.new(state, message) }
       let(:message) { double(:message) }
 
       specify { expect(response.message).to eq message }
 
       context 'when additionally initialized with a context' do
-        subject(:response) { Response.new(state, message, context) }
         let(:context) { double(:context) }
 
         specify { expect(response.context).to eq context }
 
         context 'when additionally initiaized with a set of valid states' do
-          subject(:response) { Response.new(state, message, context, valid_states) }
           let(:valid_states) { [:success, :failure] }
 
           it 'yields when sent :success with a state of :success' do
@@ -59,6 +59,7 @@ module ResponseState
 
     describe '.valid_states' do
       context 'when set to an array of states' do
+        let(:valid_states) { nil }
         before { Response.valid_states(:success, :failure) }
 
         context 'when the response state is :success' do

data/spec/lib/response_state/service_spec.rb

@@ -11,7 +11,7 @@ module ResponseState
 
     describe '.call' do
       it 'news up an instance and passes the block on to #call' do
-        expect { |b| Service.(&b) }.to yield_control
+        expect { |b| Service.(&b) }.to raise_error(NotImplementedError, "A ResponseState::Service should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponseState::Response object.\n")
       end
     end
 
@@ -29,16 +29,8 @@ module ResponseState
     end
 
     describe '#call' do
-      let(:yielded) { OpenStruct.new(response: nil) }
-      let(:response) { yielded.response }
-      before { service.call { |response| yielded.response = response} }
-
-      it 'yields an unimplemented response' do
-        expect(response.state).to eq :unimplemented
-      end
-
-      it 'yields with a response indicating instructions' do
-        expect(response.message).to eq "A ResponseState::Service should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponseState::Response object.\n"
+      it 'raises an error' do
+        expect { service.call }.to raise_error(NotImplementedError, "A ResponseState::Service should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponseState::Response object.\n")
       end
     end
 
@@ -65,6 +57,7 @@ module ResponseState
 
       context 'given :success, "a message", {}' do
         let(:response) { service.send_state(:success, 'a message', {}) }
+        before { Service.response_states :success, :failure }
 
         it 'has a success state' do
           expect(response.state).to eq :success
@@ -79,20 +72,13 @@ module ResponseState
         end
 
         it 'has valid_states nil' do
-          expect(response.valid_states).to eq []
-        end
-
-        context 'and the service has valid states set' do
-          before { Service.response_states :success, :failure }
-
-          it 'has valid_states [:success, :failure]' do
-            expect(response.valid_states).to eq [:success, :failure]
-          end
+          expect(response.valid_states).to eq [:success, :failure]
         end
       end
 
       context 'given :success, "a message"' do
         let(:response) { service.send_state(:success, 'a message') }
+        before { Service.response_states :success, :failure }
 
         it 'has a success state' do
           expect(response.state).to eq :success
@@ -107,12 +93,13 @@ module ResponseState
         end
 
         it 'has valid_states nil' do
-          expect(response.valid_states).to eq []
+          expect(response.valid_states).to eq [:success, :failure]
         end
       end
 
       context 'given :success' do
         let(:response) { service.send_state(:success) }
+        before { Service.response_states :success, :failure }
 
         it 'has a success state' do
           expect(response.state).to eq :success
@@ -127,7 +114,7 @@ module ResponseState
         end
 
         it 'has valid_states nil' do
-          expect(response.valid_states).to eq []
+          expect(response.valid_states).to eq [:success, :failure]
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: response_state
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-20 00:00:00.000000000 Z
+date: 2014-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler