hashcast 0.4.0

data/lib/hashcast/casters/datetime_caster.rb

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

data/lib/hashcast/casters/float_caster.rb

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

data/lib/hashcast/casters/hash_caster.rb

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

data/lib/hashcast/casters/integer_caster.rb

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

data/lib/hashcast/casters/string_caster.rb

@@ -0,0 +1,8 @@
+class HashCast::Casters::StringCaster
+
+  def self.cast(value, attr_name, options = {})
+    return value      if value.is_a?(String)
+    return value.to_s if value.is_a?(Symbol)
+    raise HashCast::Errors::CastingError, "should be a string, but was #{value.class}"
+  end
+end

data/lib/hashcast/casters/symbol_caster.rb

@@ -0,0 +1,15 @@
+class HashCast::Casters::SymbolCaster
+  MAX_SYMBOL_LENGTH = 1000
+
+  def self.cast(value, attr_name, options = {})
+    return value              if value.is_a?(Symbol)
+    return cast_string(value) if value.is_a?(String)
+    raise HashCast::Errors::CastingError, "should be a symbol"
+  end
+
+  def self.cast_string(value)
+    return value.to_sym if value.length <= MAX_SYMBOL_LENGTH
+    raise HashCast::Errors::CastingError, "is too long to be a symbol (#{MAX_SYMBOL_LENGTH} max.)"
+  end
+
+end

data/lib/hashcast/casters/time_caster.rb

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

data/lib/hashcast/concern.rb

@@ -0,0 +1,136 @@
+module HashCast
+  # 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/hashcast/config.rb

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

data/lib/hashcast/errors.rb

@@ -0,0 +1,49 @@
+module HashCast::Errors
+
+  # Base error class for all HashCast errors
+  class HashCastError            < StandardError; end
+
+  # Raised when caster with given name is not registered in HashCast
+  class CasterNotFoundError   < HashCastError;    end
+
+  # Raised when some of the given to HashCast argument is not valid
+  class ArgumentError         < HashCastError;    end
+
+  class AttributeError < HashCastError
+    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
+end

data/lib/hashcast/metadata/attribute.rb

@@ -0,0 +1,30 @@
+module HashCast::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/hashcast/version.rb

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

data/spec/hcast/caster_spec.rb

@@ -0,0 +1,471 @@
+require 'spec_helper'
+
+describe HashCast::Caster do
+  describe "#cast" do
+
+    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
+
+    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
+
+    describe "Custom casters" do
+      class SettingsCaster
+        include HashCast::Caster
+
+        attributes do
+          string :account
+        end
+      end
+
+      class EmailCaster
+        include HashCast::Caster
+
+        attributes do
+          string :address
+        end
+      end
+
+      class CompanyCaster
+        include HashCast::Caster
+
+        attributes do
+          string :name
+          hash   :settings, caster: SettingsCaster
+          array  :emails,  caster: EmailCaster
+        end
+      end
+
+      it "should allow specify caster for nested hash attribute" do
+        casted_hash = CompanyCaster.cast(
+          name: 'Might & Magic',
+          settings: {
+            account: :'migthy_lord'
+          },
+          emails: [
+            { address: :'test1@example.com' },
+            { address: :'test2@example.com' },
+          ]
+        )
+
+        casted_hash.should == {
+          name: "Might & Magic",
+          settings: { account: "migthy_lord" },
+          emails: [
+            { address: "test1@example.com" },
+            { address: "test2@example.com" }
+          ]
+        }
+      end
+    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(HashCast::Errors::CastingError, "contact[name] should be a string, but was Hash")
+    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(HashCast::Errors::MissingAttributeError, "contact[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 = {
+        contact: {
+          wrong_attribute: 'foo',
+          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(HashCast::Errors::UnexpectedAttributeError, "contact[wrong_attribute] is not valid attribute name")
+    end
+
+    it "shouldn't unexpected attributes error if skip_unexpected_attributes flag is set to true" do
+      input_hash = {
+        contact: {
+          wrong_attribute: 'foo',
+          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, skip_unexpected_attributes: true)
+      end.not_to raise_error(HashCast::Errors::UnexpectedAttributeError)
+
+    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 HashCast::Caster
+
+          attributes do
+            integr   :name
+          end
+        end
+      end.to raise_error(HashCast::Errors::CasterNotFoundError)
+    end
+  end
+
+  context "allow nil values" do
+    before(:all) do
+      class HomeCaster
+        include HashCast::Caster
+
+        attributes do
+          string   :city
+          integer  :zip, allow_nil: true
+        end
+      end
+    end
+
+    it "should allow nil values if allow_nil is set to true" do
+      HomeCaster.cast(
+        city: 'Kazan',
+        zip: nil
+      )
+    end
+
+    it "should allow nil values unless allow_nil is set to true" do
+      expect do
+        HomeCaster.cast(
+          city: nil,
+          zip: nil
+        )
+      end.to raise_error(HashCast::Errors::CastingError, "city should be a string, but was NilClass")
+    end
+  end
+
+  context "input_keys" do
+    it "strings -> symbol works" do
+      expect(
+        SettingsCaster.cast({"account" => "value"}, {input_keys: :string, output_keys: :symbol})
+      ).to eq({account: "value"})
+    end
+
+    it "symbol -> string works" do
+      expect(
+        SettingsCaster.cast({account: "value"}, {input_keys: :symbol, output_keys: :string})
+      ).to eq({"account" => "value"})
+    end
+
+    it "symbol -> symbol works" do
+      expect(
+        SettingsCaster.cast({account: "value"}, {input_keys: :symbol, output_keys: :symbol})
+      ).to eq({account: "value"})
+    end
+
+    it "string -> string works" do
+      pending
+      expect(
+        SettingsCaster.cast({"account" => "value"}, {input_keys: :string, output_keys: :string})
+      ).to eq({"account" => "value"})
+    end
+  end
+
+  context "possible exeptions" do
+    it "raises when attributes were not defined" do
+      class NoAttrCaster
+        include HashCast::Caster
+      end
+
+      expect{
+        NoAttrCaster.cast({a: 1})
+      }.to raise_error(HashCast::Errors::ArgumentError, "Attributes block should be defined")
+    end
+
+    context "check_options!" do
+      it "raises when options are not a hash" do
+        expect {
+          SettingsCaster.cast({account: "some"}, 1)
+        }.to raise_error(HashCast::Errors::ArgumentError, "Options should be a hash")
+      end
+
+      it "raises on bad options" do
+        expect {
+          SettingsCaster.cast({account: "some"}, {input_keys: "string"})
+        }.to raise_error(HashCast::Errors::ArgumentError, "input_keys should be :string or :symbol")
+
+        expect {
+          SettingsCaster.cast({account: "some"}, {output_keys: "string"})
+        }.to raise_error(HashCast::Errors::ArgumentError, "output_keys should be :string or :symbol")
+      end
+    end
+
+    it "raises when input is not hash" do
+      expect {
+          SettingsCaster.cast(["some"])
+        }.to raise_error(HashCast::Errors::ArgumentError, "Hash should be given")
+    end
+
+    context "AttributesParser" do
+      it "raises when attribute name is not string/symbol" do
+        expect{
+          class BadAttrNameCaster
+            include HashCast::Caster
+            attributes do
+              string 4545
+            end
+          end
+        }.to raise_error(HashCast::Errors::ArgumentError, "attribute name should be a symbol or string")
+      end
+
+      it "raises when attribute options are not hash" do
+        expect{
+          class AttrOptionsNotHashCast
+            include HashCast::Caster
+            attributes do
+              string :some, [1,2,3]
+            end
+          end
+        }.to raise_error(HashCast::Errors::ArgumentError, "attribute options should be a Hash")
+      end
+    end
+  end
+end