reaction 0.2.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a083875b2fb61b1944e5704f33fd94a347bd523
-  data.tar.gz: b1add1dbb49c659847f805f95c44ca7d8189fec9
+  metadata.gz: 988b21cec0c58acf861ccabe5a11d7ba8e0bfdb5
+  data.tar.gz: 4333f04bdd5654cf30e149b24fb4111ba22091c6
 SHA512:
-  metadata.gz: a7648be8b693217a28315d652c0845bf80d8e3ba2cffef97a8a965ccd15e5a1bf3d4fd7fe2209ef6bff706445d92837c95c78ad5d7347afa8475f1bff1e130d7
-  data.tar.gz: 9f80495f4305776e8d0009cff7a44730da078540531a65c1282fbd1e24a1054f8ce2979cbaf6640ccd251f4da277b2db802a475a73d2e2d219678769b0ae9c2e
+  metadata.gz: 52a815000393b6985df7faed9533775183ee01372605490189696585bd63d012104adecb08618cae4d73128c0414d1505c839c43daca8e10761f1240e673c0ab
+  data.tar.gz: 5bb22ce6053954669c76d0e28ba323d622fbfa1330b136089ecb3e8ba5d37974d8d7855a3330e5f4f07680537efebd13cf8cd03c9a9a51d5d1fec27e78c9d657

data/lib/reaction/action.rb

@@ -1,55 +1,109 @@
 module Reaction
   class Action
     include HasAttributes
-    include HasErrors
-    include HasParams
 
-    # meta isn't used by default, but it is supported for use cases
-    # where you need to attach metadata to parameters, such as
-    # who or what set the attribute. For example, Paid currently
-    # has a flow like:
-    #
-    #   action = Action.new(request.params, via: :request)
-    #   action.set_params(account: api_key.account, via: :api_key)
-    #
-    # Which allows us to use a validator to define who can set
-    # various attributes. Specifically, we limit certain attributes
-    # from being set by the request so end users can't set params
-    # that we don't expect them to set.
-    #
-    def initialize(params = {}, meta = {}, attributes = {})
-      set_params(params, meta)
-      set_attributes(attributes)
+    attr_accessor :successful
+    attr_accessor :result
+    attr_accessor :error
+
+    def initialize(param_values = {}, attribute_values = {})
+      set_params(param_values)
+      set_attributes(attribute_values)
     end
 
-    def invoke
-      validate
-      return self if errors.any?
+    def process
+      return false unless validate_attributes
+      _params.each do |name, param|
+        unless param.process
+          failure(param.error) and return false
+        end
+      end
       perform
-    ensure
-      cleanup
+      return !!@successful
+    end
+
+    def success(result)
+      @successful = true
+      @result = result
+    end
+
+    def failure(error)
+      @successful = false
+      @error = error
+    end
+
+    # This is how you retrieve a param. Pass in a mode of :raw in
+    # order to get the raw param if you happen to need that, but
+    # in general you shouldn't.
+    #
+    def param(name, mode = :converted)
+      if mode == :raw
+        _param(name).raw_value
+      else
+        _param(name).result
+      end
+    end
+
+    def params
+      ret = {}
+      _params.each do |name, param|
+        ret[name] = param.result
+      end
+      ret
     end
 
-    def self.invoke(params = {}, meta = {}, attributes = {})
-      new(params, meta, attributes).invoke
+    def set_params(param_values = {})
+      self.class.param_builders.each do |name, pb|
+        provided = param_values.keys.include?(name)
+        _params[name] = pb.build(self, param_values[name], provided)
+      end
     end
 
-    def perform
-      # Implement this for your action
+    def param_provided?(name)
+      _param(name).provided?
     end
 
-    def validate
-      errors.clear
-      validate_attributes
-      validate_params
-      # if errors.any?
-      #   raise ArgumentError.new("Validations failed: #{errors.full_messages.join(',')}")
-      # end
+    def self.process(param_values = {}, attribute_values = {})
+      action = new(param_values, attribute_values)
+      if action.process
+        return [action.result, nil]
+      else
+        return [nil, action.error]
+      end
     end
 
-    def cleanup
-      cleanup_types
-      cleanup_validators
+    def self.param_builders
+      @param_builders ||= {}
     end
+
+    def self.param_builder(name)
+      name.to_sym
+      param_builders[name] ||= ParamBuilder.new(name)
+    end
+
+    def self.param(name, type = RawType, options = {})
+      param_builder(name).type_builder = TypeBuilder.new(type, options)
+    end
+
+    def self.validates(name, validators = {})
+      validators.each do |validator, options|
+        param_builder(name).validator_builders << ValidatorBuilder.new(validator, options)
+      end
+    end
+
+  private
+
+    def _param(name)
+      name = name.to_sym
+      unless self.class.param_builders[name]
+        raise ArgumentError, "Invalid param: #{name}"
+      end
+      _params[name]
+    end
+
+    def _params
+      @params ||= {}
+    end
+
   end
 end

data/lib/reaction/errors/attribute_error.rb

@@ -0,0 +1,12 @@
+module Reaction
+  class AttributeError < StandardError
+    attr_accessor :attribute
+    attr_accessor :message
+
+    def initialize(attribute, message = nil)
+      @attribute = attribute
+      @message = message || "Missing value for attribute: #{attribute}."
+    end
+
+  end
+end

data/lib/reaction/errors/param_error.rb

@@ -0,0 +1,12 @@
+module Reaction
+  class ParamError < StandardError
+    attr_accessor :param
+    attr_accessor :message
+
+    def initialize(param, message = nil)
+      @param = param
+      @message = message || "Invalid value for param: #{param}."
+    end
+
+  end
+end

data/lib/reaction/has_attributes.rb

@@ -42,7 +42,11 @@ CODE
 
     def validate_attributes
       self.class.attributes.each do |attribute|
-        errors.add(attribute, 'is not set.') unless send(attribute)
+        unless send(attribute)
+          # This is a server side error - we didn't set a valid attribute
+          # for some reason, and attributes are things the server sets.
+          failure(AttributeError.new(attribute)) and return false
+        end
       end
     end
 

data/lib/reaction/has_params.rb

@@ -1,5 +1,22 @@
 module Reaction
   module HasParams
+
+    def set_params(param_values)
+      param_values.each do |name, raw_value|
+        builder = self.class.param_builder(name)
+        builder.build(self, name, raw_value)
+      end
+    end
+
+    def process_params
+      params.each do |param|
+        return false unless param.process
+      end
+    end
+
+
+
+
     def self.included(base)
       base.include HasDocs
       base.include HasMetas
@@ -10,13 +27,16 @@ module Reaction
 
     module ClassMethods
       def param(name, options = {})
-        set_type(name, options.delete(:type) || RawType)
-        set_validators(name, options)
+        set_type(name, options.delete(:type) || RawType, options)
       end
 
       def param_settable?(name)
         !type(name).nil?
       end
+
+      def validates(name, options = {})
+        set_validators(name, options)
+      end
     end
 
     def param_provided?(name)
@@ -26,7 +46,7 @@ module Reaction
     def param(name)
       typed_params[name.to_sym] ||= begin
         type = self.class.types[name.to_sym]
-        type.convert(raw_param(name))
+        type.convert(self, name, raw_param(name))
       end
     end
 
@@ -72,6 +92,9 @@ module Reaction
     def validate_params
       raw_params.each do |name, value|
         self.class.type(name).validate_each(self, name, value)
+      end
+      return if errors.any?
+      raw_params.each do |name, value|
         converted = param(name)
         self.class.validators(name).each do |validator|
           validator.validate_each(self, name, converted)

data/lib/reaction/param.rb

@@ -0,0 +1,50 @@
+module Reaction
+  class Param
+    attr_accessor :action
+    attr_accessor :type
+    attr_accessor :validators
+    attr_accessor :name
+    attr_accessor :raw_value
+
+    attr_accessor :successful
+    attr_accessor :result
+    attr_accessor :error
+
+    def initialize(action, type, validators, name, raw_value, provided = true)
+      @action = action
+      @type = type
+      @validators = validators
+      @name = name
+      @raw_value = raw_value
+      @provided = provided
+    end
+
+    def process
+      if type.process(raw_value)
+        validators.each do |validator|
+          unless validator.process(type.result)
+            failure(validator.error) and return false
+          end
+        end
+      else
+        failure(type.error) and return false
+      end
+      success(type.result) and return true
+    end
+
+    def success(result)
+      @successful = true
+      @result = result
+    end
+
+    def failure(error)
+      @successful = false
+      @error = ParamError.new(name, error)
+    end
+
+    def provided?
+      !!@provided
+    end
+
+  end
+end

data/lib/reaction/param_builder.rb

@@ -0,0 +1,20 @@
+module Reaction
+  class ParamBuilder
+    attr_accessor :name
+    attr_accessor :type_builder
+    attr_accessor :validator_builders
+
+    def initialize(name, type_builder = nil, validator_builders = [])
+      @name = name
+      @type_builder = type_builder
+      @validator_builders = validator_builders
+    end
+
+    def build(action, raw_value, provided = true)
+      type = type_builder.build(action)
+      validators = validator_builders.map{ |vb| vb.build(action) }
+      Param.new(action, type, validators, name, raw_value, provided)
+    end
+
+  end
+end

data/lib/reaction/type.rb

@@ -1,42 +1,44 @@
-module Reaction
+amodule Reaction
   class Type
-    include IsDocumented
-
-    attr_reader :name
-
-    def initialize(name = nil)
-      @name = name.nil? ? nil : name.to_sym
-    end
-
-    # If you need to validate based on type you can. These
-    # work identically to the validators, except type validations
-    # are always called before other validators, and the +options+
-    # hash isn't available. If you have a particularly good
-    # use case for passing in options to a Type reach out; It
-    # should be pretty easy to add in, we just haven't had a
-    # need for it yet.
-    #
-    def validate_each(record, attribute, value)
-    end
-
-    # Convert is used to transform a value into whatever
-    # format you expect it to be. For example, you might
-    # have a convert method that casts a string into an
-    # integer, or one that takes in various date formats
-    # and converts them to a DateTime prior to the param
-    # being used in the action.
-    #
-    def convert(value)
-      value
-    end
-
-    # Cleanup is provided in case you need to create files that
-    # require cleanup after the action has been performed. For
-    # example, Paid creates Tempfiles with some types and uses
-    # the cleanup phase to ensure these files get closed up
-    # properly.
-    #
-    def cleanup
+    attr_accessor :action
+    attr_accessor :options
+
+    attr_accessor :result
+    attr_accessor :error
+    attr_accessor :successful
+
+    def initialize(action, options = {})
+      @action = action
+      @options = options
+      @successful = nil
+    end
+
+    def process(raw_value)
+      convert(raw_value)
+      raise "You forgot to call success or failure!!!" if @successful.nil?
+      @successful
+    end
+
+    def convert(raw_value)
+      raise NotImplementedError
+    end
+
+    def successful?
+      @successful == true
+    end
+
+    def success(result)
+      @successful = true
+      @result = result
+    end
+
+    def failed?
+      @successful == false
+    end
+
+    def failure(error)
+      @successful = false
+      @error = error
     end
 
     # This isn't perfect but works well enough.

data/lib/reaction/type_builder.rb

@@ -0,0 +1,28 @@
+module Reaction
+  class TypeBuilder
+    attr_accessor :type
+    attr_accessor :options
+
+    def initialize(type = RawType, options = {})
+      @type = class_for_type!(type)
+      @options = options
+    end
+
+    def build(action)
+      type.new(action, options)
+    end
+
+    def class_for_type(type)
+      return type if type.is_a?(Class)
+      name = type.to_s.split('_').map(&:capitalize).join
+      Module.const_get("#{name}Type")
+    rescue NameError
+      nil
+    end
+
+    def class_for_type!(type)
+      class_for_type(type) or raise ArgumentError.new("Unknown type: #{type}")
+    end
+
+  end
+end

data/lib/reaction/types/raw_type.rb

@@ -3,14 +3,10 @@
 #
 module Reaction
   class RawType < Type
-    def validate_each(record, attribute, value)
-    end
 
-    def convert(value)
-      value
+    def convert(raw_value)
+      success(raw_value)
     end
 
-    def cleanup
-    end
   end
 end

data/lib/reaction/validator.rb

@@ -0,0 +1,29 @@
+module Reaction
+  class Validator
+    attr_accessor :action
+    attr_accessor :options
+
+    attr_accessor :error
+    attr_accessor :successful
+
+
+    def initialize(action, options = {})
+      @action = action
+      @options = options
+    end
+
+    def process(value)
+      # Assume successful unless a failure for validators
+      @successful = true
+
+      validate(value)
+      !!@successful
+    end
+
+    def failure(error)
+      @successful = false
+      @error = error
+    end
+
+  end
+end

data/lib/reaction/validator_builder.rb

@@ -0,0 +1,28 @@
+module Reaction
+  class ValidatorBuilder
+    attr_accessor :validator
+    attr_accessor :options
+
+    def initialize(validator, options = {})
+      @validator = class_for_validator!(validator)
+      @options = options
+    end
+
+    def build(action)
+      validator.new(action, options)
+    end
+
+    def class_for_validator(validator)
+      return validator if validator.is_a?(Class)
+      name = validator.to_s.split('_').map(&:capitalize).join
+      Module.const_get("#{name}Validator")
+    rescue NameError
+      nil
+    end
+
+    def class_for_validator!(validator)
+      class_for_validator(validator) or raise ArgumentError.new("Unknown validator: #{validator}")
+    end
+
+  end
+end

data/lib/reaction.rb

@@ -2,18 +2,14 @@ require 'redcarpet'
 
 module Reaction
   autoload :Action, 'reaction/action'
-  autoload :Doc, 'reaction/doc'
-  autoload :EachValidator, 'reaction/each_validator'
-  autoload :Errors, 'reaction/errors'
   autoload :HasAttributes, 'reaction/has_attributes'
-  autoload :HasDocs, 'reaction/has_docs'
-  autoload :HasErrors, 'reaction/has_errors'
-  autoload :HasMetas, 'reaction/has_metas'
-  autoload :HasParams, 'reaction/has_params'
-  autoload :HasTypes, 'reaction/has_types'
-  autoload :HasValidators, 'reaction/has_validators'
-  autoload :IsDocumented, 'reaction/is_documented'
-  autoload :Markdown, 'reaction/markdown'
-  autoload :RawType, 'reaction/types/raw_type'
+  autoload :Param, 'reaction/param'
+  autoload :ParamBuilder, 'reaction/param_builder'
   autoload :Type, 'reaction/type'
+  autoload :TypeBuilder, 'reaction/type_builder'
+  autoload :Validator, 'reaction/validator'
+  autoload :ValidatorBuilder, 'reaction/validator_builder'
+  autoload :AttributeError, 'reaction/errors/attribute_error'
+  autoload :ParamError, 'reaction/errors/param_error'
+  autoload :RawType, 'reaction/types/raw_type'
 end

data/reaction.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = 'reaction'
-  gem.version       = '0.2.8'
+  gem.version       = '1.0.0'
   gem.authors       = ["Jon Calhoun", "Jon Calhoun", "Ryan Jackson"]
   gem.email         = ["joncalhoun@gmail.com", "jon@paidlabs.com", "ryan@paidlabs.com"]
   gem.description   = 'Reaction makes it easy to build reusable controller actions along with reusable validators and param type converters.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reaction
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Jon Calhoun
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-21 00:00:00.000000000 Z
+date: 2016-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redcarpet
@@ -41,20 +41,17 @@ files:
 - LICENSE.txt
 - lib/reaction.rb
 - lib/reaction/action.rb
-- lib/reaction/doc.rb
-- lib/reaction/each_validator.rb
-- lib/reaction/errors.rb
+- lib/reaction/errors/attribute_error.rb
+- lib/reaction/errors/param_error.rb
 - lib/reaction/has_attributes.rb
-- lib/reaction/has_docs.rb
-- lib/reaction/has_errors.rb
-- lib/reaction/has_metas.rb
 - lib/reaction/has_params.rb
-- lib/reaction/has_types.rb
-- lib/reaction/has_validators.rb
-- lib/reaction/is_documented.rb
-- lib/reaction/markdown.rb
+- lib/reaction/param.rb
+- lib/reaction/param_builder.rb
 - lib/reaction/type.rb
+- lib/reaction/type_builder.rb
 - lib/reaction/types/raw_type.rb
+- lib/reaction/validator.rb
+- lib/reaction/validator_builder.rb
 - reaction.gemspec
 homepage: https://github.com/paidlabs/reaction
 licenses: []

data/lib/reaction/doc.rb

@@ -1,19 +0,0 @@
-# This class serves no real purpose in this gem, but is here so that
-# developers can use it to create more dynamic documentation by
-# documenting attributes used for actions directly in the actions,
-# and then access these when generating their actual documenation.
-#
-module Reaction
-  class Doc
-    attr_reader :text, :options
-
-    def initialize(text, options = {})
-      @text = text
-      @options = options
-    end
-
-    def to_html(formatter = Markdown)
-      formatter.render(text)
-    end
-  end
-end

data/lib/reaction/each_validator.rb

@@ -1,43 +0,0 @@
-module Reaction
-  class EachValidator
-    attr_reader :options
-
-    def initialize(options = {})
-      @options = options
-    end
-
-    # If you need to validate a parameter outside of the basic
-    # type then validators are your best bet. They are generally
-    # very similar to Rails' EachValidator. You provide a
-    # validate_each method that takes in a record, attribute, and
-    # value and then if the attribute isn't valid adds an error
-    # to record.errors. You can also access the data provided
-    # for the validator via the +options+ method.
-    #
-    # Example validate_each method for a RequiredValidator which
-    # would be used like:
-    #
-    #  param :cat, required: true
-    #  param :dog, required: false
-    #
-    #
-    #  def validate_each(record, attribute, value)
-    #    if options && value.nil?
-    #      record.errors.add(attribute, 'is required.')
-    #    end
-    #  end
-    #
-    def validate_each(record, attribute, value)
-      raise NotImplementedError.new('Subclasses must implement a validate_each(record, attribute, value) method')
-    end
-
-    # Cleanup is provided in case you need to create files that
-    # require cleanup after the action has been performed. For
-    # example, Paid creates Tempfiles with some types and uses
-    # the cleanup phase to ensure these files get closed up
-    # properly.
-    #
-    def cleanup
-    end
-  end
-end

data/lib/reaction/errors.rb

@@ -1,72 +0,0 @@
-module Reaction
-  class Errors
-
-    attr_accessor :messages
-
-    def initialize
-      @messages = {}
-    end
-
-    def clear
-      messages.clear
-    end
-
-    def include?(key)
-      !messages[key].nil?
-    end
-
-    def get(key)
-      messages[key]
-    end
-
-    def add(key, message, options = {})
-      messages[key] ||= []
-      messages[key] << message
-    end
-
-    def any?
-      messages.any?
-    end
-
-    def empty?
-      messages.empty?
-    end
-
-    def size
-      messages.size
-    end
-
-    def length
-      messages.length
-    end
-
-    def first
-      messages.first
-    end
-
-    def each
-      messages
-    end
-
-    def full_messages
-      ret = []
-      messages.each do |key, values|
-        ret |= full_messages_for(key, values)
-      end
-      ret
-    end
-
-    def full_messages_for(key, values = nil)
-      ret = []
-      values ||= messages[key]
-      values.each do |value|
-        if key != :base
-          ret << "Invalid value for param: #{key}. #{value}"
-        else
-          ret << value
-        end
-      end
-      ret
-    end
-  end
-end

data/lib/reaction/has_docs.rb

@@ -1,22 +0,0 @@
-module Reaction
-  module HasDocs
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def doc(name, message, options = {})
-        docs[name.to_sym] = Doc.new(message, options)
-      end
-
-      def docs
-        @docs ||= {}
-      end
-    end
-
-    def doc(name)
-      self.class.docs[name.to_sym]
-    end
-
-  end
-end

data/lib/reaction/has_errors.rb

@@ -1,15 +0,0 @@
-module Reaction
-  module HasErrors
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-    end
-
-    def errors
-      @errors ||= Errors.new
-    end
-
-  end
-end

data/lib/reaction/has_metas.rb

@@ -1,27 +0,0 @@
-module Reaction
-  module HasMetas
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-    end
-
-    def meta(name)
-      metas[name.to_sym]
-    end
-
-    def metas
-      @metas ||= {}
-    end
-
-    def rm_meta(name)
-      metas.delete(name.to_sym)
-    end
-
-    def set_meta(name, meta)
-      metas[name.to_sym] = meta
-    end
-
-  end
-end

data/lib/reaction/has_types.rb

@@ -1,46 +0,0 @@
-module Reaction
-  module HasTypes
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def type(name)
-        types[name.to_sym]
-      end
-
-      def types
-        @types ||= {}
-      end
-
-      def set_type(name, type)
-        type ||= Type
-        klass = class_for_type!(type)
-        types[name.to_sym] = klass.new(name)
-      end
-
-      def class_for_type(type)
-        return type if type.is_a?(Class)
-        name = type.to_s.split('_').map(&:capitalize).join
-        const_get("#{name}Type")
-      rescue NameError
-        nil
-      end
-
-      def class_for_type!(type)
-        class_for_type(type) or raise ArgumentError.new("Unknown type: #{type}")
-      end
-
-      def cleanup_types
-        types.each do |name, type|
-          type.cleanup
-        end
-      end
-    end
-
-    def cleanup_types
-      self.class.cleanup_types
-    end
-
-  end
-end

data/lib/reaction/has_validators.rb

@@ -1,51 +0,0 @@
-module Reaction
-  module HasValidators
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def all_validators
-        @all_validators ||= {}
-      end
-
-      def validators(name)
-        all_validators[name.to_sym] ||= []
-        all_validators[name.to_sym]
-      end
-
-      def add_validator(name, validator, options = {})
-        klass = class_for_validator(validator)
-        validators(name) << klass.new(options)
-      end
-
-      def set_validators(name, new_validators = {})
-        validators(name).clear
-        new_validators.each do |validator, options|
-          add_validator(name, validator, options)
-        end
-      end
-
-      def class_for_validator(validator)
-        return validator if validator.is_a?(Class)
-        name = validator.to_s.split('_').map(&:capitalize).join
-        const_get("#{name}Validator")
-      rescue NameError
-        raise ArgumentError.new("Unknown param validator: #{validator}")
-      end
-
-      def cleanup_validators
-        all_validators.each do |name, validators|
-          validators.each do |validator|
-            validator.cleanup
-          end
-        end
-      end
-    end
-
-    def cleanup_validators
-      self.class.cleanup_validators
-    end
-
-  end
-end

data/lib/reaction/is_documented.rb

@@ -1,18 +0,0 @@
-module Reaction
-  module IsDocumented
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def doc(message = nil, options = {})
-        if message
-          @doc = Doc.new(message, options)
-        else
-          @doc
-        end
-      end
-    end
-
-  end
-end

data/lib/reaction/markdown.rb

@@ -1,15 +0,0 @@
-module Reaction
-  class Markdown
-    def self.render(md_str)
-      markdown.render(md_str)
-    end
-
-    def self.renderer
-      @renderer ||= Redcarpet::Render::HTML.new
-    end
-
-    def self.markdown
-      @markdown ||= Redcarpet::Markdown.new(renderer, autolink: true, tables: true)
-    end
-  end
-end