morf 0.0.1

data/lib/morf/casters.rb

@@ -0,0 +1,13 @@
+# List of build in casters
+module Morf::Casters
+  require 'morf/casters/array_caster'
+  require 'morf/casters/boolean_caster'
+  require 'morf/casters/date_caster'
+  require 'morf/casters/datetime_caster'
+  require 'morf/casters/float_caster'
+  require 'morf/casters/hash_caster'
+  require 'morf/casters/integer_caster'
+  require 'morf/casters/string_caster'
+  require 'morf/casters/symbol_caster'
+  require 'morf/casters/time_caster'
+end

data/lib/morf/casters/array_caster.rb

@@ -0,0 +1,30 @@
+class Morf::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 Morf::Errors::CastingError, "should be an array"
+    end
+  end
+
+  private
+
+  def self.cast_array_items(array, attr_name, options)
+    caster_name = options[:each]
+    caster = Morf.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 Morf::Errors::CasterNotFoundError, "caster with name #{caster_name} is not found"
+    end
+  end
+end

data/lib/morf/casters/boolean_caster.rb

@@ -0,0 +1,13 @@
+class Morf::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 Morf::Errors::CastingError, "should be a boolean"
+    end
+  end
+end

data/lib/morf/casters/date_caster.rb

@@ -0,0 +1,17 @@
+require 'active_support/core_ext/date'
+
+class Morf::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 Morf::Errors::CastingError, "is invalid date"
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a date"
+    end
+  end
+end

data/lib/morf/casters/datetime_caster.rb

@@ -0,0 +1,17 @@
+class Morf::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 Morf::Errors::CastingError, "is invalid datetime"
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a datetime"
+    end
+  end
+end

data/lib/morf/casters/float_caster.rb

@@ -0,0 +1,15 @@
+class Morf::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 Morf::Errors::CastingError, "is invalid float"
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a float"
+    end
+  end
+end

data/lib/morf/casters/hash_caster.rb

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

data/lib/morf/casters/integer_caster.rb

@@ -0,0 +1,15 @@
+class Morf::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 Morf::Errors::CastingError, "is invalid integer"
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a integer"
+    end
+  end
+end

data/lib/morf/casters/string_caster.rb

@@ -0,0 +1,11 @@
+class Morf::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 Morf::Errors::CastingError, "should be a string"
+    end
+  end
+end

data/lib/morf/casters/symbol_caster.rb

@@ -0,0 +1,17 @@
+class Morf::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 Morf::Errors::CastingError, "is too long to be a symbol"
+      else
+        value.to_sym
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a symbol"
+    end
+  end
+end

data/lib/morf/casters/time_caster.rb

@@ -0,0 +1,17 @@
+require 'time'
+
+class Morf::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 Morf::Errors::CastingError, "is invalid time"
+      end
+    else
+      raise Morf::Errors::CastingError, "should be a time"
+    end
+  end
+end

data/lib/morf/concern.rb

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

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

data/lib/morf/errors.rb

@@ -0,0 +1,67 @@
+module Morf::Errors
+
+  # Base error class for all Morf errors
+  class MorfError            < StandardError; end
+
+  # Raised when caster with given name is not registered in Morf
+  class CasterNotFoundError   < MorfError;    end
+
+  # Raised when some of the given to Morf argument is not valid
+  class ArgumentError         < MorfError;    end
+
+  class AttributeError < MorfError
+    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
+
+  # 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/morf/metadata/attribute.rb

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

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

data/morf.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'morf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "morf"
+  spec.version       = Morf::VERSION
+  spec.authors       = ["Droid Labs LLC"]
+  spec.email         = ["droid@droidlabs.pro"]
+  spec.description   = %q{Declarative object morpher}
+  spec.summary       = %q{Declarative object morher}
+  spec.homepage      = "https://github.com/droidlabs/morf"
+  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 "activesupport", "~> 1.3"
+  spec.add_development_dependency "rake"
+end