jsonize 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb7d503cc06ab7caf4bad0cfb1f7162fab524a76d7cfc5d24c695f58231f5ae
-  data.tar.gz: 5d4ac6b92ab4f1893d7cd23609460e9f2009bd646f1df4f2878a5fa4db758465
+  metadata.gz: d3227e59ca0f4826ae7a108ba9ab99419e2441fa7ca4182cd288000fe5caaa5b
+  data.tar.gz: 5d79a0a28100a90b628b96820d250a10fa9b70806203b078d68c7828a035d88a
 SHA512:
-  metadata.gz: 93ee3812b793b0dd34f88df23bc3438372d7cfb07d1ddefa72026bd9a064e37e4d5689bb13d46ae8eff5e62e90ee844f16179235d4806ec71519ff6dc87e89f1
-  data.tar.gz: 8830854c6b28efcdeae92aebef0b75138a6f85fc87be5016931374b7b3c2f32c2cec8a0aa133f6a14db1634d83ed5db7f2ab8be7baa40a1603000611e882809d
+  metadata.gz: e427382e3c42a97b5991c2d382a078a198562c1686c835e7039546de9ce360890c8cd6ada52bb3339c1835fd9422d686875631ecdad6bf30f312a5bac38480ab
+  data.tar.gz: e35614f1087c93893ee1dc739b4c2a85756f632afcb99a419b70afb605714b459f5b8bf3bc2b1e0435527d4ce24999993df61e6c39366eb5c53d01cbda81a7c8

data/lib/jsonize/version.rb

@@ -1,3 +1,3 @@
 module Jsonize
-  VERSION = "0.1.1"
+  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
+   JSON_TYPES = [String, Integer, TrueClass, FalseClass, NilClass, Hash, Array]
 
-   def instance_attrs
-      self.attribute_names.map {|a| [a.to_sym, true] }.to_h
-   end
-
-   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,77 +33,120 @@ module Jsonize
       end
    end
 
-   def generate_json propses, options = {}
-      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"] == '_reflection'
-               send(name).as_json(options[name.to_sym] || {})
-            elsif props["rule"].is_a?(String) # NOTE required for sidekiq key
-               extenrals = options[:externals]
-               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] || {},
-         _reflections
-      ].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)
-
-      attr_hash.map do |(name_in, rule_in)|
-         name = /^_(?<_name>.*)/ =~ name_in && _name || name_in.to_s
-
-         next nil if except.include?(name.to_sym) || (only & [ name.to_sym, name_in.to_sym ].uniq).blank?
-
-         rule = parse_rule(rule_in)
-         [name, { "rule" => rule, "real_name" => name_in.to_s }]
-      end.compact.to_h
-   end
-
-   def parse_rule rule_in
-      case rule_in
-      when TrueClass, FalseClass, NilClass
-         true
-      when ActiveRecord::Reflection::AbstractReflection
-         '_reflection'
-      when Symbol, String
-         rule_in.to_s
-      else
-         true
+   def proceed_value value_in
+      (value_in.class.ancestors & JSON_TYPES).any? ? value_in : value_in.to_s
+   end
+
+   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
+
+   def jsonize_attributes_except a_in, except_in
+      except_in.reduce(a_in) do |res, name|
+         if res.include?(name)
+            res.delete(name)
+         end
+
+         res
+      end
+   end
+
+   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)
+      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)
+      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.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Pavel «Malo» Skrylev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-05 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