hcast 0.0.1

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/casters/array_caster.rb

@@ -0,0 +1,32 @@
+class HCast::Casters::ArrayCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Array)
+      if options[:each]
+        cast_array_items(value, attr_name, options)
+      else
+        value
+      end
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be an array"
+    end
+  end
+
+  private
+
+  def self.cast_array_items(array, attr_name, options)
+    caster_name = options[:each]
+    caster = HCast.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 HCast::Errors::CasterNotFoundError, "caster with name #{caster_name} is not found"
+    end
+  end
+
+end

data/lib/hcast/casters/boolean_caster.rb

@@ -0,0 +1,15 @@
+class HCast::Casters::BooleanCaster
+
+  def self.cast(value, attr_name, options = {})
+    if [TrueClass, FalseClass].include?(value.class)
+      value
+    elsif ['1', 'true', 'on', 1].include?(value)
+      true
+    elsif ['0', 'false', 'off', 0].include?(value)
+      false
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a boolean"
+    end
+  end
+
+end

data/lib/hcast/casters/date_caster.rb

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

data/lib/hcast/casters/datetime_caster.rb

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

data/lib/hcast/casters/float_caster.rb

@@ -0,0 +1,17 @@
+class HCast::Casters::FloatCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Float)
+      value
+    elsif value.is_a?(String)
+      begin
+        Float(value)
+      rescue ArgumentError => e
+        raise HCast::Errors::CastingError, "#{attr_name} is invalid float"
+      end
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a float"
+    end
+  end
+
+end

data/lib/hcast/casters/hash_caster.rb

@@ -0,0 +1,11 @@
+class HCast::Casters::HashCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Hash)
+      value
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a hash"
+    end
+  end
+
+end

data/lib/hcast/casters/integer_caster.rb

@@ -0,0 +1,17 @@
+class HCast::Casters::IntegerCaster
+
+  def self.cast(value, attr_name, options = {})
+    if value.is_a?(Integer)
+      value
+    elsif value.is_a?(String)
+      begin
+        Integer(value)
+      rescue ArgumentError => e
+        raise HCast::Errors::CastingError, "#{attr_name} is invalid integer"
+      end
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a integer"
+    end
+  end
+
+end

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, "#{attr_name} 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, "#{attr_name} is too long to be a symbol"
+      else
+        value.to_sym
+      end
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a symbol"
+    end
+  end
+
+end

data/lib/hcast/casters/time_caster.rb

@@ -0,0 +1,17 @@
+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, "#{attr_name} is invalid time"
+      end
+    else
+      raise HCast::Errors::CastingError, "#{attr_name} should be a time"
+    end
+  end
+
+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,38 @@
+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
+
+  # Raised when hash attribute can't be casted
+  class CastingError          < HCastError;    end
+
+  # Raised when required hash attribute wasn't given for casting
+  class MissingAttributeError < HCastError;    end
+
+  # Raised when unexpected hash attribute was given for casting
+  class UnexpectedAttributeError < HCastError; 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,26 @@
+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
+
+  end
+end

data/lib/hcast/version.rb

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

data/spec/hcast/caster_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+describe HCast::Caster do
+  describe "#cast" do
+
+    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
+
+    it "should cast hash attributes" do
+      input_hash = {
+        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,
+            },
+          ]
+        }
+      }
+
+      casted_hash = ContactCaster.cast(input_hash)
+
+      casted_hash.should == {
+        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,
+            },
+          ]
+        }
+      }
+    end
+
+    it "should raise error if some attribute can't be casted" do
+      input_hash = {
+        contact: {
+          name: {},
+          age: 22,
+          weight: 65.5,
+          birthday: Date.today,
+          last_logged_in: DateTime.now,
+          last_visited_at: Time.now,
+          company: {
+            name: "MyCo",
+          },
+          emails: [ "test@example.com", "test2@example.com" ],
+          social_accounts: [
+            {
+              name: "john_smith",
+              type: :twitter,
+            },
+            {
+              name: "John",
+              type: :facebook,
+            }
+          ]
+        }
+      }
+
+      expect do
+        ContactCaster.cast(input_hash)
+      end.to raise_error(HCast::Errors::CastingError, "name should be a string")
+    end
+
+    it "should raise error if some attribute wasn't given" do
+      input_hash = {
+        contact: {
+          age: 22,
+          weight: 65.5,
+          birthday: Date.today,
+          last_logged_in: DateTime.now,
+          last_visited_at: Time.now,
+          company: {
+            name: "MyCo",
+          },
+          emails: [ "test@example.com", "test2@example.com" ],
+          social_accounts: [
+            {
+              name: "john_smith",
+              type: :twitter,
+            },
+            {
+              name: "John",
+              type: :facebook,
+            }
+          ]
+        }
+      }
+
+      expect do
+        ContactCaster.cast(input_hash)
+      end.to raise_error(HCast::Errors::MissingAttributeError, "name should be given")
+    end
+
+    it "should not raise error if attribute is optional" do
+      input_hash = {
+        contact: {
+          name: "Jim",
+          weight: 65.5,
+          birthday: Date.today,
+          last_logged_in: DateTime.now,
+          last_visited_at: Time.now,
+          company: {
+            name: "MyCo",
+          },
+          emails: [ "test@example.com", "test2@example.com" ],
+          social_accounts: [
+            {
+              name: "john_smith",
+              type: :twitter,
+            },
+            {
+              name: "John",
+              type: :facebook,
+            },
+          ]
+        }
+      }
+
+      expect do
+        ContactCaster.cast(input_hash)
+      end.to_not raise_error
+    end
+
+    it "should raise error if unexpected attribute was given" do
+      input_hash = {
+        wrong_attribute: 'foo',
+        contact: {
+          name: "Jim",
+          weight: 65.5,
+          birthday: Date.today,
+          last_logged_in: DateTime.now,
+          last_visited_at: Time.now,
+          company: {
+            name: "MyCo",
+          },
+          emails: [ "test@example.com", "test2@example.com" ],
+          social_accounts: [
+            {
+              name: "john_smith",
+              type: :twitter,
+            },
+            {
+              name: "John",
+              type: :facebook,
+            },
+          ]
+        }
+      }
+
+      expect do
+        ContactCaster.cast(input_hash)
+      end.to raise_error(HCast::Errors::UnexpectedAttributeError, "Unexpected attributes given: [:wrong_attribute]")
+    end
+
+    it "should convert accept hash with string keys and cast them to symbol keys" do
+      input_hash = {
+        '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,
+            },
+          ]
+        }
+      }
+
+      casted_hash = ContactCaster.cast(input_hash, input_keys: :string, output_keys: :symbol)
+
+      casted_hash.should == {
+        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,
+            },
+          ]
+        }
+      }
+    end
+  end
+
+  context "checking invalid parameters" do
+    it "should raise CaterNotFound exception if caster name is invalid" do
+      expect do
+        class WrongCaster
+          include HCast::Caster
+
+          attributes do
+            integr   :name
+          end
+        end
+      end.to raise_error(HCast::Errors::CasterNotFoundError)
+    end
+  end
+
+  context "validations" do
+    before :all do
+      class ContactWithValidationsCaster
+        include HCast::Caster
+
+        attributes do
+          hash :contact do
+            string   :name, presence: true, length: { max: 5 }
+            integer  :age, optional: true
+            float    :weight, numericality: { less_than_or_equal_to: 200 }
+            date     :birthday
+            datetime :last_logged_in
+            time     :last_visited_at
+            hash :company do
+              string :name, length: { min: 2 }
+            end
+            array :emails, each: :string
+            array :social_accounts, each: :hash do
+              string :name
+              symbol :type, inclusion: { in: [:twitter, :facebook] }
+            end
+          end
+        end
+      end
+    end
+
+    it "should collect validation errors and raise exception when hash is invalid" do
+      begin
+        ContactWithValidationsCaster.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: :yahoo,
+              },
+            ]
+          }
+        )
+      rescue HCast::Errors::ValidationError => e
+        e.errors.to_hash.should == {
+          contact: {
+            name: ["can't be more than 5"],
+            social_accounts: [
+              {},
+              { type: ["should be included in [:twitter, :facebook]"] },
+            ]
+          }
+        }
+      end
+    end
+  end
+end