panko_serializer 0.1.1

data/lib/panko/cache.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require "concurrent"
+
+
+module Panko
+  # Serialer Descriptor Cache
+  class Cache
+    def initialize
+      @_cache = Concurrent::Map.new
+    end
+
+    def fetch(serializer_const, options)
+      serializer_key = build_key(serializer_const, options[:only], options[:except])
+      serializer = @_cache.compute_if_absent(serializer_key) {
+        SerializationDescriptorBuilder.build(serializer_const,
+                                             only: options.fetch(:only, []),
+                                             except: options.fetch(:except, [])
+                                            )
+      }
+
+      serializer
+    end
+
+    private
+
+    #
+    # Create key based on what we define unique serializer
+    #
+    def build_key(serializer_const, only, except)
+      [serializer_const, only, except].hash
+    end
+  end
+
+  CACHE = Panko::Cache.new
+end

data/lib/panko/serialization_descriptor.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+module Panko
+  module SerializationDescriptorBuilder
+    def self.build(serializer, options={})
+      backend = Panko::SerializationDescriptor.new
+
+      serializer_only_filters, attributes_only_filters = resolve_filters(options, :only)
+      serializer_except_filters, attributes_except_filters = resolve_filters(options, :except)
+
+      fields, method_fields = fields_of(serializer)
+
+      backend.type = serializer
+
+      backend.fields = apply_fields_filters(
+        fields,
+        serializer_only_filters,
+        serializer_except_filters
+      )
+
+      backend.method_fields = apply_fields_filters(
+        method_fields,
+        serializer_only_filters,
+        serializer_except_filters
+      )
+
+      backend.has_many_associations = build_associations(
+        apply_association_filters(
+          serializer._has_many_associations,
+          serializer_only_filters,
+          serializer_except_filters
+        ),
+        attributes_only_filters,
+        attributes_except_filters
+      )
+
+      backend.has_one_associations = build_associations(
+        apply_association_filters(
+          serializer._has_one_associations,
+          serializer_only_filters,
+          serializer_except_filters
+        ),
+        attributes_only_filters,
+        attributes_except_filters
+      )
+
+      backend
+    end
+
+    def self.fields_of(serializer)
+      fields = []
+      method_fields = []
+
+      serializer._attributes.each do |attribute|
+        if serializer.method_defined? attribute
+          method_fields << attribute
+        else
+          fields << attribute
+        end
+      end
+
+      return fields, method_fields
+    end
+
+    def self.build_associations(associations, attributes_only_filters, attributes_except_filters)
+      associations.map do |association|
+        options = association[:options]
+        serializer_const = resolve_serializer(options[:serializer])
+
+        options[:only] = options.fetch(:only, []) + attributes_only_filters.fetch(association[:name], [])
+        options[:except] = options.fetch(:except, []) + attributes_except_filters.fetch(association[:name], [])
+
+        [
+          association[:name],
+          SerializationDescriptorBuilder.build(serializer_const, options.except(:serializer))
+        ]
+      end
+    end
+
+    def self.resolve_filters(options, filter)
+      filters = options.fetch(filter, {})
+      if filters.is_a? Array
+        return filters, {}
+      end
+
+      # hash filters looks like this
+      # { instance: [:a], foo: [:b] }
+      # which mean, for the current instance use `[:a]` as filter
+      # and for association named `foo` use `[:b]`
+
+      serializer_filters = filters.fetch(:instance, [])
+      association_filters = filters.except(:instance)
+
+      return serializer_filters, association_filters
+    end
+
+    def self.apply_fields_filters(fields, only, except)
+      return fields & only if only.present?
+      return fields - except if except.present?
+
+      fields
+    end
+
+    def self.apply_association_filters(associations, only, except)
+      if only.present?
+        return associations.select { |assoc| only.include?(assoc[:name]) }
+      end
+
+      if except.present?
+        return associations.reject { |assoc| except.include?(assoc[:name]) }
+      end
+
+      associations
+    end
+
+    def self.resolve_serializer(serializer)
+      Object.const_get(serializer.name)
+    end
+  end
+end

data/lib/panko/serializer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require_relative "cache"
+require_relative "serialization_descriptor"
+require "oj"
+
+module Panko
+  class Serializer
+    class << self
+      def inherited(base)
+        base._attributes = (_attributes || []).dup
+        base._has_one_associations = (_has_one_associations || []).dup
+        base._has_many_associations = (_has_many_associations || []).dup
+
+        @_attributes = []
+        @_has_one_associations = []
+        @_has_many_associations = []
+      end
+
+      attr_accessor :_attributes, :_has_one_associations, :_has_many_associations
+
+      def attributes(*attrs)
+        @_attributes.push(*attrs).uniq!
+      end
+
+      def has_one(name, options)
+        @_has_one_associations << { name: name, options: options }
+      end
+
+      def has_many(name, options)
+        @_has_many_associations << { name: name, options: options }
+      end
+    end
+
+    def initialize(options = {})
+      @descriptor = Panko::CACHE.fetch(self.class, options)
+
+      @context = options.fetch(:context, nil)
+      @object = nil
+    end
+
+    attr_reader :object, :context
+    attr_writer :object
+
+    def serialize(object, writer = nil)
+      Oj.load(serialize_to_json(object, writer))
+    end
+
+    def serialize_to_json(object, writer = nil)
+      @object = object
+
+      writer ||= Oj::StringWriter.new(mode: :rails)
+      Panko::serialize_subject(object, writer, @descriptor, @context)
+
+      writer.to_s
+    end
+  end
+end

data/lib/panko/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Panko
+  VERSION = "0.1.1".freeze
+end

data/lib/panko.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require "panko/version"
+require "panko/serializer"
+require "panko/array_serializer"
+
+
+# C Extension
+require "panko_serializer/panko_serializer"

data/panko_serializer.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "panko/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "panko_serializer"
+  spec.version       = Panko::VERSION
+  spec.authors       = ["Yosi Attias"]
+  spec.email         = ["yosy101@gmail.com"]
+
+  spec.summary       = "Fast serialization for ActiveModel"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.extensions << "ext/panko_serializer/extconf.rb"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake-compiler"
+
+  spec.add_dependency "oj", "~> 3.2.0"
+  spec.add_dependency "concurrent-ruby"
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: panko_serializer
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Yosi Attias
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- yosy101@gmail.com
+executables: []
+extensions:
+- ext/panko_serializer/extconf.rb
+extra_rdoc_files: []
+files:
+- ".clang-format"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/BENCHMARKS.md
+- benchmarks/allocs.rb
+- benchmarks/app.rb
+- benchmarks/benchmarking_support.rb
+- benchmarks/bm_active_model_serializers.rb
+- benchmarks/bm_controller.rb
+- benchmarks/bm_panko_json.rb
+- benchmarks/bm_panko_object.rb
+- benchmarks/profile.rb
+- benchmarks/sanity.rb
+- benchmarks/setup.rb
+- benchmarks/type_casts/bm_active_record.rb
+- benchmarks/type_casts/bm_panko.rb
+- benchmarks/type_casts/bm_pg.rb
+- benchmarks/type_casts/support.rb
+- ext/panko_serializer/attributes_iterator.c
+- ext/panko_serializer/attributes_iterator.h
+- ext/panko_serializer/extconf.rb
+- ext/panko_serializer/panko_serializer.c
+- ext/panko_serializer/panko_serializer.h
+- ext/panko_serializer/serialization_descriptor.c
+- ext/panko_serializer/serialization_descriptor.h
+- ext/panko_serializer/time_conversion.c
+- ext/panko_serializer/time_conversion.h
+- ext/panko_serializer/type_cast.c
+- ext/panko_serializer/type_cast.h
+- lib/panko.rb
+- lib/panko/array_serializer.rb
+- lib/panko/cache.rb
+- lib/panko/serialization_descriptor.rb
+- lib/panko/serializer.rb
+- lib/panko/version.rb
+- panko_serializer.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Fast serialization for ActiveModel
+test_files: []