hash_cast 0.4.0

data/lib/hcast/casters/string_caster.rb

@@ -0,0 +1,13 @@
+class HCast::Casters::StringCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(String)
+      value
+    elsif value.is_a?(Symbol)
+      value.to_s
+    else
+      raise HCast::Errors::CastingError, "should be a string"
+    end
+  end
+
+end

data/lib/hcast/casters/symbol_caster.rb

@@ -0,0 +1,18 @@
+class HCast::Casters::SymbolCaster
+  MAX_SYMBOL_LENGTH = 1000
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Symbol)
+      value
+    elsif value.is_a?(String)
+      if value.length > MAX_SYMBOL_LENGTH
+        raise HCast::Errors::CastingError, "is too long to be a symbol"
+      else
+        value.to_sym
+      end
+    else
+      raise HCast::Errors::CastingError, "should be a symbol"
+    end
+  end
+
+end

data/lib/hcast/casters/time_caster.rb

@@ -0,0 +1,19 @@
+require 'time'
+
+class HCast::Casters::TimeCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Time)
+      value
+    elsif value.is_a?(String)
+      begin
+        Time.parse(value)
+      rescue ArgumentError => e
+        raise HCast::Errors::CastingError, "is invalid time"
+      end
+    else
+      raise HCast::Errors::CastingError, "should be a time"
+    end
+  end
+
+end

data/lib/hcast/casters.rb

@@ -0,0 +1,13 @@
+# List of build in casters
+module HCast::Casters
+  require 'hcast/casters/array_caster'
+  require 'hcast/casters/boolean_caster'
+  require 'hcast/casters/date_caster'
+  require 'hcast/casters/datetime_caster'
+  require 'hcast/casters/float_caster'
+  require 'hcast/casters/hash_caster'
+  require 'hcast/casters/integer_caster'
+  require 'hcast/casters/string_caster'
+  require 'hcast/casters/symbol_caster'
+  require 'hcast/casters/time_caster'
+end

data/lib/hcast/concern.rb

@@ -0,0 +1,136 @@
+module HCast
+  # Copied from here https://github.com/rails/rails/blob/master/activesupport/lib/active_support/concern.rb
+  #
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+  end
+end

data/lib/hcast/config.rb

@@ -0,0 +1,11 @@
+class HCast::Config
+  attr_accessor :input_keys, :output_keys
+
+  def input_keys
+    @input_keys || :symbol
+  end
+
+  def output_keys
+    @output_keys || :symbol
+  end
+end

data/lib/hcast/errors.rb

@@ -0,0 +1,67 @@
+module HCast::Errors
+
+  # Base error class for all HCast errors
+  class HCastError            < StandardError; end
+
+  # Raised when caster with given name is not registered in HCast
+  class CasterNotFoundError   < HCastError;    end
+
+  # Raised when some of the given to HCast argument is not valid
+  class ArgumentError         < HCastError;    end
+
+  class AttributeError < HCastError
+    attr_reader :namespaces
+
+    def initialize(message, namespace = nil)
+      super(message)
+      @namespaces = []
+      @namespaces << namespace if namespace
+    end
+
+    def add_namespace(namespace)
+      namespaces << namespace
+    end
+
+    def message
+      to_s
+    end
+
+    def to_s
+      if namespaces.empty?
+        super
+      else
+        reverted_namespaces = namespaces.reverse
+        msg = reverted_namespaces.first.to_s
+        msg += reverted_namespaces[1..-1].inject("") { |res, item| res += "[#{item}]"}
+        msg + " " + super
+      end
+    end
+
+  end
+  # Raised when hash attribute can't be casted
+  class CastingError < AttributeError;    end
+
+  # Raised when required hash attribute wasn't given for casting
+  class MissingAttributeError < AttributeError;    end
+
+  # Raised when unexpected hash attribute was given for casting
+  class UnexpectedAttributeError < AttributeError; end
+
+  # Raised when hash has validation errors
+  class ValidationError < StandardError
+    attr_reader :errors
+
+    def initialize(message, errors)
+      @errors = errors
+      super(message)
+    end
+
+    def message
+      "#{@message}\n#{errors.to_hash}"
+    end
+
+    def short_message
+      'Validation error'
+    end
+  end
+end

data/lib/hcast/metadata/attribute.rb

@@ -0,0 +1,30 @@
+module HCast::Metadata
+  class Attribute
+    attr_reader :name, :caster, :options
+    attr_accessor :children
+
+    def initialize(name, caster, options)
+      @name      = name
+      @caster    = caster
+      @options   = options
+      @children  = []
+    end
+
+    def has_children?
+      !children.empty?
+    end
+
+    def required?
+      !optional?
+    end
+
+    def optional?
+      !!options[:optional]
+    end
+
+    def allow_nil?
+      !!options[:allow_nil]
+    end
+
+  end
+end

data/lib/hcast/version.rb

@@ -0,0 +1,3 @@
+module HCast
+  VERSION = "0.4.0"
+end

data/lib/hcast.rb

@@ -0,0 +1,46 @@
+require 'hcast/version'
+require 'hcast/errors'
+require 'hcast/config'
+require 'hcast/casters'
+require 'hcast/concern.rb'
+require 'hcast/metadata/attribute'
+require 'hcast/attributes_parser'
+require 'hcast/attributes_caster'
+require 'hcast/caster'
+
+module HCast
+  @@casters = {}
+
+  # Defines caster without adding own class
+  # @note Not yet implemented
+  def self.create(&block)
+  end
+
+  # Returns list of defined casters
+  def self.casters
+    @@casters
+  end
+
+  # Adds new casters to HCast
+  # Allow extend HCast with your own casters
+  # @param caster_name [Symbol] caster name
+  # @param caster      [Class]  caster
+  def self.add_caster(caster_name, caster)
+    @@casters[caster_name] = caster
+  end
+
+  def self.config
+    @@config ||= HCast::Config.new
+  end
+end
+
+HCast.add_caster(:array,    HCast::Casters::ArrayCaster)
+HCast.add_caster(:boolean,  HCast::Casters::BooleanCaster)
+HCast.add_caster(:date,     HCast::Casters::DateCaster)
+HCast.add_caster(:datetime, HCast::Casters::DateTimeCaster)
+HCast.add_caster(:float,    HCast::Casters::FloatCaster)
+HCast.add_caster(:hash,     HCast::Casters::HashCaster)
+HCast.add_caster(:integer,  HCast::Casters::IntegerCaster)
+HCast.add_caster(:string,   HCast::Casters::StringCaster)
+HCast.add_caster(:symbol,   HCast::Casters::SymbolCaster)
+HCast.add_caster(:time,     HCast::Casters::TimeCaster)