ixtlan-babel 0.1.2

data/Gemfile

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

data/Gemfile.lock

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

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,9 @@
+# vellam [![Build Status](https://secure.travis-ci.org/mkristian/babel.png)](http://travis-ci.org/mkristian/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/ixtlan-babel.rb

@@ -0,0 +1,4 @@
+require 'ixtlan/babel/serializer'
+require 'ixtlan/babel/deserializer'
+require 'ixtlan/babel/factory'
+require 'ixtlan/babel/no_timestamp_serializer'

data/lib/ixtlan/babel/deserializer.rb

@@ -0,0 +1,65 @@
+module Ixtlan
+  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
+end

data/lib/ixtlan/babel/factory.rb

@@ -0,0 +1,48 @@
+module Ixtlan
+  module Babel
+    class Factory
+
+      class EmptyArraySerializer < Array
+        def use(arg)
+          self
+        end
+      end
+
+      def initialize(custom_serializers = {})
+        @map = {}
+        add('DateTime') do |dt|
+          dt.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % (dt.sec_fraction / Date::NANOSECONDS_IN_DAY / 1000)) + dt.strftime('%z')
+        end
+        add('ActiveSupport::TimeWithZone') do |tz|
+          tz.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % tz.usec) + tz.strftime('%z')
+        end
+        add('Time') do |t|
+          t.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % t.usec) + t.strftime('%z')
+        end
+        @map.merge!(custom_serializers)
+      end
+
+      def add(clazz, &block)
+        @map[clazz.to_s] = block
+      end
+
+      def new(resource)
+        if resource.respond_to?(:model)
+          model = resource.model
+        elsif resource.is_a? Array
+          if resource.empty?
+            return EmptyArraySerializer.new
+          else
+            r = resource.first
+            model = r.respond_to?(:model) ? r.model : r.class
+          end
+        else
+          model = resource.class
+        end
+        ser = Object.const_get("#{model}Serializer").new(resource)
+        ser.add_custom_serializers(@map)
+        ser
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/hash_filter.rb

@@ -0,0 +1,148 @@
+module Ixtlan
+  module Babel
+    class HashFilter
+
+      def initialize(context_or_options = nil)
+        use(context_or_options)
+      end
+      
+      private
+
+      def context
+        @context ||= {}
+      end
+
+      public
+
+      def add_custom_serializers(map)
+        @map = map
+      end
+
+      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 NO_MODEL.[](*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)
+        model = NO_MODEL if model == data
+        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.to_s)
+              case include
+              when Array
+                result[k.to_s] = filter_data(model.send(k), v, &block)
+              when Hash
+                result[k.to_s] = filter_data(model.send(k), v, include[k.to_s], &block)
+              end
+            end
+          when Array
+            if include.include?(k.to_s)
+              models = model.send(k)
+              j = -1
+              case include
+              when Array
+                result[k.to_s] = v.collect do |i| 
+                  j += 1
+                  if i.is_a?(Array) || i.is_a?(Hash)
+                    filter_data(models[j], i, &block)
+                  else
+                    i
+                  end
+                end
+              when Hash
+                opts = include[k]
+                result[k.to_s] = v.collect { |i| j += 1; filter_data(models[j], i, opts, &block) }
+              end
+            end
+          else
+            if methods.include?(k.to_s) || (only && only.include?(k.to_s)) || (only.nil? && !except.include?(k.to_s))
+              if @map && ser = @map[v.class.to_s]
+                result[k.to_s] = ser.call(v)
+              else
+                result[k.to_s] = v
+              end
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/no_timestamp_serializer.rb

@@ -0,0 +1,24 @@
+require 'ixtlan/babel/serializer'
+module Ixtlan
+  module Babel
+    class NoTimestampSerializer < Serializer
+      
+      def self.add_defaults(root = nil)
+        if root
+          add_context(:default, :root => root)
+          add_no_timestamp_context(:collection, :root => root)
+        else
+          add_context(:default)
+          add_no_timestamp_context(:collection)
+        end
+      end
+
+      def self.add_no_timestamp_context(key, options = {})
+        except = (options[:except] || []).dup
+        except << :updated_at
+        except << :created_at
+        add_context(key, options.merge({:except => except}))
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/serializer.rb

@@ -0,0 +1,115 @@
+require 'ixtlan/babel/hash_filter'
+module Ixtlan
+  module Babel
+    class Serializer
+
+      def id
+        if @model_or_models.is_a? Array
+          super
+        else
+          @model_or_models.id
+        end
+      end
+
+      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
+      
+      def add_custom_serializers(map)
+        filter.add_custom_serializers(map)
+      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(filter.options.dup.merge!(options)) if options
+        if @model_or_models.respond_to?(:collect) && ! @model_or_models.is_a?(Hash)
+          @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 = {})
+        opts = filter.options.dup.merge!(options)
+        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
+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 Ixtlan::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) { Ixtlan::Babel::Serializer.new(data) }
+  let(:deserializer) { Ixtlan::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/spec_helper.rb

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

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: ixtlan-babel
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Kristian Meier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-04 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/ixtlan-babel.rb
+- lib/ixtlan/babel/deserializer.rb
+- lib/ixtlan/babel/hash_filter.rb
+- lib/ixtlan/babel/no_timestamp_serializer.rb
+- lib/ixtlan/babel/factory.rb
+- lib/ixtlan/babel/serializer.rb
+- spec/spec_helper.rb
+- spec/filter_spec.rb
+- MIT-LICENSE
+- README.md
+- Gemfile
+- Gemfile.lock
+homepage: https://github.com/mkristian/ixtlan-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