fars 0.0.1 → 0.0.2

data/lib/fars/base_model_serializer.rb

@@ -7,225 +7,69 @@
 #   - create new instance, call to_json
 #   - create new instance, add objects to serialize one by one.
 #     This lets you reuse it without determining known data
-class Fars::BaseModelSerializer
+#
+class Fars::BaseModelSerializer < Fars::BaseObjectSerializer
   class << self
-    def attributes(*attrs)
-      @attributes = attrs.map(&:to_sym)
-    end
-
-    def all_attributes
-      @attributes
-    end
-
-    # Returns {Object} of class, that corresponds to model,
-    # this class meant to serialize
-    def model
-      @klass ||= get_model
-    end
-
-    # Returns {Symbol} instance hash root key, as an underscored Model name
-    def root_key
-      model.to_s.underscore.to_sym
-    end
-
-    # Returns {String} capitalized API version
-    def api_version
-      namespace_array = name.split('::')
-      namespace_array.size > 1 ? namespace_array[0] : nil
-    end
-
-    # Returns {Array} with names of Model relations. Consists of Symbols.
-    # Filtrated by #all_attributes
-    def model_relations
-      @model_relations ||= get_model_relations
-    end
-
-    # Returns {Array} with names of Model methods. Consists of Symbols
+    ##
+    # Returns: {Array} with names of Model methods. Consists of Symbols
     # Filtrated by #all_attributes
+    #
     def model_methods
-      @model_methods ||= get_model_methods
+      @model_methods ||= ((model.attribute_names.map(&:to_sym) | model.instance_methods) - model_relations - serializer_methods) & all_attributes
     end
 
-    # Returns {Array} with names of this serializer instance methods. Consists of Symbols
+    ##
+    # Returns: {Array} with names of Model relations. Consists of Symbols.
     # Filtrated by #all_attributes
-    def serializer_methods
-      @serializer_methods ||= get_serializer_methods
-    end
-
-    def serializer_for_relation(name, _api_version=nil)
-      serializers_cache[name] ||= resolve_serializer(name, _api_version)
-    end
-
-  private
-
-    def serializers_cache
-      @serializers_cache ||= {}
-    end
-
-    def resolve_serializer(relation_name, _api_version=nil)
-      (
-        api_prefix +
-        model.reflect_on_all_associations.
-          find { |assoc| assoc.name == relation_name }.
-            class_name.pluralize +
-        'Serializer'
-      ).constantize
-    end
-
-    def get_model
-      (self.to_s.match /#{api_prefix}(\w+)Serializer/)[1].singularize.constantize
-    end
-
-    def get_model_relations
-      (model.reflect_on_all_associations.map { |r| r.name.to_sym } - serializer_methods) & all_attributes
-    end
-
-    def get_model_methods
-      ((model.attribute_names.map(&:to_sym) | model.instance_methods) - model_relations - serializer_methods) & all_attributes
-    end
-
-    def get_serializer_methods
-      self.instance_methods & all_attributes
-    end
-
-    # Returns {String} prefix for serializer class name using API version
-    def api_prefix
-      api_version ? api_version + '::' : ''
+    #
+    def model_relations
+      @model_relations ||= (model.reflect_on_all_associations.map { |r| r.name.to_sym } - serializer_methods) & all_attributes
     end
   end
 
-  # Initialize new instance
-  #
-  # Params:
-  #   - object {Object} to serialize
-  #   - opts {Hash} of options:
-  #     - fields {Array} of attributes to serialize. Can be {NilClass}.
-  #       If so - will use all available.
-  #     - scope {Object} context of request. Usually current user
-  #       or current ability. Can be passed as a {Proc}. If so -
-  #       evaluated only when actually called.
-  #     - :add_metadata {Boolean} if to add a node '_metadata'
-  #     - :root_key {Symbol} overwrites the default one from serializer's Class
-  def initialize(object, opts={})
-    @object       = object
-    @scope        = opts[:scope]
-    @fields       = opts[:fields]
-    @add_metadata = opts.fetch(:add_metadata, true)
-    @root_key     = opts.fetch(:root_key,     self.class.root_key)
-
-    @serialized_klass   = self.class.model # this goes first
-    @all_attributes     = self.class.all_attributes
-    @object_relations   = self.class.model_relations
-    @object_attributes  = self.class.model_methods
-    @serializer_methods = self.class.serializer_methods
-  end
-
-  def with_object(object)
-    @object = object
-    self
-  end
-
   def as_json
     # as we can re-use one class of serializer for
     # many objects, we need to re-evaluate list
     # of available_attributes for each of them
     all_attrs = available_attributes
     item      = {}
-
-    (requested_object_attributes & all_attrs).each do |attr|
-      item[attr] = object.send(attr)
+    (requested_model_methods & all_attrs).each do |attr|
+      item[attr] = object.public_send(attr)
     end
-
     (requested_serializer_methods & all_attrs).each do |meth|
-      item[meth] = self.send(meth)
+      item[meth] = self.public_send(meth)
     end
-
-    (requested_object_relations & all_attrs).each do |rel|
+    (requested_model_relations & all_attrs).each do |rel|
       item[rel] = serialize_relation(rel)
     end
-
-    hash = {root_key => item}
+    hash = { root_key => item }
     hash[:_metadata] = meta if add_metadata?
     hash
   end
 
-  def to_json
-    MultiJson.dump(as_json)
-  end
-
-protected
-
-  # TODO: Document
-  def serialize_relation(relation_name, relation=nil)
-    klass = self.class.serializer_for_relation(relation_name)
-    relation ||= object.send(relation_name)
-    klass.new(relation,
-              root_key:     false,
-              scope:        @scope,
-              add_metadata: add_metadata?).as_json
-  end
-
 private
 
-  # Things we get from options
-  attr_reader :object, :fields, :root_key
-
-  # Utility things
-  attr_reader :serialized_klass
+  delegate :model_relations, :model_methods, to: :'self.class'
 
-  # Sets of attributes/methods/relations
-  attr_reader :all_attributes, :object_attributes, :serializer_methods, :object_relations
-
-  # List of attributes requested to be shown.
-  # This is frequently done by :fields HTTP request
-  # parameter
-  def requested_attributes
-    @requested_attributes ||= get_requested_attributes
-  end
-
-  def scope
-    if @scope.is_a? Proc
-      @scope = @scope.call
-    else
-      @scope
-    end
-  end
-
-  def add_metadata?
-    @add_metadata
-  end
-
-  def requested_object_attributes
-    @requested_object_attributes  ||= object_attributes & requested_attributes
+  def requested_model_methods
+    @requested_model_methods ||= model_methods & requested_attributes
   end
 
-  def requested_serializer_methods
-    @requested_serializer_methods ||= serializer_methods & requested_attributes
+  def requested_model_relations
+    @requested_model_relations ||= model_relations & requested_attributes
   end
 
-  def requested_object_relations
-    @requested_object_relations   ||= object_relations & requested_attributes
-  end
-
-  # List of attributes available to be shown
-  # by current security context.
+  ##
+  # Serializes object's relation
   #
-  # Can be re-defined in children classes
-  def available_attributes
-    all_attributes
-  end
-
-  def get_requested_attributes
-    case fields
-      when NilClass then all_attributes
-      when Array    then fields.map(&:to_sym) | [:id]
-      when Symbol   then [fields.to_sym]
-      when String   then [fields]
-    end
-  end
-
-  # Returns {String} - API version is got by instance class
-  def api_version
-    self.class.api_version
+  # Returns: {Hash}
+  #
+  def serialize_relation(relation_name, relation = nil)
+    relation ||= object.public_send(relation_name)
+    ::Fars::BaseCollectionSerializer.new(relation,
+      root_key: false,
+      scope: @scope,
+      add_metadata: add_metadata?,
+      api_version: api_version).as_json
   end
 end

data/lib/fars/base_object_serializer.rb

@@ -0,0 +1,147 @@
+##
+# Class: BaseObjectSerializer
+#
+class Fars::BaseObjectSerializer
+  class << self
+    def attributes(*attrs)
+      @attributes = attrs.map(&:to_sym)
+    end
+
+    def all_attributes
+      @attributes
+    end
+
+    ##
+    # Returns: {Class} of serialized model (can be nil)
+    #
+    def model
+      @model ||= begin
+        @class_name ||= self.to_s.sub(/^V\d+::/, '').sub(/Serializer$/, '')
+        @class_name.constantize if Object.const_defined?(@class_name)
+      end
+    end
+    attr_writer :model
+
+    ##
+    # Returns: {Symbol} instance hash root key, as an underscored Model name
+    #
+    def root_key
+      @root_key ||= (model ? model.to_s.underscore.to_sym : nil)
+    end
+    attr_writer :root_key
+
+    ##
+    # Returns: {String} capitalized API version (can be nil)
+    #
+    def api_version
+      namespace_array = name.split('::')
+      namespace_array.size > 1 ? namespace_array[0] : nil
+    end
+
+    ##
+    # Returns: {Array} with names of this serializer instance methods. Consists of Symbols
+    # Filtrated by #all_attributes
+    #
+    def serializer_methods
+      @serializer_methods ||= self.instance_methods & all_attributes
+    end
+  end
+
+  ##
+  # Initialize new instance
+  #
+  # Params:
+  #   - object {ActiveRecord::Base} or any {Object} to serialize
+  #   - opts {Hash} of options:
+  #     - fields {Array} of attributes to serialize. Can be {NilClass}.
+  #       If so - will use all available.
+  #     - scope {Object} context of request. Usually current user
+  #       or current ability. Can be passed as a {Proc}. If so -
+  #       evaluated only when actually called.
+  #     - :add_metadata {Boolean} if to add a node '_metadata'
+  #     - :root_key {Symbol} overwrites the default one from serializer's Class
+  #
+  def initialize(object, opts = {})
+    @object       = object
+    @scope        = opts[:scope]
+    @fields       = opts[:fields]
+    @add_metadata = opts.fetch(:add_metadata, self.respond_to?(:meta))
+    @root_key     = opts.fetch(:root_key, self.class.root_key)
+    @api_version  = opts.fetch(:api_version, self.class.api_version)
+    @params       = opts[:params] || {}
+  end
+
+  def with_object(object)
+    @object = object
+    self
+  end
+
+  def as_json
+    item = {}
+    ((requested_attributes - requested_serializer_methods) & available_attributes).each do |m|
+      next if m == :id && !object.respond_to?(:id)
+      item[m] = object.public_send(m)
+    end
+    (requested_serializer_methods & available_attributes).each do |m|
+      item[m] = self.public_send(m)
+    end
+    hash = { root_key => item }
+    hash[:_metadata] = meta if add_metadata?
+    hash
+  end
+
+  def to_json
+    MultiJson.dump(as_json)
+  end
+
+  def call(obj)
+    with_object(obj).as_json
+  end
+
+private
+
+  # Things we get from options
+  attr_reader :object, :fields, :root_key, :api_version, :params
+
+  def scope
+    if @scope.is_a? Proc
+      @scope = @scope.call
+    else
+      @scope
+    end
+  end
+
+  def add_metadata?
+    @add_metadata
+  end
+
+  delegate :all_attributes, :serializer_methods, to: :'self.class'
+
+  def requested_serializer_methods
+    @requested_serializer_methods ||= serializer_methods & requested_attributes
+  end
+
+  ##
+  # List of attributes requested to be shown.
+  # This is frequently done by :fields HTTP request
+  # parameter
+  #
+  def requested_attributes
+    @requested_attributes ||= begin
+      case fields
+      when NilClass then all_attributes
+      when Array    then fields.map(&:to_sym) | [:id]
+      when Symbol   then [fields]
+      when String   then [fields.to_sym]
+      end
+    end
+  end
+
+  ##
+  # List of attributes available to be shown
+  # by current security context.
+  #
+  # Can be re-defined in inherited class
+  #
+  alias_method :available_attributes, :all_attributes
+end

data/lib/fars/model_serializable.rb

@@ -0,0 +1,7 @@
+module Fars::ModelSerializable
+  def serialize(opts = {})
+    api_prefix = opts[:api_version] + '::' if opts[:api_version]
+    serializer_class = (opts[:serializer] || "#{api_prefix}#{self.class.base_class}Serializer").constantize
+    serializer_class.new(self, opts).to_json
+  end
+end

data/lib/fars/relation_serializable.rb

@@ -0,0 +1,5 @@
+module Fars::RelationSerializable
+  def serialize(opts = {}, &block)
+    Fars::BaseCollectionSerializer.new(self, opts, &block).to_json
+  end
+end

data/lib/fars/version.rb

@@ -1,3 +1,3 @@
 module Fars
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/active_record/base_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'ActiveRecord::Base#serialize' do
+  subject { Master.create(id: 1, name: 'Object1', data: '123') }
+
+  specify 'with default options without metadata' do
+    json_data = { master: { id: 1, name: 'Object1', data: '123', slaves: [] } }.to_json
+    subject.serialize(add_metadata: false).should == json_data 
+  end
+
+  specify 'with custom item serializer class' do
+    json_data = { father: { id: 1, name: 'Object1', number: 14, slaves: [] } }.to_json
+    subject.serialize(serializer: 'AnotherMasterSerializer').should == json_data 
+  end
+end

data/spec/active_record/relation_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'ActiveRecord::Relation#serialize' do
+  before(:each) do
+    1.upto(2) { |i| Master.create(id: i, name: "Object#{i}", data: '123') }
+    1.upto(3) { |i| Slave.create(id: i, master_id: (i % 2) + 1, name: "Slave #{i}") }
+  end
+  subject { Master.where('1 = 1').order(:id) }
+
+  specify 'add metadata for collection' do
+    json_data = { masters: [{ master: { name: 'Object1' } }, { master: { name: 'Object2' } }],
+      _metadata: { order: :id } }.to_json
+
+    subject.serialize(fields: :name, add_metadata: false, metadata: { order: :id }).should == json_data
+  end
+end