morf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 946b8a0940f00a90e751212769a15915f69d0ea4
+  data.tar.gz: 0c5bc2171fcfc37ab7af826cfa5fb7a5e6decf0e
+SHA512:
+  metadata.gz: b14c86eb318d49676e10f343d569a8ae5254fb092c7cf0415b02bbf588a31e1e0a231cae94425a4e711448773f081b86e1b72a628b80ac5f46ee6bd2bc879e59
+  data.tar.gz: 2f693a3dd1720b810093bfc7657ef1a6b26973fed1fed2f636d13ba98d5bc3752a2512da5d9e32402babc8cf2debf53e9f4c94eb7c8e7ab4c26aca760e051ca9

data/.gitignore

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

data/.travis.yml

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    v (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (1.4.4)
+    diff-lcs (1.3)
+    rake (12.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 1.3)
+  bundler (~> 1.3)
+  rake
+  rspec
+  v!
+
+BUNDLED WITH
+   1.15.4

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Droid Labs
+
+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 @@
+Readme comming soon.

data/Rakefile

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

data/lib/morf.rb

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

data/lib/morf/attributes_caster.rb

@@ -0,0 +1,98 @@
+class Morf::AttributesCaster
+  attr_reader :attributes, :options
+
+  def initialize(attributes, options)
+    @attributes         = attributes
+    @options            = options
+  end
+
+  def cast(input_hash, options = {})
+    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 Morf::Errors::AttributeError => e
+          e.add_namespace(attribute.name)
+          raise e
+        end
+      else
+        raise Morf::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)
+    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 == Morf::Casters::ArrayCaster
+      value.map do |val|
+        caster.cast(val, options)
+      end
+    else
+      caster.cast(value, options)
+    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 Morf::Errors::UnexpectedAttributeError.new("is not valid attribute name", unexpected_keys.first)
+    end
+  end
+
+end

data/lib/morf/attributes_parser.rb

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

data/lib/morf/caster.rb

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