jsonize 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 787277d3b1f9c06c0e3df496dcb3402ceaf1643ee5048ac359bc7592a67487b9
-  data.tar.gz: 1005708186a5a16ee757b5b4d0393a2af6403465c6377f4ef8defbf50d62df79
+  metadata.gz: d3227e59ca0f4826ae7a108ba9ab99419e2441fa7ca4182cd288000fe5caaa5b
+  data.tar.gz: 5d79a0a28100a90b628b96820d250a10fa9b70806203b078d68c7828a035d88a
 SHA512:
-  metadata.gz: e469b13fd8e298a003d31438dfe78dba30cf0154732e44d3c31246c75417629383a4d6499d132a2b92c003682ccba9893ded343f2d8f241e81b8f6e678402c2c
-  data.tar.gz: 8ac936e618c70b4eb5b14f6fec34754d2e4806225e23d0b9177f505b82efa91bbb6b66b87a38ca333b12f7026af0c36dce60700a3d892bb8956d3e77d7258afe
+  metadata.gz: e427382e3c42a97b5991c2d382a078a198562c1686c835e7039546de9ce360890c8cd6ada52bb3339c1835fd9422d686875631ecdad6bf30f312a5bac38480ab
+  data.tar.gz: e35614f1087c93893ee1dc739b4c2a85756f632afcb99a419b70afb605714b459f5b8bf3bc2b1e0435527d4ce24999993df61e6c39366eb5c53d01cbda81a7c8

data/lib/jsonize/version.rb

@@ -1,3 +1,3 @@
 module Jsonize
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/jsonize.rb

@@ -3,7 +3,9 @@ require 'redisize'
 require "jsonize/version"
 
 module Jsonize
-   JSON_ATTRS = {
+   DEFAULT_EXCEPT_ATTRS = [:created_at, :updated_at]
+
+   JSONIZE_ATTRS = {
       created_at: nil,
       updated_at: nil,
    }
@@ -12,26 +14,13 @@ module Jsonize
       ActiveRecord: 'active_record'
    }
 
-   def external_attrs options = {}
-      if externals = options[:externals]
-         externals.keys.map {|k| [k.to_sym, k.to_sym] }.to_h
-      else
-         {}
-      end
-   end
-
-   def instance_attrs
-      self.attribute_names.map {|a| [a.to_sym, true] }.to_h
-   end
+   JSON_TYPES = [String, Integer, TrueClass, FalseClass, NilClass, Hash, Array]
 
-   def embed_attrs
-      begin
-         self.class.const_get("JSON_ATTRS")
-      rescue
-         {}
-      end
+   def default_except_attributes
+      DEFAULT_EXCEPT_ATTRS
    end
 
+   # TODO where is the addtional sources for attributes
    def additional_attrs
       attributes = self.instance_variable_get(:@attributes).send(:attributes)
 
@@ -44,67 +33,120 @@ module Jsonize
       end
    end
 
-   def generate_json propses, externals = {}
-      propses.reduce({}) do |r, (name, props)|
+   def generate_relation rela, source_in, options
+      source = source_in.is_a?(Hash) ? source_in : source_in.polymorphic? ?
+         {} : required_attibutes(source_in.klass, {})
+
+      case rela
+      when Enumerable
+         rela.map do |rec|
+            generate_json(rec, source, options)
+         end
+      when NilClass
+         nil
+      when Object
+         generate_json(rela, source, options)
+      end
+   end
+
+   def generate_json flow, attr_props, options = {}
+     in_h = (options[:externals] || {}).map {|(x, y)| [x.to_s, y] }.to_h
+
+     attr_props.reduce(in_h) do |cr, (name, props)|
          value =
-            if props["rule"].is_a?(Proc)
-               props["rule"][self]
-            elsif props["rule"].is_a?(String)
-               externals.fetch(props["rule"].to_sym) { |x| externals[props["rule"]] }
-            elsif props["real_name"] != name.to_s
-               read_attribute(props["real_name"]).as_json
-            elsif props["rule"].instance_variable_get(:@value)
-               props["rule"].instance_variable_get(:@value)
-            elsif props["rule"]
-               read_attribute(props["real_name"] || props["rule"])
+            [props].flatten.reduce(nil) do |r, source|
+               case source
+               when UnboundMethod
+                  r || source.bind(flow)[]
+               when Proc
+                  r || source[flow]
+               when Hash, ActiveRecord::Reflection::AbstractReflection
+                  generate_relation(r || flow.send(name), source, options)
+               else
+                  raise
+               end
             end
 
-         r.merge(name => value)
+         cr.merge(name.to_s => proceed_value(value))
       end
    end
 
-   def prepare_json options = {}
-      attr_hash = [
-         instance_attrs,
-         JSON_ATTRS,
-         embed_attrs,
-         additional_attrs,
-         external_attrs(options),
-         options[:map] || {}
-      ].reduce { |r, hash| r.merge(hash.map {|k,v| [k.to_sym, v] }.to_h) }
-      except = options.fetch(:except, [])
-      only = options.fetch(:only, self.attributes.keys.map(&:to_sym) | (options[:map] || {}).keys | embed_attrs.keys | external_attrs(options).keys)
+   def proceed_value value_in
+      (value_in.class.ancestors & JSON_TYPES).any? ? value_in : value_in.to_s
+   end
 
-      attr_hash.map do |(name_in, rule_in)|
-         name = /^_(?<_name>.*)/ =~ name_in && _name || name_in.to_s
+   def prepare_attributes model, attrs
+      attrs.reduce({}) do |h, x|
+         if x.is_a?(Hash)
+            x.reduce(h) do |hh, (sub, subattrs)|
+               if submodel = model._reflections[sub]&.klass
+                  hh.merge(sub.to_sym => prepare_attributes(submodel, subattrs))
+               else
+                  hh
+               end
+            end
+         else
+            props = [
+               model._reflections[x.to_s],
+               model.instance_methods.include?(x.to_sym) ? model.instance_method(x.to_sym) : nil,
+               (self.class == model ? self.attribute_names : model.attribute_names).
+                  include?(x.to_s) ? ->(this) { this.read_attribute(x) } : nil
+            ].compact
+
+            h.merge(x.to_s.sub(/^_/, '').to_sym => props)
+         end
+      end
+   end
+
+   def attibute_tree klass, options = {}
+      options[:only] ||
+      jsonize_attributes_except(self.class == klass ? self.attribute_names : klass.attribute_names,
+         options[:except] || default_except_attributes)
+   end
+
+   def jsonize_scheme_for klass, attr_tree
+      jsonize_schemes[attr_tree] ||= prepare_attributes(klass, attr_tree)
+   end
 
-         next nil if except.include?(name.to_sym) || (only & [ name.to_sym, name_in.to_sym ].uniq).blank?
+   def jsonize_attributes_except a_in, except_in
+      except_in.reduce(a_in) do |res, name|
+         if res.include?(name)
+            res.delete(name)
+         end
 
-         rule = parse_rule(rule_in)
-         #binding.pry
-         [name, { "rule" => rule, "real_name" => name_in.to_s }]
-      end.compact.to_h
+         res
+      end
    end
 
-   def parse_rule rule_in
-      %w(TrueClass FalseClass NilClass Symbol).all? {|k| !rule_in.is_a?(k.constantize) } && true || rule_in.is_a?(Symbol) && rule_in.to_s || rule_in
+   def jsonize_schemes
+      schemes = self.class.instance_variable_get(:@jsonize_schemes) || {}
+      self.class.instance_variable_set(:@jsonize_schemes, schemes)
+
+      schemes
+   end
+
+   def primary_key
+      @primary_key
    end
 
    def jsonize options = {}
-      attr_props = prepare_json(options)
-      redisize_json(attr_props) do
-         generate_json(attr_props, options[:externals])
+      attr_tree = attibute_tree(self.class, options)
+
+      redisize_json(attr_tree) do
+         attr_props = jsonize_scheme_for(self.class, attr_tree)
+         generate_json(self, attr_props, options)
       end
    end
 
    def dejsonize options = {}
-      attr_props = prepare_json(options)
-      deredisize_json(attr_props)
+      attr_tree = attibute_tree(self.class, options)
+      deredisize_json(attr_tree)
    end
 
    def as_json options = {}
-      attr_props = prepare_json(options)
-      generate_json(attr_props, options[:externals])
+      attr_props = jsonize_scheme_for(self.class, attibute_tree(self.class, options))
+
+      generate_json(self, attr_props, options)
    end
 
    module Relation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonize
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Pavel «Malo» Skrylev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-26 00:00:00.000000000 Z
+date: 2023-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redisize
@@ -95,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Act as as_json for active record model or as a jsonize