hashcast 0.4.0

data/hcast.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hashcast/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hashcast"
+  spec.version       = HashCast::VERSION
+  spec.authors       = ["Albert Gazizov", "Roman Heinrich"]
+  spec.email         = ["deeper4k@gmail.com"]
+  spec.description   = %q{Declarative Hash Caster}
+  spec.summary       = %q{Declarative Hash Caster}
+  spec.homepage      = "http://github.com/ddd-ruby/hashcast"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "byebug",  '~> 0'
+  spec.add_development_dependency "rake",  '~> 0'
+  spec.add_development_dependency "bixby-bench",  '~> 0'
+  spec.add_development_dependency "allocation_stats",  '~> 0'
+  spec.add_development_dependency "codecov",  '~> 0'
+end

data/lib/hashcast.rb

@@ -0,0 +1,46 @@
+require 'hashcast/version'
+require 'hashcast/errors'
+require 'hashcast/config'
+require 'hashcast/casters'
+require 'hashcast/concern'
+require 'hashcast/metadata/attribute'
+require 'hashcast/attributes_parser'
+require 'hashcast/attributes_caster'
+require 'hashcast/caster'
+
+module HashCast
+  @@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 HashCast
+  # Allow extend HashCast 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 ||= HashCast::Config.new
+  end
+end
+
+HashCast.add_caster(:array,    HashCast::Casters::ArrayCaster)
+HashCast.add_caster(:boolean,  HashCast::Casters::BooleanCaster)
+HashCast.add_caster(:date,     HashCast::Casters::DateCaster)
+HashCast.add_caster(:datetime, HashCast::Casters::DateTimeCaster)
+HashCast.add_caster(:float,    HashCast::Casters::FloatCaster)
+HashCast.add_caster(:hash,     HashCast::Casters::HashCast)
+HashCast.add_caster(:integer,  HashCast::Casters::IntegerCaster)
+HashCast.add_caster(:string,   HashCast::Casters::StringCaster)
+HashCast.add_caster(:symbol,   HashCast::Casters::SymbolCaster)
+HashCast.add_caster(:time,     HashCast::Casters::TimeCaster)

data/lib/hashcast/attributes_caster.rb

@@ -0,0 +1,97 @@
+class HashCast::AttributesCaster
+  attr_reader :attributes, :options
+
+  def initialize(attributes, options)
+    @attributes = attributes
+    @options    = options
+  end
+
+  def cast(input_hash)
+    casted_hash = {}
+
+    hash_keys = get_keys(input_hash)
+    attributes.each do |attribute|
+      if hash_keys.include?(attribute.name)
+        begin
+          casted_value = cast_attribute(attribute, input_hash)
+          casted_hash[cast_key(attribute.name, options)] = casted_value
+        rescue HashCast::Errors::AttributeError => e
+          e.add_namespace(attribute.name)
+          raise e
+        end
+      else
+        raise HashCast::Errors::MissingAttributeError.new("should be given", attribute.name) if attribute.required?
+      end
+    end
+
+    if !options[:skip_unexpected_attributes]
+      check_unexpected_attributes_not_given!(hash_keys, casted_hash.keys)
+    end
+
+    casted_hash
+  end
+
+  private
+
+  def cast_attribute(attribute, hash)
+    value = get_value(hash, attribute.name)
+    return nil if value.nil? && attribute.allow_nil?
+
+    casted_value = attribute.caster.cast(value, attribute.name, attribute.options)
+
+    if attribute.has_children?
+      return cast_children(casted_value, attribute)
+    end
+    if caster = attribute.options[:caster]
+      return cast_children_with_caster(casted_value, attribute, caster)
+    end
+
+    casted_value
+  end
+
+  def cast_children(value, attribute)
+    caster = self.class.new(attribute.children, options)
+    cast_children_with_caster(value, attribute, caster)
+  end
+
+  def cast_children_with_caster(value, attribute, caster)
+    return caster.cast(value) if attribute.caster != HashCast::Casters::ArrayCaster
+
+    value.map do |val|
+      caster.cast(val)
+    end
+  end
+
+  def cast_key(value, options)
+    return value      if options[:output_keys] == :symbol
+    return value.to_s if options[:output_keys] == :string
+  end
+
+  def get_keys(hash)
+    return hash.keys if same_in_out_key_format?
+    hash.keys.map(&:to_sym)
+  end
+
+  def get_value(hash, key)
+    return hash[key]        if same_in_out_key_format?
+    return hash[key.to_sym] if options[:input_keys] == :symbol
+    hash[key.to_s]
+  end
+
+  def check_unexpected_attributes_not_given!(input_hash_keys, casted_hash_keys)
+    unexpected_keys = keys_diff(input_hash_keys, casted_hash_keys)
+    unless unexpected_keys.empty?
+      raise HashCast::Errors::UnexpectedAttributeError.new("is not valid attribute name", unexpected_keys.first)
+    end
+  end
+
+  def same_in_out_key_format?
+    options[:input_keys] == options[:output_keys]
+  end
+
+  def keys_diff(input_hash_keys, casted_hash_keys)
+    return (input_hash_keys - casted_hash_keys) if same_in_out_key_format?
+    return (input_hash_keys - casted_hash_keys) if options[:output_keys] == :symbol # same for symbol
+    return (input_hash_keys - casted_hash_keys.map(&:to_sym)) if options[:output_keys] == :string
+  end
+end

data/lib/hashcast/attributes_parser.rb

@@ -0,0 +1,63 @@
+# Parses caster rules
+# and returns list of HashCast::Metadata::Attribute instances
+# which contains casting rules
+class HashCast::AttributesParser
+
+  # Performs casting
+  # @param block [Proc] block with casting rules
+  # @return Array(HashCast::Metadata::Attribute) list of casting rules
+  def self.parse(&block)
+    dsl = DSL.new
+    dsl.instance_exec(&block)
+    dsl.attributes
+  end
+
+  class DSL
+    attr_reader :attributes
+
+    def initialize
+      @attributes = []
+    end
+
+    # Redefined becase each class has the built in hash method
+    def hash(*args, &block)
+      method_missing(:hash, *args, &block)
+    end
+
+    def method_missing(caster_name, *args, &block)
+      attr_name = args[0]
+      options   = args[1] || {}
+      caster = HashCast.casters[caster_name]
+
+      check_caster_exists!(caster, caster_name)
+      check_attr_name_valid!(attr_name)
+      check_options_is_hash!(options)
+
+      attribute = HashCast::Metadata::Attribute.new(attr_name, caster, options)
+      if block_given?
+        attribute.children = HashCast::AttributesParser.parse(&block)
+      end
+      attributes << attribute
+    end
+
+    private
+
+    def check_caster_exists!(caster, caster_name)
+      if !caster
+        raise HashCast::Errors::CasterNotFoundError, "caster with name '#{caster_name}' is not found"
+      end
+    end
+
+    def check_attr_name_valid!(attr_name)
+      if !attr_name.is_a?(Symbol) && !attr_name.is_a?(String)
+        raise HashCast::Errors::ArgumentError, "attribute name should be a symbol or string"
+      end
+    end
+
+    def check_options_is_hash!(options)
+      if !options.is_a?(Hash)
+        raise HashCast::Errors::ArgumentError, "attribute options should be a Hash"
+      end
+    end
+  end
+end

data/lib/hashcast/caster.rb

@@ -0,0 +1,144 @@
+# Include this module to create your caster
+#
+# Example caster:
+#   class ContactCaster
+#     include HashCast::Caster
+#
+#     attributes do
+#       hash :contact do
+#         string   :name
+#         integer  :age, optional: true
+#         float    :weight
+#         date     :birthday
+#         datetime :last_logged_in
+#         time     :last_visited_at
+#         hash :company do
+#           string :name
+#         end
+#         array :emails, each: :string
+#         array :social_accounts, each: :hash do
+#           string :name
+#           symbol :type
+#         end
+#       end
+#     end
+#   end
+#
+# The defined caster will have #cast method which accepts hash
+# Use it to cast hash:
+#   ContactCaster.new.cast({
+#     contact: {
+#       name: "John Smith",
+#       age: "22",
+#       weight: "65.5",
+#       birthday: "2014-02-02",
+#       last_logged_in: "2014-02-02 10:10:00",
+#       last_visited_at: "2014-02-02 10:10:00",
+#       company: {
+#         name: "MyCo",
+#       },
+#       emails: [ "test@example.com", "test2@example.com" ],
+#       social_accounts: [
+#         {
+#           name: "john_smith",
+#           type: 'twitter',
+#         },
+#         {
+#           name: "John",
+#           type: :facebook,
+#         },
+#       ]
+#     }
+#   })
+#
+#   The output will be casted hash:
+#   {
+#     contact: {
+#       name: "John Smith",
+#       age: 22,
+#       weight: 65.5,
+#       birthday: Date.parse("2014-02-02"),
+#       last_logged_in: DateTime.parse("2014-02-02 10:10:00"),
+#       last_visited_at: Time.parse("2014-02-02 10:10:00"),
+#       company: {
+#         name: "MyCo",
+#       },
+#       emails: [ "test@example.com", "test2@example.com" ],
+#       social_accounts: [
+#         {
+#           name: "john_smith",
+#           type: :twitter,
+#         },
+#         {
+#           name: "John",
+#           type: :facebook,
+#         },
+#       ]
+#     }
+#   }
+module HashCast::Caster
+  extend HashCast::Concern
+
+  module ClassMethods
+    ALLOWED_OPTIONS = [:string, :symbol]
+
+    # Defines casting rules
+    # @example
+    #  attributes do
+    #    string   :first_name
+    #    string   :last_name
+    #    integer  :age, optional: true
+    #  end
+    def attributes(&block)
+      raise ArgumentError, "You should provide block" unless block_given?
+
+      attributes = HashCast::AttributesParser.parse(&block)
+      self.instance_variable_set(:@attributes, attributes)
+    end
+
+    # Performs casting
+    # @param hash [Hash] hash for casting
+    # @param options [Hash] options, input_keys: :string, output_key: :symbol
+    def cast(hash, options = {})
+      check_attributes_defined!
+      check_hash_given!(hash)
+      check_options!(options)
+      options = set_default_options(options)
+
+      attributes_caster = HashCast::AttributesCaster.new(instance_variable_get(:@attributes), options)
+      attributes_caster.cast(hash)
+    end
+
+    private
+
+    def check_attributes_defined!
+      unless instance_variable_defined?(:@attributes)
+        raise HashCast::Errors::ArgumentError, "Attributes block should be defined"
+      end
+    end
+
+    def check_options!(options)
+      unless options.is_a?(Hash)
+        raise HashCast::Errors::ArgumentError, "Options should be a hash"
+      end
+      if options[:input_keys] && !ALLOWED_OPTIONS.include?(options[:input_keys])
+        raise HashCast::Errors::ArgumentError, "input_keys should be :string or :symbol"
+      end
+      if options[:output_keys] && !ALLOWED_OPTIONS.include?(options[:output_keys])
+        raise HashCast::Errors::ArgumentError, "output_keys should be :string or :symbol"
+      end
+    end
+
+    def check_hash_given!(hash)
+      unless hash.is_a?(Hash)
+        raise HashCast::Errors::ArgumentError, "Hash should be given"
+      end
+    end
+
+    def set_default_options(options)
+      options[:input_keys]  ||= HashCast.config.input_keys
+      options[:output_keys] ||= HashCast.config.output_keys
+      options
+    end
+  end
+end

data/lib/hashcast/casters.rb

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

data/lib/hashcast/casters/array_caster.rb

@@ -0,0 +1,27 @@
+class HashCast::Casters::ArrayCaster
+
+  def self.cast(value, attr_name, options = {})
+    raise HashCast::Errors::CastingError, "should be an array" unless value.is_a?(Array)
+    return value unless options[:each]
+
+    cast_array_items(value, attr_name, options)
+  end
+
+  private
+
+  def self.cast_array_items(array, attr_name, options)
+    caster_name = options[:each]
+    caster      = HashCast.casters[caster_name]
+    check_caster_exists!(caster, caster_name)
+    array.map do |item|
+      caster.cast(item, "#{attr_name} item", options)
+    end
+  end
+
+  def self.check_caster_exists!(caster, caster_name)
+    unless caster
+      raise HashCast::Errors::CasterNotFoundError, "caster with name #{caster_name} is not found"
+    end
+  end
+
+end

data/lib/hashcast/casters/boolean_caster.rb

@@ -0,0 +1,13 @@
+class HashCast::Casters::BooleanCaster
+  REAL_BOOLEANS = [TrueClass, FalseClass]
+  TRUE_VALUES   = ['1', 'true', 'on', 1]
+  FALSE_VALUES  = ['0', 'false', 'off', 0]
+
+  def self.cast(value, attr_name, options = {})
+    return value if REAL_BOOLEANS.include?(value.class)
+    return true  if TRUE_VALUES.include?(value)
+    return false if FALSE_VALUES.include?(value)
+    raise HashCast::Errors::CastingError, "should be a boolean"
+  end
+
+end

data/lib/hashcast/casters/date_caster.rb

@@ -0,0 +1,15 @@
+class HashCast::Casters::DateCaster
+
+  def self.cast(value, attr_name, options = {})
+    return value              if value.is_a?(Date)
+    return cast_string(value) if value.is_a?(String)
+    raise HashCast::Errors::CastingError, "should be a date"
+  end
+
+  def self.cast_string(value)
+    Date.parse(value)
+  rescue ArgumentError => e
+    raise HashCast::Errors::CastingError, "is invalid date"
+  end
+
+end