jsonize 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb7d503cc06ab7caf4bad0cfb1f7162fab524a76d7cfc5d24c695f58231f5ae
-  data.tar.gz: 5d4ac6b92ab4f1893d7cd23609460e9f2009bd646f1df4f2878a5fa4db758465
+  metadata.gz: 5f9ca1fdab05a8d207c70e1600579a486d4532431fae68683398cb1ee1d8e7ec
+  data.tar.gz: bd1db6eda7a52b81fbfdeda0b83c9ede523da3c06df6fecefe961e9006784def
 SHA512:
-  metadata.gz: 93ee3812b793b0dd34f88df23bc3438372d7cfb07d1ddefa72026bd9a064e37e4d5689bb13d46ae8eff5e62e90ee844f16179235d4806ec71519ff6dc87e89f1
-  data.tar.gz: 8830854c6b28efcdeae92aebef0b75138a6f85fc87be5016931374b7b3c2f32c2cec8a0aa133f6a14db1634d83ed5db7f2ab8be7baa40a1603000611e882809d
+  metadata.gz: 427fbc6d4eb02797ffcf4a93915b044d14cfb205ec7b8cd2784258f989b98739cef5b69a294e37cbd6a5e02a6895a9eecf45a92911906f64229296ae3398ce14
+  data.tar.gz: 47329b942f4f8f89243c5cb8c775186d80febecb0233944978cfdd3d1b8a3cae2bc90bb9e79ce893487dbea49b86c5b3505a0c8259b23657a548819febc6dcca

data/README.md

@@ -32,7 +32,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jsonize. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/jsonize/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://codeberg.org/majioa/jsonize. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://codeberg.org/majioa/jsonize/blob/master/CODE_OF_CONDUCT.md).
 
 
 ## License
@@ -41,4 +41,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Jsonize project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/jsonize/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Jsonize project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://codeberg.org/majioa/jsonize/blob/master/CODE_OF_CONDUCT.md).

data/jsonize.gemspec

@@ -8,15 +8,15 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Act as as_json for active record model or as a jsonize}
   spec.description   = %q{Act as as_json for active record model or as a jsonize using the cacheable redisize}
-  spec.homepage      = "https://github.com/majioa/jsonize"
+  spec.homepage      = "https://codeberg.org/majioa/jsonize"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/majioa/jsonize"
-  spec.metadata["changelog_uri"] = "https://github.com/majioa/jsonize/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "https://codeberg.org/majioa/jsonize"
+  spec.metadata["changelog_uri"] = "https://codeberg.org/majioa/jsonize/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/lib/jsonize/orm/active_record.rb

@@ -3,4 +3,5 @@ require 'active_support/lazy_load_hooks'
 ActiveSupport.on_load :active_record do
    ::ActiveRecord::Base.send :include, Jsonize
    ::ActiveRecord::Relation.send :include, Jsonize::Relation
+   ::Enumerable.send :include, Jsonize::Collection
 end

data/lib/jsonize/version.rb

@@ -1,3 +1,3 @@
 module Jsonize
-  VERSION = "0.1.1"
+  VERSION = "0.3.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,188 @@ module Jsonize
       end
    end
 
-   def generate_json propses, options = {}
-      propses.reduce({}) do |r, (name, props)|
+   def generate_relation rela, source_in, options
+      attr_props = source_in.is_a?(Hash) ? source_in : source_in.polymorphic? ?
+         {} : jsonize_scheme_for(source_in.klass, attibute_tree(source_in.klass, options))
+
+      case rela
+      when Enumerable
+         rela.map do |rec|
+            generate_json(rec, attr_props, options)
+         end
+      when NilClass
+         nil
+      when Object
+         generate_json(rela, attr_props, 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 ||
+                     begin
+                        source.bind(flow)[]
+                     rescue ActiveModel::MissingAttributeError, TypeError, NoMethodError
+                     rescue Exception => e
+                        $stderr.puts("#{e.class}: #{e.message}")
+                        # binding.pry
+                     end
+               when Proc
+                  r || source[flow]
+               when Hash, ActiveRecord::Reflection::AbstractReflection
+                  o = !options[:only] ? options :
+                     options[:only].is_a?(Hash) ? options.merge(only: options[:only][name]) :
+                     options.merge(only: nil)
+
+                  generate_relation(r || flow.respond_to?(name) && flow.send(name) || nil, source, o)
+               when NilClass
+                  r
+               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
+   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
+                  collect_attributes(hh, model, sub, sub.to_sym, prepare_attributes(submodel, subattrs))
+               else
+                  hh
+               end
+            end
+         else
+            collect_attributes(h, model, x, x.to_s.sub(/^_/, '').to_sym, nil)
+         end
+      end
+   end
+
+   def collect_attributes h, model, name, key, value
+      base = [ ->(this) { this.respond_to?(:read_attribute) ? this.read_attribute("_#{name}") : nil } ]
+
+      props =
+      unless value
+         [model._reflections[name.to_s],
+         model.instance_methods.include?(name.to_sym) ? model.instance_method(name.to_sym) : nil,
+         ->(this) { this.is_a?(Hash) ? this[name] : nil },
+         (self.class == model ? self.attribute_names : model.attribute_names).include?(name.to_s) ?
+         ->(this) { this.respond_to?(:read_attribute) ? this.read_attribute(name) : nil } : nil,
+         ].compact
       else
-         true
+         [value]
+      end
+
+      h.merge(key => base.concat(props))
+   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 Collection
+      def jsonize context = {}
+         method =
+            case self
+            when Hash
+               :redisize_hash
+            when Array
+               :redisize_array
+            end
+
+         send(method) do
+            as_pure_json(context)
+         end
+      end
+
+      def recontext context, key
+         context_only = [context[:only]].flatten(1).reduce(nil) { |r, x| r || (x.is_a?(Hash) ? x[key] : r) }
+         context_except = [context[:except]].flatten(1).reduce(nil) { |r, x| r || (x.is_a?(Hash) ? x[key] : r) }
+
+         context.merge(only: context_only, except: context_except)
+      end
+
+      def as_pure_json context = {}
+         case self
+         when Hash
+            self.map do |key, value_in|
+               new_context = recontext(context, key)
+
+               value = value_in.respond_to?(:as_pure_json) ? value_in.as_pure_json(new_context) : value_in.as_json(new_context)
+
+               [key.to_s, value]
+            end.to_h
+         when Array
+            self.map.with_index do |value_in, index|
+               new_context = recontext(context, index.to_i)
+
+               value_in.respond_to?(:as_pure_json) ? value_in.as_pure_json(new_context) : value_in.as_json(new_context)
+            end
+         else
+            as_json(context)
+         end
+      end
    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.3.0
 platform: ruby
 authors:
 - Pavel «Malo» Skrylev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-05 00:00:00.000000000 Z
+date: 2024-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redisize
@@ -72,14 +72,14 @@ files:
 - lib/jsonize.rb
 - lib/jsonize/orm/active_record.rb
 - lib/jsonize/version.rb
-homepage: https://github.com/majioa/jsonize
+homepage: https://codeberg.org/majioa/jsonize
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/majioa/jsonize
-  source_code_uri: https://github.com/majioa/jsonize
-  changelog_uri: https://github.com/majioa/jsonize/CHANGELOG.md
+  homepage_uri: https://codeberg.org/majioa/jsonize
+  source_code_uri: https://codeberg.org/majioa/jsonize
+  changelog_uri: https://codeberg.org/majioa/jsonize/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -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.26
 signing_key:
 specification_version: 4
 summary: Act as as_json for active record model or as a jsonize