simple_json_api 0.0.3 → 0.0.4

data/lib/simple_json_api/helper.rb

@@ -0,0 +1,5 @@
+module SimpleJsonApi
+  # Controller helper methods
+  module Helper
+  end
+end

data/lib/simple_json_api/include_list.rb

@@ -2,19 +2,24 @@
 module SimpleJsonApi
   # List of Included associations for a resource
   class IncludeList
+    attr_reader :include_hash
+
     def initialize(include)
       @include = include
-      @include_list = []
+      # autovivificious hash
+      @include_hash = Hash.new do |hash, key|
+        hash[key] = Hash.new(&hash.default_proc)
+      end
     end
 
     def parse
-      @include_list = @include.split(',').map(&:to_s) if @include.is_a? String
+      @include.split(',').each do |a|
+        inc = a.split('.').inject(@include_hash) do |hash, key|
+          hash[key.pluralize.to_sym]
+        end
+        inc[:include] = true
+      end if @include
       self
     end
-
-    def include?(resource, parent = [])
-      path = [parent, resource].flatten.compact.join('.')
-      @include_list.include?(path)
-    end
   end
 end

data/lib/simple_json_api/json_api_wrapper.rb

@@ -0,0 +1,46 @@
+require 'simple_json_api/member/data'
+require 'simple_json_api/member/included'
+require 'simple_json_api/member/links'
+require 'simple_json_api/member/meta'
+
+module SimpleJsonApi
+  # JSONAPI Wrapper
+  class JsonApiWrapper
+    def initialize(root_node)
+      @root_node = root_node
+      @result = {}
+    end
+
+    def as_json(_options = nil)
+      add_members
+      @result.delete_if { |_, content| content.blank? }
+      @result
+    end
+
+    private
+
+    def add_members
+      links
+      meta
+      data
+      included
+    end
+
+    def links
+      @result[:links] ||= Member::Links.new.content
+    end
+
+    def meta
+      @result[:meta] ||= Member::Meta.new.content
+    end
+
+    def data
+      @result[:data] ||= Member::Data.new(@root_node).content
+    end
+
+    def included
+      @result[:included] ||=
+        Member::Included.new(@root_node, @result[:data]).content
+    end
+  end
+end

data/lib/simple_json_api/member/data.rb

@@ -0,0 +1,14 @@
+module SimpleJsonApi
+  module Member
+    # JSONAPI Data top-level member
+    class Data
+      def initialize(root_node)
+        @root_node = root_node
+      end
+
+      def content
+        @root_node.serialize
+      end
+    end
+  end
+end

data/lib/simple_json_api/member/included.rb

@@ -0,0 +1,38 @@
+module SimpleJsonApi
+  module Member
+    # JSONAPI Included top-level member
+    class Included
+      def initialize(root_node, data)
+        @root_node = root_node
+        @data = data
+        @included = []
+      end
+
+      def content
+        visit(@root_node)
+        @included
+      end
+
+      def visit(node)
+        node.associations.each do |association|
+          process(association) if included?(association)
+          visit(association)
+        end
+      end
+
+      def process(association)
+        Array[association.serialize].flatten.each do |hash|
+          @included << hash unless already_included? hash
+        end
+      end
+
+      def included?(association)
+        association.assoc_list[:include].present?
+      end
+
+      def already_included?(resource)
+        @included.include?(resource) || Array(@data).include?(resource)
+      end
+    end
+  end
+end

data/lib/simple_json_api/member/links.rb

@@ -0,0 +1,9 @@
+module SimpleJsonApi
+  module Member
+    # JSONAPI Links top-level member
+    class Links
+      def content
+      end
+    end
+  end
+end

data/lib/simple_json_api/member/meta.rb

@@ -0,0 +1,9 @@
+module SimpleJsonApi
+  module Member
+    # JSONAPI Meta top-level member
+    class Meta
+      def content
+      end
+    end
+  end
+end

data/lib/simple_json_api/refinements/active_record.rb

@@ -0,0 +1,23 @@
+require 'active_record'
+
+# SimpleJsonApi
+module SimpleJsonApi
+  module Refinements
+    # Refinements on ActiveRecord
+    module ActiveRecord
+      refine ::ActiveRecord::Base do
+        def typed_json_id
+          [self.class.to_s.downcase.pluralize, json_id]
+        end
+
+        def json_id
+          send(json_pk).to_s
+        end
+
+        def json_pk
+          self.class.primary_key.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_api/refinements/array.rb

@@ -0,0 +1,13 @@
+# SimpleJsonApi
+module SimpleJsonApi
+  module Refinements
+    # Refinements on Array
+    module Array
+      refine ::Array do
+        def includes(includes = nil)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_api/refinements/symbol.rb

@@ -0,0 +1,17 @@
+# SimpleJsonApi
+module SimpleJsonApi
+  module Refinements
+    # Refinements on Hash
+    module Symbol
+      refine ::Symbol do
+        def pluralize
+          to_s.pluralize.to_sym
+        end
+
+        def singularize
+          to_s.singularize.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_api/resource.rb

@@ -0,0 +1,23 @@
+module SimpleJsonApi
+  # The representation of a Resource
+  class Resource
+    extend Forwardable
+    def_delegators :@content, :[], :as_json
+
+    def initialize(content)
+      @content = content
+    end
+
+    def ==(other)
+      (@content[:type] &&
+        (@content[:type] == other[:type])) &&
+        (@content[:id] &&
+          (@content[:id] == other[:id]))
+    end
+    # alias_method :eql?, :==
+
+    # def hash
+    #   [@content[:id], @content[:type], Resource].hash
+    # end
+  end
+end

data/lib/simple_json_api/resource_serializer.rb

@@ -1,27 +1,39 @@
+require 'simple_json_api/refinements/active_record'
+require 'simple_json_api/refinements/symbol'
+
 # SimpleJsonApi
 module SimpleJsonApi
   # The Serializer will serialize a model
   class ResourceSerializer < Serializer
-    using ActiveRecordRefinements
+    using Refinements::ActiveRecord
+    using Refinements::Symbol
 
     def _root_name
       self.class._root_name
     end
 
+    def type
+      _root_name
+    end
+
+    def id
+      _object.try(:id) || _object.try(:guid)
+    end
+
     def _fields
-      @_fields ||= begin
-        defaults = self.class.default_fields.split(',')
-        builders = _builder.fields_for(_root_name).presence
-        (builders || defaults).map(&:to_sym)
-      end
+      @_fields ||= _get_fields
+    end
+
+    # If default_fields is not specified, use all_fields
+    def _get_fields
+      builder_fields
     end
 
     def serialize
       hash = {}
       attribute_values(hash)
       link_values(hash[:links] = {})
-      _association_values
-      hash
+      Resource.new(hash)
     end
 
     def attribute_values(hash)
@@ -38,31 +50,20 @@ module SimpleJsonApi
     end
 
     def link(association)
-      resource = send(association.name)
       if association.type == :has_many
-        resource.to_a.map do |obj|
+        includes = association.polymorphic ? [] : Serializer.includes(association)
+        resource = send(association.name, includes)
+        resource.map do |obj|
           association[:polymorphic] ? obj.typed_json_id : obj.json_id
         end
       else
-        resource.json_id
+        resource = send(association.name)
+        resource.json_id if resource
       end
     end
 
     def _associations
       self.class._associations
     end
-
-    def _association_values
-      _associations.each do |association|
-        name = association[:name]
-        obj = send(name)
-        _builder.add_linked_elem(
-          name,
-          obj,
-          association,
-          @_base
-        )
-      end
-    end
   end
 end

data/lib/simple_json_api/serializer.rb

@@ -1,3 +1,6 @@
+require 'simple_json_api/dsl'
+# require 'simple_json_api/refinements/array'
+
 # SimpleJsonApi
 module SimpleJsonApi
   # The Serializer will serialize a model
@@ -16,6 +19,34 @@ module SimpleJsonApi
       @_base = base
     end
 
+    def associated_object(association_name)
+      send(association_name)
+    end
+
+    private
+
+    def default_fields
+      self.class._default_fields
+    end
+
+    def all_fields
+      self.class.default_attributes.split(',')
+    end
+
+    def required_fields
+      [:type, :id]
+    end
+
+    def builder_fields
+      bf = _builder.fields_for(_root_name).presence
+      fields = if bf.present?
+        (required_fields + Array(bf)).uniq
+      else
+        default_fields ? default_fields & all_fields : all_fields
+      end
+      (required_fields + Array(fields)).uniq.map(&:to_sym)
+    end
+
     class << self
       attr_reader :registered_serializers
 
@@ -26,6 +57,7 @@ module SimpleJsonApi
       end
 
       def for(model, association)
+        return association.serializer if association.serializer.present?
         if association[:polymorphic]
           for_polymorphic(model)
         else
@@ -33,19 +65,24 @@ module SimpleJsonApi
         end
       end
 
+      def includes(association)
+        serializer = Serializer.for_regular(association)
+        serializer._associations.reject(&:polymorphic).map { |a| a[:name] } if serializer
+      end
+
       def for_regular(association)
         resource = association[:name].to_s.pluralize.to_sym
         serializer = @registered_serializers.find do |entry|
           entry[:resource] == resource
         end
-        serializer[:serializer]
+        serializer[:serializer] if serializer
       end
 
       def for_polymorphic(model)
         serializer = @registered_serializers.find do |entry|
           entry[:model] == model.class
         end
-        serializer[:serializer]
+        serializer[:serializer] if serializer
       end
     end
   end

data/lib/simple_json_api/serializer_factory.rb

@@ -0,0 +1,22 @@
+require 'simple_json_api/serializer'
+require 'simple_json_api/array_serializer'
+require 'simple_json_api/resource_serializer'
+
+# SimpleJsonApi
+module SimpleJsonApi
+  # The SerializerFactory will return the serializer for an object
+  class SerializerFactory
+    def self.create(object, serializer, builder)
+      if use_array_serializer?(object)
+        ArraySerializer.new(object, builder, serializer)
+      else
+        serializer.new(object, builder)
+      end
+    end
+
+    def self.use_array_serializer?(object)
+      object.is_a?(Array) ||
+        object.is_a?(ActiveRecord::Associations::CollectionProxy)
+    end
+  end
+end

data/lib/simple_json_api/version.rb

@@ -1,4 +1,4 @@
 # SimpleJsonApi
 module SimpleJsonApi
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/simple_json_api.rb

@@ -1,38 +1,16 @@
 require 'simple_json_api/version'
 
-require 'simple_json_api/active_record_refinements'
-require 'simple_json_api/array_refinements'
-# require 'simple_json_api/association'
-# require 'simple_json_api/attribute'
-require 'simple_json_api/dsl'
-require 'simple_json_api/field_list'
-require 'simple_json_api/include_list'
+require 'simple_json_api/json_api_wrapper'
+require 'simple_json_api/builder'
+require 'simple_json_api/resource'
+require 'simple_json_api/helper'
 
-require 'simple_json_api/serializer'
-require 'simple_json_api/array_serializer'
-require 'simple_json_api/resource_serializer'
-
-require 'simple_json_api/json_api_builder'
+# require 'simple_json_api/helper'
 
 # SimpleJsonApi
 module SimpleJsonApi
-  # Wrapper for a linked association
-  Association = Struct.new(:name, :type, :serializer, :polymorphic, :key) do
-    def key
-      name_s = name.to_s
-      (type == :has_many) ? name_s.pluralize.to_sym : name_s.singularize.to_sym
-    end
-  end
-
-  # Attribute
-  Attribute = Struct.new(:name, :key) do
-    def key
-      self[:key] || self[:name]
-    end
-  end
-
   # Main hook to generate json
-  def self.render(model:, serializer:, options: {})
-    JsonApiBuilder.new(model, serializer, options).to_json
+  def self.render(model:, serializer:, fields: nil, include: nil, wrapper: JsonApiWrapper)
+    Builder.new(model, wrapper, serializer, fields, include).to_json
   end
 end