active_serializer 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle/
+vendor/
+.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aggregate_builder.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'debugger'
+end

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    active_serializer (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.1)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    columnize (0.3.6)
+    debugger (1.6.2)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.3)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.3)
+    diff-lcs (1.2.4)
+    i18n (0.6.5)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  active_serializer!
+  activesupport
+  bundler (~> 1.3)
+  debugger
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Albert Gazizov
+
+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,77 @@
+# ActiveSerializer
+
+Active Serializer is a simple objects to hash serializer.
+
+## Usage
+
+Here's an example serializer:
+```ruby
+class ContactSerializer
+  include ActiveSerializer::SerializableObject
+
+  serialization_rules do |contact, home_address, contact_emails|
+    attributes :first_name, :last_name, contact
+
+    attribute :full_name do
+      "#{contact.first_name} #{contact.last_name}"
+    end
+
+    resource :address, home_address do |address|
+      attributes :country, :city, :street, address
+    end
+
+    resources :emails, contact_emails do |email|
+      attributes :email
+      attribute :type do
+        'home'
+      end
+    end
+  end
+end
+```
+
+Let's use it:
+```ruby
+ContactSerializer.serialize(contact, home_address, contact_emails)
+```
+
+And we get a result:
+```ruby
+{
+  first_name: "John",
+  last_name: "Smith",
+  full_name: "John Smith",
+  address: {
+    country: "Russia",
+    city: "Kazan",
+    street: "Kosmonavton"
+  },
+  emails: [
+    { email: "test@test.com", type: "home" },
+    { email: "test2@test.com", type: "home" }
+  ]
+}
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_serializer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_serializer
+
+## 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/active_serializer.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_serializer"
+  spec.version       = ActiveSerializer::VERSION
+  spec.authors       = ["Albert Gazizov", "Ruslan Gatiyatov"]
+  spec.email         = ["deeper4k@gmail.com", "ruslan.gatiyatov@gmail.com"]
+  spec.description   = %q{Object to Hash serializer}
+  spec.summary       = %q{Adds simple DSL to convert ruby objects to hash}
+  spec.homepage      = "http://github.com/droidlabs/active_serializer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "activesupport"
+end

data/lib/active_serializer.rb

@@ -0,0 +1,13 @@
+require 'active_support/concern.rb'
+require 'active_support/core_ext/array/wrap.rb'
+require 'active_serializer/version'
+require 'active_serializer/support/fake_object'
+require 'active_serializer/support/args_validator'
+require 'active_serializer/serialization_rules_validator'
+require 'active_serializer/serializers'
+require 'active_serializer/serializable'
+require 'active_serializer/serializable_hash'
+require 'active_serializer/serializable_object'
+
+module ActiveSerializer
+end

data/lib/active_serializer/serializable.rb

@@ -0,0 +1,35 @@
+module ActiveSerializer::Serializable
+
+  def serialize(*objects)
+    serialization_options = self.class_variable_get(:@@serialization_options)
+    serialization_rules   = self.class_variable_get(:@@serialization_rules)
+    ActiveSerializer::Support::ArgsValidator.not_nil!(serialization_rules, :serialization_rules)
+
+    serialized_data = run_serialization(objects, serialization_rules, serialization_options)
+
+    if serialization_options[:no_root_node]
+      serialized_data.first[1]
+    else
+      serialized_data
+    end
+  end
+
+  def serialize_all(collection, options = {})
+    collection.map do |object|
+      serialize(object, options)
+    end
+  end
+
+  def serialization_rules(options = {}, &block)
+    self.class_variable_set(:@@serialization_options, options)
+    ActiveSerializer::SerializationRulesValidator.validate!(&block)
+    self.class_variable_set(:@@serialization_rules, block)
+  end
+
+  private
+
+  def run_serialization(objects, serialization_rules, serialization_options)
+    raise NotImplementedError, "should be implemented in derived class"
+  end
+
+end

data/lib/active_serializer/serializable_hash.rb

@@ -0,0 +1,25 @@
+require 'active_serializer/serializers/hash_serializer'
+require 'active_serializer/serializers/ignore_blank_hash_serializer'
+
+module ActiveSerializer::SerializableHash
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    include ActiveSerializer::Serializable
+
+    private
+
+    def run_serialization(objects, serialization_rules, serialization_options)
+      if serialization_options[:ignore_blank]
+        serializer = ActiveSerializer::Serializers::IgnoreBlankHashSerializer.new(objects.first, serialization_options)
+      else
+        serializer = ActiveSerializer::Serializers::HashSerializer.new(objects.first, serialization_options)
+      end
+      instance_exec do
+        serializer.instance_exec(*objects, &serialization_rules)
+      end
+      serializer.serialized_data
+    end
+  end
+
+end

data/lib/active_serializer/serializable_object.rb

@@ -0,0 +1,44 @@
+require 'active_serializer/serializers/object_serializer'
+require 'active_serializer/serializers/restrict_fields_object_serializer'
+
+module ActiveSerializer::SerializableObject
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def serialize(*objects)
+      first_object = objects.first
+      options = objects.last.is_a?(Hash) ? objects.last : {}
+
+      serialization_options = self.class_variable_get(:@@serialization_options)
+      serialization_rules   = self.class_variable_get(:@@serialization_rules)
+
+      if options[:serializable_fields]
+        serializer = ActiveSerializer::Serializers::RestrictFieldsObjectSerializer.new(first_object, options)
+      else
+        serializer = ActiveSerializer::Serializers::ObjectSerializer.new(first_object, options)
+      end
+      instance_exec do
+        serializer.instance_exec(*objects, &serialization_rules)
+      end
+      if serialization_options[:no_root_node]
+        serializer.attrs.first[1]
+      else
+        serializer.attrs
+      end
+    end
+
+    def serialize_all(collection, options = {})
+      collection.map do |object|
+        serialize(object, options)
+      end
+    end
+
+    def serialization_rules(options = {}, &block)
+      self.class_variable_set(:@@serialization_options, options)
+      self.class_variable_set(:@@serialization_rules, block)
+    end
+
+    private
+  end
+
+end

data/lib/active_serializer/serialization_rules_validator.rb

@@ -0,0 +1,35 @@
+class ActiveSerializer::SerializationRulesValidator
+  private :initialize
+
+  def self.validate!(&rules)
+    fake_objects = rules.arity.times.map do
+      ActiveSerializer::Support::FakeObject.new
+    end
+    validator = self.new
+    validator.instance_exec(*fake_objects, &rules)
+  end
+
+  def attribute(name, value = nil, &block)
+    ActiveSerializer::Support::ArgsValidator.is_symbol!(name, 'attributes')
+  end
+
+  def attributes(*attrs)
+    attrs.delete_at(-1)
+    ActiveSerializer::Support::ArgsValidator.is_array_of_symbols!(attrs, 'attributes')
+  end
+
+  def namespace(name, &block)
+    ActiveSerializer::Support::ArgsValidator.is_symbol!(name, 'namespace name')
+    ActiveSerializer::Support::ArgsValidator.block_given!(block, 'namespace block')
+  end
+
+  def resource(name, object = nil, &block)
+    ActiveSerializer::Support::ArgsValidator.is_symbol!(name, 'resource name')
+    ActiveSerializer::Support::ArgsValidator.block_given!(block, 'resource block')
+  end
+
+  def resources(name, objects = nil, &block)
+    ActiveSerializer::Support::ArgsValidator.is_symbol!(name, 'resources name')
+    ActiveSerializer::Support::ArgsValidator.block_given!(block, 'resources block')
+  end
+end

data/lib/active_serializer/serializers.rb

@@ -0,0 +1,2 @@
+module ActiveSerializer::Serializers
+end

data/lib/active_serializer/serializers/hash_serializer.rb

@@ -0,0 +1,64 @@
+class ActiveSerializer::Serializers::HashSerializer
+  attr_reader :serialized_data
+
+  def initialize(root_hash, options = {})
+    @root_hash       = root_hash
+    @options         = options
+    @serialized_data = {}
+  end
+
+  def attribute(name, value = nil, &block)
+    if block_given?
+      value = yield
+    elsif !value
+      value = @root_hash[name]
+    end
+    set_value(name, value)
+  end
+
+  def attributes(*serialized_data, &block)
+    if !serialized_data.last.is_a?(Symbol)
+      source_hash = serialized_data.delete_at(-1)
+    else
+      source_hash = @root_hash
+    end
+
+    serialized_data.each do |attr_name|
+      set_value(attr_name, source_hash[attr_name])
+    end
+  end
+
+  def namespace(name, &block)
+    serializer = self.class.new(@root_hash, @options)
+    serializer.instance_exec(@root_hash, &block)
+    set_value(name, serializer.serialized_data)
+  end
+
+  def resource(name, source_hash = nil, &block)
+    source_hash ||= @root_hash[name]
+    set_value(name, serialize_resource(source_hash, &block))
+  end
+
+  def resources(name, source_hashes = nil, &block)
+    source_hashes ||= @root_hash[name]
+
+    self.serialized_data[name] = (source_hashes || []).inject([]) do |result, source_hash|
+      data = serialize_resource(source_hash, &block)
+      data.empty? ? result : (result << data)
+    end
+  end
+
+  protected
+
+  def serialize_resource(source_hash, &block)
+    return nil unless source_hash
+    serializer = self.class.new(source_hash, @options)
+    serializer.instance_exec(source_hash, &block)
+    serializer.serialized_data
+  end
+
+  def set_value(name, value)
+    self.serialized_data[name] = value
+  end
+
+end

data/lib/active_serializer/serializers/ignore_blank_hash_serializer.rb

@@ -0,0 +1,9 @@
+class ActiveSerializer::Serializers::IgnoreBlankHashSerializer < ActiveSerializer::Serializers::HashSerializer
+
+  protected
+
+  def set_value(name, value)
+    self.serialized_data[name] = value unless value.nil?
+  end
+
+end

data/lib/active_serializer/serializers/object_serializer.rb

@@ -0,0 +1,97 @@
+class ActiveSerializer::Serializers::ObjectSerializer
+  attr_reader :attrs
+
+  def initialize(object, options = {})
+    @object, @options = object, options
+    @attrs = {}
+  end
+
+  def namespace(name, &block)
+    serializer = self.class.new(@object, @options)
+    serializer.instance_exec(@object, &block)
+    self.attrs[name] = serializer.attrs
+  end
+
+  def resource(name, object = nil, &block)
+    raise "You should set name for resource" unless name
+    raise "You should specify object" if @object.nil? && object.nil?
+    nested_name = name
+    nested_object = object || @object.send(nested_name)
+    unless nested_object
+      self.attrs[nested_name] = {}
+    else
+      if block_given?
+        self.attrs[nested_name] = nested_resource(nested_name, nested_object, @options, &block)
+      elsif nested_object.respond_to?(:to_hash)
+        self.attrs[nested_name] = nested_object.to_hash
+      elsif nested_object.is_a?(String)
+        self.attrs[nested_name] = nested_object
+      else
+        raise "You should specify block or declare 'to_hash' method"
+      end
+    end
+  end
+
+  def resources(name, objects = nil, &block)
+    raise "You should specify object" if @object.nil? && objects.nil?
+    objects = objects.flatten unless objects.nil?
+    nested_objects = objects || @object.send(name.to_s)
+    unless nested_objects
+      self.attrs[name] = []
+    else
+      self.attrs[name] = (nested_objects || []).inject([]) do |result, obj|
+        resource = nested_resource(name, obj, @options, &block)
+        resource.empty? ? result : (result << resource)
+      end
+    end
+  end
+
+  def attributes(*attrs, &block)
+    if !attrs.last.is_a?(Symbol) && !attrs.last.is_a?(String)
+      object = attrs.last
+      attrs.delete(attrs.last)
+    end
+    if !@object && !object
+      raise ArgumentError, "Object was not specified"
+    end
+
+    target = object || @object
+    Array.wrap(attrs).flatten.each do |attribute|
+      serialize_attribute(attribute, target)
+    end
+  end
+
+  def attribute(attr, val = nil, &block)
+    if block_given?
+      self.attrs[attr] = yield
+      return
+    end
+
+    if @object.blank?
+      raise ArgumentError, "Neither object was specified nor block was given"
+    end
+    self.attrs[attr] = val || @object.send(attr.to_s)
+  end
+
+  protected
+
+  def serialize_attribute(attribute, target)
+    self.attrs[attribute] = target.send(attribute.to_s)
+  end
+
+  def nested_resource(name, object, options, serializer_class = self.class, &block)
+    return nil if !object
+    serializer = serializer_class.new(object, options)
+    if block_given?
+      serializer.instance_exec(object, &block)
+      serializer.attrs
+    else
+      if object.respond_to?(:to_hash)
+        object.to_hash
+      elsif object.is_a?(String)
+        object
+      end
+    end
+  end
+
+end

data/lib/active_serializer/serializers/restrict_fields_object_serializer.rb

@@ -0,0 +1,40 @@
+class ActiveSerializer::Serializers::RestrictFieldsObjectSerializer < ActiveSerializer::Serializers::ObjectSerializer
+  def initialize(object, options)
+    raise ArgumentError, 'serializable_fields should be specified' unless options[:serializable_fields]
+    super
+    @serializable_fields = options[:serializable_fields].keys
+  end
+
+  def resource(name, object = nil, &block)
+    super if @serializable_fields.include?(name)
+  end
+
+  def resources(name, objects = nil, &block)
+    super if @serializable_fields.include?(name)
+  end
+
+  def attribute(name, val = nil, &block)
+    super if @serializable_fields.include?(name)
+  end
+
+  protected
+
+  def serialize_attribute(attribute, target)
+    super if @serializable_fields.include?(attribute)
+  end
+
+  def nested_resource(name, object, root_options, serializer_class = self.class, &block)
+    options = root_options.dup
+    serializable_fields = root_options[:serializable_fields][name]
+    if !serializable_fields
+      return
+    elsif serializable_fields == true
+      super(name, object, options, ActiveSerializer::Serializers::ObjectSerializer, &block)
+    elsif serializable_fields.is_a?(Hash)
+      options[:serializable_fields] = serializable_fields
+      super(name, object, options, &block)
+    else
+      raise ArgumentError, "serializable_fields' values should be boolean or hash"
+    end
+  end
+end

data/lib/active_serializer/support/args_validator.rb

@@ -0,0 +1,46 @@
+module ActiveSerializer::Support::ArgsValidator
+  class << self
+    def is_symbol!(obj, obj_name)
+      unless obj.is_a?(Symbol)
+        raise ArgumentError, "#{obj_name} should be a Symbol"
+      end
+    end
+
+    def is_array!(obj, obj_name)
+      unless obj.is_a?(Array)
+        raise ArgumentError, "#{obj_name} should be an Array"
+      end
+    end
+
+    def is_hash!(obj, obj_name)
+      unless obj.is_a?(Hash)
+        raise ArgumentError, "#{obj_name} should be a Hash"
+      end
+    end
+
+    def has_key!(hash, key)
+      unless hash.has_key?(key)
+        raise ArgumentError, "#{hash} should has #{key} key"
+      end
+    end
+
+    def is_array_of_symbols!(array, obj_name)
+      is_array!(array, obj_name)
+      unless array.all? { |item| item.is_a?(Symbol) }
+        raise ArgumentError, "#{obj_name} elements should be a symbols"
+      end
+    end
+
+    def block_given!(block, obj_name)
+      unless block
+        raise ArgumentError, "Block should be given to #{obj_name}"
+      end
+    end
+
+    def not_nil!(obj, obj_name)
+      unless obj
+        raise ArgumentError, "#{obj_name} can not be nil"
+      end
+    end
+  end
+end

data/lib/active_serializer/support/fake_object.rb

@@ -0,0 +1,9 @@
+module ActiveSerializer
+  module Support
+    class FakeObject
+      def method_missing(method_name, *args, &block)
+        self.class.new
+      end
+    end
+  end
+end

data/lib/active_serializer/version.rb

@@ -0,0 +1,3 @@
+module ActiveSerializer
+  VERSION = "0.1.0"
+end

data/spec/active_serializer/serializable_hash_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module SerializableHashTest
+  describe ActiveSerializer::SerializableHash do
+    class ContactSerializer
+      include ActiveSerializer::SerializableHash
+
+      serialization_rules do |contact, home_address, contact_emails|
+        attributes :first_name, :last_name, contact
+
+        attribute :full_name do
+          "#{contact[:first_name]} #{contact[:last_name]}"
+        end
+
+        resource :address, home_address do |address|
+          attributes :country, :city, :street, address
+        end
+
+        resources :emails, contact_emails do |email|
+          attributes :email
+          attribute :type do
+            'home'
+          end
+        end
+      end
+    end
+
+    describe "#serialize" do
+      it "should serialize object" do
+        contact = {
+          first_name: 'John',
+          last_name: 'Smith',
+        }
+
+        contact_emails = [
+          { email: 'test@test.com'},
+          { email: 'test2@test.com'},
+        ]
+
+        home_address = {
+          country: 'Russia',
+          city:    'Kazan',
+          street:  'Kosmonavton',
+        }
+
+        serialized_contact = ContactSerializer.serialize(contact, home_address, contact_emails)
+        serialized_contact.should == {
+          first_name: "John",
+          last_name: "Smith",
+          full_name: "John Smith",
+          address: {
+            country: "Russia",
+            city: "Kazan",
+            street: "Kosmonavton"
+          },
+          emails: [
+            { email: "test@test.com", type: "home" },
+            { email: "test2@test.com", type: "home" }
+          ]
+        }
+      end
+    end
+
+    class ContactIgnoreBlankSerializer
+      include ActiveSerializer::SerializableHash
+
+      serialization_rules ignore_blank: true do |contact|
+        attributes :first_name, :last_name
+
+        attribute :full_name
+        attribute(:address) if contact[:full_name]
+      end
+    end
+
+    describe "#serialize" do
+      it "should not return blank values" do
+        contact = {
+          first_name: nil,
+          last_name: nil,
+          full_name: nil,
+        }
+
+        serialized_contact = ContactIgnoreBlankSerializer.serialize(contact)
+        serialized_contact.should == {}
+      end
+    end
+  end
+end
+

data/spec/active_serializer/serializable_object_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+module SerializableObjectTest
+  describe ActiveSerializer::SerializableObject do
+    class Contact
+      attr_accessor :first_name, :last_name
+    end
+
+    class Address
+      attr_accessor :country, :city, :street
+    end
+
+    class Email
+      attr_accessor :email
+    end
+
+    class ContactSerializer
+      include ActiveSerializer::SerializableObject
+
+      serialization_rules do |contact, home_address, contact_emails|
+        attributes :first_name, :last_name, contact
+
+        attribute :full_name do
+          "#{contact.first_name} #{contact.last_name}"
+        end
+
+        resource :address, home_address do |address|
+          attributes :country, :city, :street, address
+        end
+
+        resources :emails, contact_emails do |email|
+          attributes :email
+          attribute :type do
+            'home'
+          end
+        end
+      end
+    end
+
+    describe "#serialize" do
+      it "should serialize object" do
+        contact = Contact.new
+        contact.first_name = 'John'
+        contact.last_name  = 'Smith'
+
+        home_email1 = Email.new
+        home_email1.email = 'test@test.com'
+        home_email2 = Email.new
+        home_email2.email = 'test2@test.com'
+        contact_emails = [home_email1, home_email2]
+
+        home_address = Address.new
+        home_address.country = 'Russia'
+        home_address.city    = 'Kazan'
+        home_address.street  = 'Kosmonavton'
+
+        serialized_contact = ContactSerializer.serialize(contact, home_address, contact_emails)
+        serialized_contact.should == {
+          first_name: "John",
+          last_name: "Smith",
+          full_name: "John Smith",
+          address: {
+            country: "Russia",
+            city: "Kazan",
+            street: "Kosmonavton"
+          },
+          emails: [
+            { email: "test@test.com", type: "home" },
+            { email: "test2@test.com", type: "home" }
+          ]
+        }
+      end
+
+      class ContactsSerializer
+        include ActiveSerializer::SerializableObject
+
+        serialization_rules no_root_node: true do |contacts, home_address|
+          resources :contacts, contacts do |contact|
+            attributes :first_name, :last_name, contact
+            resource :address, home_address do |address|
+              attributes :country, :city, :street, address
+            end
+          end
+        end
+      end
+
+      it "should return Array when no_root_node: true specified" do
+        contact1 = Contact.new
+        contact1.first_name = 'John'
+        contact1.last_name  = 'Smith'
+        contact2 = Contact.new
+        contact2.first_name = 'John'
+        contact2.last_name  = 'Smith'
+        home_address = Address.new
+        home_address.country = 'Russia'
+        home_address.city    = 'Kazan'
+        home_address.street  = 'Kosmonavton'
+
+        serialized_contacts = ContactsSerializer.serialize([contact1, contact2], home_address)
+        serialized_contacts.should be_an_instance_of(Array)
+      end
+
+
+      class Company
+        attr_accessor :name, :emails, :address
+      end
+      class CompanySerializer
+        include ActiveSerializer::SerializableObject
+
+        serialization_rules do |company|
+          attributes :name
+          resource :address do |address|
+            attributes :country, :city, :street
+          end
+          resources :emails do |email|
+            attribute :email do
+              email.email
+            end
+          end
+        end
+      end
+
+      it "should serialize only fields spefied in serializable_fields option" do
+        company = Company.new
+        company.name = "MyCo"
+
+        email1 = Email.new
+        email1.email = 'test@test.com'
+        email2 = Email.new
+        email2.email = 'test2@test.com'
+        company.emails = [email1, email2]
+
+        address = Address.new
+        address.country = 'Russia'
+        address.city    = 'Kazan'
+        address.street  = 'Kosmonavton'
+        company.address = address
+
+        serialized_company = CompanySerializer.serialize(company, serializable_fields: { name: true, emails: { email: true}, address: { country: true }})
+        serialized_company.should =={
+          name: "MyCo",
+          address: {country: "Russia"},
+          emails: [
+            { email: "test@test.com"  },
+            { email: "test2@test.com" }
+          ]
+        }
+        serialized_company = CompanySerializer.serialize(company, serializable_fields: { emails: true})
+        serialized_company.should == {
+          emails: [
+            { email: "test@test.com"  },
+            { email: "test2@test.com" }
+          ]
+        }
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'debugger'
+require 'active_serializer'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: active_serializer
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors:
+- Albert Gazizov
+- Ruslan Gatiyatov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: bundler
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activesupport
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Object to Hash serializer
+email:
+- deeper4k@gmail.com
+- ruslan.gatiyatov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_serializer.gemspec
+- lib/active_serializer.rb
+- lib/active_serializer/serializable.rb
+- lib/active_serializer/serializable_hash.rb
+- lib/active_serializer/serializable_object.rb
+- lib/active_serializer/serialization_rules_validator.rb
+- lib/active_serializer/serializers.rb
+- lib/active_serializer/serializers/hash_serializer.rb
+- lib/active_serializer/serializers/ignore_blank_hash_serializer.rb
+- lib/active_serializer/serializers/object_serializer.rb
+- lib/active_serializer/serializers/restrict_fields_object_serializer.rb
+- lib/active_serializer/support/args_validator.rb
+- lib/active_serializer/support/fake_object.rb
+- lib/active_serializer/version.rb
+- spec/active_serializer/serializable_hash_spec.rb
+- spec/active_serializer/serializable_object_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/droidlabs/active_serializer
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 3700777157026269907
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 3700777157026269907
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Adds simple DSL to convert ruby objects to hash
+test_files:
+- spec/active_serializer/serializable_hash_spec.rb
+- spec/active_serializer/serializable_object_spec.rb
+- spec/spec_helper.rb