jserializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eff59fc3af48019c3a9800760d5d09c58a934c78
+  data.tar.gz: 308fc34cd019fd9c29a0e5b06dc9068ee19c431c
+SHA512:
+  metadata.gz: 87093b362a7810c4a65475790f91e80c55ea450c9c459c053e7bd0582eb402b46583d5332e5d47d62444fd7b71ea189ba84ba0d0deb73e82a2f2f21697c7a53b
+  data.tar.gz: be66e3b62de854ceb486e329f8678a2ea767b54352452911d39eccffbaeeb650003a1e4dea9f9542c98206a3bd571b02dc1073d7332a95c87c596a2240321f2b

data/lib/jserializer/association.rb

@@ -0,0 +1,85 @@
+module Jserializer
+  class Association
+    attr_reader :relation_type, :serializer, :id_only
+
+    def initialize(name, relation_type, key:, serializer:, id_only:, embed_key:)
+      @attribute_name = name.to_s
+      @relation_type = relation_type
+      @key = key
+      @serializer = serializer
+      @id_only = id_only || false
+      @embed_key = embed_key || :id
+    end
+
+    def key
+      return @key if @key || !@id_only
+      case @relation_type
+      when :has_many
+        :"#{singularize_attribute_name}_ids"
+      when :has_one
+        :"#{@attribute_name}_id"
+      end
+    end
+
+    # The method name to access the data of the attribute
+    def access_name
+      return @attribute_name unless @id_only
+      # for simplicity without guessing
+      # the access method is post_ids for posts if associated with has_many
+      # and post.id for post if associated with has_one
+      # This also means for serializing a Hash object with has_one association
+      # It must provide access key like "post.id" to get data
+      case @relation_type
+      when :has_many
+        "#{singularize_attribute_name}_#{@embed_key}s"
+      when :has_one
+        "#{@attribute_name}.#{@embed_key}"
+      else
+        @attribute_name
+      end
+    end
+
+    def serialize(record)
+      return nil if record.nil?
+      return [] if relation_type == :has_many && record.empty?
+      return serialize_collection(record) if relation_type == :has_many
+      return serialize_one(record) if relation_type == :has_one
+      raise "Unable to serialize association type: #{relation_type}"
+    end
+
+    private
+
+    def serialize_collection(records)
+      klass = find_serializer_class(records.first)
+      return klass.new(records).serializable_collection if klass
+
+      unless records.first.respond_to?(:as_json)
+        raise "Unable to find serializer for #{records.first.class.name}"
+      end
+
+      # loop through collection and serialize with as_json
+      records.map { |record| record.as_json(root: false) }
+    end
+
+    def serialize_one(record)
+      klass = find_serializer_class(record)
+      return klass.new(record).serializable_hash if klass
+
+      unless record.respond_to?(:as_json)
+        raise "Unable to find serializer for #{record.class.name}"
+      end
+      record.as_json(root: false)
+    end
+
+    def find_serializer_class(model)
+      return serializer if serializer
+      return nil unless model.respond_to?(:active_model_serializer)
+      model.active_model_serializer
+    end
+
+    def singularize_attribute_name
+      return @attribute_name unless @attribute_name.end_with?('s')
+      @attribute_name[0...-1]
+    end
+  end
+end

data/lib/jserializer/base.rb

@@ -0,0 +1,202 @@
+module Jserializer
+  class Base
+    @_attributes = {}
+    @_embed = :objects
+
+    class << self
+      attr_accessor :_attributes, :_root_key, :_embed
+
+      def attributes(*names)
+        names.each { |name| _add_attribute(name, nil) }
+      end
+
+      def attribute(name, key: nil)
+        _add_attribute(name, key)
+      end
+
+      def root(name)
+        self._root_key = name
+      end
+
+      # Define how associations should be embedded.
+      #
+      #   embed :objects # Embed associations as full objects
+      #   embed :ids     # Embed only the association ids
+      #
+      def embed(type = :objects)
+        self._embed = type
+      end
+
+      # embed: :objects || :ids
+      # the embed_key only works when embed: ids
+      def has_many(name, serializer: nil, key: nil, embed: nil, embed_key: nil)
+        association = _build_association(
+          name, :has_many, key, serializer, embed, embed_key
+        )
+        _add_attribute(name, key, association: association)
+      end
+
+      def has_one(name, serializer: nil, key: nil, embed: nil, embed_key: nil)
+        association = _build_association(
+          name, :has_one, key, serializer, embed, embed_key
+        )
+        _add_attribute(name, key, association: association)
+      end
+
+      def _build_association(name, type, key, serializer, embed, embed_key)
+        id_only = embed == :ids || (embed.nil? && self._embed == :ids)
+        Association.new(
+          name, type,
+          key: key, serializer: serializer,
+          id_only: id_only, embed_key: embed_key
+        )
+      end
+
+      def _add_attribute(name, key, association: nil)
+        self._attributes[name] = {
+          key: key,
+          include_method: "include_#{name}?".to_sym
+        }
+        if association
+          self._attributes[name][:association] = association
+          self._attributes[name][:key] = association.key
+        end
+        access_name = association ? association.access_name : name
+        generate_attribute_methods(name, access_name)
+      end
+
+      # Generate attribute access and inclusion check methods
+      # This improves performance by avoiding method lookups like:
+      #     public_send(name) if respond_to?(name)
+      def generate_attribute_methods(name, access_name)
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{name}
+            if ::Hash === @object
+              @object.fetch(#{access_name})
+            else
+              @object.#{access_name}
+            end
+          end
+
+          def include_#{name}?
+            true
+          end
+        METHOD
+      end
+
+      def inherited(subclass)
+        super(subclass)
+        subclass._attributes = _attributes.dup
+      end
+    end
+
+    attr_reader :object, :options, :current_user
+
+    # supported options:
+    #   root:
+    #   meta:
+    #   meta_key:
+    #   current_user:
+    #   is_collection:
+    #   only: []
+    #   except: []
+    def initialize(object, options = {})
+      @object = object
+      @current_user = options[:current_user]
+      @is_collection = options.delete(:is_collection) || false
+      @options = options
+      _update_attributes_filter
+    end
+
+    # reset object to reuse the serializer instance
+    # clear any cached or memoized things
+    def reset(object)
+      @object = object
+    end
+
+    # Returns a hash representation without the root
+    def serializable_hash
+      return serializable_collection if collection?
+      self.class._attributes.each_with_object({}) do |(name, option), hash|
+        if _include_from_options?(name) && public_send(option[:include_method])
+          hash[option[:key] || name] = _set_value(name, option)
+        end
+      end
+    end
+
+    def serializable_collection
+      serializer_object = self.class.new(nil, @options)
+      @object.map do |record|
+        serializer_object.reset(record)
+        serializer_object.serializable_hash
+      end
+    end
+
+    def collection?
+      @is_collection
+    end
+
+    def root_name
+      return nil if @options[:root] == false
+      @options[:root] || self.class._root_key
+    end
+
+    def meta_key
+      @options[:meta_key] || :meta
+    end
+
+    def to_json(*)
+      ::Oj.dump(as_json, mode: :compat)
+    end
+
+    # Returns a hash representation with the root
+    # Available options:
+    # :root => true or false
+    def as_json(options = {})
+      root = options.key?(:root) ? options[:root] : true
+      hash = if root && root_name
+               { root_name => serializable_hash }
+             else
+               serializable_hash
+             end
+      hash[meta_key] = @options[:meta] if @options.key?(:meta)
+      hash
+    end
+
+    private
+
+    def _include_from_options?(name)
+      return true unless @attributes_filter_list
+      return @filter_include_return if @attributes_filter_list.include?(name)
+      !@filter_include_return
+    end
+
+    def _set_value(name, option)
+      if option.key?(:association)
+        return _build_from_association(name, option[:association])
+      end
+      public_send(name)
+    end
+
+    def _build_from_association(name, association)
+      resource = public_send(name)
+      return resource if association.id_only
+      association.serialize(resource)
+    end
+
+    # either only or except can be used to filter attributes
+    def _update_attributes_filter
+      if @options.key?(:only) && @options[:only].is_a?(Array)
+        @attributes_filter_list = @options[:only]
+        # if the attribute is included in :only, we will serialize it
+        @filter_include_return = true
+      elsif @options.key?(:except) && @options[:except].is_a?(Array)
+        @attributes_filter_list = @options[:except]
+        # if the attribute is included in :except, we will not serialize it
+        @filter_include_return = false
+      else
+        @attributes_filter_list = nil
+      end
+    end
+  end
+end

data/lib/jserializer/errors.rb

@@ -0,0 +1,8 @@
+module Jserializer
+  class NoAttributeError < ::StandardError
+    def self.build(klass, name, object)
+      message = "undefined attribute `#{name}' for #{object} in #{klass.name}"
+      new(message)
+    end
+  end
+end

data/lib/jserializer.rb

@@ -0,0 +1,3 @@
+require 'oj'
+require 'jserializer/association'
+require 'jserializer/base'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: jserializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Steven Yue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A simple JSON serializer used as a drop-in replacement of Active Model
+  Serializer
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jserializer.rb
+- lib/jserializer/association.rb
+- lib/jserializer/base.rb
+- lib/jserializer/errors.rb
+homepage: http://www.github.com/distil/jserializer
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A JSON Serializer for Ruby Objects
+test_files: []