toolchain 0.1.0

data/lib/toolchain/attributes/configuration.rb

@@ -0,0 +1,41 @@
+module Toolchain::Attributes::Configuration
+  extend self
+
+  # @param type [Symbol] :symbol or :string.
+  #
+  def hash_transformation=(type)
+    if [:symbolize_keys, :stringify_keys].include?(type)
+      @hash_transformation = type
+    else
+      raise Toolchain::Attributes::Errors::InvalidHashTransformation,
+        "valid types: :symbolize_keys, :stringify_keys."
+    end
+  end
+
+  # @return [Symbol] :symbolize_keys or :stringify_keys.
+  #
+  def hash_transformation
+    @hash_transformation ||= :symbolize_keys
+  end
+
+  # Determines whether or not to include nil values
+  # in the object.attributes Hash.
+  #
+  # @param value [Boolean]
+  #
+  def include_nil_in_attributes=(value)
+    @include_nil_in_attributes = value
+  end
+
+  # @return [Boolean]
+  #
+  def include_nil_in_attributes
+    @include_nil_in_attributes ||= false
+  end
+
+  # @yield Toolchain::Attributes::Configuration
+  #
+  def configure
+    yield self
+  end
+end

data/lib/toolchain/attributes/errors.rb

@@ -0,0 +1,5 @@
+module Toolchain::Attributes::Errors
+  require_relative "errors/invalid_hash_transformation"
+  require_relative "errors/invalid_mass_assignment"
+  require_relative "errors/type_mismatch"
+end

data/lib/toolchain/attributes/errors/invalid_hash_transformation.rb

@@ -0,0 +1,4 @@
+module Toolchain::Attributes::Errors
+  class InvalidHashTransformation < StandardError
+  end
+end

data/lib/toolchain/attributes/errors/invalid_mass_assignment.rb

@@ -0,0 +1,4 @@
+module Toolchain::Attributes::Errors
+  class InvalidMassAssignment < StandardError
+  end
+end

data/lib/toolchain/attributes/errors/type_mismatch.rb

@@ -0,0 +1,4 @@
+module Toolchain::Attributes::Errors
+  class TypeMismatch < StandardError
+  end
+end

data/lib/toolchain/attributes/ext/boolean.rb

@@ -0,0 +1,4 @@
+unless defined?(Boolean)
+  class Boolean
+  end
+end

data/lib/toolchain/attributes/helpers.rb

@@ -0,0 +1,72 @@
+module Toolchain::Attributes::Helpers
+  extend self
+
+  # @param klass [Class]
+  #
+  # @yield [Symbol] Each defined attribute (key) name.
+  #
+  def each_key(klass)
+    while ![Class, Module, Object, BasicObject, nil].include?(klass)
+      klass.keys.each { |key| yield key }
+      klass = klass.superclass
+    end
+  end
+
+  # @param value [Object]
+  # @param types [Array<Class>]
+  #
+  # @return [Boolean] true if the provided value doesn't
+  #   match any of the provided type classes.
+  #
+  def invalid_value?(value, *types)
+    value = value.call if value.kind_of?(Proc)
+
+    return false if value.nil?
+
+    types.flatten.each do |type|
+      return false if value.kind_of?(type)
+    end
+
+    true
+  end
+
+  # Converts all keys to Symbol-type, including
+  # nested hashes.
+  #
+  # @param value [Hash]
+  # @return [Hash]
+  #
+  def symbolize_keys(value)
+    deep_transform_keys(value) { |key| key.to_sym rescue key }
+  end
+
+  # Converts all keys to String-type, including
+  # nested hashes.
+  #
+  # @param value [Hash]
+  # @return [Hash]
+  #
+  def stringify_keys(value)
+    deep_transform_keys(value) { |key| key.to_s rescue key }
+  end
+
+  private
+
+  # Recursive key transformation method.
+  #
+  # @param value [Hash]
+  # @param block [Proc]
+  #
+  def deep_transform_keys(value, &block)
+    Hash.new.tap do |result|
+      value.each do |key, value|
+        result[yield(key)] =
+          if value.kind_of?(Hash)
+            deep_transform_keys(value, &block)
+          else
+            value
+          end
+      end
+    end
+  end
+end

data/lib/toolchain/validations.rb

@@ -0,0 +1,103 @@
+require_relative "version"
+
+module Toolchain::Validations
+  require_relative "validations/helpers"
+  require_relative "validations/validation_errors"
+  require_relative "validations/validators"
+  require_relative "validations/delegator"
+  require_relative "validations/delegation"
+
+  module ClassMethods
+
+    # @return [Array] all the standard validation operations to run.
+    #
+    def validations
+      @validations ||= []
+    end
+
+    # @return [Array] all the custom validation operations to run.
+    #
+    def custom_validations
+      @custom_validations ||= []
+    end
+
+    # Adds the provided validator to the validations array for
+    # the provided attribute key_path.
+    #
+    # @param args [Array<Symbol, Hash>]
+    #
+    # @example
+    #   class Device
+    #     validates :name, presence: true
+    #     validates :config, :url, presence: true
+    #   end
+    #
+    def validates(*args)
+      options, key_path = args.pop, args
+
+      options.each do |key, data|
+        if validator = Helpers.find_validator(key)
+          validations.push(key_path: key_path, validator: validator, data: data)
+        end
+      end
+    end
+
+    # Adds the provided method name to the validations array.
+    # This method will be called during validation time and allows
+    # you to do program-specific validations.
+    #
+    # @param method [Symbol, String]
+    #
+    def validate(method)
+      custom_validations.push(method.to_sym)
+    end
+
+    # Takes a Proc that contains validation logic and applies
+    # that to this class.
+    #
+    # @param validations [Proc]
+    #
+    def include_validations(validations)
+      class_eval(&validations)
+    end
+  end
+
+  module InstanceMethods
+
+    # @return [Toolchain::Validations::ValidationErrors]
+    #
+    def errors
+      @errors ||= ValidationErrors.new
+    end
+
+    # Runs all the validation operations and will apply error
+    # messages to the ValidationErrors object when validator errors occur.
+    #
+    def validate
+      Helpers.each_validation(self.class) do |v|
+        v[:validator].new(self, v[:key_path], v[:data]).validate
+      end
+
+      Helpers.each_validation(self.class, :custom_validations) { |v| send(v) }
+    end
+
+    # Resets the ValidationErrors object, re-validates the current object
+    # and then determines whether or not this object is valid.
+    #
+    # @note If invalid (returns `false`), errors will have been
+    #   added to the `object.errors` class.
+    #
+    # @return [Boolean]
+    #
+    def valid?
+      errors.reset
+      validate
+      errors.empty?
+    end
+  end
+
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+    base.extend(ClassMethods)
+  end
+end

data/lib/toolchain/validations/delegation.rb

@@ -0,0 +1,31 @@
+module Toolchain::Validations::Delegation
+  module InstanceMethods
+
+    # @return [Object]
+    #
+    attr_reader :delegator
+
+    # @param delegator [Object]
+    #
+    def initialize(delegator)
+      @delegator = delegator
+    end
+  end
+
+  # @param base [Class]
+  #
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+    base.class_eval do
+
+      alias_method :_valid?, :valid?
+
+      # @return [Boolean]
+      #
+      def valid?
+        self.attributes = delegator.attributes
+        _valid?.tap { delegator.errors = errors }
+      end
+    end
+  end
+end

data/lib/toolchain/validations/delegator.rb

@@ -0,0 +1,51 @@
+module Toolchain::Validations::Delegator
+  module InstanceMethods
+
+    # @param value [Hash]
+    #
+    attr_writer :errors
+
+    # @return [Hash]
+    #
+    def errors
+      @errors || {}
+    end
+
+    # @return [Boolean]
+    #
+    def valid?
+      validator.valid?
+    end
+  end
+
+  module ClassMethods
+
+    # @param block [Proc]
+    #
+    # @example
+    #   class MyClass
+    #     include Toolchain::Validations::Delegator
+    #
+    #     validate_with do |instance|
+    #       if instance.new?
+    #         NewResourceValidator
+    #       else
+    #         ExistingResourceValidator
+    #       end
+    #     end
+    #   end
+    #
+    def validate_with(&block)
+      define_method(:validator) do
+        @validator ||= block.call(self).new(self)
+      end
+    end
+  end
+
+  # @param base [Class]
+  #
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+    base.extend(ClassMethods)
+  end
+end

data/lib/toolchain/validations/helpers.rb

@@ -0,0 +1,58 @@
+module Toolchain::Validations::Helpers
+  extend self
+
+  # Finds the validator by key name.
+  #
+  # @param key [Symbol, String]
+  #
+  # @return [Object, nil] nil if the validator doesn't exist.
+  #
+  def find_validator(key)
+    Toolchain::Validations::Validators.const_get(classify(key))
+  rescue NameError
+  end
+
+  # Yields all defined validations from the current class,
+  # as well as all the (relavant) super-classes.
+  #
+  # @param klass [Class]
+  # @param method [Symbol, String]
+  #
+  # @yield [Hash]
+  #
+  def each_validation(klass, method = :validations)
+    while ![Class, Module, Object, BasicObject, nil].include?(klass)
+      klass.send(method).each { |v| yield v } if klass.respond_to?(method)
+      klass = klass.superclass
+    end
+  end
+
+  # Converts the provided value to it's class name.
+  #
+  # @param value [Symbol, String]
+  #
+  # @return [String]
+  #
+  def classify(value)
+    value.to_s.split("_").map(&:capitalize).join
+  end
+
+  # Custom inject method that includes a 3rd yield argument
+  # that determines whether the current iteration is the last.
+  #
+  # @param array [Array]
+  # @param init [Object] uses first value of array if nil.
+  #
+  # @yield memo [Object], value [Object], last [Boolean]
+  #
+  # @return [Object] The final memo result.
+  #
+  def inject(array, init = nil)
+    memo = init || array.shift
+    length = array.length
+    array.each_with_index do |value, index|
+      memo = yield memo, value, index == length - 1
+    end
+    memo
+  end
+end

data/lib/toolchain/validations/validation_errors.rb

@@ -0,0 +1,82 @@
+class Toolchain::Validations::ValidationErrors
+
+  Helpers = Toolchain::Validations::Helpers
+
+  # @return [Hash]
+  #
+  attr_reader :errors
+
+  # Creates a new instance of Toolchain::Validations::ValidationErrors
+  # and sets the initial errors state to an empty Hash.
+  #
+  def initialize
+    @errors = {}
+  end
+
+  # Adds a new message to the Toolchain::Validations::ValidationErrors object.
+  #
+  # @param args [Array<Symbol, String>]
+  #
+  # @example
+  #   errors.add(:name, "is required")
+  #   errors.add(:config, :url, "isn't valid")
+  #
+  def add(*args)
+    message, key_path = args.pop, args
+    key_path = [key_path].flatten
+
+    Helpers.inject(key_path, errors) do |memo, key, last|
+      if last
+        memo[key] ||= []
+        memo[key].push(message)
+      else
+        memo[key] ||= {}
+      end
+
+      memo[key]
+    end
+  end
+
+  # Resets all errors to an empty Hash.
+  #
+  def reset
+    @errors = {}
+  end
+
+  # Proxy method to allow individual values of the errors Hash
+  # to be accessed directly through the Toolchain::Validations::ValidationErrors object.
+  #
+  # @param key [Symbol] The key of the value you want to retrieve.
+  #
+  # @return [Object] the value of the key you want to retrieve.
+  #
+  def [](key)
+    errors[key]
+  end
+
+  # Proxy method to delegate the comparison of two values to
+  # the errors Hash.
+  #
+  # @param value [Object]
+  #
+  # @return [Boolean] true if both values are equal.
+  #
+  def ==(value)
+    errors == value
+  end
+
+  # Proxy method to check if there currently are any errors.
+  #
+  # @return [Boolean] true if there aren't any errors.
+  #
+  def empty?
+    errors.empty?
+  end
+
+  # @return [Hash] the Hash representation of the
+  #   Toolchain::Validations::ValidationErrors.
+  #
+  def to_hash
+    errors
+  end
+end