reaction 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70ffb42ccf83ba294bfb07d8887055c9a2343d2e
+  data.tar.gz: 44a1abae9c843a15bbe634c28ab867216b1042f4
+SHA512:
+  metadata.gz: cc74f3443a4b55a2828c03ce89b971f7022320f8cbb994b5e8c099ee4ebdb48d24abd2ab8e78e9a76049d2bd257a4ec45504ba963c590238a7ddbcb6e8b9010d
+  data.tar.gz: be02f4c83dbf04a96762b3d009942542ff477e0c21962d8a5d5b475598939293d8db2db83a48fc72894ae26a6b2f108c12b1f3b5121dc2695111ea3c81b8922f

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in reaction.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Jonathan Calhoun
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/reaction/action.rb

@@ -0,0 +1,55 @@
+module Reaction
+  class Action
+    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 = {})
+      set_params(params, meta)
+    end
+
+    def invoke
+      validate!
+      ret = perform
+    ensure
+      cleanup
+    end
+
+    def perform
+      # Implement this for your action
+    end
+
+    def validate!
+      self.class.types.each do |name, type|
+        type.validate_each(self, name, raw_param(name))
+      end
+      self.class.validators.each do |name, validator|
+        validator.validate_each(self, name, raw_param(name))
+      end
+      if errors.any?
+        raise ArgumentError.new("Validations failed: #{errors.full_messages.join(',')}")
+      end
+    end
+
+    def cleanup
+      self.class.types.each do |name, type|
+        type.cleanup
+      end
+      self.class.validators.each do |name, validator|
+        validator.cleanup
+      end
+    end
+  end
+end

data/lib/reaction/doc.rb

@@ -0,0 +1,17 @@
+# 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 :name, :message, :options
+
+    def initialize(name, message, options = {})
+      @name = name.to_sym
+      @message = message
+      @options = options
+    end
+
+  end
+end

data/lib/reaction/each_validator.rb

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,45 @@
+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)
+      messages[key] ||= []
+      messages[key] << message
+    end
+
+    def any?
+      messages.any?
+    end
+
+    def each
+      messages
+    end
+
+    def full_messages
+      ret = []
+      messages.each do |key, values|
+        values.each do |value|
+          ret << "#{key}: #{value}"
+        end
+      end
+      ret
+    end
+  end
+end

data/lib/reaction/has_docs.rb

@@ -0,0 +1,18 @@
+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(name, message, options)
+      end
+
+      def docs
+        @docs ||= {}
+      end
+    end
+
+  end
+end

data/lib/reaction/has_errors.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,23 @@
+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 set_meta(name, meta)
+      metas[name.to_sym] = meta
+    end
+
+  end
+end

data/lib/reaction/has_params.rb

@@ -0,0 +1,49 @@
+module Reaction
+  module HasParams
+    def self.included(base)
+      base.include HasDocs
+      base.include HasMetas
+      base.include HasTypes
+      base.include HasValidators
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def param(name, options = {})
+        set_type(name, options.delete(:type))
+        set_validators(name, options)
+      end
+    end
+
+    def param(name)
+      typed_params[name.to_sym] ||= begin
+        type = self.class.types[name.to_sym]
+        type ? type.convert(raw_param(name)) : raw_param(name)
+      end
+    end
+
+    def params
+      @params ||= {}
+    end
+
+    def typed_params
+      @typed_params ||= {}
+    end
+
+    def set_param(name, value, meta = {})
+      set_meta(name, meta)
+      params[name.to_sym] = value
+    end
+
+    def set_params(params = {}, meta = {})
+      params.each do |name, value|
+        set_param(name, value, meta)
+      end
+    end
+
+    def raw_param(name)
+      params[name.to_sym]
+    end
+
+  end
+end

data/lib/reaction/has_types.rb

@@ -0,0 +1,28 @@
+module Reaction
+  module HasTypes
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      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
+        raise ArgumentError.new("Unknown param type: #{type}")
+      end
+    end
+
+  end
+end

data/lib/reaction/has_validators.rb

@@ -0,0 +1,33 @@
+module Reaction
+  module HasValidators
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def validators
+        @validators ||= {}
+      end
+
+      def set_validator(name, validator, options = {})
+        klass = class_for_validator(validator)
+        validators[name.to_sym] = klass.new(options)
+      end
+
+      def set_validators(name, validators = {})
+        validators.each do |validator, options|
+          set_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
+    end
+
+  end
+end

data/lib/reaction/type.rb

@@ -0,0 +1,40 @@
+module Reaction
+  class Type
+    attr_reader :name
+
+    def initialize(name)
+      @name = 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
+    end
+  end
+end

data/lib/reaction/types/raw_type.rb

@@ -0,0 +1,16 @@
+# This is the default type for any param. It doesn't do any
+# validations and simply returns the value as provided.
+#
+module Reaction
+  class RawType < Type
+    def validate_each(record, attribute, value)
+    end
+
+    def convert(value)
+      value
+    end
+
+    def cleanup
+    end
+  end
+end

data/lib/reaction.rb

@@ -0,0 +1,14 @@
+module Reaction
+  autoload :Action, 'reaction/action'
+  autoload :Doc, 'reaction/doc'
+  autoload :EachValidator, 'reaction/each_validator'
+  autoload :Errors, 'reaction/errors'
+  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 :RawType, 'reaction/types/raw_type'
+  autoload :Type, 'reaction/type'
+end

data/reaction.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'reaction'
+  gem.version       = '0.0.0'
+  gem.authors       = ["Jonathan Calhoun"]
+  gem.email         = ["joncalhoun@gmail.com"]
+  gem.description   = 'Reaction is a library to help build reusable actions for Rails controllers.'
+  gem.summary       = 'Reaction is a library to help build reusable actions for Rails controllers.'
+  gem.homepage      = 'https://github.com/joncalhoun/reaction'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: reaction
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Jonathan Calhoun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-25 00:00:00.000000000 Z
+dependencies: []
+description: Reaction is a library to help build reusable actions for Rails controllers.
+email:
+- joncalhoun@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- lib/reaction.rb
+- lib/reaction/action.rb
+- lib/reaction/doc.rb
+- lib/reaction/each_validator.rb
+- lib/reaction/errors.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/type.rb
+- lib/reaction/types/raw_type.rb
+- reaction.gemspec
+homepage: https://github.com/joncalhoun/reaction
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Reaction is a library to help build reusable actions for Rails controllers.
+test_files: []