ixtlan-babel 0.4.0 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f025bd8665c42f07f792f3fb8a28331a62e47274
+  data.tar.gz: 4c3df0b63c0574acc37ec06cd33e9f18e0c1c809
+SHA512:
+  metadata.gz: 8b5267f3135e38b8053da3d39a30a87093ccd11f0c9e2837c3264b346dffd96613a17031f3d6ef5e98a34657652475452f12c96bcdcc81484f21021f01ce2dec
+  data.tar.gz: f1be049f637b3dd246fb4f8353f71662e3e3bfd8fe806d3514c82b74f80e839723ed9345b4d5e2cce38c6d290397d2f9eaf59bd36b7bfcff3d61b2bc6713a494

data/Gemfile

@@ -2,5 +2,5 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem  'copyright-header', '~> 1.0', :platform => :mri
+gem  'copyright-header', '~> 1.0', :platform => :mri, :group => :copyright
 

data/lib/ixtlan/babel/hash_filter.rb

@@ -51,8 +51,10 @@ module Ixtlan
             result[ k ] = filter_data( v,
                                        context[ k ] ) if context.include?( k )
           when Array
-            result[ k ] = filter_array( v,
-                                        context[ k ] ) if context.include?( k )
+            if context.allowed?( k ) || context.include?( k )
+              result[ k ] = filter_array( v,
+                                          context[ k ] )
+            end
           else
             result[ k ] = serialize( v ) if context.allowed?( k )
           end

data/lib/ixtlan/babel/params_filter.rb

@@ -45,12 +45,42 @@ module Ixtlan
         config.default_context_key(default)
       end
 
-      def self.add_context(key, options = {})
-        config[key] = options
+      def self.add_context( key = :single, options = nil, &block )
+        current = config[key] = options || { :only => [] }
+        @context = key
+        yield if block
+        current[ :keep ] = @keep if @keep
+        current.merge!( @allow ) if @allow
+        current[ :root ] = @root
+      ensure
+        @context = nil
+	@allow = nil
+	@keep = nil
+        @root = nil
       end
 
       def self.root( root )
-        config.root = root
+        if @context
+          @root = root
+        else
+          config.root = root
+        end
+      end
+
+      def self.keep( *args )
+        @keep = *args
+      end
+
+      def self.only( *args )
+        result = {}
+        if args.last.is_a? Hash
+          result[ :include ] = args.last
+          result[ :only ] = args[ 0..-2 ]
+        else
+          result[ :only ] = args
+        end
+        @allow = result
+        result
       end
 
       public
@@ -72,6 +102,10 @@ module Ixtlan
           @model.send( :new, params )
         end
 
+        def []( key )
+           params[ key ]
+        end
+
         def params
           @data[ :params ]
         end
@@ -105,6 +139,8 @@ module Ixtlan
         ( filter.options[ :keep ] || [] ).each do |k|
           keeps[ k.to_s ] = filtered_data.delete( k.to_s ) ||
             filtered_data.delete( k.to_sym ) unless keeps.member?( k.to_s )
+          # just make sure we have an entry for each keeps key
+          keeps[ k.to_s ] ||= nil
         end
         FilterResult.new( @model_class, filtered_data, keeps )
       end

data/lib/ixtlan/babel/serializer.rb

@@ -77,12 +77,37 @@ module Ixtlan
         config.default_context_key(single, collection)
       end
 
-      def self.add_context(key, options = {})
-        config[key] = options
+      def self.add_context(key = :single, options = nil, &block)
+        current = config[key] = options || { :only => Array.new }
+	@only = nil
+        @root = nil
+        @context = key
+        yield if block
+        current.merge!( @only ) if @only
+        current[ :root ] = @root
+      ensure
+        @context = nil
+      end
+      
+      def self.only( *args )
+        args.flatten!
+        result = { :only => Array.new }
+        if args.last.is_a? Hash
+          result[ :include ] = args.last
+          result[ :methods ] = args[ 0..-2 ]
+        else
+          result[ :methods ] = args
+        end
+        @only = result
+        result
       end
 
       def self.root( root )
-        config.root = root
+        if @context
+          @root = root
+        else
+          config.root = root
+        end
       end
 
       public

data/spec/hash_filter_spec.rb

@@ -4,7 +4,7 @@ class Hash
   def attributes
     self
   end
-  def method_missing(method)
+  def method_missing(method, *args)
     self[method.to_s]
   end
 end

data/spec/model_filter_with_dsl_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+require 'virtus'
+
+class Address2
+  include Virtus
+
+  attribute :street, String
+  attribute :zipcode, String
+end
+class Area2
+  include Virtus
+
+  attribute :code, String
+  attribute :iso, String
+end
+class PhoneNumber2
+  include Virtus
+
+  attribute :prefix, Integer
+  attribute :number, String
+  attribute :area, Area2
+end
+class Person2
+  include Virtus
+
+  attribute :id, String
+  attribute :name, String
+  attribute :address, Address2
+
+  attr_accessor :phone_numbers, :age, :children_names
+
+  def phone_numbers
+    @phone_numbers ||= [PhoneNumber2.new(
+        :prefix => 12,
+        :number => '123',
+        :area => Area2.new( :code => '001', :iso => 'us' ) )]
+  end
+
+  def age
+    @age ||= 123
+  end
+
+  def children_names
+    @children_names ||= ['anna', 'jack', 'rama', 'mia']
+  end
+
+  def children_ages
+    @children_ages ||= [12, 3, 6, 9]
+  end
+end
+
+describe Ixtlan::Babel::ModelFilter.to_s + ':with_methods' do
+  let( :person ) do
+   Person2.new( :id => 987,
+                         :name => 'me and the corner',
+                         :address => Address2.new( :street => 'Foo 12',
+                                                   :zipcode => '12345' ) )
+  end
+
+  let( :serializer ) { factory.new_serializer( person ) }
+
+  let( :factory ) { Ixtlan::Babel::Factory.new }
+
+  it 'should serialize and deserialize with methods' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :nested ) do
+        only :id, :name, :age, :children_names, :children_ages
+      end
+    end
+    json = serializer.use( :nested ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                            "name"=>"me and the corner",
+                            "age"=>123,
+                            "children_names"=> [ "anna",
+                                                 "jack",
+                                                 "rama",
+                                                 "mia" ],
+                            "children_ages"=>[ 12, 3, 6, 9 ] ]
+  end
+
+  it 'should serialize and deserialize without root' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :plain ) do
+        only :id, :name
+      end
+    end
+    json = serializer.use( :plain ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ]
+  end
+
+  it 'should serialize and deserialize with root' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :root ) do
+        root 'my'
+        only :id, :name
+      end
+    end
+    json = serializer.use( :root ).to_json
+    result = MultiJson.load(json)[ 'my' ]
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ]
+  end
+
+  it 'should serialize and deserialize a hash with include list' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :deep_nested) do
+        only( :id, :name, 
+              :address => only( :street, :zipcode ),
+              :phone_numbers => only( :prefix, :number ) )
+      end
+    end
+    json = serializer.use( :deep_nested ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ,
+                            "address"=> {
+                              "street"=>"Foo 12",
+                              "zipcode"=>"12345"
+                            },
+                            "phone_numbers"=> [ { "prefix"=>12,
+                                                  "number"=>"123" } ] ]
+  end
+
+  it 'should serialize and deserialize with only' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :only ) do
+        only :name
+      end
+    end
+    json = serializer.use( :only ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "name"=>"me and the corner" ]
+  end
+
+  it 'should serialize and deserialize with nested only' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :nested_only ) do
+        only :address => only( :street )
+      end
+    end
+    json = serializer.use( :nested_only ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "address"=> {
+                              "street"=>"Foo 12"
+                            } ]
+  end
+
+  it 'should serialize and deserialize with nested include' do
+    class Person2Serializer < Ixtlan::Babel::Serializer
+      add_context( :nested_deep ) do
+        only( :id, :name,
+              :address => only( :street, :zipcode ),
+              :phone_numbers => only( :prefix, 
+                                      :number, 
+                                      :area => only( :code, :iso) ) )
+      end
+    end
+    json = serializer.use( :nested_deep ).to_json
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ,
+                            "address"=> {
+                              "street"=>"Foo 12",
+                              "zipcode"=>"12345"
+                            },
+                            "phone_numbers"=> [ { "prefix"=>12,
+                                                  "number"=>"123",
+                                                  "area"=> {
+                                                    "code"=>"001",
+                                                    "iso"=>"us"
+                                                  }
+                                                } ] ]
+  end
+end

data/spec/params_filter_dsl_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'ixtlan/babel/params_filter'
+
+class A; end
+class AFilter < Ixtlan::Babel::ParamsFilter
+
+end
+
+class Hash
+  def attributes
+    self
+  end
+  def method_missing(method)
+    self[method.to_s]
+  end
+end
+
+describe Ixtlan::Babel::ParamsFilter do
+  let(:data) do
+    {
+      'id' => 987,
+      'name' => 'me and the corner',
+      'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
+      'list' => [1,2,3,4],
+      'phone_numbers' => {
+        'prefix' => 12,
+        'number' => '123',
+        'area' => { 'code' => '001', 'iso' => 'us'}
+      }
+    }
+  end
+
+  let(:factory) { Ixtlan::Babel::Factory.new }
+  let(:filter) { factory.new_filter( A ) }
+  let(:deserializer) { Ixtlan::Babel::Deserializer.new(Hash) }
+
+  it 'should filter a hash' do
+    AFilter.add_context( :plain )
+    result = filter.use( :plain ).filter_it( data )
+    result.params.must_equal Hash[]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with keep' do
+    class AFilter
+      add_context( :keep ) do
+        keep :id
+      end
+    end
+    result = filter.use( :keep ).filter_it( data )
+    result.params.must_equal Hash[]
+    result.id.must_equal data['id']
+    result.size.must_equal 2
+  end
+
+  it 'should filter a hash with root' do
+    class AFilter
+      add_context( :root ) do
+        root 'my'
+        only :id, :name
+      end
+    end
+    result = filter.use( :root ).filter_it( 'my' => data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a nested object' do
+    class AFilter
+      add_context( :nested ) do
+        only( :id, :name,
+              :address => only( :street, :zipcode),
+              :phone_numbers => only( :prefix, :number ) )
+      end
+    end
+    result = filter.use( :nested ).filter_it( data )
+
+    data['phone_numbers'].delete('area')
+    data.delete('list')
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with only' do
+    class AFilter
+      add_context( :only ) do
+        only :name
+      end
+    end
+    result = filter.use( :only ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with only and keep' do
+    class AFilter
+      add_context( :only_and_keep ) do
+        keep :id
+        only :name
+      end
+    end
+    result = filter.use( :only_and_keep ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.id.must_equal data['id']
+    result.size.must_equal 2
+  end
+
+  it 'should filter a hash with nested only' do
+    class AFilter
+      add_context( :filtered_nested ) do
+        only :id, :name, :list, :address => only( :street )
+      end
+    end
+    result = filter.use( :filtered_nested ).filter_it( data )
+    data.delete('phone_numbers')
+    data['address'].delete('zipcode')
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with deep nested include' do
+    class AFilter
+      add_context( :deep_nested ) do
+        only( :id, :name, :list,
+              :address => only( :street, :zipcode), 
+              :phone_numbers => only( :prefix, :number,
+                                      :area => only( :code, :iso ) ) )
+      end
+    end
+    result = filter.use( :deep_nested ).filter_it( data )
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+end

data/spec/params_filter_dsl_spec.rb~

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'ixtlan/babel/params_filter'
+
+class A; end
+class AFilter < Ixtlan::Babel::ParamsFilter
+
+end
+
+class Hash
+  def attributes
+    self
+  end
+  def method_missing(method)
+    self[method.to_s]
+  end
+end
+
+describe Ixtlan::Babel::ParamsFilter do
+  let(:data) do
+    {
+      'id' => 987,
+      'name' => 'me and the corner',
+      'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
+      'phone_numbers' => {
+        'prefix' => 12,
+        'number' => '123',
+        'area' => { 'code' => '001', 'iso' => 'us'}
+      }
+    }
+  end
+
+  let(:factory) { Ixtlan::Babel::Factory.new }
+  let(:filter) { factory.new_filter( A ) }
+  let(:deserializer) { Ixtlan::Babel::Deserializer.new(Hash) }
+
+  it 'should filter a hash' do
+    result = filter.filter_it( data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with keep' do
+    result = filter.use( :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash[ 'name' => data['name'] ]
+    result.id.must_equal data['id']
+    result.size.must_equal 2
+  end
+
+  it 'should filter a hash with root' do
+    result = filter.use( :root => 'my' ).filter_it( 'my' => data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with include list' do
+    result = filter.use( :include => ['address',
+                                    'phone_numbers'] ).filter_it( data )
+
+    data['phone_numbers'].delete('area')
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with except' do
+    result = filter.use( :except => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with except and keep' do
+    result = filter.use( :except => ['id'], :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.id.must_equal data['id']
+  end
+
+  it 'should filter a hash with only' do
+    result = filter.use( :only => ['name'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with only and keep' do
+    result = filter.use( :only => ['name'], :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.id.must_equal data['id']
+    result.size.must_equal 2
+  end
+
+  it 'should filter a hash with nested only' do
+    result = filter.use( :include => { 'address' =>
+                         {:only => ['street']}} ).filter_it( data )
+    data.delete('phone_numbers')
+    data['address'].delete('zipcode')
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with nested except' do
+    result = filter.use( :include => { 'address' =>
+                         {:except => ['zipcode']}} ).filter_it( data )
+    data.delete('phone_numbers')
+    data['address'].delete('zipcode')
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+
+  it 'should filter a hash with nested include' do
+    result = filter.use( :include => { 'address' => {}, 'phone_numbers' =>
+                         { :include => ['area']}} ).filter_it( data )
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
+  end
+end

data/spec/params_filter_spec.rb

@@ -42,7 +42,7 @@ describe Ixtlan::Babel::ParamsFilter do
   it 'should filter a hash with keep' do
     result = filter.use( :keep => ['id'] ).filter_it( data )
     result.params.must_equal Hash[ 'name' => data['name'] ]
-    result[ 'id' ].must_equal data['id']
+    result.id.must_equal data['id']
     result.size.must_equal 2
   end
 
@@ -70,7 +70,7 @@ describe Ixtlan::Babel::ParamsFilter do
   it 'should filter a hash with except and keep' do
     result = filter.use( :except => ['id'], :keep => ['id'] ).filter_it( data )
     result.params.must_equal Hash['name' => data['name']]
-    result['id'].must_equal data['id']
+    result.id.must_equal data['id']
   end
 
   it 'should filter a hash with only' do
@@ -82,7 +82,7 @@ describe Ixtlan::Babel::ParamsFilter do
   it 'should filter a hash with only and keep' do
     result = filter.use( :only => ['name'], :keep => ['id'] ).filter_it( data )
     result.params.must_equal Hash['name' => data['name']]
-    result[ 'id' ].must_equal data['id']
+    result.id.must_equal data['id']
     result.size.must_equal 2
   end
 

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $LOAD_PATH << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+gem 'minitest'
 require 'minitest/autorun'
 require 'json'
 require 'ixtlan-babel'

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: ixtlan-babel
 version: !ruby/object:Gem::Version
-  version: 0.4.0
-  prerelease:
+  version: 0.5.0
 platform: ruby
 authors:
 - Christian Meier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2013-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
-    none: false
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
   name: minitest
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.0'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '4.0'
-    none: false
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
   name: virtus
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.5'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.5'
-    none: false
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
   name: multi_json
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-    none: false
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
   name: json
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
-    none: false
   prerelease: false
   type: :development
 description: babel offers a filter for hashes and with that comes json/yaml/xml de/serialization of models which provides a hash representationi. possible models are activerecord, activemodel, resources from datamapper, virtus
@@ -99,68 +88,70 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ixtlan-babel.rb
-- lib/ixtlan/babel/dm_validation_errors_serializer.rb~
-- lib/ixtlan/babel/context.rb~
-- lib/ixtlan/babel/filter_config.rb~
-- lib/ixtlan/babel/context.rb
-- lib/ixtlan/babel/hash_only_filter.rb~
-- lib/ixtlan/babel/hash_filter.rb
-- lib/ixtlan/babel/abstract_filter.rb~
-- lib/ixtlan/babel/serializer.rb~
-- lib/ixtlan/babel/serializer.rb
-- lib/ixtlan/babel/factory.rb~
 - lib/ixtlan/babel/config.rb~
+- lib/ixtlan/babel/filter_config.rb
+- lib/ixtlan/babel/params_filter.rb~
+- lib/ixtlan/babel/model_filter.rb
+- lib/ixtlan/babel/dm_validation_errors_serializer.rb~
+- lib/ixtlan/babel/hash_filter.rb~
 - lib/ixtlan/babel/params_filter.rb
+- lib/ixtlan/babel/serializer.rb~
 - lib/ixtlan/babel/factory.rb
+- lib/ixtlan/babel/abstract_filter.rb~
+- lib/ixtlan/babel/hash_only_filter.rb~
+- lib/ixtlan/babel/context.rb
+- lib/ixtlan/babel/dm_validation_errors_serializer.rb
 - lib/ixtlan/babel/model_filter.rb~
-- lib/ixtlan/babel/model_filter.rb
-- lib/ixtlan/babel/params_filter.rb~
-- lib/ixtlan/babel/filter_config.rb
+- lib/ixtlan/babel/serializer.rb
+- lib/ixtlan/babel/filter_config.rb~
+- lib/ixtlan/babel/context.rb~
 - lib/ixtlan/babel/abstract_filter.rb
-- lib/ixtlan/babel/dm_validation_errors_serializer.rb
-- lib/ixtlan/babel/hash_filter.rb~
-- spec/model_filter_spec.rb
+- lib/ixtlan/babel/factory.rb~
+- lib/ixtlan/babel/hash_filter.rb
+- spec/params_filter_dsl_spec.rb
+- spec/model_filter_spec.rb~
+- spec/params_filter_spec.rb~
+- spec/model_filter_with_methods_spec.rb~
 - spec/params_filter_spec.rb
-- spec/model_filter_with_methods_spec.rb
+- spec/params_filter_dsl_spec.rb~
 - spec/hash_filter_spec.rb~
+- spec/model_filter_with_dsl_spec.rb
+- spec/model_filter_with_methods_spec.rb
 - spec/spec_helper.rb
-- spec/model_filter_with_methods.spec.rb~
-- spec/params_filter_spec.rb~
 - spec/hash_filter_spec.rb
-- spec/model_filter_with_methods_spec.rb~
-- spec/model_filter_spec.rb~
+- spec/model_filter_with_methods.spec.rb~
+- spec/model_filter_spec.rb
 - MIT-LICENSE
 - README.md
 - Gemfile
 homepage: https://github.com/mkristian/ixtlan-babel
 licenses:
 - MIT
+metadata: {}
 post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 1.8.24
+rubygems_version: 2.1.9
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: babel offers a filter for hashes and with that comes json/yaml/xml de/serialization of models which provides a hash representation
 test_files:
-- spec/model_filter_spec.rb
+- spec/params_filter_dsl_spec.rb
 - spec/params_filter_spec.rb
+- spec/model_filter_with_dsl_spec.rb
 - spec/model_filter_with_methods_spec.rb
 - spec/hash_filter_spec.rb
+- spec/model_filter_spec.rb