render_json_rails 0.1.7 → 0.2.3

data/Gemfile

@@ -3,5 +3,5 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in render_json_rails.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
 gem "minitest", "~> 5.0"
+gem "rake", "~> 12.0"

data/README.md

@@ -24,9 +24,17 @@ class User < ActiveRecord::Base
   include RenderJsonRails::Concern
 
   render_json_config name: :user,
+                     except: [:account_id, :id],
+                     # only: [:login, :email], # jesli wolelibyśmy wymienić pola zamiast je wykluczać przy pomocy "except"
+                     default_fields: [:login, :email, :calculated_age],
+                     allowed_methods: [:calculated_age],
                      includes: {
                        team: Team
                      }
+
+  def calculated_age
+    rand(100)
+  end
 end
 ```
 
@@ -62,14 +70,26 @@ i możemy łączyć to z include
 http://example.text/teams/1.json?fields[team]=name,description&fields[user]=email,name&include=users
 ```
 
-## Pełny opis ```render_json_config```
+include mogą być zagnieżdżane (po kropce)
+
+```html
+http://example.text/teams/1.json?fields[team]=name,description&fields[user]=email,name&fields[role]=name&include=users,users.roles
+```
+
+## Wiecej przykładów użycia
+
+Więcej przykładów jest w testach: [test/render_json_rails_test.rb](test/render_json_rails_test.rb)
+
+## Wszystkie opcje ```render_json_config```
 
 ```ruby
 render_json_config name: :team,
   except: [:account_id, :config], # tych pól nie będzie w json-ie
-  methods: [:image], # te metody zostaną dołączone
-  allowed_methods: [:members], # te metody mogą być dodane przez parametr fileds np: fields[team]=id,members
-  includes: { # to mozna dołączać za pomoca parametru include np include=users,category
+  only: [:id, :name], # dozwolone pola będą w jsonie (wymiennie z except)
+  methods: [:image], # dozwolone i domyślnie wyświetlone metody, ten parametr warto uzywac tylko, gdy nie ma parametru "default_fields" - przy ustawionym "default_fields" trzeba metody wymienic w allowed_methods
+  default_fields: [:id, :name, :members], # domyślnie wyświetlone pola + metody
+  allowed_methods: [:members], # dozwolone metody, mogą być dodane przez parametr fileds np: fields[team]=id,members
+  includes: { # to mozna dołączać za pomoca parametru include np include=users,category,users.roles
    users: Users,
    category: Category
   }

data/Rakefile

@@ -9,4 +9,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => :test
+task default: :test

data/lib/render_json_rails/concern.rb

@@ -17,14 +17,22 @@ module RenderJsonRails
       #  zostaną one wyświelone w json-ie
       # TODO:
       # [ ] spradzanie czy parametry "fields" i "include" sa ok i jesli nie to error
-      def default_json_options(name:, fields: nil, except: nil, methods: nil, allowed_methods: nil)
+      def default_json_options(name:, fields: nil, only: nil, except: nil, methods: nil, allowed_methods: nil, additional_fields: nil)
         # name ||= self.name.underscore.gsub('/', '_')
         # raise self.name.underscore.gsub('/', '_')
-        except ||= [:account_id, :agent, :ip]
+        # except ||= [:account_id, :agent, :ip]
 
         options = {}
         if fields && fields[name].present?
-          options[:only] = fields[name].split(',').map{ |e| e.to_s.strip.to_sym }.find_all { |el| !except.include?(el) }
+          if additional_fields && additional_fields[name].present?
+            fields[name] += ",#{additional_fields[name]}"
+          end
+          options[:only] = fields[name].split(',').map{ |e| e.to_s.strip.to_sym }.find_all { |el| !except&.include?(el) }
+          if only.present?
+            options[:only] = options[:only].find_all do |el|
+              only.include?(el) || allowed_methods&.include?(el) || methods&.include?(el)
+            end
+          end
           options[:methods] = methods&.find_all { |el| options[:only].include?(el) }
           if allowed_methods
             options[:methods] = (options[:methods] || []) | allowed_methods.find_all { |el| options[:only].include?(el) }
@@ -34,7 +42,12 @@ module RenderJsonRails
           end
         else
           options[:except] = except
+          options[:only] = only if only.present?
           options[:methods] = methods
+          if additional_fields && additional_fields[name].present? && allowed_methods
+            additional_methods = additional_fields[name].split(',').map{ |e| e.to_s.strip.to_sym }.find_all { |el| allowed_methods.include?(el) }
+            options[:methods] = (options[:methods] || []) | additional_methods
+          end
         end
         options
       end
@@ -43,34 +56,44 @@ module RenderJsonRails
         @render_json_config = config
       end
 
-      def render_json_options(includes: nil, fields: nil, additional_config: nil)
+      def render_json_options(includes: nil, fields: nil, override_render_json_config: nil, additional_config: nil, additional_fields: nil)
         raise "należy skonfigurowac render_json metodą: render_json_config" if !defined?(@render_json_config)
 
-        name = @render_json_config[:name].to_s
+        if override_render_json_config
+          current_json_config = override_render_json_config # @render_json_config.merge(override_render_json_config)
+          current_json_config[:name] ||= @render_json_config[:name]
+          current_json_config[:default_fields] ||= @render_json_config[:default_fields]
+        else
+          current_json_config = @render_json_config
+        end
+
+        name = current_json_config[:name].to_s
 
-        if (fields.blank? || fields[name].blank?) && @render_json_config[:default_fields].present?
+        if (fields.blank? || fields[name].blank?) && current_json_config[:default_fields].present?
           fields ||= {}
-          fields[name] = @render_json_config[:default_fields].join(',')
+          fields[name] = current_json_config[:default_fields].join(',')
         end
 
         options = default_json_options(
           name: name,
           fields: fields,
-          except: @render_json_config[:except],
-          methods: @render_json_config[:methods],
-          allowed_methods: @render_json_config[:allowed_methods]
+          only: current_json_config[:only],
+          except: current_json_config[:except],
+          methods: current_json_config[:methods],
+          allowed_methods: current_json_config[:allowed_methods],
+          additional_fields: additional_fields
         )
 
         if includes
           include_options = []
-          @render_json_config[:includes].each do |name, klass|
-            if includes.include?(name.to_s)
-              includes2 = RenderJsonRails::Concern.includes_for_model(includes: includes, model: name.to_s)
-              include_options << { name => klass.render_json_options(includes: includes2, fields: fields) }
+          current_json_config[:includes]&.each do |model_name, klass|
+            if includes.include?(model_name.to_s)
+              includes2 = RenderJsonRails::Concern.includes_for_model(includes: includes, model: model_name.to_s)
+              include_options << { model_name => klass.render_json_options(includes: includes2, fields: fields) }
             end
-          end if @render_json_config[:includes]
+          end
 
-          options[:include] = include_options
+          options[:include] = include_options if include_options.present?
         end
 
         options = RenderJsonRails::Concern.deep_meld(options, additional_config) if additional_config
@@ -82,23 +105,15 @@ module RenderJsonRails
     end # class_methods
 
     def self.includes_for_model(includes:, model:)
-      includes = includes.map do |el|
-        if el.start_with?(model + '.')
-          el = el.gsub(/^#{model}\./, '')
-        else
-          el = nil
-        end
-      end
+      includes = includes.map { |el| el.gsub(/^#{model}\./, '') if el.start_with?(model + '.') }
       includes.find_all { |el| el.present? }
     end
 
-    private
-
-    def self.deep_meld(h1, h2)
-      h1.deep_merge(h2) do |key, this_val, other_val|
-        if this_val != nil && other_val == nil
+    def self.deep_meld(hh1, hh2)
+      hh1.deep_merge(hh2) do |_key, this_val, other_val|
+        if !this_val.nil? && other_val == nil
           this_val
-        elsif this_val == nil && other_val != nil
+        elsif this_val == nil && !other_val.nil?
           other_val
         elsif this_val.is_a?(Array) && other_val.is_a?(Array)
           this_val | other_val

data/lib/render_json_rails/helper.rb

@@ -17,22 +17,21 @@ module RenderJsonRails
     # fields[invoice]=number,sales_code
     # fields[invoice_position]=price_gross
     # include=positions
-    def render_json(object, additional_config: nil, status: nil, location: nil)
-      raise "objekt nie moze byc null" if object == nil
+    def render_json(object, override_render_json_config: nil, additional_config: nil, status: nil, location: nil)
 
-      if object.class.to_s.include?('ActiveRecord_Relation')
-        return render json: [] if !object[0]
-
-        class_object = object[0].class
+      if (class_object = RenderJsonRails::Helper.find_render_json_options_class!(object))
+        includes = params[:include].to_s.split(',').map { |el| el.to_s.strip } if params[:include]
+        options = class_object.render_json_options(
+          includes: includes,
+          fields: params[:fields],
+          override_render_json_config: override_render_json_config,
+          additional_config: additional_config,
+          additional_fields: params[:additional_fields]
+        )
       else
-        class_object = object.class
+        options = {}
       end
-      includes = params[:include].to_s.split(',').map { |el| el.to_s.strip } if params[:include]
-      options = class_object.render_json_options(
-        includes: includes,
-        fields: params[:fields],
-        additional_config: additional_config
-      )
+
       if params[:formatted] && !Rails.env.development? || params[:formatted] != 'no' && Rails.env.development?
         json = JSON.pretty_generate(object.as_json(options))
         render json: json, status: status, location: location
@@ -43,5 +42,21 @@ module RenderJsonRails
         render options
       end
     end
+
+    def self.find_render_json_options_class!(object)
+      return nil if object == nil
+
+      if object.class.respond_to?(:render_json_options)
+        object.class
+      # elsif object.is_a?(ActiveRecord::Base)
+      #   raise "klasa: #{object.class} nie ma konfiguracji 'render_json_config'"
+      elsif object.respond_to?(:first)
+        RenderJsonRails::Helper.find_render_json_options_class!(object[0])
+      else
+        nil
+      end
+
+    end
+
   end
 end

data/lib/render_json_rails/version.rb

@@ -1,3 +1,3 @@
 module RenderJsonRails
-  VERSION = "0.1.7"
+  VERSION = "0.2.3"
 end

data/render_json_rails.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   # 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.
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_json_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.3
 platform: ruby
 authors:
 - Marcin
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-20 00:00:00.000000000 Z
+date: 2021-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -61,7 +62,7 @@ homepage: https://github.com/intum/render_json_rails
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -76,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Simle JSON API render like JonApi
 test_files: []