mutils 0.2.37 → 1.1.2

data/lib/mutils/lib/helper.rb

@@ -4,20 +4,30 @@ require 'singleton'
 # module Mutils
 module Mutils
   module Lib
-    # BaseSerializer: inherit this class to get Serializer functionality
+    # 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)
-        inflector_object.underscore string
+        underscore_cache[string] = inflector_object.underscore string unless underscore_cache[string]
+        underscore_cache[string]
       end
 
       def pluralize(string)
-        inflector_object.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)
@@ -26,7 +36,7 @@ module Mutils
 
       private
 
-      attr_accessor :inflector_object
+      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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  # Module SerializationCore
+  module Serialization
+    # Module Methods
+    module Methods
+      # Module Relations
+      module Relations
+        def relationship(relationship_name, options = {})
+          raise "if: should be a Proc object for attribute #{relationship_name}" if options[:if] && !options[:if].instance_of?(Proc)
+
+          options = prepare_options(relationship_name, options, __callee__)
+          self.relationships = {} if relationships.nil?
+          relationships[relationship_name] = options
+        end
+
+        alias belongs_to relationship
+        alias has_many relationship
+        alias has_one relationship
+
+        def prepare_options(relationship_name, options, option_name)
+          class_name = options[:serializer]
+          if class_name.nil?
+            raise "Serializer is Required for belongs_to :#{relationship_name}." \
+                    "\nDefine it like:\n#{option_name} :#{relationship_name}, " \
+                    'serializer: SERIALIZER_CLASS'
+          end
+          raise "Serializer class not defined for relationship: #{relationship_name}" unless class_exists? class_name
+
+          options[:serializer] = class_name.to_s
+          options[:always_include] = options[:always_include].nil? ? false : options[:always_include]
+          options[:label] = Lib::Helper.instance.underscore options[:label] || relationship_name
+          options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  module Serialization
+    # Module Results
+    module Results
+      # Module Attributes
+      module Attributes
+        def fetch_block_attributes(attributes, result_hash)
+          attributes&.each do |key, s_options|
+            result_hash[key] = s_options[:block].call(scope, options[:params] || {})
+          end
+        end
+
+        def fetch_attributes(attributes, result_hash)
+          attributes&.each do |key, s_options|
+            check_if_included(s_options, key) && (result_hash[key] = s_options[:method] ? send(key) : scope.send(key))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  module Serialization
+    # Module Results
+    module Results
+      # Module Attributes
+      module Main
+        def generate_hash
+          if scope
+            if scope_is_collection?
+              options[:child] = true
+              scope.map { |inner_scope| self.class.new(inner_scope, options).generate_hash }
+            else
+              hashed_result(Lib::ResultHash.new)
+            end
+          else
+            {}
+          end
+        end
+
+        def hashed_result(result_hash)
+          fetch_block_attributes(self.class.attributes_to_serialize_blocks, result_hash)
+          fetch_attributes(self.class.attributes_to_serialize, result_hash)
+          hash_relationships(self.class.relationships, result_hash)
+
+          result_hash.hash
+        end
+
+        def check_if_included(s_options, key)
+          return s_options[:if].call(scope, options[:params] || {}) unless s_options[:if].nil? || scope_is_collection?
+
+          s_options[:always_include] || options[:includes]&.include?(key)
+        end
+
+        def scope_is_collection?
+          Lib::Helper.instance.collection? scope
+        end
+
+        def class_name
+          if scope_is_collection?
+            Lib::Helper.instance.pluralize(format_class_name(scope[0]))
+          else
+            format_class_name(scope)
+          end
+        end
+
+        def format_class_name(object)
+          if self.class.serializer_name&.length&.positive?
+            self.class.serializer_name
+          else
+            object.class.to_s.downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutils/serialization/results/relations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Module Mutils
+module Mutils
+  module Serialization
+    # Module Results
+    module Results
+      # Module Relations
+      module Relations
+        def hash_relationships(relationships_array, result_hash)
+          relationships = relationships_array&.compact
+          relationships&.each do |key, s_options|
+            object = scope.send(key)
+            name = s_options[:label]
+            Lib::Helper.instance.collection?(object) && (name = Lib::Helper.instance.pluralize(name))
+            name = name.to_sym
+            check_if_included(s_options, key) && (result_hash[name] = Lib::Helper.instance.constantize(s_options[:serializer]).new(object).to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutils/serialization/serialization_methods.rb

@@ -1,90 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'methods/main'
+require_relative 'methods/relations'
+require_relative 'methods/attributes'
 # Module Mutils
 module Mutils
   module Serialization
     # Module SerializationCore
     module SerializationMethods
       def self.included(base)
-        base.extend ClassMethods
-      end
-
-      # Module ClassMethods
-      module ClassMethods
-        def name_tag(name_tag, root = nil)
-          self.serializer_name = name_tag
-          self.include_root = root
-        end
-
-        def attributes(*attributes_list)
-          parse_attributes_methods(attributes_list, 'attributes')
-        end
-
-        def custom_methods(*attributes_list)
-          parse_attributes_methods(attributes_list, 'method')
-        end
-
-        def parse_attributes_methods(list, type)
-          self.attributes_to_serialize = {} if attributes_to_serialize.nil?
-          list&.each do |attr|
-            value = { method: type == '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].class.to_s != 'Proc')
-
-          if proc.class.to_s == '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, 'attribute')
-          end
-        end
-
-        def custom_method(method_name, options = {})
-          add_single_attribute(method_name, options, 'method')
-        end
-
-        def add_single_attribute(method_name, options, type)
-          self.attributes_to_serialize = {} if attributes_to_serialize.nil?
-          always_include = options[:always_include].nil? ? false : options[:always_include]
-          value = { method: type == 'method', always_include: always_include, if: options[:if] }
-          attributes_to_serialize[method_name] = value
-        end
-
-        def relationship(relationship_name, options = {})
-          options = prepare_options(relationship_name, options, __callee__)
-          self.relationships = {} if relationships.nil?
-          relationships[relationship_name] = options
-        end
-
-        alias belongs_to relationship
-        alias has_many relationship
-        alias has_one relationship
-
-        def prepare_options(relationship_name, options, option_name)
-          class_name = options[:serializer]
-          if class_name.nil?
-            raise "Serializer is Required for belongs_to :#{relationship_name}." \
-                  "\nDefine it like:\n#{option_name} :#{relationship_name}, " \
-                  'serializer: SERIALIZER_CLASS'
-          end
-          raise "Serializer class not defined for relationship: #{relationship_name}" unless class_exists? class_name
-          raise "if: should be a Proc object for attribute #{relationship_name}" if options[:if] && (options[:if].class.to_s != 'Proc')
-
-          options[:serializer] = Object.const_get class_name.to_s
-          options[:option_name] = option_name
-          options[:label] = options[:label]
-          options
-        end
-
-        def class_exists?(class_name)
-          klass = Object.const_get class_name.to_s rescue nil
-          klass && defined?(klass) && klass.is_a?(Class)
-        end
+        base.extend Methods::Main
+        base.extend Methods::Attributes
+        base.extend Methods::Relations
       end
     end
   end

data/lib/mutils/serialization/serialization_results.rb

@@ -1,87 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'results/main'
+require_relative 'results/attributes'
+require_relative 'results/relations'
 # Module Mutils
 module Mutils
   module Serialization
     # Module SerializationResults
     module SerializationResults
-      def generate_hash
-        if scope
-          if scope_is_collection?
-            options[:child] = true
-            scope.map { |inner_scope| self.class.new(inner_scope, options).generate_hash }
-          else
-            hashed_result
-          end
-        else
-          {}
-        end
-      end
-
-      def hashed_result
-        [fetch_block_attributes(self.class.attributes_to_serialize_blocks),
-         fetch_attributes(self.class.attributes_to_serialize),
-         hash_relationships(self.class.relationships)].reduce(&:merge)
-      end
-
-      def fetch_block_attributes(attributes)
-        hash = {}
-        attributes&.keys&.each do |key|
-          hash[key] = attributes[key][:block].call(scope, options[:params])
-        end
-        hash
-      end
-
-      def fetch_attributes(attributes)
-        hash = {}
-        attributes&.keys&.each do |key|
-          check_if_included(attributes, key) && (hash[key] = attributes[key][:method] ? send(key) : scope.send(key))
-        end
-        hash
-      end
-
-      def hash_relationships(relationships_array)
-        relationships = relationships_array&.compact
-        hash = {}
-        relationships&.keys&.each do |key|
-          object = scope.send(key)
-          name = key
-          if (label = relationships[key][:label])
-            name = Lib::Helper.instance.underscore label
-            Lib::Helper.instance.collection?(object) && (name = Lib::Helper.instance.pluralize(name))
-            name = name.to_sym
-          end
-          check_if_included(relationships, key) && (hash[name] = relationships[key][:serializer].new(object).to_h)
-        end
-        hash
-      end
-
-      def check_if_included(relationships, key)
-        return relationships[key][:if].call(scope) unless relationships[key][:if].nil? || scope_is_collection?
-
-        always_include = relationships[key][:always_include] == true
-        always_include || options[:includes]&.include?(key)
-      end
-
-      def scope_is_collection?
-        Lib::Helper.instance.collection? scope
-      end
-
-      def class_name
-        if scope_is_collection?
-          Lib::Helper.name.pluralize(format_class_name(scope[0]))
-        else
-          format_class_name(scope)
-        end
-      end
-
-      def format_class_name(object)
-        if self.class.serializer_name&.length&.positive?
-          self.class.serializer_name
-        else
-          object.class.to_s.downcase
-        end
-      end
+      include Mutils::Serialization::Results::Main
+      include Mutils::Serialization::Results::Attributes
+      include Mutils::Serialization::Results::Relations
     end
   end
 end