responsive_service 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5c99af05e50eb7ce1fdc4fc46ac0ae85791584a
-  data.tar.gz: 8377670a0580fa671948ae5683771178f99a60ef
+  metadata.gz: d201035ae2b1931491a0cdefb73867927a105026
+  data.tar.gz: e18b6ce1c12afc5b857985d6d172837970d57d56
 SHA512:
-  metadata.gz: f755a9ddbc13d16b9d08d566c926dae033a3c3352093ee876131b6fb4845ab956e22ee5bbc1c7331ce6363528978aef9c37139e474663f94d02cbb37fd99355b
-  data.tar.gz: fce27956087d7c51d1a326a5d501c28931ede073ebd077f2c6756ae13d2147c818a02696da1a4bb0f552a6b36955a0fecd5ea2f09722408f620efa58b1b34981
+  metadata.gz: 4c24e42a63f3fe65f9600afb95b700e261aa301c1a1ca7d6463d880cf348b79fec0f4eaee4bdbbec1d9094ece7471c630bd5b20059d2d7ad85a54d686dd950b8
+  data.tar.gz: 725f27ea43686a14e3bd3ab6eb9655e595a90b29f605458543b8b7f261ad7b4597d3872b35c49bc29141be431aaaaabd8734712e4ffa12a2b2c9700184e41475

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/responsive_service/response.rb

@@ -0,0 +1,31 @@
+module ResponsiveService
+  class Response
+    attr_reader :type, :message, :context, :valid_states
+
+    def initialize(type, message=nil, context=nil, valid_states=nil)
+      @valid_states = Array(valid_states || self.class.class_valid_states)
+      raise "Invalid type of response: #{type}" unless (@valid_states.empty? || @valid_states.include?(type))
+      @type = type
+      @context = context
+      @message = message
+    end
+
+    def self.valid_states(*args)
+      @class_valid_states = Array(args)
+    end
+
+    def self.class_valid_states
+      @class_valid_states
+    end
+
+    def method_missing(method, *args, &block)
+      if valid_states.empty? || valid_states.include?(method)
+        yield if method == type
+      else
+        super
+      end
+    end
+  end
+
+  Responder = Response
+end

data/lib/responsive_service/responsive_service.rb

@@ -1,13 +1,16 @@
 module ResponsiveService
   class ResponsiveService
-    attr_reader :responder_factory
+    attr_reader :response_factory
+
+    # Deprecated
+    alias_method :responder_factory, :response_factory
 
     def initialize(dependencies={})
-      @responder_factory = dependencies.fetch(:responder_factory, Responder)
+      @response_factory = dependencies[:response_factory] || dependencies.fetch(:responder_factory) { Response }
     end
 
     def call(&block)
-      yield responder_factory.new(:unimplemented, "A ResponsiveService should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponsiveService::Responder object.\n")
+      yield response_factory.new(:unimplemented, "A ResponsiveService should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponsiveService::Response object.\n")
     end
   end
 end

data/lib/responsive_service/version.rb

@@ -1,3 +1,3 @@
 module ResponsiveService
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/responsive_service.rb

@@ -1,6 +1,6 @@
 require "responsive_service/version"
 require "responsive_service/responsive_service"
-require "responsive_service/responder"
+require "responsive_service/response"
 
 module ResponsiveService
 end

data/spec/lib/responsive_service/response_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module ResponsiveService
+  describe Response do
+    subject(:response) { Response.new(type) }
+    let(:type) { :success }
+    before { Response.instance_variable_set :@class_valid_states, nil }
+
+    it 'yields when sent :success with a type of :success' do
+      expect { |b| response.success(&b) }.to yield_control
+    end
+
+    it 'does not yield when sent :failure with a type of :success' do
+      expect { |b| response.failure(&b) }.not_to yield_control
+    end
+
+    context 'when initialized with a message' do
+      subject(:response) { Response.new(type, message) }
+      let(:message) { double(:message) }
+
+      specify { expect(response.message).to eq message }
+
+      context 'when additionally initialized with a context' do
+        subject(:response) { Response.new(type, 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(type, message, context, valid_states) }
+          let(:valid_states) { [:success, :failure] }
+
+          it 'yields when sent :success with a type of :success' do
+            expect { |b| response.success(&b) }.to yield_control
+          end
+
+          it 'does not yield when sent :failure with a type of :success' do
+            expect { |b| response.failure(&b) }.not_to yield_control
+          end
+
+          it 'throws method missing exception if sent a non-valid state' do
+            expect { |b| response.foo(&b) }.to raise_exception
+          end
+
+          it 'reflects the valid_states' do
+            expect(response.valid_states).to eq [:success, :failure]
+          end
+
+          context 'when initialized with an invalid type' do
+            let(:type) { :foo }
+            
+            it 'raises an exception' do
+              expect { response }.to raise_exception('Invalid type of response: foo')
+            end
+          end
+        end
+      end
+    end
+
+    context 'backwards compatibility' do
+      it 'sets Responder as an alias for Response' do
+        expect(Responder).to eq Response
+      end
+    end
+
+    describe '.valid_states' do
+      context 'when set to an array of states' do
+        before { Response.valid_states(:success, :failure) }
+
+        context 'when the response type is :success' do
+          subject(:response) { Response.new(:success) }
+
+          it 'yields when sent :success' do
+            expect { |b| response.success(&b) }.to yield_control
+          end
+
+          it 'does not yield when sent :failure' do
+            expect { |b| response.failure(&b) }.not_to yield_control
+          end
+
+          it 'throws method missing exception if sent a non-valid state' do
+            expect { |b| response.foo(&b) }.to raise_exception
+          end
+        end
+
+        context 'when initialized with an invalid type' do
+          subject(:response) { Response.new(:foo) }
+          
+          it 'raises an exception' do
+            expect { response }.to raise_exception('Invalid type of response: foo')
+          end
+        end
+
+        describe '#valid_states' do
+          subject(:response) { Response.new(:success) }
+
+          it 'reflects the valid_states' do
+            expect(response.valid_states).to eq [:success, :failure]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/responsive_service/responsive_service_spec.rb

@@ -3,14 +3,21 @@ require 'spec_helper'
 module ResponsiveService
   describe ResponsiveService do
     subject(:service) { ResponsiveService.new(dependencies) }
-    let(:dependencies) { { responder_factory: responder_factory } }
-    let(:responder_factory) { double :responder_factory, new: nil }
-    let(:responder) { double :responder }
+    let(:dependencies) { { response_factory: response_factory } }
+    let(:response_factory) { double :response_factory, new: nil }
+    let(:response) { double :response }
 
     describe '#call' do
-      before { responder_factory.stub(:new).with(:unimplemented, "A ResponsiveService should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponsiveService::Responder object.\n").and_return(responder) }
-      it 'yields with a responder indicating instructions' do
-        expect { |b| service.call(&b) }.to yield_with_args(responder)
+      before { response_factory.stub(:new).with(:unimplemented, "A ResponsiveService should implement the call method.\nThe call method should perform the relevant work of the service and yield a ResponsiveService::Response object.\n").and_return(response) }
+      it 'yields with a response indicating instructions' do
+        expect { |b| service.call(&b) }.to yield_with_args(response)
+      end
+    end
+
+    # Deprecated
+    describe '#responder_factory' do
+      it 'is just a pointer to response_factory' do
+        expect(service.responder_factory).to eq service.response_factory
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: responsive_service
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-01 00:00:00.000000000 Z
+date: 2014-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,11 +80,11 @@ files:
 - README.md
 - Rakefile
 - lib/responsive_service.rb
-- lib/responsive_service/responder.rb
+- lib/responsive_service/response.rb
 - lib/responsive_service/responsive_service.rb
 - lib/responsive_service/version.rb
 - responsive_service.gemspec
-- spec/lib/responsive_service/responder_spec.rb
+- spec/lib/responsive_service/response_spec.rb
 - spec/lib/responsive_service/responsive_service_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/alexpeachey/responsive_service
@@ -112,6 +112,6 @@ signing_key:
 specification_version: 4
 summary: Easy to use responsive service pattern
 test_files:
-- spec/lib/responsive_service/responder_spec.rb
+- spec/lib/responsive_service/response_spec.rb
 - spec/lib/responsive_service/responsive_service_spec.rb
 - spec/spec_helper.rb

data/lib/responsive_service/responder.rb

@@ -1,16 +0,0 @@
-module ResponsiveService
-  class Responder
-
-    attr_reader :type, :message, :context
-
-    def initialize(type, message=nil, context=nil)
-      @type = type
-      @context = context
-      @message = message
-    end
-
-    def method_missing(method, *args, &block)
-      yield if method == type
-    end
-  end
-end

data/spec/lib/responsive_service/responder_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-module ResponsiveService
-  describe Responder do
-    subject(:responder) { Responder.new(type) }
-    let(:type) { :success }
-
-    it 'yields when sent :success with a type of :success' do
-      expect { |b| responder.success(&b) }.to yield_control
-    end
-
-    it 'does not yield when sent :failure with a type of :success' do
-      expect { |b| responder.failure(&b) }.to_not yield_control
-    end
-
-    context 'when initialized with a message' do
-      subject(:responder) { Responder.new(type, message) }
-      let(:message) { double(:message) }
-
-      specify { expect(responder.message).to eq message }
-
-      context 'when additionally initialized with a context' do
-        subject(:responder) { Responder.new(type, message, context) }
-        let(:context) { double(:context) }
-
-        specify { expect(responder.context).to eq context }
-      end
-    end
-  end
-end