simple_json_api 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a442243658287849495015d9e7d70033be758c9
-  data.tar.gz: 47fa80783b4c0689f3e26051a012aeda9e077caf
+  metadata.gz: d342c421da25b887edeade3d14b1a145bbe3a352
+  data.tar.gz: 2720735c97db2a23d45ac6154460f2c92f8dfa67
 SHA512:
-  metadata.gz: 39b59ac72db54031090ca63f62bdc8387cef3ce49039a49841ca7cb0df7cd0ea3972dbf88af350ed81b3c6b34e2d77e6baf2996eb3714525c35811f2942787e4
-  data.tar.gz: 5d3a296127944821174cc21c352ad079989899501268d34517499b4700e44b88642d639b83770a35f7c210d5ad86a4bcf3939a14687c9789457ac280bcb3aff0
+  metadata.gz: 87165f1029afae88c79cae12d06d502ad77fe55c6d2a68cdb02b6446ef757b73cc2ea3e0906418083ba1f358f5a79a88a7348acdb8754227e6d24c65f9182038
+  data.tar.gz: 7f0428e1ab60247971c0ef04ad4a09a156ab62c5c784473024c90da6809ec6656fd77b006025593aa3b021852219830f585cbd004e401544a07a6c905fd2e825

data/Gemfile

@@ -8,7 +8,6 @@ version = ENV['RAILS_VERSION'] || '4.1'
 case version
 when 'master'
   gem 'rails', github: 'rails/rails'
-
   # Learned from AMS
   # ugh https://github.com/rails/rails/issues/16063#issuecomment-48090125
   gem 'arel', github: 'rails/arel'
@@ -18,4 +17,17 @@ else
   fail GemfileError, "Unsupported Rails version - #{version}"
 end
 
-gem 'codeclimate-test-reporter', group: :test, require: nil
+group :test do
+  gem 'codeclimate-test-reporter', require: nil
+end
+
+group :development do
+  gem 'rdoc'
+
+  gem 'awesome_print'
+  gem 'minitest-match_json'
+  gem 'diffy'
+  gem 'minitest'
+  gem 'minitest-reporters'
+  gem 'sqlite3'
+end

data/README.md

@@ -1,6 +1,6 @@
 # SimpleJsonApi
 
-[![Build Status](https://travis-ci.org/ggordon/simple_json_api.svg?branch=master)](https://travis-ci.org/ggordon/simple_json_api) [![Code Climate](https://codeclimate.com/github/ggordon/simple_json_api/badges/gpa.svg)](https://codeclimate.com/github/ggordon/simple_json_api) [![Test Coverage](https://codeclimate.com/github/ggordon/simple_json_api/badges/coverage.svg)](https://codeclimate.com/github/ggordon/simple_json_api)
+[![Build Status](https://travis-ci.org/ggordon/simple_json_api.svg?branch=master)](https://travis-ci.org/ggordon/simple_json_api) [![Code Climate](https://codeclimate.com/github/ggordon/simple_json_api/badges/gpa.svg)](https://codeclimate.com/github/ggordon/simple_json_api) [![Test Coverage](https://codeclimate.com/github/ggordon/simple_json_api/badges/coverage.svg)](https://codeclimate.com/github/ggordon/simple_json_api) [![Gem Version](https://badge.fury.io/rb/simple_json_api.svg)](http://badge.fury.io/rb/simple_json_api)
 
 A gem to render json following the [jsonapi](http://jsonapi.org) spec.
 

data/lib/generators/simple_json_api/resource/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate simple_json_api:resource resource
+
+    This will create:
+        what/will/it/create

data/lib/generators/simple_json_api/resource/resource_generator.rb

@@ -0,0 +1,73 @@
+module SimpleJsonApi
+  module Generators
+    # Generates the resource template files
+    class ResourceGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :name, type: :string, required: true, banner: 'ResourceName'
+
+      class_option :model,
+                   desc: 'Model class if different than Resource',
+                   type: :string
+      class_option :namespace,
+                   desc: 'Namespace for the generated files',
+                   type: :string
+      class_option :controller,
+                   desc: 'Base controller for resources',
+                   type: :string
+      class_option :skip_serializer,
+                   desc: "Don't generate a serializer file.",
+                   type: :boolean
+      class_option :skip_controller,
+                   desc: "Don't generate a controller file.",
+                   type: :boolean
+      class_option :skip_service,
+                   desc: "Don't generate a service file.",
+                   type: :boolean
+      class_option :root_dir,
+                   desc: "Root dir for generated code, default: '.'.",
+                   type: :string
+
+      def create_resource
+        @namespace = options[:namespace]
+        @model = options[:model] || class_name
+        namespaced_name = [@namespace, class_name].compact.join('::')
+        @serializer_name = "#{namespaced_name}Serializer"
+        @controller_name = "#{namespaced_name.pluralize}Controller"
+        @base_controller = options[:controller] || 'ApplicationController'
+        @root_dir = options[:root_dir] || '.'
+        file_path = "#{@namespace.underscore}/#{class_name.underscore}"
+
+        check_model
+
+        unless options[:skip_serializer]
+          template 'serializer_template.rb.erb',
+                   "#{@root_dir}/app/serializers/#{file_path}_serializer.rb"
+          # TODO: create serializer test
+        end
+
+        unless options[:skip_controller]
+          template 'controller_template.rb.erb',
+                   "#{@root_dir}/app/controllers/#{file_path.pluralize}_controller.rb"
+          # TODO: create controller test
+        end
+
+        unless options[:skip_service]
+          # TODO: create service
+          # TODO: create service test
+        end
+      end
+
+      private
+
+      def check_model
+        unless @model.constantize.ancestors.include?(ActiveRecord::Base)
+          fail NameError
+        end
+      rescue NameError
+        puts "Error: '#{@model}' is not an AR model"
+        exit
+      end
+    end
+  end
+end

data/lib/generators/simple_json_api/resource/templates/controller_template.rb.erb

@@ -0,0 +1,34 @@
+class <%= @controller_name -%> < <%= @base_controller %>
+  include SimpleJsonApi::Helper
+
+  def index
+    @<%= class_name.underscore.gsub('/', '__').pluralize %> = <%= @model -%>.paginate(page: params[:page], per_page: params[:per_page]).to_a
+    render json: SimpleJsonApi.render(
+                   model: @<%= class_name.underscore.gsub('/', '__').pluralize %>,
+                   serializer: <%= @serializer_name %>,
+                   fields: options_hash.fetch(:fields, nil),
+                   include: options_hash.fetch(:include, nil)
+                 ),
+           status: 200
+  end
+
+  def show
+    @<%= class_name.underscore.gsub('/', '__') %> = <%= @model -%>.find(params[:id])
+    render json: SimpleJsonApi.render(
+                   model: @<%= class_name.underscore.gsub('/', '__') %>,
+                   serializer: <%= @serializer_name %>,
+                   fields: options_hash.fetch(:fields, nil),
+                   include: options_hash.fetch(:include, nil)
+                 ),
+           status: 200
+  end
+
+  private
+
+  def options_hash
+    {
+      fields: params[:fields],
+      include: params[:include]
+    }
+  end
+end

data/lib/generators/simple_json_api/resource/templates/serializer_template.rb.erb

@@ -0,0 +1,14 @@
+class <%= @serializer_name -%> < SimpleJsonApi::ResourceSerializer
+  serializes :<%= class_name.underscore.gsub('/', '__').pluralize %>, model: <%= "::#{@model}" -%>, primary_key: :<%= @model.constantize.primary_key %>
+
+  <%- @model.constantize.column_names.each do |col| -%>
+  attribute :<%= col %>
+  <%- end -%>
+
+  <%- @model.constantize.reflect_on_all_associations.each do |assoc| -%>
+    <%- klass_name = assoc.options[:class_name] -%>
+    <%- serializer = [@namespace, klass_name].compact.join('::') + 'Serializer' if klass_name -%>
+  <%= assoc.macro %> :<%= assoc.name %><%= ', polymorphic: true' if assoc.options[:polymorphic] %><%= ', serializer: ' + serializer if serializer %>
+  <%- end -%>
+end
+

data/lib/simple_json_api/api_node.rb

@@ -0,0 +1,68 @@
+require 'simple_json_api/refinements/symbol'
+
+module SimpleJsonApi
+  # Node in the directed graph of associations (eventually)
+  # Will start as a tree with duplication
+  class ApiNode
+    extend Forwardable
+    def_delegators :serializer, :serialize
+
+    attr_reader :name
+    attr_reader :serializer
+    attr_reader :associations
+    attr_reader :assoc_list
+
+    def initialize(name, serializer, assoc_list, each_serializer = nil)
+      @name = name
+      @serializer = serializer
+      @each_serializer = each_serializer
+      @assoc_list = assoc_list
+      @associations = [] # list of api_nodes
+    end
+
+    def load
+      return self unless serializer_actual._associations
+      serializer_actual._associations.each do |association|
+        add_association(association)
+      end
+      self
+    end
+
+    def serializer_actual
+      @serializer_actual ||= @each_serializer || self.serializer
+    end
+
+    def add_association(association)
+      return unless @assoc_list.key? association.plural_name
+      resource = serializer.associated_object(association.name)
+      Array(resource).each do |object|
+        each_serializer = Serializer.for(object, association)
+        serializer = SerializerFactory.create(
+          object, each_serializer, self.serializer._builder
+        )
+        self <<
+          ApiNode.new(
+            association.plural_name,
+            serializer,
+            @assoc_list[association.plural_name],
+            serializer._each_serializer
+          ).load
+      end
+    end
+
+    def <<(node)
+      add_assoc(node)
+    end
+
+    def add_assoc(node)
+      @associations << node
+    end
+
+    # def display(offset = '')
+    #   ap "DISPLAY: #{offset}#{@name}, #{@assoc_list}, #{Array(@object).first.class}, #{Array(@object).map(&:id)}"
+    #   @associations.each do |assoc|
+    #     assoc.display(offset + '  ')
+    #   end
+    # end
+  end
+end

data/lib/simple_json_api/array_serializer.rb

@@ -5,12 +5,26 @@ module SimpleJsonApi
     def serialize
       _object.map do |object|
         serializer = _each_serializer.new(object, _builder)
-        serializer.serialize
+        Resource.new(serializer.serialize)
       end
     end
 
+    def associated_object(association_name)
+      serializers.map { |serializer| serializer.send(association_name) }
+    end
+
     def _root_name
       _each_serializer._root_name
     end
+
+    def _associations
+      _each_serializer._associations if _each_serializer
+    end
+
+    def serializers
+      _object.map do |object|
+        _each_serializer.new(object, _builder)
+      end
+    end
   end
 end

data/lib/simple_json_api/association.rb

@@ -0,0 +1,16 @@
+# SimpleJsonApi
+module SimpleJsonApi
+  # Wrapper for an included association
+  Association = Struct.new(:name, :type, :serializer, :polymorphic, :key) do
+    using Refinements::Symbol
+
+    def key
+      name_s = name.to_s
+      (type == :has_many) ? name_s.pluralize.to_sym : name_s.singularize.to_sym
+    end
+
+    def plural_name
+      name.pluralize
+    end
+  end
+end

data/lib/simple_json_api/attribute.rb

@@ -0,0 +1,9 @@
+# SimpleJsonApi
+module SimpleJsonApi
+  # Wrapper for an Attribute
+  Attribute = Struct.new(:name, :key) do
+    def key
+      self[:key] || self[:name]
+    end
+  end
+end

data/lib/simple_json_api/builder.rb

@@ -0,0 +1,35 @@
+require 'simple_json_api/api_node'
+require 'simple_json_api/field_list'
+require 'simple_json_api/include_list'
+require 'simple_json_api/refinements/active_record'
+require 'simple_json_api/serializer_factory'
+
+# SimpleJsonApi
+module SimpleJsonApi
+  # The Builder to walk the hierarchy and construct the JSON
+  class Builder
+    extend Forwardable
+
+    attr_reader :wrapper
+    attr_reader :field_list
+    attr_reader :include
+    attr_reader :object
+    attr_reader :serializer
+
+    def_delegators :@field_list, :fields_for
+
+    # TODO: sort: nil
+    def initialize(object, wrapper, serializer, fields, include)
+      @object = object
+      @wrapper = wrapper
+      @field_list = FieldList.new(fields, serializer)
+      @include = IncludeList.new(include).parse
+      @serializer = SerializerFactory.create(object, serializer, self)
+    end
+
+    def as_json(options = nil)
+      root_node = ApiNode.new(serializer._root_name, serializer, include.include_hash).load
+      wrapper.new(root_node).as_json(options)
+    end
+  end
+end

data/lib/simple_json_api/dsl.rb

@@ -1,9 +1,17 @@
+require 'simple_json_api/association'
+require 'simple_json_api/attribute'
+require 'simple_json_api/refinements/array'
+
 # SimpleJsonApi
 module SimpleJsonApi
   # Define the public API for creating serializers
   module DSL
+    using Refinements::Array
+
     attr_accessor :_associations
     attr_accessor :_attributes
+    attr_accessor :_default_fields
+    attr_accessor :_required_associations
     attr_reader :_root_name
 
     def inherited(base)
@@ -12,7 +20,7 @@ module SimpleJsonApi
     end
 
     def serializes(name, options = {})
-      ResourceSerializer.register_serializer(
+      Serializer.register_serializer(
         { serializer: self, resource: name },
         options
       )
@@ -23,6 +31,16 @@ module SimpleJsonApi
       register_attribute(name, options)
     end
 
+    # Attributes presented if no fields specified
+    def default_fields(attrs)
+      @_default_fields = attrs
+    end
+
+    # Associations that are always included
+    def required_associations(assocs)
+      @_required_associations = assocs
+    end
+
     def belongs_to(name, options = {})
       register_association(name, :belongs_to, options)
     end
@@ -35,7 +53,7 @@ module SimpleJsonApi
       register_association(name, :has_one, options)
     end
 
-    def default_fields
+    def default_attributes
       @_attributes.map(&:first).join(',')
     end
 
@@ -44,16 +62,28 @@ module SimpleJsonApi
     def register_association(name, type, options)
       serializer = options.fetch(:serializer, nil)
       polymorphic = options.fetch(:polymorphic, false)
-      association = SimpleJsonApi::Association.new(
+      association = Association.new(
         name, type, serializer, polymorphic
       )
       _associations << association
-      def_delegator :_object, association.name
+      define_assoc_method(association) # unless defined? association.name
+    end
+
+    def define_assoc_method(association)
+      if association.type == :has_many
+        define_method association.name do |includes = nil|
+          _object.send(association.name).includes(includes).to_a if _object.respond_to?(association.name)
+        end
+      else
+        define_method association.name do |includes = nil|
+          _object.send(association.name) if _object.respond_to?(association.name)
+        end
+      end
     end
 
     def register_attribute(name, options)
       key = options.fetch(:key, nil)
-      attribute = SimpleJsonApi::Attribute.new(name, key)
+      attribute = Attribute.new(name, key)
       _attributes << attribute
       def_delegator :_object, attribute.name
     end

data/lib/simple_json_api/field_list.rb

@@ -13,13 +13,10 @@ module SimpleJsonApi
 
     def parse
       result = {}
-      case @fields
-      when Hash
+      if @fields.is_a? Hash
         @fields.each do |resource, fields|
-          result[resource.to_sym] = FIELD_LIST_PARSER.call(fields)
+          result[resource.to_sym] = fields.split(',').map(&:to_s)
         end
-      when String
-        result[@root_serializer._root_name] = FIELD_LIST_PARSER.call(@fields)
       end
       result
     end
@@ -27,7 +24,5 @@ module SimpleJsonApi
     def fields_for(resource)
       field_list.fetch(resource, nil)
     end
-
-    FIELD_LIST_PARSER = ->(list) { list.split(',').map(&:to_s) }
   end
 end