mutils 0.2.34 → 1.0.1

data/README.md

@@ -1,13 +1,34 @@
-[![Maintainability](https://api.codeclimate.com/v1/badges/2c937dd6d25937ec41bd/maintainability)](https://codeclimate.com/github/niteshpurohit/mutils/maintainability)
+[![Maintainability](https://api.codeclimate.com/v1/badges/42e8a34f839ca0c5ec45/maintainability)](https://codeclimate.com/github/code-vedas/mutils/maintainability)
 ![](https://ruby-gem-downloads-badge.herokuapp.com/mutils?type=total&color=brightgreen)
 [![Gem Version](https://badge.fury.io/rb/mutils.svg)](https://badge.fury.io/rb/mutils)
-[![Coverage Status](https://coveralls.io/repos/github/niteshpurohit/mutils/badge.svg?branch=feature/coverall)](https://coveralls.io/github/niteshpurohit/mutils?branch=feature/coverall)
-[![Build Status](https://travis-ci.com/niteshpurohit/mutils.svg?branch=master)](https://travis-ci.com/niteshpurohit/mutils)
+[![Coverage Status](https://coveralls.io/repos/github/Code-Vedas/mutils/badge.svg?branch=master)](https://coveralls.io/github/Code-Vedas/mutils?branch=master)
+[![Build Status](https://travis-ci.com/code-vedas/mutils.svg?branch=master)](https://travis-ci.com/code-vedas/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 :-)
+# Table of Contents
+
+* [Features](#features)
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Rails Generator](#rails-generator)
+  * [Attributes](#attributes)
+  * [Relations](#relations)
+  * [Conditional Attributes](#conditional-attributes)
+  * [Conditional Relations](#conditional-relations)
+  * [Attributes Block](#attributes-blocks)
+  * [Attributes Block with Params](#attributes-blocks-with-params)
+  * [Custom Methods](#custom-methods)
+  * [Name Tag](#name-tag)
+  * [Sample Usage](#sample-usage)
+
+## Features
+* Simple declaration syntax similar to Active Model Serializer
+* Realtionships support `belongs_to`, `has_many`, `has_one`
+* Block style attributes with params
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -22,17 +43,9 @@ Or install it yourself as:
 
     $ gem install mutils
 
-## Modules
-| Sno 	|        Name       	| Status 	|
-|:---:	|:-----------------:	|:------:	|
-|  1  	| Serializer - JSON 	|  Done  	|
-|  2  	|  Serializer - XML 	|  Done  	|
-
-## Usage
-### Serializer - JSON
-JSON Serializer for Active Models 
+## Usage 
 
-#### Generate Serializer by command
+### Rails Generator
 ```shell script
 rails g mutils:serializer User id first_name last_name email
 
@@ -50,13 +63,7 @@ class UserSerializer < Mutils::Serialization::BaseSerializer
 end
 ```
 
-#### Decorations Available
-1. Attributes
-2. Custom Methods
-3. Relations
-3. name_tag
-
-##### Attributes
+### Attributes
 Attributes are fields in the model itself. You can reference them by below example
 ```ruby
 # frozen_string_literal: true
@@ -64,48 +71,116 @@ Attributes are fields in the model itself. You can reference them by below examp
 # User Serializer
 class UserSerializer < Mutils::Serialization::BaseSerializer
   attributes :id, :first_name, :last_name, :email
+  ## OR
+  attribute :email, {always_include: true} ## this will allow to selectively include 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`
-
+### 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
+4. `label` option can be used to override model class name while serializing
 ```ruby
 # frozen_string_literal: true
 
 # User Serializer
 class UserSerializer < Mutils::Serialization::BaseSerializer
   attributes :id, :first_name, :last_name, :email
-  custom_methods :full_name
+  
+  belongs_to :company, serializer: CompanySerializer, always_include: true
+  ## OR
+  belongs_to :company, serializer: CompanySerializer, always_include: true, label: 'organization'   ##<== important to give singular name
+  
+  has_many :comments, serializer: CommentSerializer
+  has_one :account, serializer: AccountSerializer
   
   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
+### Conditional 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
+  attribute :email, if: proc { |scope| scope.name == 'mutils' } ## Email will only serialize if user's name is 'mutils'
+end
+```
+    in proc {|scope|}, scope is object which is being serialized
+### Conditional Relations
+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
+  has_many :comments, serializer: CommentSerializer, if: proc { |scope| scope.name == 'mutils' } ## comments will only serialize if user's name is 'mutils'
+  belongs_to :account, serializer: AccountSerializer, if: proc { |scope| scope.name != 'mutils' } ## account will only serialize if user's name is not 'mutils'
+end
+```
+    in proc {|scope|}, scope is object which is being serialized    
+### Attributes Blocks
+While writting attribute a block can be provided for useful transformations like `full_name` as shown below
 ```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
+  attribute :full_name do |object|
+    "#{object.first_name} #{object.last_name}"
+  end
+end
+```
+### Attributes Blocks with Params
+While writting attribute a block can be provided for useful transformations like `full_name` as shown below
+```ruby
+# frozen_string_literal: true
+
+# User Serializer
+class UserSerializer < Mutils::Serialization::BaseSerializer
+  attributes :id, :first_name, :last_name, :email
+  attribute :is_owner do |object,params|
+    params[:owner].id == object.id ? true:false
+  end
+end
+```
+```ruby
+# in controller
+
+user = current_user
+owner = owner_user
+render json: UserSerializer.new(user,{params:{owner:owner}})
+```
+### 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
+  ## OR
+  custom_method :full_name, {always_include: true}   ## this will allow to selectively include full_name
+  ### 
   
   def full_name
     "#{scope.first_name} #{scope.last_name}"
   end
 end
 ```
-##### name_tag
-name_tag is used to provide custom name to serializer output keys for json or tags for xml
+### Name Tag
+name_tag is used to provide custom name to serializer output keys for json
 
 **Options**
   - ``name_tag 'Person', true`` # Include Person or People in JSON serialization as root, true|false this only implies to root serializer
@@ -127,20 +202,20 @@ class UserSerializer < Mutils::Serialization::BaseSerializer
 end
 ```
 
-## Usage: Use anywhere by
+### Sample Usage
 
 ```ruby
 user = User.first
 options = {includes: [:comments,:account]}
 UserSerializer.new(user,options).to_h
 ```
-###or
+### or
 ```ruby
 users = User.all
 options = {includes: [:account]}
 UserSerializer.new(users,options).to_json
 ```
-###or in controllers
+### or in controllers
 ```ruby
 users = User.all
 options = {includes: [:account]}
@@ -158,4 +233,8 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## 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).
+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/code-vedas/mutils/blob/master/CODE_OF_CONDUCT.md).
+
+## Security
+
+For security refer to [security](https://github.com/Code-Vedas/mutils/blob/master/SECURITY.md) document.

data/SECURITY.md

@@ -0,0 +1,13 @@
+# Security Policy
+
+## Supported Versions
+
+Versions currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Create an issue or email at security@codevedas.com

data/Version

@@ -0,0 +1 @@
+v1.0.1

data/commitlint.config.js

@@ -0,0 +1 @@
+module.exports = {extends: ['@commitlint/config-angular']};

data/gemdeploy.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -euo pipefail
+
+mkdir -p $HOME/.gem
+touch $HOME/.gem/credentials
+chmod 0600 $HOME/.gem/credentials
+printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+gem build *.gemspec
+gem push *.gem

data/lib/mutils.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require 'dry/inflector'
 require_relative 'mutils/version'
-require 'active_support/concern'
-require 'active_support/inflector'
-require 'active_support/core_ext/hash'
+require_relative 'mutils/lib/helper'
+require_relative 'mutils/lib/result_hash'
 require_relative 'mutils/serialization/serialization_results'
 require_relative 'mutils/serialization/serialization_includes'
 require_relative 'mutils/serialization/serialization_methods'

data/lib/mutils/lib/helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'singleton'
+# module Mutils
+module Mutils
+  module Lib
+    # Helper: caching expensive repetitive operations
+    class Helper
+      include Singleton
+
+      def initialize
+        self.inflector_object = Dry::Inflector.new
+        self.pluralize_cache = {}
+        self.underscore_cache = {}
+        self.constantize_cache = {}
+      end
+
+      def underscore(string)
+        underscore_cache[string] = inflector_object.underscore string unless underscore_cache[string]
+        underscore_cache[string]
+      end
+
+      def pluralize(string)
+        pluralize_cache[string] = inflector_object.pluralize string unless pluralize_cache[string]
+        pluralize_cache[string]
+      end
+
+      def constantize(string)
+        constantize_cache[string] = Object.const_get string unless constantize_cache[string]
+        constantize_cache[string]
+      end
+
+      def collection?(object)
+        object.respond_to?(:size) && !object.respond_to?(:each_pair)
+      end
+
+      private
+
+      attr_accessor :inflector_object, :pluralize_cache, :underscore_cache, :constantize_cache
+    end
+  end
+end

data/lib/mutils/lib/result_hash.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# module Mutils
+module Mutils
+  module Lib
+    # ResultHash: Store result using this class.
+    class ResultHash
+      def initialize
+        self._hash = {}
+      end
+
+      def []=(key, value)
+        _hash[key] = value
+      end
+
+      def hash
+        _hash
+      end
+
+      private
+
+      attr_accessor :_hash
+    end
+  end
+end

data/lib/mutils/serialization/base_serializer.rb

@@ -33,14 +33,6 @@ module Mutils
         JSON.generate(as_json, options)
       end
 
-      def to_xml(_options = {})
-        to_h.to_xml(root: class_name, skip_instruct: true, indent: 2)
-      end
-
-      def as_xml(_options = {})
-        to_xml
-      end
-
       private
 
       attr_writer :scope

data/lib/mutils/serialization/methods/attributes.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  # Module SerializationCore
+  module Serialization
+    # Module Methods
+    module Methods
+      # Module Attributes
+      module Attributes
+        def attributes(*attributes_list)
+          parse_attributes_methods(attributes_list, false)
+        end
+
+        def custom_methods(*attributes_list)
+          parse_attributes_methods(attributes_list, true)
+        end
+
+        def parse_attributes_methods(list, is_method)
+          self.attributes_to_serialize = {} if attributes_to_serialize.nil?
+          list&.each do |attr|
+            value = { method: is_method, always_include: true }
+            attributes_to_serialize[attr] = value
+          end
+        end
+
+        def attribute(method_name, options = {}, &proc)
+          raise "if: should be a Proc object for attribute #{method_name}" if options[:if] && !options[:if].instance_of?(Proc)
+
+          if proc.instance_of? Proc
+            self.attributes_to_serialize_blocks = {} if attributes_to_serialize_blocks.nil?
+            options[:block] = proc
+            attributes_to_serialize_blocks[method_name] = options
+          else
+            add_single_attribute(method_name, options, false)
+          end
+        end
+
+        def custom_method(method_name, options = {})
+          add_single_attribute(method_name, options, true)
+        end
+
+        def add_single_attribute(method_name, options, is_method)
+          self.attributes_to_serialize = {} if attributes_to_serialize.nil?
+          always_include = options[:always_include].nil? ? false : options[:always_include]
+          value = { method: is_method, always_include: always_include, if: options[:if] }
+          attributes_to_serialize[method_name] = value
+        end
+      end
+    end
+  end
+end

data/lib/mutils/serialization/methods/main.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  # Module SerializationCore
+  module Serialization
+    # Module Methods
+    module Methods
+      # Module Main
+      module Main
+        def name_tag(name_tag, root = nil)
+          self.serializer_name = name_tag
+          self.include_root = root
+        end
+
+        def class_exists?(class_name)
+          klass = begin
+                    Mutils::Lib::Helper.instance.constantize(class_name.to_s)
+                  rescue StandardError
+                    nil
+                  end
+          klass && defined?(klass) && klass.is_a?(Class)
+        end
+      end
+    end
+  end
+end