Ticket #8920: add_options_to_AR_to_json.diff

test/json_encoding_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/author'
+require 'fixtures/comment'
+
+class Contact < ActiveRecord::Base
+  # mock out self.columns so no pesky db is needed for these tests
+  def self.columns() @columns ||= []; end
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  end
+
+  column :name,       :string
+  column :age,        :integer
+  column :avatar,     :binary
+  column :created_at, :datetime
+  column :awesome,    :boolean
+  column :gender,     :string
+end
+
+
+class JsonEncodingTest < Test::Unit::TestCase
+
+  def setup
+    @david = Contact.new(
+               :name => 'David',
+               :age => 27,
+               :awesome => true,
+               :gender => 'Male')
+  end
+
+  def test_should_encode_all_encodable_attributes
+    json = @david.to_json
+
+    assert_match %r{name: "David"}, json
+    assert_match %r{age: 27}, json
+    assert_match %r{awesome: true}, json
+    assert_match %r{gender: "Male"}, json
+  end
+
+  def test_binary_attributes_should_be_skipped
+    assert_no_match %r{avatar: }, @david.to_json
+  end
+
+  def test_should_allow_attribute_filtering_with_only
+    json = @david.to_json(:only => [:age, :name])
+
+    assert_match %r{name: "David"}, json
+    assert_match %r{age: 27}, json
+    assert_no_match %r{awesome: true}, json
+    assert_no_match %r{gender: "Male"}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_except
+    json = @david.to_json(:except => [:age, :gender])
+
+    assert_match %r{name: "David"}, json
+    assert_match %r{awesome: true}, json
+    assert_no_match %r{age: 27}, json
+    assert_no_match %r{gender: "Male"}, json
+  end
+
+  def test_methods_are_called_on_object
+    # Define methods on fixture.
+    def @david.label; "Father of Rails"; end
+    def @david.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_equal %({name: "David", label: "Father of Rails"}), @david.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @david.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{label: "Father of Rails"}, methods_json
+    assert_match %r{favorite_quote: "Constraints are liberating"}, methods_json
+  end
+end
+
+
+class DatabaseConnectedJsonEncodingTest < Test::Unit::TestCase
+  fixtures :authors, :posts, :comments
+
+  def setup
+    @david = authors(:david)
+  end
+
+  def test_includes_uses_association_name
+    json = @david.to_json(:include => :posts)
+
+    assert_match %r{id: 1}, json
+    assert_match %r{name: "David"}, json
+    assert_match %r{posts: \[}, json
+
+    assert_match %r{author_id: 1}, json
+    assert_match %r{title: "Welcome to the weblog"}, json
+    assert_match %r{body: "Such a lovely day"}, json
+
+    assert_match %r{title: "So I was thinking"}, json
+    assert_match %r{body: "Like I hopefully always am"}, json
+  end
+
+  def test_includes_uses_association_name_and_applies_attribute_filters
+    json = @david.to_json(:include => { :posts => { :only => :title } })
+
+    assert_match %r{name: "David"}, json
+    assert_match %r{posts: \[}, json
+
+    assert_match %r{title: "Welcome to the weblog"}, json
+    assert_no_match %r{body: "Such a lovely day"}, json
+
+    assert_match %r{title: "So I was thinking"}, json
+    assert_no_match %r{body: "Like I hopefully always am"}, json
+  end
+
+  def test_includes_fetches_second_level_associations
+    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
+
+    assert_match %r{name: "David"}, json
+    assert_match %r{posts: \[}, json
+
+    assert_match %r{comments: \[}, json
+    assert_match %r{\{body: "Thank you again for the welcome"\}}, json
+    assert_match %r{\{body: "Don't think too hard"\}}, json
+    assert_no_match %r{post_id: }, json
+  end
+
+  def test_should_not_call_methods_on_associations_that_dont_respond
+    def @david.favorite_quote; "Constraints are liberating"; end
+    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
+
+    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_match %r{favorite_quote: "Constraints are liberating"}, json
+    assert_equal %r{favorite_quote: }.match(json).size, 1
+  end
+end

lib/active_record/json_encoding.rb

@@ +1 @@
+module ActiveRecord #:nodoc:
+  module JsonEncoding
+    def to_json(options = {})
+      hashifier = JsonHashifier.new(self, options)
+      hashifier.to_hash.to_json
+    end
+
+
+    class JsonHashifier #:nodoc:
+      attr_reader :options
+
+      def initialize(record, options = {})
+        @record, @options = record, options.dup
+      end
+
+      # Outputs AR record instance method as a hash that can be easily
+      # encoded as JSON.
+      def to_hash
+        hash = {}
+
+        hash.merge!(simple_attributes)
+        hash.merge!(method_attributes)
+        hash.merge!(association_attributes)
+
+        hash
+      end
+
+      # Returns 1st level attributes as a hash.
+      def simple_attributes
+        attribute_names = @record.attribute_names
+
+        if options[:only]
+          options.delete(:except)
+          attribute_names = attribute_names & Array(options[:only]).collect(&:to_s)
+        else
+          options[:except] = Array(options[:except]) | Array(@record.class.inheritance_column)
+          attribute_names = attribute_names - options[:except].collect(&:to_s)
+        end
+
+        attribute_names.reject! { |n| binary_attribute?(n) } # Don't JSON-ify binary fields!
+
+        @record.attributes(:only => attribute_names)
+      end
+
+      # Returns 1st level methods as a hash.
+      def method_attributes
+        Array(options[:methods]).inject({}) do |method_attributes, name|
+          method_attributes.merge!({ name.to_s => @record.send(name.to_s) }) if @record.respond_to?(name.to_s)
+          method_attributes
+        end
+      end
+
+      # Returns 1st level associations as a hash. Recursively "hashifies"
+      # associations so that nth level associations are converted to JSON as well.
+      def association_attributes
+        hash = {}
+
+        if include_associations = options.delete(:include)
+          base_only_or_except = { :except => options[:except],
+                                  :only => options[:only] }
+
+          include_has_options = include_associations.is_a?(Hash)
+
+          for association in include_has_options ? include_associations.keys : Array(include_associations)
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+
+            opts = options.merge(association_options)
+
+            case @record.class.reflect_on_association(association).macro
+            when :has_many, :has_and_belongs_to_many
+              records = @record.send(association).to_a
+              unless records.empty?
+                hash[association] = records.collect { |r| JsonHashifier.new(r, opts).to_hash }
+              end
+            when :has_one, :belongs_to
+              if record = @record.send(association)
+                hash[association] = JsonHashifier.new(record, opts).to_hash
+              end
+            end
+          end
+
+          options[:include] = include_associations
+        end
+
+        hash
+      end
+
+      protected
+
+        def binary_attribute?(name)
+          !@record.class.serialized_attributes.has_key?(name) && @record.class.columns_hash[name].type == :binary
+        end
+    end
+
+  end
+end

lib/active_record.rb

@@ -52 +52 @@
-require 'active_record/schema'
-require 'active_record/calculations'
-require 'active_record/xml_serialization'
+require 'active_record/json_encoding'
-require 'active_record/attribute_methods'
-
-ActiveRecord::Base.class_eval do
@@ -70 +71 @@
-  include ActiveRecord::Acts::NestedSet
-  include ActiveRecord::Calculations
-  include ActiveRecord::XmlSerialization
+  include ActiveRecord::JsonEncoding
-  include ActiveRecord::AttributeMethods
-end
-