cuprum 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 457807ef9d8b39d6980467ad264972081f01b9ec
-  data.tar.gz: 92fedf44dfd331ef25e1429c8f35c2af7ede6180
+  metadata.gz: 5a329ab1299b862bc041a64a19da75c47101f902
+  data.tar.gz: 570f6b167f4b76570166a6293f81682b10197b59
 SHA512:
-  metadata.gz: ef543f82ad31ce828f01d4bfea7805da392ea524f4477af24ca77cb80b77ad623d9439af35ef2f8f5ef6d25b119e03dec104b73db966e287f2ebfc8141ab70de
-  data.tar.gz: 73c642f2383e11273184ec3145ab61808cd80646bdf1687ca9abb94a439d3f9bfbc12fceb4806845c49ac7b91eda570997a2e2d669a2c566da5dbca88a9e4df4
+  metadata.gz: 3bc9f429efab47bf5fcee2f843481afeae3e0709bafefd0810b7b4cb91038826ae0af00218b26f08d033f76fa7d90445ddc6f410a9a725741c3f43d0b8fcec02
+  data.tar.gz: 5aab1f5a727267c4b6cd95c037a987b36fdbc7c5c94fc2d03add97c996fcb1eabcbc36247bf2dddb89ae09ac252e4543ebd34d4f03cfcd984ab0d29726e30daf

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.0
+
+The "Nothing To Lose But Your Chains" Update.
+
+## Functions
+
+Now support chaining via the `#chain`, `#then`, and `#else` methods.
+
+## Results
+
+Can pass a value and/or an errors object to the constructor.
+
 ## 0.2.0
 
 The "Fully Armed and Operational" Update.

data/DEVELOPMENT.md

@@ -1,13 +1,35 @@
 # Development
 
-## Errors
+## Function
 
-- Dedicated errors object.
+- Handle when block or #process returns a Result instance.
+- #build_errors method
+- Predefined functions/operations:
+  - NullFunction
+  - IdentityFunction
+  - MapFunction
 
-## Function
+## Operation
 
-- Chaining with #then, #else, etc.
+- #reset! should return self
 
 ## Result
 
+- Abort chaining with #halt!, #halted? methods.
 - Force success or failure status with #success!, #failure! methods.
+
+## Documentation
+
+Chaining Case Study: |
+
+  CMS application - creating a new post.
+  Directory has many Posts
+  Post has a Content
+  Content has many ContentVersions
+  Post has many Tags
+
+  Find Directory
+  Create Post
+  Create Content
+  Create ContentVersion
+  Tags.each { FindOrCreate Tag }

data/README.md

@@ -7,6 +7,12 @@ citizen of your application.
 
 Cuprum is tested against Ruby 2.4.
 
+## Documentation
+
+Method and class documentation is available courtesy of [RubyDoc](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master).
+
+Documentation is generated using [YARD](https://yardoc.org/), and can be generated locally using the `yard` gem.
+
 ## Contribute
 
 ### GitHub
@@ -17,32 +23,100 @@ The canonical repository for this gem is located at https://github.com/sleepingk
 
 Hi, I'm Rob Smith, a Ruby Engineer and the developer of this library. I use these tools every day, but they're not just written for me. If you find this project helpful in your own work, or if you have any questions, suggestions or critiques, please feel free to get in touch! I can be reached on GitHub (see above, and feel encouraged to submit bug reports or merge requests there) or via email at merlin@sleepingkingstudios.com. I look forward to hearing from you!
 
-## Features
+## Functions
 
-### Functions
+[Class Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum%2FFunction)
 
 Functions are the core feature of Cuprum. In a nutshell, each Cuprum::Function is a functional object that encapsulates a business logic operation. A Function provides a consistent interface and tracking of result value and status. This minimizes boilerplate and allows for interchangeability between different implementations or strategies for managing your data and processes.
 
 Each Function implements a `#call` method that wraps your defined business logic and returns an instance of Cuprum::Result. The result wraps the returned data (with the `#value` method), any `#errors` generated when running the Function, and the overall status with the `#success?` and `#failure` methods. For more details about Cuprum::Result, see below.
 
-#### Defining With a Block
+### Methods
+
+A Cuprum::Function defines the following methods:
+
+#### #initialize
+
+    initialize { |*arguments, **keywords, &block| ... } #=> Cuprum::Function
+
+Returns a new instance of Cuprum::Function. If a block is given, the `#call` method will wrap the block and set the result `#value` to the return value of the block. This overrides the implementation in `#process`, if any.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Function#initialize-instance_method)
+
+#### #call
+
+    call(*arguments, **keywords) { ... } #=> Cuprum::Result
+
+Executes the logic encoded in the constructor block, or the #process method if no block was passed to the constructor.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Function#call-instance_method)
+
+#### #chain
+
+Registers a function or block to run after the current function, or after the last chained function if the current function already has one or more chained function(s). This creates and modifies a copy of the current function. See Chaining Functions, below.
+
+    chain(function, on: nil) #=> Cuprum::Function
+
+The function will be passed the `#value` of the previous function result as its parameter, and the result of the chained function will be returned (or passed to the next chained function, if any).
+
+    chain(on: nil) { |result| ... } #=> Cuprum::Function
+
+The block will be passed the #result of the previous function as its parameter. If your use case depends on the status of the previous function or on any errors generated, use the block form of #chain.
+
+If the block returns a Cuprum::Result (or an object responding to #value and #success?), the block result will be returned (or passed to the next chained function, if any). If the block returns any other value (including nil), the #result of the previous function will be returned or passed to the next function.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Function#chain-instance_method)
+
+#### `#then`
+
+Shorthand for `function.chain(:on => :success)`. Registers a function or block to run after the current function. The chained function will only run if the previous function was successfully run.
+
+    then(function) #=> Cuprum::Function
+
+The function will be passed the `#value` of the previous function result as its parameter, and the result of the chained function will be returned (or passed to the next chained function, if any).
+
+    then() { |result| ... } #=> Cuprum::Function
+
+The block will be passed the #result of the previous function as its parameter. If your use case depends on the status of the previous function or on any errors generated, use the block form of #chain.
+
+If the block returns a Cuprum::Result (or an object responding to #value and #success?), the block result will be returned (or passed to the next chained function, if any). If the block returns any other value (including nil), the #result of the previous function will be returned or passed to the next function.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Function#then-instance_method)
+
+#### `#else`
+
+Shorthand for `function.chain(:on => :failure)`. Registers a function or block to run after the current function. The chained function will only run if the previous function was unsuccessfully run.
+
+    else(function) #=> Cuprum::Function
+
+The function will be passed the `#value` of the previous function result as its parameter, and the result of the chained function will be returned (or passed to the next chained function, if any).
+
+    else() { |result| ... } #=> Cuprum::Function
+
+The block will be passed the #result of the previous function as its parameter. If your use case depends on the status of the previous function or on any errors generated, use the block form of #chain.
+
+If the block returns a Cuprum::Result (or an object responding to #value and #success?), the block result will be returned (or passed to the next chained function, if any). If the block returns any other value (including nil), the #result of the previous function will be returned or passed to the next function.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Function#else-instance_method)
+
+### Defining With a Block
 
 Functions can be used right out of the box by passing a block to the Cuprum::Function constructor, as follows:
 
     # A Function with a block
-    double_function = Function.new { |int| 2 * int }
+    double_function = Cuprum::Function.new { |int| 2 * int }
     result          = double_function.call(5)
 
     result.value #=> 10
 
 The constructor block will be called each time `Function#call` is executed, and will be passed all of the arguments given to `#call`. You can even define a block parameter, which will be passed along to the constructor block when `#call` is called with a block argument.
 
-#### Defining With a Subclass
+### Defining With a Subclass
 
 Larger applications will want to create Function subclasses that encapsulate their business logic in a reusable, composable fashion. The implementation for each subclass is handled by the `#process` private method. If a subclass or its ancestors does not implement `#process`, a `Cuprum::Function::NotImplementedError` will be raised.
 
     # A Function subclass
-    class MultiplyFunction
+    class MultiplyFunction < Cuprum::Function
       def initialize multiplier
         @multiplier = multiplier
       end # constructor
@@ -61,12 +135,12 @@ Larger applications will want to create Function subclasses that encapsulate the
 
 As with the block syntax, a Function whose implementation is defined via the `#process` method will call `#process` each time that `#call` is executed, and will pass all arguments from `#call` on to `#process`. The value returned by `#process` will be assigned to the result `#value`.
 
-#### Success, Failure, and Errors
+### Success, Failure, and Errors
 
 Whether defined with a block or in the `#process` method, the Function implementation can access an `#errors` object while in the `#call` method. Any errors added to the errors object will be exposed by the `#errors` method on the result object.
 
     # A Function with errors
-    class DivideFunction
+    class DivideFunction < Cuprum::Function
       def initialize divisor
         @divisor = divisor
       end # constructor
@@ -104,7 +178,77 @@ In addition, the result object defines `#success?` and `#failure?` predicates. I
     result.failure? #=> true
     result.value    #=> nil
 
-### Operations
+### Chaining Functions
+
+Because Cuprum::Function instances are proper objects, they can be composed like any other object. Cuprum::Function also defines methods for chaining functions together. When a chain of functions is called, each function in the chain is called in sequence and passed the value of the previous function. The result of the last function in the chain is returned from the chained call.
+
+    class AddFunction < Cuprum::Function
+      def initialize addend
+        @addend = addend
+      end # constructor
+
+      private
+
+      def process int
+        int + @addend
+      end # method process
+    end # class
+
+    double_and_add_one = MultiplyFunction.new(2).chain(AddFunction.new(1))
+    result             = double_and_add_one(5)
+
+    result.value #=> 5
+
+For finer control over the returned result, `#chain` can instead be called with a block that yields the most recent result. If the block returns a Cuprum::Result, that result is returned or passed to the next function.
+
+    MultiplyFunction.new(3).
+      chain { |result| Cuprum::Result.new(result + 1) }.
+      call(3)
+    #=> Returns a Cuprum::Result with a value of 10.
+
+Otherwise, the block is still called but the previous result is returned or passed to the next function in the chain.
+
+    AddFunction.new(2).
+      chain { |result| puts "There are #{result.value} lights!" }.
+      call(2)
+    #=> Writes "There are 4 lights!" to STDOUT.
+    #=> Returns a Cuprum::Result with a value of 4.
+
+#### Conditional Chaining
+
+The `#chain` method can be passed an optional `:on` keyword, with values of `:success` and `:failure` accepted. If `#chain` is called with `:on => :success`, then the chained function or block will **only** be called if the previous result `#success?` returns true. Conversely, if `#chain` is called with `:on => :failure`, then the chained function will only be called if the previous result `#failure?` returns true.
+
+In either case, execution will then pass to the next function in the chain, which may itself be called or not if it was conditionally chained. Calling a conditional function chain will return the result of the last called function.
+
+The methods `#then` and `#else` serve as shortcuts for `#chain` with `:on => :success` and `:on => :failure`, respectively.
+
+    class EvenFunction < Cuprum::Function
+      private
+
+      def process int
+        errors << 'errors.messages.not_even' unless int.even?
+
+        int
+      end # method process
+    end # class
+
+    # The next step in a Collatz sequence is determined as follows:
+    # - If the number is even, divide it by 2.
+    # - If the number is odd, multiply it by 3 and add 1.
+    collatz_function =
+      EvenFunction.new.
+        then(DivideFunction.new(2)).
+        else(MultiplyFunction.new(3).chain(AddFunction.new(1)))
+
+    result = collatz_function.new(5)
+    result.value #=> 16
+
+    result = collatz_function.new(16)
+    result.value #=> 8
+
+## Operations
+
+[Class Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum%2FOperation)
 
 An Operation is like a Function, but with an additional trick of tracking its own most recent execution result. This allows us to simplify some conditional logic, especially boilerplate code used to interact with frameworks.
 
@@ -130,36 +274,78 @@ Like a Function, an Operation can be defined directly by passing an implementati
 
 An operation inherits the `#call` method from Cuprum::Function (see above), and delegates the `#value`, `#errors`, `#success?`, and `#failure` methods to the most recent result (see below). If the operation has not been called, the operation will return default values.
 
-In addition, an operation defines the following methods:
+### Methods
+
+A Cuprum::Operation inherits the methods from Cuprum::Function (see above), and defines the following additional methods:
 
 #### `#result`
 
+    result() #=> Cuprum::Result
+
 The most recent result, from the previous time `#call` was executed for the operation.
 
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Operation#result-instance_method)
+
 #### `#called?`
 
+    called?() #=> true, false
+
 True if the operation has been called and there is a result available by calling `#result` or one of the delegated methods, otherwise false.
 
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Operation#called%3F-instance_method)
+
 #### `#reset!`
 
+    reset!()
+
 Clears the most recent result and resets `#called?` to false. This frees the result and any linked data for garbage collection. It also clears any internal state from the operation.
 
-### Results
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Operation#reset!-instance_method)
+
+## Results
+
+[Class Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum%2FResult)
+
+A Cuprum::Result is a data object that encapsulates the result of calling a Cuprum function - the returned value, the success or failure status, and any errors generated by the function.
 
-A Cuprum::Result is a data object that encapsulates the result of calling a Cuprum function - the returned value, the success or failure status, and any errors generated by the function. It defines the following methods:
+    value  = 'A result value'.freeze
+    result = Cuprum::Result.new(value)
+
+    result.value
+    #=> 'A result value'
+
+### Methods
+
+A Cuprum::Result defines the following methods:
 
 #### `#value`
 
+    value() #=> Object
+
 The value returned by the function. For example, for an increment function that added 1 to a given integer, the `#value` of the result object would be the incremented integer.
 
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Result#value-instance_method)
+
 #### `#errors`
 
+    errors() #=> Array
+
 The errors generated by the function, or an empty array if no errors were generated.
 
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Result#errors-instance_method)
+
 #### `#success?`
 
+    success?() #=> true, false
+
 True if the function did not generate any errors, otherwise false.
 
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Result#success%3F-instance_method)
+
 #### `#failure?`
 
+    failure?() #=> true, false
+
 True if the function generated one or more errors, otherwise false.
+
+[Method Documentation](http://www.rubydoc.info/github/sleepingkingstudios/cuprum/master/Cuprum/Result#failure%3F-instance_method)

data/lib/cuprum/function.rb

@@ -8,13 +8,13 @@ module Cuprum
   # by defining a subclass of Function and implementing the #process method.
   #
   # @example A Function with a block
-  #   double_function = Function.new { |int| 2 * int }
+  #   double_function = Cuprum::Function.new { |int| 2 * int }
   #   result          = double_function.call(5)
   #
   #   result.value #=> 10
   #
   # @example A Function subclass
-  #   class MultiplyFunction
+  #   class MultiplyFunction < Cuprum::Function
   #     def initialize multiplier
   #       @multiplier = multiplier
   #     end # constructor
@@ -32,7 +32,7 @@ module Cuprum
   #   result.value #=> 15
   #
   # @example A Function with errors
-  #   class DivideFunction
+  #   class DivideFunction < Cuprum::Function
   #     def initialize divisor
   #       @divisor = divisor
   #     end # constructor
@@ -61,6 +61,49 @@ module Cuprum
   #
   #   result.errors #=> ['errors.messages.divide_by_zero']
   #   result.value  #=> nil
+  #
+  # @example Function Chaining
+  #   class AddFunction < Cuprum::Function
+  #     def initialize addend
+  #       @addend = addend
+  #     end # constructor
+  #
+  #     private
+  #
+  #     def process int
+  #       int + @addend
+  #     end # method process
+  #   end # class
+  #
+  #   double_and_add_one = MultiplyFunction.new(2).chain(AddFunction.new(1))
+  #   result             = double_and_add_one(5)
+  #
+  #   result.value #=> 5
+  #
+  # @example Conditional Chaining With #then And #else
+  #   class EvenFunction < Cuprum::Function
+  #     private
+  #
+  #     def process int
+  #       errors << 'errors.messages.not_even' unless int.even?
+  #
+  #       int
+  #     end # method process
+  #   end # class
+  #
+  #   # The next step in a Collatz sequence is determined as follows:
+  #   # - If the number is even, divide it by 2.
+  #   # - If the number is odd, multiply it by 3 and add 1.
+  #   collatz_function =
+  #     EvenFunction.new.
+  #       then(DivideFunction.new(2)).
+  #       else(MultiplyFunction.new(3).chain(AddFunction.new(1)))
+  #
+  #   result = collatz_function.new(5)
+  #   result.value #=> 16
+  #
+  #   result = collatz_function.new(16)
+  #   result.value #=> 8
   class Function
     # Error class for calling a Function that was not given a definition block
     # or have a #process method defined.
@@ -83,7 +126,7 @@ module Cuprum
       define_singleton_method :process, &implementation if implementation
     end # method initialize
 
-    # @overload call(*arguments, *keywords, &block)
+    # @overload call(*arguments, **keywords, &block)
     #   Executes the logic encoded in the constructor block, or the #process
     #   method if no block was passed to the constructor.
     #
@@ -96,25 +139,158 @@ module Cuprum
     #   @yield If a block argument is given, it will be passed to the
     #     implementation.
     #
-    #   @raise [NotImplementedError] unless a block was passed to the
+    #   @raise [NotImplementedError] Unless a block was passed to the
     #     constructor or the #process method was overriden by a Function
     #     subclass.
     def call *args, &block
-      Cuprum::Result.new.tap do |result|
-        @errors = result.errors
+      call_chained_functions do
+        Cuprum::Result.new.tap do |result|
+          @errors = result.errors
 
-        result.value = process(*args, &block)
+          result.value = process(*args, &block)
 
-        @errors = nil
-      end # tap
+          @errors = nil
+        end # tap
+      end # call_chained_functions
     end # method call
 
+    # Registers a function or block to run after the current function, or after
+    # the last chained function if the current function already has one or more
+    # chained function(s). This creates and modifies a copy of the current
+    # function.
+    #
+    # @param on [Symbol] Sets a condition on when the chained function can run,
+    #   based on the status of the previous function. Valid values are :success
+    #   and :failure, and will constrain the function to run only if the
+    #   previous function succeeded or failed, respectively. If no value is
+    #   given, the function will run whether the previous function was a success
+    #   or a failure.
+    #
+    # @overload chain(function, on: nil)
+    #   The function will be passed the #value of the previous function result
+    #   as its parameter, and the result of the chained function will be
+    #   returned (or passed to the next chained function, if any).
+    #
+    #   @param function [Cuprum::Function] The function to call after the
+    #     current or last chained function.
+    #
+    # @overload chain(on: :nil, &block)
+    #   The block will be passed the #result of the previous function as its
+    #   parameter. If your use case depends on the status of the previous
+    #   function or on any errors generated, use the block form of #chain.
+    #
+    #   If the block returns a Cuprum::Result (or an object responding to #value
+    #   and #success?), the block result will be returned (or passed to the next
+    #   chained function, if any). If the block returns any other value
+    #   (including nil), the #result of the previous function will be returned
+    #   or passed to the next function.
+    #
+    #   @yieldparam result [Cuprum::Result] The #result of the previous
+    #     function.
+    #
+    # @return [Cuprum::Function] The chained function.
+    def chain function = nil, on: nil, &block
+      proc = convert_function_or_proc_to_proc(block || function)
+
+      chain_function(proc, :on => on)
+    end # method chain
+
+    # Shorthand for function.chain(:on => :failure). Registers a function or
+    # block to run after the current function. The chained function will only
+    # run if the previous function was unsuccessfully run.
+    #
+    # @overload else(function)
+    #
+    #   @param function [Cuprum::Function] The function to call after the
+    #     current or last chained function.
+    #
+    # @overload else(&block)
+    #
+    #   @yieldparam result [Cuprum::Result] The #result of the previous
+    #     function.
+    #
+    # @return [Cuprum::Function] The chained function.
+    #
+    # @see #chain
+    def else function = nil, &block
+      proc = convert_function_or_proc_to_proc(block || function)
+
+      chain_function(proc, :on => :failure)
+    end # method else
+
+    # Shorthand for function.chain(:on => :success). Registers a function or
+    # block to run after the current function. The chained function will only
+    # run if the previous function was successfully run.
+    #
+    # @overload then(function)
+    #
+    #   @param function [Cuprum::Function] The function to call after the
+    #     current or last chained function.
+    #
+    # @overload then(&block)
+    #
+    #   @yieldparam result [Cuprum::Result] The #result of the previous
+    #     function.
+    #
+    # @return [Cuprum::Function] The chained function.
+    #
+    # @see #chain
+    def then function = nil, &block
+      proc = convert_function_or_proc_to_proc(block || function)
+
+      chain_function(proc, :on => :success)
+    end # method then
+
+    protected
+
+    def call_chained_functions
+      chained_functions.reduce(yield) do |result, hsh|
+        next result if skip_chained_function?(result, :on => hsh[:on])
+
+        value = hsh.fetch(:proc).call(result)
+
+        value_is_result?(value) ? value : result
+      end # reduce
+    end # method call_chained_functions
+
+    def chain_function proc, on: nil
+      hsh = { :proc => proc }
+      hsh[:on] = on if on
+
+      clone.tap do |fn|
+        fn.chained_functions << hsh
+      end # tap
+    end # method chain_function
+
+    def chained_functions
+      @chained_functions ||= []
+    end # method chained_functions
+
     private
 
     attr_reader :errors
 
+    def convert_function_or_proc_to_proc function_or_proc
+      return function_or_proc if function_or_proc.is_a?(Proc)
+
+      ->(result) { function_or_proc.call(result) }
+    end # method convert_function_or_proc_to_proc
+
     def process *_args
       raise NotImplementedError, nil, caller(1..-1)
     end # method process
+
+    def skip_chained_function? last_result, on:
+      case on
+      when :success
+        !last_result.success?
+      when :failure
+        !last_result.failure?
+      end # case
+    end # method skip_chained_function?
+
+    def value_is_result? value
+      value.respond_to?(:value) && value.respond_to?(:success?)
+    end # method value
   end # class
 end # module

data/lib/cuprum/result.rb

@@ -4,16 +4,20 @@ module Cuprum
   # Data object that encapsulates the result of calling a Cuprum function or
   # operation.
   class Result
+    # @param value [Object] The value returned by calling the function.
+    # @param errors [Array] The errors (if any) generated when the function was
+    #   called.
+    def initialize value = nil, errors: []
+      @value  = value
+      @errors = errors
+    end # constructor
+
     # @return [Object] the value returned by calling the function.
     attr_accessor :value
 
-    attr_writer :errors
-
     # @return [Array] the errors (if any) generated when the function was
     #   called.
-    def errors
-      @errors ||= []
-    end # method errors
+    attr_accessor :errors
 
     # @return [Boolean] false if the function did not generate any errors,
     #   otherwise true.

data/lib/cuprum/version.rb

@@ -8,7 +8,7 @@ module Cuprum
     # Major version.
     MAJOR = 0
     # Minor version.
-    MINOR = 2
+    MINOR = 3
     # Patch version.
     PATCH = 0
     # Prerelease version.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuprum
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rob "Merlin" Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2017-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec