holla_back 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ccaa754e972d5506f0559b10564e8685e601fce
-  data.tar.gz: 163b69aa7405593d6ca55330fa2ee99dd5dbedcb
+  metadata.gz: 2d3cdb1ab0b7097d38b9e53bdb9e2fb844718d6e
+  data.tar.gz: 03802d0d26af9674af2c28bbedbcc504e29b4e67
 SHA512:
-  metadata.gz: 00594d4f2e7b168846de8365ae2ad27f8f4880eae097dad9733bb78151986fa576065ef9cfdebcbe13dc4cb34da2c744482020d3858766717e50903c542e8d2d
-  data.tar.gz: e4888389ef496d624db493feb8c863764696e62fab5f9d498213b168864d35223f0a17b686a1cad84690e83b42fba586eaf7a2f05254e068a6404d30d369a075
+  metadata.gz: b11a00e5d99920efd607c666810a07d8b2d88bfc59172a2bd3341101d60e4daee4280032906b0cbca54b9bc9198770b04bf2d0f6251a8aa925b7318f97e3f714
+  data.tar.gz: e8a4fefa7efc0edc69e16f9abec94f801699622d38c063b54f16e8bed01817aa445abe5cab873c9145599106938cd27619a8502dcba0409179577f0806c47a07

data/README.md

@@ -21,73 +21,87 @@ Or install it yourself as:
 
 ## Usage
 
-Ponder the hypothetical class with HollaBack included that will be used for these examples as defined below:
+Ponder the hypothetical class with HollaBack included that will be used for these examples:
 
 > `some_class.rb`
 
-```ruby
-class SomeClass
-  include HollaBack
+    class SomeClass
+      include HollaBack
 
-  def truthy_method
-    true
-  end
+      def truthy_method
+        true
+      end
 
-  def falsey_method
-    [nil, false].sample
-  end
+      def falsey_method
+        [nil, false].sample
+      end
 
-  def conditional_method_with_params(condition=nil)
-    condition ? true : false
-  end
+      def conditional_method_with_params(condition=nil)
+        condition ? true : false
+      end
+
+      def info_method
+        'some random info'
+      end
+
+      def optional_method
+        'some random info'
+      end
+
+      def optional_method_with_params(param=nil)
+        param ? true : false
+      end
+    end
 
-  def info_method
-    'some random info'
-  end
-end
-```
 
 Simple example:
 
-```ruby
-klass = SomeClass.new
+    klass = SomeClass.new
+
+    # Minimal request
+    response = klass.response(status_method: 'truthy_method') 
+    # => #<HollaBack::Response>
+    response.successful?
+    # => true
+    response.status_message
+    # => "Status: successful"
+
+With params in the status method:
+
+    klass = SomeClass.new
 
-# Minimal request
-response = klass.response(status_method: 'truthy_method') 
-# => #<HollaBack::Response>
-response.successful?
-# => true
-response.status_message
-# => "Status: successful"
-```
+    # Minimal request
+    response = klass.response(status_method: {optional_method_with_params: [true]}) 
+    # => #<HollaBack::Response>
+    response.successful?
+    # => true
+    response.status_message
+    # => "Status: successful"
 
 With customized status messages:
 
-```ruby
-# If we have a truthy status method
-response = klass.response(status_method: 'truthy_method', success_message: "It worked! :D", failure_message: "It didn't work! D:") 
-# => #<HollaBack::Response>
-response.successful?
-# => true
-response.status_message
-# => "It worked! :D"
-
-# If we have a falsy status method
-response = klass.response(status_method: 'falsey_method', success_message: "It worked! :D", failure_message: "It didn't work! D:") 
-# => #<HollaBack::Response>
-response.successful?
-# => false
-response.status_message
-# => "It didn't work! D:"
-```
+    # If we have a truthy status method
+    response = klass.response(status_method: 'truthy_method', success_message: "It worked! :D", failure_message: "It didn't work! D:") 
+    # => #<HollaBack::Response>
+    response.successful?
+    # => true
+    response.status_message
+    # => "It worked! :D"
+
+    # If we have a falsy status method
+    response = klass.response(status_method: 'falsey_method', success_message: "It worked! :D", failure_message: "It didn't work! D:") 
+    # => #<HollaBack::Response>
+    response.successful?
+    # => false
+    response.status_message
+    # => "It didn't work! D:"
+
 With extra methods you need information from
 
-```ruby
-response = klass.response(status_method: 'falsey_method', responding_methods: [:optional_method, {:optional_method_with_params => ['some param']}])
-# => #<HollaBack::Response>
-response.responding_methods
-#=> {:optional_method=>"this was only optional", :optional_method_with_params=>true}
-```
+    response = klass.response(status_method: 'falsey_method', responding_methods: [:optional_method, {:optional_method_with_params => ['some param']}])
+    # => #<HollaBack::Response>
+    response.responding_methods
+    #=> {:optional_method=>"this was only optional", :optional_method_with_params=>true}
 
 If you pass in a status method or some responding methods that raise exceptions, HollaBack will
 simply handle these gracefully, because exceptions are still a response from your code. The important
@@ -96,14 +110,26 @@ the exception on the status method, else you can check the responding object for
 
 With some method that totally doesn't exist
 
-```ruby
-response = klass.response(status_method: 'some_method_that_totally_doesnt_exist')
-# => #<HollaBack::Response>
-response.responding_object
-#=> NoMethodError
-response.status_message
-#=> "undefined method `some_method_that_totally_doesnt_exist' for #<SomeClass:0x00000001e1b008>"
-```
+    response = klass.response(status_method: 'some_method_that_totally_doesnt_exist')
+    # => #<HollaBack::Response>
+    response.responding_object
+    #=> NoMethodError
+    response.status_message
+    #=> "undefined method `some_method_that_totally_doesnt_exist' for #<SomeClass:0x00000001e1b008>"
+
+## Synopsis For Sending Methods
+
+Synopsis for sending a method with parameters (the all important status method):
+
+    # This is how you'd do it for the status method
+    {:name_of_status_method => ['array', 'of', 'input', 'parameters']}
+
+Synopsis for sending multiple methods, some requiring parameters:
+
+    # This is how you'd do it for the responding methods, which follows the same
+    # pattern as the status method, but as elements in an array so that you can
+    # respond with multiple responding methods
+    ['name_of_some_method_with_no_params', {:name_of_some_method_with_params => ['array', 'of', 'input', 'parameters']}]
 
 
 ## Contributing

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/holla_back.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |gem|
   gem.name          = "holla_back"
   gem.version       = `cat VERSION`.strip
   gem.authors       = ["David Chapman"]
-  gem.email         = ["david@isotope11.com"]
+  gem.email         = ["david@dchapman.io"]
   gem.description   = %q{A simple Ruby gem for providing a response standard to your libraries}
   gem.summary       = %q{HollaBack will simply provide a unified response object containing needed information and responses.}
-  gem.homepage      = ""
+  gem.homepage      = "http://dchapman.io/"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)

data/lib/holla_back/response.rb

@@ -40,7 +40,7 @@ module HollaBack
     # @return [Boolean] false - if the status method is nil or false
     # @api public
     def successful?
-      !!@responding_object.send(@status_method)
+      !!get_status_method
     end
 
     private
@@ -53,18 +53,36 @@ module HollaBack
     # @api private
     def set_response!
       get_responding_methods
+      self.responding_object = @responding_object
+      if successful?
+        self.status_message ||= (@success_message || "Status: successful")
+      else
+        self.status_message ||= (@failure_message || "Status: unsuccessful")
+      end
+      return true
+    end
+
+    # Gets the returning value of the status method
+    #
+    # @example
+    #   response.get_status_method
+    #
+    # @return [Object] the returned object from the status method
+    # @api private
+    def get_status_method
+      status = false
       begin
-        self.responding_object = @responding_object
-        if successful?
-          self.status_message = @success_message || "Status: successful"
+        if @status_method.is_a? Hash
+          meth = @status_method.first
+          status = !!@responding_object.send(meth.first, *meth.last)
         else
-          self.status_message = @failure_message || "Status: unsuccessful"
+          status = !!@responding_object.send(@status_method)
         end
       rescue Exception => e
         self.responding_object = e.class
         self.status_message = e.message
       end
-      return true
+      return status
     end
 
     # Gets the responding methods
@@ -78,17 +96,13 @@ module HollaBack
       @responding_methods.each do |meth|
         begin
           if meth.is_a? Hash
-            meth.each_pair { |k,v|
-              meth_responses[k.to_sym] = @responding_object.send(k, *v)
-            }
+            meth.each_pair { |k,v| meth_responses[k.to_sym] = @responding_object.send(k, *v) }
           else
             meth_responses[meth.to_sym] = @responding_object.send(meth)
           end
         rescue Exception => e
           if meth.is_a? Hash
-            meth.each_pair { |k,v|
-              meth_responses[k.to_sym] = "#{e.class}: #{e.message}"
-            }
+            meth.each_pair { |k,v| meth_responses[k.to_sym] = "#{e.class}: #{e.message}" }
           else
             meth_responses[meth.to_sym] = "#{e.class}: #{e.message}"
           end

data/test/unit/holla_back/response_test.rb

@@ -33,6 +33,38 @@ describe HollaBack::Response do
     end
   end
 
+  describe "A successful response with params in the status method" do
+    before do
+      responding_object = mock('responding_object')
+      responding_object.expects(:status_meth_with_params).with('some param').returns([]).at_least_once
+      responding_object.expects(:meth1).returns(42).at_least_once
+      responding_object.expects(:meth2).with('param').returns(42).at_least_once
+      responding_methods = [:meth1, {:meth2 => ['param']}]
+      @options = {
+        responding_methods: responding_methods,
+        status_method: {:status_meth_with_params => ['some param']},
+        success_message: 'success',
+        failure_message: 'failure'
+      }
+      @response = HollaBack::Response.new(responding_object, @options)
+    end
+
+    it 'should provide a successful status method' do
+      @response.successful?.must_equal true
+    end
+
+    it 'should provide the responding methods' do
+      @response.responding_methods.must_be_kind_of Hash
+      @response.responding_methods[:meth1].must_equal 42
+      @response.responding_methods[:meth2].must_equal 42
+    end
+
+    it 'should return the success message' do
+      @response.status_message.must_be_kind_of String
+      @response.status_message.must_equal "success"
+    end
+  end
+
   describe "A unsuccessful response" do
     before do
       responding_object = mock('responding_object')
@@ -63,6 +95,67 @@ describe HollaBack::Response do
     end
   end
 
+  describe "A unsuccessful response with params in the status method" do
+    before do
+      responding_object = mock('responding_object')
+      responding_object.expects(:status_meth_with_params).with('some param').returns([false, nil].sample).at_least_once
+      responding_object.expects(:meth).returns(42).at_least_once
+      responding_methods = ['meth']
+      @options = {
+        responding_methods: responding_methods,
+        status_method: {:status_meth_with_params => ['some param']},
+        success_message: 'success',
+        failure_message: 'failure'
+      }
+      @response = HollaBack::Response.new(responding_object, @options)
+    end
+
+    it 'should provide a successful status method' do
+      @response.successful?.must_equal false
+    end
+
+    it 'should provide the responding methods' do
+      @response.responding_methods.must_be_kind_of Hash
+      @response.responding_methods[:meth].must_equal 42
+    end
+
+    it 'should return the success message' do
+      @response.status_message.must_be_kind_of String
+      @response.status_message.must_equal "failure"
+    end
+  end
+
+  describe "A unsuccessful response due to undefined status method with params" do
+    before do
+      responding_object = TestClass.new
+      responding_methods = ['meth']
+      @options = {
+        responding_methods: responding_methods,
+        status_method: {:status_meth_with_params => ['some param']},
+        success_message: 'success',
+        failure_message: 'failure'
+      }
+      @response = HollaBack::Response.new(@options)
+    end
+
+    it 'should provide a successful status method' do
+      @response.successful?.must_equal false
+    end
+
+    it 'should provide the responding methods' do
+      @response.responding_methods.must_be_kind_of Hash
+    end
+
+    it 'should return the exception class as the responding object' do
+      @response.responding_object.must_equal NoMethodError
+    end
+
+    it 'should provide the error message as the response' do
+      @response.status_message.must_be_kind_of String
+    end
+  end
+
+
   describe "A unsuccessful response due to a undefined methods" do
     before do
       responding_object = TestClass.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: holla_back
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - David Chapman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-27 00:00:00.000000000 Z
+date: 2013-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -264,7 +264,7 @@ dependencies:
         version: '0'
 description: A simple Ruby gem for providing a response standard to your libraries
 email:
-- david@isotope11.com
+- david@dchapman.io
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -286,7 +286,7 @@ files:
 - test/unit/holla_back/option_loader_test.rb
 - test/unit/holla_back/response_test.rb
 - test/unit/holla_back_test.rb
-homepage: ''
+homepage: http://dchapman.io/
 licenses:
 - MIT
 metadata: {}