hash_cast 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 71b3bcf7f98727c99228d5fb0ceaba02b87767721c251ba69d5c91079f936b5a
+  data.tar.gz: 1cd37fcce0009d5895dc72a4af32bd0c2dd2ea6ce5abee97b7e6b190a33c1655
+SHA512:
+  metadata.gz: e607f921e463af6ff705ad3cfd86c9ca5532d7813913f6c795bfec73879b02cc4a8101b44ab9f475f45576ccbadd8b47d5d71e57ca3565b98813e4a3e5c6427c
+  data.tar.gz: a7297e7a81c4165dcda83135131e68817e29c043fd20594f5ce3ec9ab8b37eef07afd16bd9d606bf2a6ab0a8bb041e0cf17067ddc0b46212749e56b2a55afe34

data/.github/workflows/rspec.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Rspec
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.1', '3.3']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rspec spec/

data/.gitignore

@@ -0,0 +1,6 @@
+vendor/
+tags
+.bundle
+.DS_Store
+tmp/
+pkg

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+hash_caster

data/.ruby-version

@@ -0,0 +1 @@
+3.3.4

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    hash_cast (0.4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.1)
+    rake (10.1.1)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.2)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  hash_cast!
+  rake
+  rspec
+
+BUNDLED WITH
+   2.5.22

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,93 @@
+# HCast
+[![Rspec](https://github.com/droidlabs/hcast/workflows/Rspec/badge.svg)](https://github.com/droidlabs/hcast/actions?query=workflow%3ARspec)
+
+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.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 caster will cast your hash attributes to:
+```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 is raised
+
+
+## Author
+Albert Gazizov, [@deeper4k](https://twitter.com/deeper4k)

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          = "hash_cast"
+  spec.version       = HCast::VERSION
+  spec.authors       = ["Albert Gazizov"]
+  spec.email         = ["deeper4k@gmail.com"]
+  spec.description   = %q{Declarative Hash Caster}
+  spec.summary       = %q{Declarative Hash Caster}
+  spec.homepage      = "http://github.com/droidlabs/hash_cast"
+  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"
+  spec.add_development_dependency "rake"
+end

data/lib/hcast/attributes_caster.rb

@@ -0,0 +1,102 @@
+class HCast::AttributesCaster
+  attr_reader :attributes, :options
+
+  def initialize(attributes, options)
+    @attributes         = attributes
+    @options            = options
+  end
+
+  def cast(input_hash, opts = {})
+    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[attribute.name] = casted_value
+        rescue HCast::Errors::AttributeError => e
+          handle_attribute_error(e, attribute)
+        end
+      else
+        raise HCast::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 handle_attribute_error(exception, attribute)
+    exception.add_namespace(attribute.name)
+    raise exception
+  end
+
+  def cast_attribute(attribute, hash)
+    value = get_value(hash, attribute.name)
+    if value.nil? && attribute.allow_nil?
+      nil
+    else
+      casted_value = attribute.caster.cast(value, attribute.name, attribute.options)
+      if attribute.has_children?
+        cast_children(casted_value, attribute)
+      elsif caster = attribute.options[:caster]
+        cast_children_with_caster(casted_value, attribute, caster)
+      else
+        casted_value
+      end
+    end
+  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)
+    if attribute.caster == HCast::Casters::ArrayCaster
+      value.map do |val|
+        caster.cast(val)
+      end
+    else
+      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.new("is not valid attribute name", unexpected_keys.first)
+    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, caster_name)
+      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, caster_name)
+      if !caster
+        raise HCast::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 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

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, "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, "should be a boolean"
+    end
+  end
+
+end

data/lib/hcast/casters/date_caster.rb

@@ -0,0 +1,19 @@
+require 'date'
+
+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, "is invalid date"
+      end
+    else
+      raise HCast::Errors::CastingError, "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, "is invalid datetime"
+      end
+    else
+      raise HCast::Errors::CastingError, "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, "is invalid float"
+      end
+    else
+      raise HCast::Errors::CastingError, "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, "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, "is invalid integer"
+      end
+    else
+      raise HCast::Errors::CastingError, "should be a integer"
+    end
+  end
+
+end