agile_serializer 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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.markdown

@@ -0,0 +1,85 @@
+The fork
+========
+
+This fork changes the core behavior of SerializeWithOptions plugin, it follows deep relations so it's up to you to handle infinite recursions (SerializeWithOptions drops 1+ level relations). This repo is a work in progress so use it with care.
+
+SerializeWithOptions
+====================
+
+This plugin is designed to make creating XML and JSON APIs for your Rails apps dead simple. We noticed a lot of repetition when creating API responses in our controllers. With this plugin, you can set the serialization options for a model with a simple DSL, rather than repeating them in every controller that includes it.
+
+
+Example
+-------
+
+Here is a simple example of SerializeWithOptions in action:
+
+    class User < ActiveRecord::Base
+      has_many :posts
+
+      serialize_with_options do
+        methods   :post_count
+        includes  :posts
+        except    :email
+      end
+
+      serialize_with_options(:with_email) do
+        methods   :post_count
+        includes  :posts
+      end
+
+      def post_count
+        self.posts.count
+      end
+    end
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+      belongs_to :user
+
+      serialize_with_options do
+        only      :title
+        includes  :user, :comments
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+With these directives in place, we can call `@post.to_xml` (or `@post.to_json`) and it's as if we entered:
+
+    @post.to_xml(:include => { :user => { :methods => :post_count, :except => :email }, :comments => { } })
+
+In our controller, we can just say:
+
+    def show
+      @post = Post.find(params[:id])
+
+      respond_to do |format|
+        format.html
+        format.xml { render :xml => @post }
+        format.json { render :json => @post }
+      end
+    end
+
+All serialization options are enclosed in a `serialize_with_options` block. There are four options, lifted directly from ActiveRecord's [serialization API][ser]: `methods` are the methods to add to the default attributes, `only` are the attributes to include, excluding all others, `except` are the attributes to leave out, and `includes` are the associated models.
+
+If an included model has its own `serialize_with_options` block, its `methods`, `only`, and `except` will be respected. However, the included model's `includes` directive will be ignored (only one level of nesting is supported). If you need more than one level of nesting, you can use a hash to set your included models, rather than an array.
+
+The `serialize_with_options` class method takes an optional argument for naming a configuration set (see the User model above). This is useful if you need to multiple serialization configuration sets. You can access these secondary configuration sets by passing the set name to the serialization method, e.g., `@post.to_xml(:with_email)`.
+
+
+Installation
+------------
+
+From your app root:
+
+    script/plugin install git://github.com/vigetlabs/serialize_with_options.git
+
+* * *
+
+Copyright (c) 2009 David Eisinger ([Viget Labs][vgt]), released under the MIT license.
+
+[ser]: http://api.rubyonrails.org/classes/ActiveRecord/Serialization.html
+[vgt]: http://www.viget.com/

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the serialize_with_options plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the serialize_with_options plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SerializeWithOptions'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/agile_serializer.rb

@@ -0,0 +1,95 @@
+module AgileSerializer
+
+  def serialize_with_options(set = :default, &block)
+    configuration = read_inheritable_attribute(:configuration) || {}
+    options       = read_inheritable_attribute(:options) || {}
+
+    configuration[set] = Config.new(configuration).instance_eval(&block)
+
+    write_inheritable_attribute :configuration, configuration
+    write_inheritable_attribute :options, options
+
+    include InstanceMethods
+  end
+
+  def serialization_configuration(set)
+    configuration = read_inheritable_attribute(:configuration)
+    conf = if configuration
+      configuration[set] || configuration[:default]
+    end
+
+    conf.try(:dup) || { :methods => nil, :only => nil, :except => nil }
+  end
+
+  def serialization_options(set)
+    options = read_inheritable_attribute(:options)
+    options[set] ||= returning serialization_configuration(set) do |opts|
+      includes = opts.delete(:includes)
+
+      if includes
+        opts[:include] = includes.inject({}) do |hash, class_name|
+          if class_name.is_a? Hash
+            hash.merge(class_name)
+          else
+            begin
+              klass = class_name.to_s.classify.constantize
+              hash[class_name] = klass.serialization_options(set)
+              hash
+            rescue NameError
+              hash.merge(class_name => { :include => nil })
+            end
+          end
+        end
+      end
+    end
+    write_inheritable_attribute :options, options
+    options[set]
+  end
+
+  class Config
+    undef_method :methods
+    Instructions = [:skip_instruct, :dasherize, :skip_types, :root_in_json].freeze
+
+    def initialize(conf)
+      @conf = conf
+      @data = { :methods => nil, :only => nil, :except => nil }
+    end
+
+    def method_missing(method, *args)
+      @data[method] = Instructions.include?(method) ? args.first : args
+      @data
+    end
+
+    def inherit(set)
+      raise "Not known configuration!" unless @conf[set]
+      @data = @conf[set].dup
+    end
+    
+  end
+
+  module InstanceMethods
+    def to_xml(opts = {})
+      set, opts = parse_serialization_options(opts)
+      super(self.class.serialization_options(set).deep_merge(opts))
+    end
+
+    def as_json(opts = {})
+      set, opts = parse_serialization_options(opts)
+      super(self.class.serialization_options(set).deep_merge(opts))
+    end
+
+    private
+
+    def parse_serialization_options(opts)
+      if set = opts[:flavor]
+        new_opts = {}
+        root = opts[:root] and new_opts.merge!(:root => root)
+      else
+        set = :default
+        new_opts = opts
+      end
+
+      [set, opts]
+    end
+  end
+end

data/lib/agile_serializer/version.rb

@@ -0,0 +1,3 @@
+module AgileSerializer
+  VERSION = "0.0.1"
+end

data/rails/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.extend(AgileSerializer)

data/test/serialize_with_options_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :blog_posts
+  has_many :check_ins
+  
+  serialize_with_options do
+    methods   :post_count
+    includes  :posts
+    except    :email
+  end
+
+  serialize_with_options(:deep) do
+    includes :check_ins
+  end
+
+  serialize_with_options(:with_email) do
+    methods   :post_count
+    includes  :posts
+  end
+
+  serialize_with_options(:with_comments) do
+    includes  :posts => { :include => :comments }
+  end
+  
+  serialize_with_options(:with_check_ins) do
+    includes :check_ins
+    dasherize false
+    skip_types true
+  end
+
+  def post_count
+    self.posts.count
+  end
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  belongs_to :user
+
+  serialize_with_options do
+    only :title
+    includes :user, :comments
+  end
+
+  serialize_with_options(:deep) do
+    includes :user
+  end
+
+  serialize_with_options(:with_email) do
+    includes :user, :comments
+  end
+end
+
+class BlogPost < Post
+  serialize_with_options(:with_email) do
+    includes :user
+  end
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+
+class CheckIn < ActiveRecord::Base
+  belongs_to :user
+
+  serialize_with_options(:deep) do
+    only :code_name
+  end
+
+  serialize_with_options do
+    only :code_name
+    includes :user
+  end
+end
+
+class SerializeWithOptionsTest < Test::Unit::TestCase
+  def self.should_serialize_with_options
+    should "include active_record attributes" do
+      assert_equal @user.name, @user_hash["name"]
+    end
+
+    should "include specified methods" do
+      assert_equal @user.post_count, @user_hash["post_count"]
+    end
+
+    should "exclude specified attributes" do
+      assert_equal nil, @user_hash["email"]
+    end
+
+    should "exclude attributes not in :only list" do
+      assert_equal nil, @post_hash["content"]
+    end
+
+    should "include specified associations" do
+      assert_equal @post.title, @user_hash["posts"].first["title"]
+    end
+    
+    should "be identical in inherited model" do
+      assert_equal @post_hash["title"], @blog_post_hash["title"]
+    end
+    
+    should "include specified methods on associations" do
+      assert_equal @user.post_count, @post_hash["user"]["post_count"]
+    end
+
+    should "exclude specified methods on associations" do
+      assert_equal nil,  @post_hash["user"]["email"]
+    end
+
+    should "not include associations of associations" do
+      assert_equal nil, @user_hash["posts"].first["comments"]
+    end
+
+    should "include association without serialization options properly" do
+      assert_equal @comment.content, @post_hash["comments"].first["content"]
+    end
+    
+    should "override sets on inherited models" do
+      assert_equal nil, @blog_post_hash["comments"].first
+    end
+  end
+
+  context "propagate includes" do
+    setup do
+      @user = User.create(:name => "John User", :email => "john@example.com")
+      @post = @user.posts.create(:title => "Hello World!", :content => "Welcome to my blog.")
+      @checkin = @user.check_ins.create(:code_name => "Natasa")
+    end
+
+    should "Include deep relations" do
+      post_hash = JSON.parse @post.to_json(:flavor => :deep)
+      assert_equal @user.email, post_hash["user"]["email"]
+      assert_equal @checkin.code_name, post_hash["user"]["check_ins"].first['code_name']
+    end
+      
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'active_record'
+require 'test/unit'
+require 'shoulda'
+require 'json'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'serialize_with_options'
+require File.dirname(__FILE__) + "/../init"
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => 'test.db'
+)
+
+[:users, :posts, :comments, :check_ins, :reviews].each do |table|
+  ActiveRecord::Base.connection.drop_table table rescue nil
+end
+
+ActiveRecord::Base.connection.create_table :users do |t|
+  t.string :name
+  t.string :email
+end
+
+ActiveRecord::Base.connection.create_table :posts do |t|
+  t.string :title
+  t.text :content
+  t.integer :user_id
+  t.string :type
+end
+
+ActiveRecord::Base.connection.create_table :comments do |t|
+  t.text :content
+  t.integer :post_id
+end
+
+ActiveRecord::Base.connection.create_table :check_ins do |t|
+  t.integer :user_id
+  t.string :code_name
+end
+
+ActiveRecord::Base.connection.create_table :reviews do |t|
+  t.string :content
+  t.integer :reviewable_id
+  t.string :reviewable_type
+end
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: agile_serializer
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Christos Trochalakis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-18 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: A fork of serializer_with_options enabling deep serializer and other features
+email: yatiohi@ideopolis.gr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- Rakefile
+- MIT-LICENSE
+- lib/agile_serializer.rb
+- lib/agile_serializer/version.rb
+- test/serialize_with_options_test.rb
+- test/test_helper.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/ctrochalakis/agile_serializer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Enhanced serialize options for rails, forked from serialize_with_options
+test_files: []
+