vellam 0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    vellam (0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json_pure (1.6.1)
+    minitest (2.11.3)
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json_pure (~> 1.6.1)
+  minitest (= 2.11.3)
+  rake (= 0.9.2.2)
+  vellam!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Kristian Meier
+
+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,11 @@
+[![Build Status](https://secure.travis-ci.org/mkristian/babel.png)](http://travis-ci.org/mkristian/babel)
+
+# babel #
+
+rails comes with `to_json` and `to_xml` on models and you can give them an option map to control how the whole object tree gets serialized.
+
+the first problem I had was that I needed serveral options map at different controllers/actions so I needed a place to store them. the model itself felt to be the wrong place.
+
+the next problem was that I could include the result of a given method with `:methods => ['age']` but only on the root level of the object tree. but if I wanted to `age` method to be part of the serialization somewhere deep inside the object tree, it is not possible.
+
+please have a look at **spec/filter_spec.rb** how to use it :)

data/lib/babel.rb

@@ -0,0 +1,2 @@
+require 'babel/serializer'
+require 'babel/deserializer'

data/lib/babel.rb~

@@ -0,0 +1,2 @@
+require 'babel/serializer'
+require 'babel/factory'

data/lib/babel/deserializer.rb

@@ -0,0 +1,63 @@
+module Babel
+  class Deserializer
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    private
+
+    def self.filter
+      @filter ||= HashFilter.new
+    end
+
+    def filter
+      @filter ||= self.class.filter.dup
+    end
+
+    protected
+
+    def self.default_context_key(default)
+      filter.default_context_key(default)
+    end
+
+    def self.add_context(key, options = {})
+      filter[key] = options
+    end
+
+    public
+
+    def use(context_or_options)
+      filter.use(context_or_options)
+      self
+    end
+
+    def from_hash(data, options = nil)
+      filter.use(options) if options
+      if root = filter.options[:root]
+        if data.is_a? Array
+          root = root.to_s
+          data.collect{ |d| @model_class.new(filter.filter(d[root])) }
+        else
+          @model_class.new(filter.filter(data[root.to_s]))
+        end
+      else
+        if data.is_a? Array
+          data.collect{ |d| @model_class.new(filter.filter(d)) }
+        else
+          @model_class.new(filter.filter(data))
+        end
+      end
+    end
+
+    def from_json(json, options = nil)
+      data = JSON.parse(json)
+      from_hash(data, options)
+    end
+    
+    def from_yaml(yaml, options = nil)
+      data = YAML.load_stream(StringIO.new(yaml)).documents
+      from_hash(data, options)
+    end
+  end
+end

data/lib/babel/deserializer.rb~

@@ -0,0 +1,16 @@
+class Babel::Deserializer
+
+  def initialize(model_class)
+    @model_class = model_class
+  end
+
+  def from_json(json)
+    data = JSON.parse(json)
+    if data.is_a? Array
+      data.collect{ |d| @model_class.new(d) }
+    else
+      @model_class.new(data)
+    end
+  end
+
+end

data/lib/babel/factory.rb~

@@ -0,0 +1,27 @@
+class Babel::Factory
+
+  def initialize(options = {})
+    @options = options
+  end
+    
+  def serializer(model_class, serializer_class = nil)
+    @serializers[model_class] = serializer_class  if serializer_class
+    @serializers[model_class] ||= ("#{model_class}Serializer".to_const rescue Babel::Serializer)
+  end
+
+  def deserializer(model_class, deserializer_class = nil)
+    @deserializers[model_class] = deserializer_class  if deserializer_class
+    @serializers[model_class] ||= Deserializer.new(model_class)
+  end
+
+  def to_json(model_or_models, options = {})
+    if model_or_models.is_a? Array
+      json = model_or_models.collect do |m| 
+        serializer(m.class).new(m).to_json(@options.merge(options))
+      end
+      "[#{json.join(',')}]"
+    else
+      serializer(model_or_models.class).new(model_or_models).to_json(@options.merge(options))
+    end
+  end
+end

data/lib/babel/hash_filter.rb

@@ -0,0 +1,126 @@
+module Babel
+  class HashFilter
+
+    def initialize(context_or_options = nil)
+      use(context_or_options)
+    end
+    
+    private
+
+    def context
+      @context ||= {}
+    end
+
+    public
+
+    def default_context_key(default = nil)
+      @default = default if default
+      @default
+    end
+
+    def []=(key, options)
+      context[key.to_sym] = options if key
+    end
+
+    def [](key)
+      context[key.to_sym] if key
+    end
+
+    def use(context_or_options)
+      if context_or_options
+        case context_or_options
+        when Symbol  
+          if opts = context[context_or_options]
+            @options = opts.dup
+          end
+        when Hash
+          @options = context_or_options
+        end
+      else
+        @options = nil
+      end
+      self
+    end
+
+    NO_MODEL = Object.new
+    def NO_MODEL.send(*args)
+      self
+    end
+
+    def filter(hash = {}, model = NO_MODEL, &block)
+      filter_data(model, hash, options, &block) if hash
+    end
+
+    def options
+      @options || context[default_context_key] || {}
+    end
+
+    private
+
+    def filter_data(model, data, options = {}, &block)
+      only = options[:only].collect { |o| o.to_s } if options[:only]
+      except = (options[:except] || []).collect { |e| e.to_s }
+
+      include =
+        case options[:include]
+        when Array
+          options[:include].collect { |i| i.to_s }
+        when Hash
+          Hash[options[:include].collect {|k,v| [k.to_s, v]}]
+        else
+          []
+        end
+      if model != NO_MODEL
+        methods = (options[:methods] || []).collect { |e| e.to_s }
+        methods.each do |m|
+          data[m] = model.send(m.to_sym)
+        end
+
+        include_methods = include.is_a?(Array) ? include : include.keys 
+        include_methods.each do |m|
+          unless data.include?(m)
+            raise "no block given to calculate the attributes from model" unless block
+            models_or_model = model.send(m)
+            if models_or_model.respond_to?(:collect)
+              data[m] = models_or_model.collect { |i| block.call(i) }
+            else
+              data[m]= block.call(model.send(m))
+            end
+          end
+        end
+      end
+      methods ||= []
+
+      result = {}
+      data.each do |k,v|
+        case v
+        when Hash
+          if include.include?(k)
+            case include
+            when Array
+              result[k] = filter_data(model.send(k), v, &block)
+            when Hash
+              result[k] = filter_data(model.send(k), v, include[k], &block)
+            end
+          end
+        when Array
+          if include.include?(k)
+            models = model.send(k)
+            case include
+            when Array
+              result[k] = v.enum_with_index.collect { |i, j| filter_data(models[j], i, &block) }
+            when Hash
+              opts = include[k]
+              result[k] = v.enum_with_index.collect { |i, j| filter_data(models[j], i, opts, &block) }
+            end
+          end
+        else
+          if methods.include?(k) || (only && only.include?(k)) || (only.nil? && !except.include?(k))
+            result[k] = v
+          end
+        end
+      end
+      result
+    end
+  end
+end

data/lib/babel/hash_filter.rb~

@@ -0,0 +1,120 @@
+class HashFilter
+
+  def initialize(flavor = nil)
+    use(flavor)
+  end
+  
+  private
+
+  def context
+    @context ||= {}
+  end
+
+  public
+
+  def default_key(default = nil)
+    @default = default if default
+    @default
+  end
+
+  def []=(key, options)
+    context[key.to_sym] = options if key
+  end
+
+  def [](key)
+    context[key.to_sym] if key
+  end
+
+  def use(context_or_options)
+    case context_or_options
+    when Symbol  
+      if opts = context[context_or_options]
+        @options = opts.dup
+      end
+    when Hash
+      @options = context_or_options
+    end
+    self
+  end
+
+  NO_MODEL = Object.new
+  def NO_MODEL.send(*args)
+    self
+  end
+
+  def filter(params = {}, model = NO_MODEL, &block)
+    filter_data(model, params, options, &block) if params
+  end
+
+  def options
+    @options || context[default_key] || {}
+  end
+
+  private
+
+  def filter_data(model, data, options = {}, &block)
+    only = options[:only].collect { |o| o.to_s } if options[:only]
+    except = (options[:except] || []).collect { |e| e.to_s }
+
+    include =
+      case options[:include]
+      when Array
+        options[:include].collect { |i| i.to_s }
+      when Hash
+        Hash[options[:include].collect {|k,v| [k.to_s, v]}]
+      else
+        []
+      end
+    if model != NO_MODEL
+      methods = (options[:methods] || []).collect { |e| e.to_s }
+      methods.each do |m|
+        data[m] = model.send(m.to_sym)
+      end
+
+      include_methods = include.is_a?(Array) ? include : include.keys 
+      include_methods.each do |m|
+        unless data.include?(m)
+          raise "no block given to calculate the attributes from model" unless block
+          models_or_model = model.send(m)
+          if models_or_model.respond_to?(:collect)
+            data[m] = models_or_model.collect { |i| block.call(i) }
+          else
+            data[m]= block.call(model.send(m))
+          end
+        end
+      end
+    end
+    methods ||= []
+
+    result = {}
+    data.each do |k,v|
+      case v
+      when Hash
+        if include.include?(k)
+          case include
+          when Array
+            result[k] = filter_data(model.send(k), v, &block)
+          when Hash
+            result[k] = filter_data(model.send(k), v, include[k], &block)
+          end
+        end
+      when Array
+        if include.include?(k)
+          models = model.send(k)
+          case include
+          when Array
+            result[k] = v.enum_with_index.collect { |i, j| filter_data(models[j], i, &block) }
+          when Hash
+            opts = include[k]
+            result[k] = v.enum_with_index.collect { |i, j| filter_data(models[j], i, opts, &block) }
+          end
+        end
+      else
+        if methods.include?(k) || (only && only.include?(k)) || (only.nil? && !except.include?(k))
+          result[k] = v
+        end
+      end
+    end
+    result
+  end
+end

data/lib/babel/serializer.rb

@@ -0,0 +1,102 @@
+require 'babel/hash_filter'
+module Babel
+  class Serializer
+
+    def initialize(model_or_models)
+      @model_or_models = model_or_models
+    end
+    
+    def respond_to?(method)
+      @model_or_models.respond_to?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      @model_or_models.send(method, *args, &block)
+    end
+    
+    private
+
+    def self.filter
+      @filter ||= HashFilter.new
+    end
+
+    def filter
+      @filter ||= self.class.filter.dup
+    end
+
+    protected
+
+    # for rails
+    def self.model(model = nil)
+      @model_class = model if model
+      @model_class ||= self.to_s.sub(/Serializer$/, '').constantize
+    end
+
+    # for rails
+    def self.model_name
+      model.model_name
+    end
+
+    def self.default_context_key(default)
+      filter.default_context_key(default)
+    end
+
+    def self.add_context(key, options = {})
+      filter[key] = options
+    end
+
+    public
+
+    def use(context_or_options)
+      filter.use(context_or_options)
+      self
+    end
+
+    def to_hash(options = nil)
+      filter.use(options) if options
+      case @model_or_models
+      when Array
+        @model_or_models.collect do |m|
+          filter_model(attr(m), m)
+        end
+      else
+        filter_model(attr(@model_or_models), @model_or_models)
+      end
+    end
+
+    def to_json(options = nil)
+      to_hash(options).to_json
+    end
+
+    def to_xml(options = nil)
+      opts = fitler.options.dup
+      root = opts.delete :root
+      fitler.use(opts)
+      result = to_hash
+      if root && result.is_a?(Array) && root.respond_to?(:pluralize)
+        root = root.to_s.pluralize
+      end
+      result.to_xml :root => root
+    end
+
+    def to_yaml(options = nil)
+      to_hash(options).to_yaml
+    end
+    
+    protected
+
+    def attr(model)
+      model.attributes if model
+    end
+
+    private
+
+    def filter_model(model, data)
+      if root = filter.options[:root]
+        {root.to_s => filter.filter(model, data){ |model| attr(model) } }
+      else
+        filter.filter(model, data){ |model| attr(model) }
+      end
+    end 
+  end
+end

data/lib/babel/serializer.rb~

@@ -0,0 +1,101 @@
+require 'hash_filter'
+class Serializer
+
+  def initialize(model_or_models)
+    @model_or_models = model_or_models
+  end
+  
+  def respond_to?(method)
+    @model_or_models.respond_to?(method)
+  end
+
+  def method_missing(method, *args, &block)
+    @model_or_models.send(method, *args, &block)
+  end
+  
+  private
+
+  def self.filter
+    @filter ||= HashFilter.new
+  end
+
+  def filter
+    self.class.filter
+  end
+
+  def self.views
+    @views ||= {}
+  end
+
+  protected
+
+  def self.model(model = nil)
+    @model_class = model if model
+    @model_class ||= self.to_s.sub(/Presenter$/, '').constantize
+  end
+
+  def self.model_name
+    model.model_name
+  end
+
+  def self.default(default)
+    filter.default_key(default)
+  end
+
+  def self.add_view(key, options = {})
+    filter[key] = options
+  end
+
+  public
+
+  def use(flavor)
+    filter.use(flavor)
+    self
+  end
+
+  def to_hash(options = nil)
+    case @model_or_models
+    when Array
+      @model_or_models.collect do |m|
+        filter_model(attr(m), m)
+      end
+    else
+      filter_model(attr(@model_or_models), @model_or_models)
+    end
+  end
+
+  def to_json(options = nil)
+    to_hash(options).to_json
+  end
+
+  def to_xml(options = nil)
+    opts = fitler.options.dup
+    root = opts.delete :root
+    fitler.use(opts)
+    result = to_hash
+    if root && result.is_a?(Array) && root.respond_to?(:pluralize)
+      root = root.to_s.pluralize
+    end
+    result.to_xml :root => root
+  end
+
+  def to_yaml(options = nil)
+    to_hash(options).to_yaml
+  end
+  
+  protected
+
+  def attr(model)
+    model.attributes if model
+  end
+
+  private
+
+  def filter_model(model, data)
+    if root = filter.options[:root]
+      {root.to_s => filter.filter(model, data){ |model| attr(model) } }
+    else
+      filter.filter(model, data){ |model| attr(model) }
+    end
+  end 
+end

data/spec/filter_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Hash
+  def attributes
+    self
+  end
+  def method_missing(method)
+    self[method.to_s]
+  end
+end
+
+describe Babel do
+  let(:data) do
+    data = {
+      'id' => 987,
+      'name' => 'me and the corner',
+      'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
+      'phone_numbers' => { 
+        'prefix' => 12, 
+        'number' => '123',
+        'area' => { 'code' => '001', 'iso' => 'us'}
+      }
+    }
+    class Hash
+      def self.new(hash = nil, &block) 
+        if hash
+          self[hash]
+        else 
+          super &block
+        end
+      end
+    end
+    data
+  end
+
+  let(:serializer) { Babel::Serializer.new(data) }
+  let(:deserializer) { Babel::Deserializer.new(Hash) }
+
+  it 'should serialize and deserialize a hash' do
+    json = serializer.to_json
+    result = deserializer.from_json(json)
+    result.must_equal Hash['id' => data['id'], 'name' => data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with root' do
+    json = serializer.to_json :root => :my
+    result = deserializer.from_json(json, :root => :my)
+    result.must_equal Hash['id' => data['id'], 'name' => data['name']]
+  end  
+
+  it 'should serialize and deserialize a hash with include list' do
+    json = serializer.to_json(:include => ['address', 'phone_numbers']) 
+    result = deserializer.from_json(json, :include => ['address', 'phone_numbers'])
+    data['phone_numbers'].delete('area')
+    result.must_equal Hash[data]
+  end
+
+  it 'should serialize and deserialize a hash with except' do
+    json = serializer.to_json(:except => ['id'])  
+    result = deserializer.from_json(json, :except => ['id'])  
+    result.must_equal Hash['name' => data['name']]
+    result = deserializer.from_json(json)  
+    result.must_equal Hash['name' => data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with only' do
+    json = serializer.to_json(:only => ['name']) 
+    result = deserializer.from_json(json, :only => ['name'])
+    result.must_equal Hash['name' => data['name']]
+    result = deserializer.from_json(json)
+    result.must_equal Hash['name' => data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with nested only' do
+    json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
+    data.delete('phone_numbers')
+    data['address'].delete('zipcode')
+    result = deserializer.from_json(json, :include => { 'address' => {:only => ['street']}})
+    result.must_equal data
+    result = deserializer.from_json(json, :include => ['address'])
+    result.must_equal data
+  end
+
+  it 'should serialize and deserialize a hash with nested except' do
+    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}}) 
+    data.delete('phone_numbers')
+    data['address'].delete('zipcode')
+    result = deserializer.from_json(json, :include => { 'address' => {:except => ['zipcode']}})
+    result.must_equal data
+    result = deserializer.from_json(json, :include => ['address'])
+    result.must_equal data
+  end
+
+  it 'should serialize and deserialize a hash with nested include' do
+    json = serializer.to_json(:include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}}) 
+    result = deserializer.from_json(json, :include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}})
+    result.must_equal data
+  end
+end

data/spec/filter_spec.rb~

@@ -0,0 +1,89 @@
+$LOAD_PATH << File.dirname(__FILE__)
+$LOAD_PATH << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+
+require 'spec_helper'
+require 'babel'
+
+describe Babel::Serializer do
+  before do
+    @data = {
+      'id' => 987,
+      'name' => 'me and the corner',
+      'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
+      'phone_numbers' => { 
+        'prefix' => 12, 
+        'number' => '123',
+        'area' => { 'code' => '001', 'iso' => 'us'}
+      }
+    }
+    # make the hash behave like a model
+    def @data.to_hash
+      self
+    end
+    class Hash
+      def self.new(hash) 
+        self[hash]
+      end
+    end
+  end
+
+  it 'should serialize and deserialize a hash' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json
+    data = Babel::Factory.from_json(Hash, json)
+    data.must_equal Hash['id' => @data['id'], 'name' => @data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with root' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json :root => :my
+    data = Babel::Factory.from_json(Hash, json)
+    data['my'].must_equal Hash['id' => @data['id'], 'name' => @data['name']]
+  end  
+
+  it 'should serialize and deserialize a hash with include list' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:include => ['address', 'phone_numbers']) 
+    data = Babel::Factory.from_json(Hash, json)
+    @data['phone_numbers'].delete('area')
+    data.must_equal Hash[@data]
+  end
+
+  it 'should serialize and deserialize a hash with except' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:except => ['id']) 
+    data = Babel::Factory.from_json(Hash, json)
+    data.must_equal Hash['name' => @data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with only' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:only => ['name']) 
+    data = Babel::Factory.from_json(Hash, json)
+    data.must_equal Hash['name' => @data['name']]
+  end
+
+  it 'should serialize and deserialize a hash with nested only' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:include => { 'address' => {:only => ['street']}}) 
+    data = Babel::Factory.from_json(Hash, json)
+    @data.delete('phone_numbers')
+    @data['address'].delete('zipcode')
+    data.must_equal @data
+  end
+  it 'should serialize and deserialize a hash with nested except' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:include => { 'address' => {:except => ['zipcode']}}) 
+    data = Babel::Factory.from_json(Hash, json)
+    @data.delete('phone_numbers')
+    @data['address'].delete('zipcode')
+    data.must_equal @data
+  end
+
+  it 'should serialize and deserialize a hash with nested include' do
+    json_data = Babel::Serializer.new(@data)
+    json = json_data.to_json(:include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}}) 
+    data = Babel::Factory.from_json(Hash, json)
+    data.must_equal @data
+  end
+end

data/spec/resty.rb~

@@ -0,0 +1,76 @@
+$LOAD_PATH << File.dirname(__FILE__)
+$LOAD_PATH << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+
+require 'spec_helper'
+require 'babel'
+
+class Babel::RemoteService
+
+  def initialize(url, options = {})
+    @url = url
+    @options = options
+    @urls = []
+  end
+
+  def resource(subject_class)
+    Resource.new(subject_class, url(subject_class), @options)
+  end
+
+  def url(subject_class, path = nil)
+    @urls[subject_class] = "#{@url}/#{path}" if path
+    @urls[subject_class] || "#{@url}/#{subject_class.to_s.downcase}s"
+  end
+end
+
+class Babel::Resource
+
+  def initialize(subject_class, url, options = {})
+    @options = options.dup
+    @options[:accept] ||= :json
+    @factory = Factory.new(subject_class)
+    @resource = RestClient::Resource.new(url:, @options)
+  end
+
+  def member_resource(model_or_id)
+    id = case model_or_id
+         when String
+           model_or_id
+         when Fixnum
+           model_or_id.to_s
+         else
+           model_or_id.id.to_s
+         end
+    @resource[id]
+  end
+
+  def get(model_or_params)
+    case model_or_params
+    when Hash
+      @resource.get(:params => model_or_params) do |res|
+        @factory.from_json(res)
+      end
+    else
+      model_resource(model_or_params).get do |res|
+        @factory.from_json(res)
+      end
+    end
+  end
+
+  def post(model)
+    member_resource(model).post(@factory.to_json(model)) do |res|
+      @factory.from_json(res)
+    end
+  end
+
+  def put(model)
+    member_resource(model).put(@factory.to_json(model)) do |res|
+      @factory.from_json(res)
+    end
+  end
+
+  def delete(model)
+    member_resource(model).delete( @factory.to_json(model))
+  end
+end
+
+user_service.resource(User).get

data/spec/spec_helper.rb

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

data/spec/spec_helper.rb~

@@ -0,0 +1 @@
+require 'minitest/autorun'

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: vellam
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Kristian Meier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 9
+        - 2
+        - 2
+        version: 0.9.2.2
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 37
+        segments: 
+        - 2
+        - 11
+        - 3
+        version: 2.11.3
+  type: :development
+  version_requirements: *id003
+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
+email: 
+- m.kristian@web.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/babel.rb~
+- lib/babel/deserializer.rb
+- lib/babel/hash_filter.rb
+- lib/babel/serializer.rb~
+- lib/babel/deserializer.rb~
+- lib/babel/hash_filter.rb~
+- lib/babel/factory.rb~
+- lib/babel/serializer.rb
+- lib/babel.rb
+- spec/spec_helper.rb~
+- spec/spec_helper.rb
+- spec/resty.rb~
+- spec/filter_spec.rb
+- spec/filter_spec.rb~
+- MIT-LICENSE
+- README.md
+- Gemfile
+- Gemfile.lock
+homepage: https://github.com/mkristian/babel
+licenses: []
+
+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.8.21
+signing_key: 
+specification_version: 3
+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/filter_spec.rb