hcast 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+vendor/
+tags
+.bundle
+.DS_Store

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+- 2.0.0
+script: "bundle exec rspec spec/"

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'debugger'
+end

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    hcast (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.6.5)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.3.1)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.3.1)
+    diff-lcs (1.2.5)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  debugger
+  hcast!
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Albert Gazizov
+
+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/README.md

@@ -0,0 +1,113 @@
+# HCast [![Build Status](https://travis-ci.org/AlbertGazizov/hcast.png)](https://travis-ci.org/AlbertGazizov/hcast) [![Code Climate](https://codeclimate.com/github/AlbertGazizov/hcast.png)](https://codeclimate.com/github/AlbertGazizov/hcast)
+
+
+
+HCast is a library for casting hash attributes
+
+## Usage
+
+Create caster class and declare hash attributes inside:
+```ruby
+class ContactCaster
+  include HCast::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
+```
+Instanticate the caster and give your hash for casting:
+```ruby
+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 casted will cast your hash and output will be:
+```ruby
+{
+  contact: {
+    name: "John Smith",
+    age: 22,
+    weight: 65.5,
+    birthday: #<Date: 2014-02-02 ((2456691j,0s,0n),+0s,2299161j)>,
+    last_logged_in: #<DateTime: 2014-02-02T10:10:00+00:00 ((2456691j,36600s,0n),+0s,2299161j)>,
+    last_visited_at: 2014-02-02 10:10:00 +0400,
+    company: {
+      name: "MyCo"
+    },
+    emails: ["test@example.com", "test2@example.com"],
+    social_accounts: [
+      {
+        name: "john_smith",
+        type: :twitter"
+      },
+      {
+        name: "John",
+        type: :facebook
+      }
+    ]
+  }
+}
+```
+
+if some of the attributes can't be casted the HCast::Errors::CastingError will be raised
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hcast'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hcast
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/hcast.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hcast/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hcast"
+  spec.version       = HCast::VERSION
+  spec.authors       = ["Albert Gazizov"]
+  spec.email         = ["deeper4k@gmail.com"]
+  spec.description   = %q{Hash Caster and Validator}
+  spec.summary       = %q{Hash Caster and Validator}
+  spec.homepage      = "http://github.com/AlbertGazizov/hcast"
+  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 "rake"
+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)

data/lib/hcast/attributes_caster.rb

@@ -0,0 +1,83 @@
+class HCast::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)
+         casted_value = cast_attribute(attribute, input_hash)
+         casted_hash[attribute.name] = casted_value
+      else
+        raise HCast::Errors::MissingAttributeError, "#{attribute.name} should be given" if attribute.required?
+      end
+    end
+    check_unexpected_attributes_not_given!(hash_keys, casted_hash.keys)
+
+    casted_hash
+  end
+
+  private
+
+  def cast_attribute(attribute, hash)
+    value        = get_value(hash, attribute.name)
+    casted_value = attribute.caster.cast(value, attribute.name, attribute.options)
+
+    if attribute.has_children?
+      cast_children(hash, attribute)
+    else
+      casted_value
+    end
+  end
+
+  def cast_children(hash, attribute)
+    value = get_value(hash, attribute.name)
+    if attribute.caster == HCast::Casters::ArrayCaster
+      value.map do |val|
+        caster = self.class.new(attribute.children, options)
+        caster.cast(val)
+      end
+    else
+      caster = self.class.new(attribute.children, options)
+      caster.cast(value)
+    end
+  end
+
+  def get_keys(hash)
+    if options[:input_keys] != options[:output_keys]
+      if options[:input_keys] == :symbol
+        hash.keys.map(&:to_s)
+      else
+        hash.keys.map(&:to_sym)
+      end
+    else
+      hash.keys
+    end
+  end
+
+  def get_value(hash, key)
+    if options[:input_keys] != options[:output_keys]
+      if options[:input_keys] == :symbol
+        hash[key.to_sym]
+      else
+        hash[key.to_s]
+      end
+    else
+      hash[key]
+    end
+  end
+
+  def check_unexpected_attributes_not_given!(input_hash_keys, casted_hash_keys)
+    unexpected_keys = input_hash_keys - casted_hash_keys
+    unless unexpected_keys.empty?
+      raise HCast::Errors::UnexpectedAttributeError, "Unexpected attributes given: #{unexpected_keys}"
+    end
+  end
+
+end

data/lib/hcast/attributes_parser.rb

@@ -0,0 +1,63 @@
+# Parses caster rules
+# and returns list of HCast::Metadata::Attribute instances
+# which contains casting rules
+class HCast::AttributesParser
+
+  # Performs casting
+  # @param block [Proc] block with casting rules
+  # @return Array(HCast::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 = HCast.casters[caster_name]
+
+      check_caster_exists!(caster)
+      check_attr_name_valid!(attr_name)
+      check_options_is_hash!(options)
+
+      attribute = HCast::Metadata::Attribute.new(attr_name, caster, options)
+      if block_given?
+        attribute.children = HCast::AttributesParser.parse(&block)
+      end
+      attributes << attribute
+    end
+
+    private
+
+    def check_caster_exists!(caster)
+      if !caster
+        raise HCast::Errors::CasterNotFoundError, "caster with name '#{caster}' is not found"
+      end
+    end
+
+    def check_attr_name_valid!(attr_name)
+      if !attr_name.is_a?(Symbol) && !attr_name.is_a?(String)
+        raise HCast::Errors::ArgumentError, "attribute name should be a symbol or string"
+      end
+    end
+
+    def check_options_is_hash!(options)
+      if !options.is_a?(Hash)
+        raise HCast::Errors::ArgumentError, "attribute options should be a Hash"
+      end
+    end
+  end
+end

data/lib/hcast/caster.rb

@@ -0,0 +1,142 @@
+# Include this module to create your caster
+#
+# Example caster:
+#   class ContactCaster
+#     include HCast::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 HCast::Caster
+  extend HCast::Concern
+
+  module ClassMethods
+
+    # 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 = HCast::AttributesParser.parse(&block)
+      self.class_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)
+      set_default_options(options)
+
+      attributes_caster = HCast::AttributesCaster.new(class_variable_get(:@@attributes), options)
+      attributes_caster.cast(hash)
+    end
+
+    private
+
+    def check_attributes_defined!
+      unless class_variable_defined?(:@@attributes)
+        raise HCast::Errors::ArgumentError, "Attributes block should be defined"
+      end
+    end
+
+    def check_options!(options)
+      unless options.is_a?(Hash)
+        raise HCast::Errors::ArgumentError, "Options should be a hash"
+      end
+      if options[:input_keys] && ![:string, :symbol].include?(options[:input_keys])
+        raise HCast::Errors::ArgumentError, "input_keys should be :string or :symbol"
+      end
+      if options[:output_keys] && ![:string, :symbol].include?(options[:output_keys])
+        raise HCast::Errors::ArgumentError, "output_keys should be :string or :symbol"
+      end
+    end
+
+    def check_hash_given!(hash)
+      unless hash.is_a?(Hash)
+        raise HCast::Errors::ArgumentError, "Hash should be given"
+      end
+    end
+
+    def set_default_options(options)
+      options[:input_keys]  ||= HCast.config.input_keys
+      options[:output_keys] ||= HCast.config.output_keys
+    end
+  end
+end