serialize_with 0.1.2

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "debugger"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 JC Grubbs
+
+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,113 @@
+# SerializeWith
+
+SerializeWith is a small add-on to ActiveRecord and Mongoid which allows
+for storing serialization options within model classes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "serialize_with"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install serialize_with
+
+## Usage
+
+### Basics
+
+SerializeWith works with the normal serialization options that can be
+passed to `as_json`, `to_json`, `to_xml`, or `serializable_hash`.
+
+```ruby
+class Order < ActiveRecord::Base
+  serialize_with include: [:customer, :shipment], except: :auth_token
+end
+```
+
+Supported options are:
+
+* include
+* methods
+* only
+* except
+
+Now you can execute any serialization method and the `serialize_with`
+options will be applied.
+
+```ruby
+order = Order.first(customer_id: 1, shipment_id: 2, auth_token: "12345")
+order.as_json #=> { customer: {...}, shipment: {...} }
+```
+
+### Contexts
+
+When you need to apply different serialization rules depending on a
+context you can name the serialization options and apply them
+conditionally.
+
+```ruby
+class Order < ActiveRecord::Base
+  serialize_with include: [:customer, :shipment], except: :auth_token
+  serialize_with :public, include: [:shipment], only: [:ship_date, :delivery_date]
+end
+
+order = Order.first
+order.to_json(:public)
+```
+
+### Local/Global Configuration
+
+You can still use locally applied configuration in addition to the
+configuration specified in the model.
+
+```ruby
+class Order < ActiveRecord::Base
+  serialize_with include: [:customer, :shipment], except: :auth_token
+end
+
+order = Order.first
+order.as_json(include: [:product], methods: :order_total)
+```
+
+In the case of `include` and `methods` options, local configuration will
+be merged with global configuration.  In the above example `customer`,
+`shipment`, and `product` associations will be included.
+
+Locally applied `only` or `except` options will override the global
+options.
+
+### Active Record
+
+The SerializeWith library requires no additional setup to work with
+ActiveRecord.  Just include the gem and call `serialize_with` from
+within any model class.
+
+### Mongoid
+
+To use SerializeWith in Mongoid models you'll need to include the
+`Mongoid::SerializeWith` module.
+
+```ruby
+class Order
+  include Mongoid::Document
+  include Mongoid::SerializeWith
+  field :ship_date, type: Date
+  embeds_many :order_items
+  belongs_to :customer
+  serialize_with include: :customer
+end
+```
+
+## 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,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/mongoid/serialize_with.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module SerializeWith
+
+    def self.included(base)
+      base.extend ::SerializeWith
+    end
+
+  end
+end

data/lib/serialize_with/railtie.rb

@@ -0,0 +1,11 @@
+module SerializeWith
+  class Railtie < Rails::Railtie
+    initializer "serialize_with.extend_active_record_base" do |app|
+      if defined?(ActiveRecord)
+        ActiveSupport.on_load(:active_record) do
+          self.include SerializeWith
+        end
+      end
+    end
+  end
+end

data/lib/serialize_with/version.rb

@@ -0,0 +1,3 @@
+module SerializeWith
+  VERSION = "0.1.2"
+end

data/lib/serialize_with.rb

@@ -0,0 +1,83 @@
+require "serialize_with/version"
+require "serialize_with/railtie" if defined?(Rails)
+
+module SerializeWith
+
+  def serialize_with(context, options = {})
+    options, context = context, :default unless context.is_a?(Symbol)
+    __setup_serialize_with unless self.respond_to?(:__serialization_options)
+    self.__serialization_options[context] = options
+  end
+
+  private
+
+  def __setup_serialize_with
+    self.class_attribute :__serialization_options
+    self.__serialization_options = {}
+    include InstanceMethods
+    include MongoidSerializationOverrides if defined?(Mongoid)
+  end
+
+  module InstanceMethods
+
+    def as_json(context = nil, options = {})
+      super(__prepare_options_arguments(context, options))
+    end
+
+    def to_xml(context = nil, options = {})
+      super(__prepare_options_arguments(context, options))
+    end
+
+    def serializable_hash(local_options = nil)
+      local_options ||= {}
+      context = local_options[:context] || :default
+      options = self.class.__serialization_options
+      merged_options = __merge_serialization_options(context, local_options, options)
+      HashWithIndifferentAccess.new(super(merged_options))
+    end
+
+    private
+
+    def __merge_serialization_options(context, local_options, options)
+      [:include, :methods].each do |key|
+        next unless options[context] && options[context][key]
+        local_options[key] ||= []
+        local_options[key] += Array.wrap(options[context][key])
+      end
+      [:only, :except].each do |key|
+        next unless options[context] && options[context][key]
+        local_options[key] = Array.wrap(options[context][key]) unless local_options[key]
+      end
+      local_options
+    end
+
+    def __prepare_options_arguments(context, options)
+      options[:context] = context if context.is_a?(Symbol)
+      options = context if context.is_a?(Hash)
+      options
+    end
+
+  end
+
+  # This overrides the serialize_relations method in Mongoid::Serialization to
+  # prevent it from passing serialization options through to relations.
+  module MongoidSerializationOverrides
+
+    def serialize_relations(attributes = {}, options = {})
+      inclusions = options[:include]
+      relation_names(inclusions).each do |name|
+        metadata = relations[name.to_s]
+        if metadata && relation = send(metadata.name)
+          attributes[metadata.name.to_s] =
+            relation.serializable_hash #(relation_options(inclusions, options, name))
+        end
+      end
+    end
+
+    def relation_names(inclusions)
+      inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
+    end
+
+  end
+
+end

data/serialize_with.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/serialize_with/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["JC Grubbs", "Kori Roys"]
+  gem.email         = ["jc@devmynd.com", "kori@devmynd.com"]
+  gem.description   = %q{An add-on for ActiveRecord and Mongoid which allows serialization options to be stored on a model.}
+  gem.summary       = %q{An add-on for ActiveRecord and Mongoid which allows serialization options to be stored on a model.}
+  gem.homepage      = "https://github.com/thegrubbsian/serialize_with"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "serialize_with"
+  gem.require_paths = ["lib"]
+  gem.version       = SerializeWith::VERSION
+
+  gem.add_dependency "activesupport", "~>3.0"
+
+  gem.add_development_dependency "activerecord", "~>3.0"
+  gem.add_development_dependency "mongoid", "~>3.0"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "sqlite3"
+end

data/spec/active_record_serialize_with_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+module ActiveRecordSpec
+
+  class Order < ActiveRecord::Base
+    serialize_with include: :order_items
+    serialize_with :private, include: [:order_items, :customer]
+    has_many :order_items
+    belongs_to :customer
+  end
+
+  class OrderItem < ActiveRecord::Base
+    serialize_with methods: [:tax_amount], include: [:product]
+    belongs_to :order
+    belongs_to :product
+    def tax_amount; price * 0.09 end
+    def apple_tax_amount; price * 999 end
+  end
+
+  class Product < ActiveRecord::Base
+    serialize_with only: [:name, :price]
+  end
+
+  class Customer < ActiveRecord::Base
+    serialize_with except: :last_name
+    has_many :orders
+    has_many :order_items, through: :orders
+  end
+
+end
+
+describe "SerializeWith ActiveRecord" do
+
+  before do
+    ActiveRecordSpec::Customer.delete_all
+    ActiveRecordSpec::Order.delete_all
+    ActiveRecordSpec::OrderItem.delete_all
+
+    @customer = ActiveRecordSpec::Customer.create!(last_name: "Smith", first_name: "Carol", address: "123 Address Street")
+    @order = ActiveRecordSpec::Order.create!(customer_id: @customer.id, order_total: 400)
+    @product = ActiveRecordSpec::Product.create!(name: "Banana", price: 140.00, sku: "sdfh3j234k")
+    @order_item = ActiveRecordSpec::OrderItem.create!(order_id: @order.id, quantity: 7000, product_id: @product.id,
+                                    product_sku: "skdjfhkjwehr", price: 50.00)
+  end
+
+  describe "default context" do
+
+    context "when serialize_with is given an include option it" do
+
+      it "returns the association" do
+        @order.as_json[:order_items].should == [@order_item.as_json]
+      end
+
+      it "allows default and local configuration" do
+        json = @order.as_json(include: [:customer])
+        json[:customer].should == @customer.as_json
+        json[:order_items].should == [@order_item.as_json]
+      end
+
+    end
+
+    context "when serialize_with is given a methods option it" do
+
+      it "returns the method" do
+        @order_item.as_json[:tax_amount].should == @order_item.tax_amount
+      end
+
+      it "allows default and local configuration" do
+        json = @order_item.as_json(methods: [:apple_tax_amount])
+        json[:tax_amount].should == @order_item.tax_amount
+        json[:apple_tax_amount].should == @order_item.apple_tax_amount
+      end
+
+    end
+
+    context "when serialize_with is given an except option it" do
+
+      it "does not return the specified property" do
+        @customer.as_json["last_name"].should be_nil
+      end
+
+      it "allows local configuration to override the default" do
+        json = @customer.as_json(except: [:first_name])
+        json["first_name"].should be_nil
+        json["last_name"].should == @customer.last_name
+      end
+
+    end
+
+    context "when serialize_with is given an only option" do
+
+      it "returns only the specified properties" do
+        @product.as_json.keys.sort.should == ["name", "price"]
+      end
+
+      it "allows local configuration to override the default" do
+        json = @product.as_json(only: [:price, :sku])
+        json.keys.sort.should == ["price", "sku"]
+      end
+
+    end
+
+  end
+
+  describe "alternate contexts" do
+
+    it "apply the correct serialization rules" do
+      @order.as_json.should_not include(:customer)
+      @order.as_json(:private)[:customer].should == @customer.as_json
+    end
+
+    it "respects the context and local rules" do
+      json = @order.as_json(:private, except: [:order_total])
+      json[:customer].should == @customer.as_json
+      json["order_total"].should be_nil
+    end
+
+  end
+
+  # This is not standard as the built-in serialization logic returns
+  # method, includes, except, and only properties with different key
+  # types.
+  it "returns a hash that can be accessed with strings or symbol keys" do
+    json = @order.as_json(:private)
+    json["customer"].should == @customer.as_json
+    json[:customer].should == @customer.as_json
+  end
+
+  it "all works together as expected :)" do
+    json = @customer.as_json(include: [:order_items])
+    json[:last_name].should be_nil
+    json[:order_items].should == [@order_item.as_json]
+    json[:order_items][0][:product].should == @product.as_json
+  end
+
+end

data/spec/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: serialize_with_development
+      hosts:
+        - localhost:27017

data/spec/mongoid_serialize_with_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+module MongoidSpec
+
+  class Order
+    include Mongoid::Document
+    include Mongoid::SerializeWith
+    serialize_with :private, include: [:customer]
+    embeds_many :order_items
+    belongs_to :customer
+    field :order_total
+  end
+
+  class OrderItem
+    include Mongoid::Document
+    include Mongoid::SerializeWith
+    serialize_with methods: [:tax_amount], include: [:product]
+    embedded_in :order
+    belongs_to :product
+    field :product_sku
+    field :quantity, type: Integer
+    field :price, type: Float
+    def tax_amount; price * 0.09 end
+    def apple_tax_amount; price * 999 end
+  end
+
+  class Product
+    include Mongoid::Document
+    include Mongoid::SerializeWith
+    serialize_with only: [:name, :price]
+    field :name
+    field :sku
+    field :manufacturer
+    field :price, type: Float
+  end
+
+  class Customer
+    include Mongoid::Document
+    include Mongoid::SerializeWith
+    serialize_with except: [:last_name]
+    has_many :orders
+    field :first_name
+    field :last_name
+    field :address
+  end
+
+end
+
+describe "SerializeWith Mongoid" do
+
+  before do
+    MongoidSpec::Customer.delete_all
+    MongoidSpec::Order.delete_all
+    MongoidSpec::OrderItem.delete_all
+
+    @customer = MongoidSpec::Customer.create!(last_name: "Smith", first_name: "Carol", address: "123 Address Street")
+    @product = MongoidSpec::Product.create!(name: "Banana", price: 140.00, sku: "sdfh3j234k")
+    @order_item = MongoidSpec::OrderItem.new(quantity: 7000, product_id: @product.id, product_sku: "skdjfhkjwehr", price: 50.00)
+    @order = MongoidSpec::Order.create!(customer_id: @customer.id, order_total: 400, order_items: [@order_item])
+  end
+
+  describe "default context" do
+
+    context "when serialize_with is given an include option it" do
+
+      it "returns the association" do
+        @order.as_json[:order_items].should == [@order_item.as_json]
+      end
+
+      it "allows default and local configuration" do
+        json = @order.as_json(include: [:customer])
+        json[:customer].should == @customer.as_json
+        json[:order_items].should == [@order_item.as_json]
+      end
+
+    end
+
+    context "when serialize_with is given a methods option it" do
+
+      it "returns the method" do
+        @order_item.as_json[:tax_amount].should == @order_item.tax_amount
+      end
+
+      it "allows default and local configuration" do
+        json = @order_item.as_json(methods: [:apple_tax_amount])
+        json[:tax_amount].should == @order_item.tax_amount
+        json[:apple_tax_amount].should == @order_item.apple_tax_amount
+      end
+
+    end
+
+    context "when serialize_with is given an except option it" do
+
+      it "does not return the specified property" do
+        @customer.as_json["last_name"].should be_nil
+      end
+
+      it "allows local configuration to override the default" do
+        json = @customer.as_json(except: [:first_name])
+        json["first_name"].should be_nil
+        json["last_name"].should == @customer.last_name
+      end
+
+    end
+
+    context "when serialize_with is given an only option" do
+
+      it "returns only the specified properties" do
+        @product.as_json.keys.sort.should == ["name", "price"]
+      end
+
+      it "allows local configuration to override the default" do
+        json = @product.as_json(only: [:price, :sku])
+        json.keys.sort.should == ["price", "sku"]
+      end
+
+    end
+
+  end
+
+  describe "alternate contexts" do
+
+    it "apply the correct serialization rules" do
+      @order.as_json.should_not include(:customer)
+      @order.as_json(:private)[:customer].should == @customer.as_json
+    end
+
+    it "respects the context and local rules" do
+      json = @order.as_json(:private, except: [:order_total])
+      json[:customer].should == @customer.as_json
+      json["order_total"].should be_nil
+    end
+
+  end
+
+  # This is not standard as the built-in serialization logic returns
+  # method, includes, except, and only properties with different key
+  # types.
+  it "returns a hash that can be accessed with strings or symbol keys" do
+    json = @order.as_json(:private)
+    json["customer"].should == @customer.as_json
+    json[:customer].should == @customer.as_json
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+ENV["RAILS_ENV"] = "development"
+ENV["MONGOID_ENV"] = "development"
+
+require "rubygems"
+require "serialize_with"
+require "active_record"
+require "mongoid"
+require "mongoid/serialize_with"
+
+Mongoid.load!("#{Dir.pwd}/spec/mongoid.yml")
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.include_root_in_json = false
+
+migration = Class.new(ActiveRecord::Migration) do
+  def change
+    create_table :customers, :force => true do |t|
+      t.string :first_name
+      t.string :last_name
+      t.string :address
+    end
+    create_table :products, :force => true do |t|
+      t.string :name
+      t.string :sku
+      t.string :manufacturer
+      t.decimal :price
+    end
+    create_table :orders, :force => true do |t|
+      t.integer :customer_id
+      t.decimal :order_total
+    end
+    create_table :order_items, :force => true do |t|
+      t.integer :order_id
+      t.string :product_sku
+      t.integer :quantity
+      t.integer :product_id
+      t.decimal :price
+    end
+  end
+end
+
+migration.new.migrate(:up)
+
+ActiveSupport.on_load(:active_record) do
+  self.extend SerializeWith
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: serialize_with
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- JC Grubbs
+- Kori Roys
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An add-on for ActiveRecord and Mongoid which allows serialization options
+  to be stored on a model.
+email:
+- jc@devmynd.com
+- kori@devmynd.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mongoid/serialize_with.rb
+- lib/serialize_with.rb
+- lib/serialize_with/railtie.rb
+- lib/serialize_with/version.rb
+- serialize_with.gemspec
+- spec/active_record_serialize_with_spec.rb
+- spec/mongoid.yml
+- spec/mongoid_serialize_with_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/thegrubbsian/serialize_with
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: An add-on for ActiveRecord and Mongoid which allows serialization options
+  to be stored on a model.
+test_files:
+- spec/active_record_serialize_with_spec.rb
+- spec/mongoid.yml
+- spec/mongoid_serialize_with_spec.rb
+- spec/spec_helper.rb