mutils 0.2.25

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Nitesh Purohit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Makefile

@@ -0,0 +1,6 @@
+build:
+	bundle exec rake build
+release: build
+	git add .
+	git commit -am '$(MESSAGE)'
+	bundle exec rake release

data/README.md

@@ -0,0 +1,126 @@
+
+[![Gem Version](https://badge.fury.io/rb/mutils.svg)](https://badge.fury.io/rb/mutils)
+
+# Mutils
+## Introduction
+`mutils` is collection of useful modules for `ruby on rails` which is tested and benchmarked against high load.
+
+These collection of modules are built by developer for developers :-)
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'mutils'
+```
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install mutils
+
+## Modules
+| Sno 	|        Name       	| Status 	|
+|:---:	|:-----------------:	|:------:	|
+|  1  	| Serializer - JSON 	|  Beta  	|
+|  2  	|  Serializer - XML 	|  In-Dev  	|
+|  3    | Active Storage Helpers | In-Dev |
+## Usage
+### Serializer - JSON
+JSON Serializer for Active Models 
+
+#### Generate Serializer by command
+```shell script
+rails g serializer User id first_name last_name email
+
+OUTPUT
+Running via Spring preloader in process xxxxx
+      create  app/serializers/user_serializer.rb
+```
+You will get serializer in app/serializers/user_serializer.rb
+```ruby
+# frozen_string_literal: true
+
+# User Serializer
+class UserSerializer < Mutils::Serialization::BaseSerializer
+  attributes :id, :first_name, :last_name, :email
+end
+```
+
+#### Decorations Available
+1. Attributes
+2. Custom Methods
+3. Relations
+
+##### Attributes
+Attributes are fields in the model itself. You can reference them by below example
+```ruby
+# frozen_string_literal: true
+
+# User Serializer
+class UserSerializer < Mutils::Serialization::BaseSerializer
+  attributes :id, :first_name, :last_name, :email
+end
+```
+##### Custom Methods
+Custom methods used in Serializer can be useful for cases as below.
+`scope` will be available to reference object in Serializer in below case its `user`
+
+```ruby
+# frozen_string_literal: true
+
+# User Serializer
+class UserSerializer < Mutils::Serialization::BaseSerializer
+  attributes :id, :first_name, :last_name, :email
+  custom_methods :full_name
+  
+  def full_name
+    "#{scope.first_name} #{scope.last_name}"
+  end
+end
+```
+##### Relations
+Relations such as `has_many`, `belongs_to`, `has_one` can be used as follows
+1. Every relation must be provided with their own serializer
+2. `always_include` option can be used to instruct `Serializer` to always include this relation
+3. `always_include` by default is disabled, relations which are not `always_include` can be included while using the serializer. Refer to next section for this usage
+
+```ruby
+# frozen_string_literal: true
+
+# User Serializer
+class UserSerializer < Mutils::Serialization::BaseSerializer
+  attributes :id, :first_name, :last_name, :email
+  belongs_to :company, serializer: CompanySerializer, always_include: true
+  has_many :comments, serializer: CommentSerializer
+  has_one :account, serializer: AccountSerializer
+  
+  def full_name
+    "#{scope.first_name} #{scope.last_name}"
+  end
+end
+```
+Usage: Use anywhere by
+
+```ruby
+user = User.first
+options = {includes: [:comments,:account]}
+UserSerializer.new(user,options).to_h
+# or
+users = User.all
+options = {includes: [:account]}
+UserSerializer.new(users,options).to_json
+```
+
+## Contributing
+
+Bug Reports and PR's are welcomed in this repository kindly follow guidelines from `.github` directory.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Mutils project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/niteshpurohit/mutils/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/benchmark/benchmark-serializer-json.rb

@@ -0,0 +1,248 @@
+require 'bundler/inline'
+
+require_relative '../lib//mutils'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'oj'
+  gem 'benchmark-ips', require: 'benchmark/ips'
+  gem 'kalibera'
+  gem 'benchmark-memory', require: 'benchmark/memory'
+
+  gem 'activesupport'
+
+  # https://github.com/Netflix/fast_jsonapi
+  gem 'fast_jsonapi'
+
+  # https://github.com/ruby-grape/grape-entity
+  gem 'grape-entity'
+
+  # https://github.com/procore/blueprinter
+  gem 'blueprinter'
+
+  # https://github.com/trailblazer/roar
+  # https://github.com/trailblazer/representable
+  gem 'roar'
+  gem 'multi_json'
+
+  # https://github.com/yosiat/panko_serializer
+  gem 'panko_serializer'
+end
+
+require 'active_support'
+require 'active_support/core_ext/object' # For Hash#deep_dup
+
+# Define models
+Issue = Struct.new(:id, :number, :title, :user, :labels) do
+  alias_method :read_attribute_for_serialization, :send
+
+  def label_ids
+    labels.map(&:id)
+  end
+
+  def user_id
+    user.id
+  end
+end
+User = Struct.new(:id, :login) do
+  alias_method :read_attribute_for_serialization, :send
+end
+Label = Struct.new(:id, :name, :color) do
+  alias_method :read_attribute_for_serialization, :send
+end
+
+# Define serializers
+module FastJsonApi
+  class IssueSerializer
+    include FastJsonapi::ObjectSerializer
+
+    attributes :number, :title
+    has_many :labels
+    belongs_to :user
+  end
+
+  class LabelSerializer
+    include FastJsonapi::ObjectSerializer
+
+    attributes :name, :color
+  end
+
+  class UserSerializer
+    include FastJsonapi::ObjectSerializer
+
+    attributes :login
+  end
+end
+
+module GrapeEntity
+  class Label < Grape::Entity
+    expose :id
+    expose :name
+    expose :color
+  end
+
+  class User < Grape::Entity
+    expose :id
+    expose :login
+  end
+
+  class Issue < Grape::Entity
+    expose :id
+    expose :number
+    expose :title
+    expose :labels, using: Label
+    expose :user, using: User
+  end
+end
+
+Blueprinter.configure do |config|
+  config.generator = Oj
+  config.sort_fields_by = :definition
+end
+
+module BluePrint
+  class Label < Blueprinter::Base
+    identifier :id
+    fields :name, :color
+  end
+
+  class User < Blueprinter::Base
+    identifier :id
+    field :login
+  end
+
+  class Issue < Blueprinter::Base
+    identifier :id
+    fields :number, :title
+    association :labels, blueprint: Label
+    association :user, blueprint: User
+  end
+end
+
+module Mutils
+  class Label < Mutils::Serialization::BaseSerializer
+    attributes :id, :name, :color
+  end
+
+  class User < Mutils::Serialization::BaseSerializer
+    attributes :id, :login
+  end
+
+  class Issue < Mutils::Serialization::BaseSerializer
+    attributes :id, :number, :title
+    has_many :labels, serializer: Mutils::Label, always_include: true
+    belongs_to :user, serializer: Mutils::User, always_include: true
+  end
+end
+
+require 'roar/decorator'
+require 'roar/json'
+module ROAR
+  class IssueRepresenter < Roar::Decorator
+    include Roar::JSON
+
+    property :id
+    property :number
+    property :title
+
+    collection :labels do
+      property :id
+      property :name
+      property :color
+    end
+
+    property :user do
+      property :id
+      property :login
+    end
+  end
+end
+
+module PANKO
+  class LabelSerializer < Panko::Serializer
+    attributes :id, :name, :color
+  end
+
+  class UserSerializer < Panko::Serializer
+    attributes :id, :login
+  end
+
+  class IssueSerializer < Panko::Serializer
+    attributes :id, :number, :title
+    has_many :labels, serializer: LabelSerializer
+    has_one :user, serializer: UserSerializer
+  end
+end
+
+# Generate data
+users = Array.new(10) { |i| User.new(i, "User #{i}") }
+labels = Array.new(4) { |i| Label.new(i, "Label #{i}", 'ffffff') }
+issues = Array.new(10_000) { |i| Issue.new(i, i, "Issue #{i}", users.sample, labels.sample(rand(2..4))) }
+
+serializers = [
+    {
+        name: :as_json,
+        serializer: -> { issues.as_json },
+        output_inspector: ->(output) { output.first }
+    },
+    {
+        name: :fast_jsonapi,
+        serializer: -> { FastJsonApi::IssueSerializer.new(issues, include: [:labels, :user]).serializable_hash },
+        output_inspector: ->(output) { output[:data].first }
+    },
+    {
+        name: :grape_entity,
+        serializer: -> { GrapeEntity::Issue.represent(issues).as_json },
+        output_inspector: ->(output) { output.first }
+    },
+    {
+        name: :blueprinter,
+        serializer: -> { BluePrint::Issue.render_as_hash(issues) },
+        output_inspector: ->(output) { output.first }
+    },
+    {
+        name: :mutils,
+        serializer: -> { Mutils::Issue.new(issues).as_json },
+        output_inspector: ->(output) { output.first }
+    },
+    {
+        name: :roar,
+        serializer: -> { ROAR::IssueRepresenter.for_collection.new(issues).as_json },
+        output_inspector: ->(output) { output.first }
+    },
+    {
+        name: :panko,
+        serializer: -> { Panko::ArraySerializer.new(issues, each_serializer: PANKO::IssueSerializer).as_json },
+        output_inspector: ->(output) { output['subjects'].first }
+    }
+]
+
+# Display output
+serializers.each do |name:, serializer:, output_inspector:|
+  puts "\n#{name}:\n"
+  puts output_inspector.call(serializer.call).inspect
+  puts
+end
+
+# Run benchmarks
+require 'benchmark'
+Benchmark.bmbm do |b|
+  serializers.each do |name:, serializer:, **_other|
+    b.report(name, &serializer)
+  end
+end
+
+%i[ips memory].each do |bench|
+  puts '##################################################'
+  puts "START #{bench}"
+  puts '##################################################'
+  Benchmark.send(bench) do |b|
+    b.config(time: 10, warmup: 5, stats: :bootstrap, confidence: 95) if b.respond_to?(:config)
+
+    serializers.each do |name:, serializer:, **_other|
+      b.report(name, &serializer)
+    end
+
+    b.compare!
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mutils"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/generators/serializer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a serializer for the given model.
+
+Example:
+    rails generate serializer User
+
+    This will create:
+        app/serializers/user_serializer.rb