parsable_hash 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-2.1.1
+  - ree
+
+before_install:
+  - gem update --system 2.1.11
+  - gem --version
+
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in parsable_hash.gemspec
+gemspec
+
+gem 'pry', :require => 'pry'
+gem 'pry-nav', :require => 'pry-nav'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Konrad Oleksiuk
+
+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,114 @@
+[![Code Climate](https://codeclimate.com/github/koleksiuk/parsable_hash.png)](https://codeclimate.com/github/koleksiuk/parsable_hash)
+[![Build Status](https://secure.travis-ci.org/koleksiuk/parsable_hash.png)](http://travis-ci.org/koleksiuk/parsable_hash)
+
+# ParsableHash
+
+Allows to parse hash values in easy way, by extending class with hash
+strategies.
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'parsable_hash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parsable_hash
+
+## Usage
+
+    class FooTx
+      include ParsableHash
+
+      parse_strategy :transaction_strategy, :date => :date, 
+                                            :amount => :big_decimal, 
+                                            :id => :integer
+
+      attr_accessor :transaction
+
+      def initialize(raw_transaction = {})
+        self.transaction = parse_hash(raw_transaction, with: :transaction_strategy) 
+      end
+    end
+
+    # Fetch transaction from e.g. queue
+    transaction = { :date => '12-12-2013', :amount => '23.22', :id => '124564' }
+
+    tx = FooTx.new(transaction)
+
+    tx.transaction #=> { :date=>#<Date: 2013-12-12 ((2456639j,0s,0n),+0s,2299161j)>, :amount=>23.22, :id=>124564 } 
+
+## Available parsers
+:big_decimal => BigDecimal
+:boolean     => Boolean
+:date        => Date
+:float       => Float
+:integer     => Integer
+:date_time   => DateTime
+:null        => default parser (if parser is missing it simply leaves value as it is)
+
+### Parsing with modules and other features
+
+    # Using strategies from other modules / classes
+    module ParseStrategies
+      include ParsableHash
+
+      parse_strategy :transaction_strategy, :date => :date, 
+                                            :amount => :big_decimal, 
+                                            :id => :integer
+    end
+
+    class FooTx
+      include ParsableHash
+
+
+      attr_accessor :transaction
+
+      def initialize(raw_transaction = {})
+        self.transaction = parse_hash(
+                                       raw_transaction,
+                                       :with  => :transaction_strategy,
+                                       :const => ParseStrategies # must be kind of module/class
+                                     )
+      end
+    end
+
+
+## Extending with own parsers
+
+    module ParsableHash
+      module Converters
+        class MyClass < Base
+          private
+
+          def try_convert
+            ::MyClass.parse_string(@value)
+          end
+        end
+      end
+    end
+
+And then use ```:my_class``` as parse strategy for key
+
+## Configuration
+    ParsableHash::Strategy.fallbacks = true # set to false if you want to raise ParsableHash::MissingStrategy if strategy doesn't exist. 
+    # In other case it is empty strategy (you can override it by adding :default to your strategies)
+
+## To-do
+* Add support for adding default values
+* Add support for configurable fallback to string if key as symbol is missing (&
+  vice-versa)
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/parsable_hash.rb

@@ -0,0 +1,49 @@
+require 'parsable_hash/version'
+require 'parsable_hash/strategies'
+require 'parsable_hash/converters/base'
+require 'parsable_hash/strategy/converter_loader'
+require 'parsable_hash/hash_strategy'
+require 'parsable_hash/parser'
+
+require 'parsable_hash/core_ext/hash/parse_with'
+
+module ParsableHash
+  NotDefinedError = Class.new(StandardError)
+
+  def self.included(klass)
+    klass.send(:include, InstanceMethods)
+    klass.extend(ClassMethods)
+  end
+
+  module InstanceMethods
+    def parse_hash(object, options = {})
+      parse_with_strategy(object, options[:with], options[:const])
+    end
+
+    private
+
+    def parse_with_strategy(hash, strategy, const = nil)
+      if const && const.is_a?(Module)
+        raise NotDefinedError.new unless const.include?(ParsableHash)
+
+        Parser.new(hash, const.parse_strategies[strategy]).call
+      else
+        Parser.new(hash, parse_strategies[strategy]).call
+      end
+    end
+
+    def parse_strategies
+      self.class.parse_strategies
+    end
+  end
+
+  module ClassMethods
+    def parse_strategy(name, options = {})
+      parse_strategies.add(name, options)
+    end
+
+    def parse_strategies
+      @strategies ||= Strategies.new
+    end
+  end
+end

data/lib/parsable_hash/converters/base.rb

@@ -0,0 +1,27 @@
+module ParsableHash
+  module Converters
+    class Base
+      def initialize(value)
+        @value = value
+      end
+
+      def call(&block)
+        try_convert
+      rescue => e
+        if block_given?
+          block.call(@value)
+        else
+          @value
+        end
+      end
+
+      protected
+
+      def try_convert
+        raise NotImplementedError.new
+      end
+    end
+  end
+end
+
+Gem.find_files("parsable_hash/converters/*.rb").delete_if {|f| f =~ /base/ }.each {|f| require f }

data/lib/parsable_hash/converters/big_decimal.rb

@@ -0,0 +1,13 @@
+require 'bigdecimal'
+
+module ParsableHash
+  module Converters
+    class BigDecimal < Base
+      private
+
+      def try_convert
+        ::BigDecimal.new(@value)
+      end
+    end
+  end
+end

data/lib/parsable_hash/converters/boolean.rb

@@ -0,0 +1,11 @@
+module ParsableHash
+  module Converters
+    class Boolean < Base
+      private
+
+      def try_convert
+        @value.to_s == "true"
+      end
+    end
+  end
+end

data/lib/parsable_hash/converters/date.rb

@@ -0,0 +1,13 @@
+require 'date' if RUBY_VERSION < '1.9.3'
+
+module ParsableHash
+  module Converters
+    class Date < Base
+      private
+
+      def try_convert
+        ::Date.parse(@value)
+      end
+    end
+  end
+end

data/lib/parsable_hash/converters/float.rb

@@ -0,0 +1,11 @@
+module ParsableHash
+  module Converters
+    class Float < Base
+      private
+
+      def try_convert
+        @value.to_f
+      end
+    end
+  end
+end

data/lib/parsable_hash/converters/integer.rb

@@ -0,0 +1,11 @@
+module ParsableHash
+  module Converters
+    class Integer < Base
+      private
+
+      def try_convert
+        @value.to_i
+      end
+    end
+  end
+end

data/lib/parsable_hash/converters/null.rb

@@ -0,0 +1,11 @@
+module ParsableHash
+  module Converters
+    class Null < Base
+      private
+
+      def try_convert
+        @value
+      end
+    end
+  end
+end

data/lib/parsable_hash/core_ext/hash/parse_with.rb

@@ -0,0 +1,11 @@
+Hash.class_eval do
+  define_method :parse_with do |object, strategy|
+    if object.is_a? Module
+      raise ParsableHash::NotDefinedError.new unless object.include?(ParsableHash)
+
+      ParsableHash::Parser.new(self, object.parse_strategies[strategy]).call
+    else
+      object.parse_hash(self, :with => strategy)
+    end
+  end
+end

data/lib/parsable_hash/hash_strategy.rb

@@ -0,0 +1,51 @@
+module ParsableHash
+  class HashStrategy
+    include Enumerable
+
+    attr_reader   :hash
+    attr_accessor :origin_hash
+
+    def initialize(strategy, origin_hash = nil)
+      @hash = prepare(strategy)
+      self.origin_hash = origin_hash
+
+      clean_for_hash!(origin_hash) unless origin_hash.nil?
+    end
+
+    def each(&block)
+      hash.each { |strategy| yield strategy }
+    end
+
+    def clean_for_hash!(value_hash)
+      @hash = clean_pairs(@hash, value_hash)
+    end
+
+    private
+
+    def prepare(hash)
+      hash.inject({}) do |h, (k, v)|
+        h[k] = if v.is_a? Hash
+                    prepare(v)
+                  else
+                    Strategy::ConverterLoader.from_value(v)
+                  end
+
+        h
+      end
+    end
+
+    def clean_pairs(strategy_hash, value_hash)
+      strategy_hash.each_pair do |key, val|
+        if value_hash[key].is_a?(Hash)
+          if val.is_a?(Hash)
+            clean_pairs(strategy_hash[key], value_hash[key])
+          else
+            strategy_hash.delete(key)
+          end
+        else
+          strategy_hash.delete(key) unless value_hash.has_key?(key)
+        end
+      end
+    end
+  end
+end

data/lib/parsable_hash/parser.rb

@@ -0,0 +1,27 @@
+module ParsableHash
+  class Parser
+    def initialize(hash, strategy)
+      @hash     = hash
+      @strategy = HashStrategy.new(strategy, @hash)
+    end
+
+    def call
+      deep_parse(@hash, @strategy.hash)
+    end
+
+    private
+    def deep_parse(hash, strategy)
+      hash.merge(strategy) do |key, val, str|
+        if val.is_a?(Hash) && str.is_a?(Hash)
+          deep_parse(val, str)
+        else
+          parse_with_strategy(val, str)
+        end
+      end
+    end
+
+    def parse_with_strategy(value, strategy)
+      strategy.call(value)
+    end
+  end
+end

data/lib/parsable_hash/strategies.rb

@@ -0,0 +1,44 @@
+module ParsableHash
+  MissingStrategy = Class.new(StandardError)
+
+  class Strategies
+    class << self
+      def fallbacks
+        @fallbacks.nil? ? true : @fallbacks
+      end
+
+      attr_writer :fallbacks
+    end
+
+    def initialize(value = {})
+      strategies[:default] = value
+    end
+
+    def [](strategy)
+      get(strategy)
+    end
+
+    def []=(strategy, value)
+      add(strategy, value)
+    end
+
+    def get(strategy)
+      _strategy = strategies[strategy.to_sym]
+
+      return _strategy           unless _strategy.nil?
+      return strategies[:default] if _strategy.nil? && self.class.fallbacks
+
+      raise MissingStrategy.new("Strategy #{strategy} is missing!")
+    end
+
+    def add(strategy, value)
+      strategies[strategy] = value
+    end
+
+    private
+
+    def strategies
+      @strategies ||= {}
+    end
+  end
+end

data/lib/parsable_hash/strategy/converter_loader.rb

@@ -0,0 +1,48 @@
+module ParsableHash
+  module Strategy
+    class ConverterLoader
+      def self.from_value(value)
+        if value.is_a? Class
+          from_class(value)
+        else
+          from_name(value)
+        end
+      end
+
+      def self.from_name(name)
+        new(name)
+      end
+
+      def self.from_class(klass)
+        new(nil, :converter => klass)
+      end
+
+      attr_accessor :klass
+
+      def initialize(name, options = {})
+        @name      = name.to_s
+        self.klass = options.fetch(:converter) { load_from_name }
+      end
+
+      def call(val)
+        klass.new(val).call
+      end
+
+      private
+
+      def load_from_name
+        klass = camelize(@name)
+
+        if ParsableHash::Converters.const_defined?(klass)
+          ParsableHash::Converters.const_get(klass)
+        else
+          ParsableHash::Converters::Null
+        end
+      end
+
+      def camelize(name)
+        name.split('_').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/parsable_hash/version.rb

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

data/parsable_hash.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parsable_hash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "parsable_hash"
+  spec.version       = ParsableHash::VERSION
+  spec.authors       = ["Konrad Oleksiuk"]
+  spec.email         = ["konole@gmail.com"]
+  spec.description   = %q{Allows to parse hash with e.g. string values to other class instances}
+  spec.summary       = %q{ParsableHash extension for classes}
+  spec.homepage      = ""
+  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{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/converters/big_decimal_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::BigDecimal do
+  describe '#call' do
+    context 'when value can be parsed' do
+      subject { described_class.new('5.3') }
+
+      it 'should return float object' do
+        expect(subject.call).to eq(BigDecimal.new('5.3'))
+      end
+    end
+
+    it_should_behave_like "with fallback"
+  end
+end
+

data/spec/converters/boolean_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::Boolean do
+  describe '#call' do
+    describe 'when value == "true"' do
+      subject { described_class.new('true') }
+
+      it 'should return true value' do
+        expect(subject.call).to eq(true)
+      end
+    end
+
+    describe 'when value != "true"' do
+      subject { described_class.new('falsy') }
+
+      it 'should return false value' do
+        expect(subject.call).to eq(false)
+      end
+    end
+  end
+end

data/spec/converters/date_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::Date do
+  describe '#call' do
+    context 'when value can be parsed' do
+      let(:date_str) { '12.12.2012' }
+      let(:date_obj) { Date.parse(date_str) }
+
+      subject { described_class.new('12.12.2012') }
+
+      it 'should return date object' do
+        expect(subject.call).to eq(date_obj)
+      end
+    end
+
+    it_should_behave_like "with fallback"
+  end
+end

data/spec/converters/float_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::Float do
+  describe '#call' do
+    context 'when value can be parsed' do
+      subject { described_class.new('5.3') }
+
+      it 'should return float object' do
+        expect(subject.call).to eq(5.3)
+      end
+    end
+
+    it_should_behave_like "with fallback"
+  end
+end

data/spec/converters/integer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::Integer do
+  describe '#call' do
+    context 'when value can be parsed' do
+      subject { described_class.new('5') }
+
+      it 'should return integer object' do
+        expect(subject.call).to eq(5)
+      end
+    end
+
+    it_should_behave_like "with fallback"
+  end
+end

data/spec/converters/null_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe ParsableHash::Converters::Null do
+  describe '#call' do
+    [3, 'test', Object.new, {}].each do |obj|
+      it "should return passed object (e.g. #{obj.class}) without any change" do
+        converter = described_class.new(obj)
+
+        expect(converter.call).to eq(obj)
+      end
+    end
+  end
+end

data/spec/dummy/module_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module DummyParsers
+  include ParsableHash
+
+  parse_strategy :rands, :int => :integer, :fl => :float, :nested => { :dt => :date }
+end
+
+class Dummy
+  include ParsableHash
+
+  parse_strategy :random_values, :int => :integer, :fl => :float, :nested => { :dt => :date }
+  parse_strategy :int, :int => :integer
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def call
+    parse_hash(@options, :with => :random_values)
+  end
+
+  def call_with_const
+    parse_hash(@options, :with => :rands, :const => DummyParsers)
+  end
+
+  def call_with_wrong_const
+    parse_hash(@options, :with => :rands, :const => Object)
+  end
+
+  def direct_call
+    @options.parse_with(self, :random_values)
+  end
+
+  def const_call
+    @options.parse_with(DummyParsers, :rands)
+  end
+end
+
+describe Dummy do
+  describe '#parse_hash' do
+    context 'when all values exist' do
+      let(:obj) { Dummy.new(:int => '3', :fl => '3.5', :nested => { :dt => str_date }) }
+      let(:str_date) { '12.12.2013' }
+      let(:obj_date) { Date.parse(str_date) }
+
+      after do
+        expect(parsed_obj_with_hash).to eq({
+          :int    => 3,
+          :fl     => 3.5,
+          :nested => { :dt => obj_date },
+        })
+      end
+
+      describe 'call' do
+        let(:parsed_obj_with_hash) { obj.call }
+
+        it 'should parse hash to values passed with given strategy' do
+        end
+      end
+
+      describe 'call with constant passed' do
+        let(:parsed_obj_with_hash) { obj.call_with_const }
+
+        it 'should parse hash to values passed with given strategy' do
+        end
+      end
+
+    end
+
+    describe 'call with wrong constant passed' do
+      let(:obj) { Dummy.new }
+
+      it 'should raise an error' do
+        expect {
+          obj.call_with_wrong_const
+        }.to raise_error(ParsableHash::NotDefinedError)
+      end
+    end
+
+    context 'when hash value is missing' do
+      let(:obj) { Dummy.new(:int => '3', :nested => { :foo => 'test' }, :bar => { :test => 'foobar' }) }
+
+      let(:parsed_obj_with_hash) { obj.call }
+      it 'should not create new key-value pair in hash' do
+        expect(parsed_obj_with_hash).to eq({
+          :int    => 3,
+          :nested => { :foo  => 'test'   },
+          :bar    => { :test => 'foobar' },
+        })
+      end
+    end
+  end
+
+  describe 'hash#parse_with' do
+    let(:str_date) { '12.12.2013' }
+    let(:obj_date) { Date.parse(str_date) }
+    let(:obj) { Dummy.new(:int => '3', :fl => '3.5', :nested => { :dt => str_date }) }
+
+    after do
+      expect(subject).to eq({
+        :int    => 3,
+        :fl     => 3.5,
+        :nested => { :dt => obj_date },
+      })
+    end
+
+    context 'with self' do
+      subject { obj.direct_call }
+      it 'should parse hash to values passed with given strategy' do
+      end
+    end
+
+    context 'with class / module' do
+      subject { obj.const_call }
+      it 'should parse hash to values passed with given strategy' do
+      end
+    end
+  end
+end
+

data/spec/hash_strategy_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe ParsableHash::HashStrategy do
+
+  let(:integer_klass) { double('integer_klass') }
+  let(:float_klass)   { double('float_klass')   }
+  let(:object_klass)  { double('object_klass') }
+
+  context 'when all values are symbols' do
+    before do
+      ParsableHash::Strategy::ConverterLoader.stub(:from_name).with(:integer) { integer_klass }
+      ParsableHash::Strategy::ConverterLoader.stub(:from_name).with(:float)   { float_klass }
+    end
+
+    subject { described_class.new(:one => :integer, :two => :float) }
+
+    it 'should replace them with callable converters' do
+      expect(subject.hash).to eq({
+        :one => integer_klass,
+        :two => float_klass,
+      })
+    end
+  end
+
+  context 'when there are direct class passed' do
+    before do
+      ParsableHash::Strategy::ConverterLoader.stub(:from_name).with(:integer) { integer_klass }
+      ParsableHash::Strategy::ConverterLoader.stub(:from_class).with(Object)  { object_klass  }
+    end
+
+    subject { described_class.new(:one => :integer, :two => Object) }
+
+    it 'should leave them as they are' do
+      expect(subject.hash).to eq({
+        :one => integer_klass,
+        :two => object_klass,
+      })
+    end
+  end
+
+  describe 'cleaning up strategy hash' do
+    it 'should be possible with passing value hash into initializer' do
+      pending
+    end
+
+    it 'should be possible by invoking directly #clean_for_hash!' do
+      pending
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'pry'
+require './lib/parsable_hash'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+Gem.find_files("support/**/*.rb").each {|f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/strategies_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ParsableHash::Strategies do
+  let(:strategies)    { described_class.new }
+  let(:foo_strategy)  { { :bar => :integer } }
+
+  describe 'on initialize' do
+    it 'should have at least default strategy' do
+      expect(strategies[:default]).to eq({})
+    end
+  end
+
+  describe 'accessing strategry' do
+
+    before { strategies.add(:new, foo_strategy) }
+
+    it 'should return strategy with array accessor' do
+      expect(strategies[:new]).to eq(foo_strategy)
+    end
+
+    describe '#get' do
+      context 'for string' do
+        it 'should return strategy' do
+          expect(strategies.get('new')).to eq(foo_strategy)
+        end
+      end
+
+      context 'for symbol' do
+        it 'should return strategy' do
+          expect(strategies.get(:new)).to eq(foo_strategy)
+        end
+      end
+    end
+  end
+
+  describe 'setting strategy' do
+    it 'should allow to set strategy with array accessor' do
+      strategies[:new] = foo_strategy
+      expect(strategies.get(:new)).to eq(foo_strategy)
+    end
+
+    it 'should allow to set strategy with #add method' do
+      strategies.add(:new, foo_strategy)
+      expect(strategies.get(:new)).to eq(foo_strategy)
+    end
+  end
+
+
+  describe 'dealing with missing strategies' do
+    context 'by default' do
+      it 'should return default strategy' do
+        expect(strategies[:foobar]).to eq({})
+      end
+    end
+
+    context 'when set fallbacks to false' do
+      before { ParsableHash::Strategies.fallbacks = false }
+      after  { ParsableHash::Strategies.fallbacks = true }
+
+      it 'should raise an error' do
+        expect { 
+          strategies[:foobar]
+        }.to raise_error(ParsableHash::MissingStrategy, "Strategy foobar is missing!")
+      end
+    end
+  end
+end

data/spec/strategy/converter_loader_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ParsableHash::Strategy::ConverterLoader do
+  let(:klass) { double('my_converter') }
+
+  before do
+    ParsableHash::Converters.stub(:const_defined?).with('MyConverter') { true }
+    ParsableHash::Converters.stub(:const_get).with('MyConverter')      { klass }
+  end
+
+  describe 'coverter loading' do
+    subject { described_class.new(:my_converter) }
+
+    it 'should load converter class from name' do
+      expect(subject.klass).to eq(klass)
+    end
+  end
+
+  describe 'calling converter' do
+    before do
+      klass.stub(:new).with('my_val').and_return(inst = double('converter_inst', :call => :my_val))
+    end
+
+    it 'should allow to load converter by passed symbol' do
+      expect(described_class.new(:my_converter).call('my_val')).to eq(:my_val)
+    end
+  end
+
+
+  it 'should allow to initialize loader with given converter' do
+    expect(described_class.from_class(klass).klass).to eq(klass)
+  end
+end

data/spec/support/converters/with_fallback.rb

@@ -0,0 +1,17 @@
+shared_examples "with fallback" do
+  context 'when value can not be parsed' do
+    subject { described_class.new([1,2]) }
+
+    describe 'and block is given' do
+      it 'should return value of called block' do
+        expect(subject.call {|x| x.count }).to eq(2)
+      end
+    end
+
+    describe 'and block is missing' do
+      it 'should return unchanged value' do
+        expect(subject.call).to eq([1,2])
+      end
+    end
+  end
+end

data/tags

@@ -0,0 +1,3 @@
+Copyright	LICENSE.txt	/^Copyright (c) 2013 Konrad Oleksiuk$/
+parsable_hash	Gemfile.lock	/^    parsable_hash (0.0.1)$/
+unshift	parsable_hash.gemspec	/^$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?/

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: parsable_hash
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Konrad Oleksiuk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-01-04 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Allows to parse hash with e.g. string values to other class instances
+email: 
+- konole@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/parsable_hash.rb
+- lib/parsable_hash/converters/base.rb
+- lib/parsable_hash/converters/big_decimal.rb
+- lib/parsable_hash/converters/boolean.rb
+- lib/parsable_hash/converters/date.rb
+- lib/parsable_hash/converters/float.rb
+- lib/parsable_hash/converters/integer.rb
+- lib/parsable_hash/converters/null.rb
+- lib/parsable_hash/core_ext/hash/parse_with.rb
+- lib/parsable_hash/hash_strategy.rb
+- lib/parsable_hash/parser.rb
+- lib/parsable_hash/strategies.rb
+- lib/parsable_hash/strategy/converter_loader.rb
+- lib/parsable_hash/version.rb
+- parsable_hash.gemspec
+- spec/converters/big_decimal_spec.rb
+- spec/converters/boolean_spec.rb
+- spec/converters/date_spec.rb
+- spec/converters/float_spec.rb
+- spec/converters/integer_spec.rb
+- spec/converters/null_spec.rb
+- spec/dummy/module_spec.rb
+- spec/hash_strategy_spec.rb
+- spec/spec_helper.rb
+- spec/strategies_spec.rb
+- spec/strategy/converter_loader_spec.rb
+- spec/support/converters/with_fallback.rb
+- tags
+has_rdoc: true
+homepage: ""
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: ParsableHash extension for classes
+test_files: 
+- spec/converters/big_decimal_spec.rb
+- spec/converters/boolean_spec.rb
+- spec/converters/date_spec.rb
+- spec/converters/float_spec.rb
+- spec/converters/integer_spec.rb
+- spec/converters/null_spec.rb
+- spec/dummy/module_spec.rb
+- spec/hash_strategy_spec.rb
+- spec/spec_helper.rb
+- spec/strategies_spec.rb
+- spec/strategy/converter_loader_spec.rb
+- spec/support/converters/with_fallback.rb