glib-web 4.39.0 → 4.39.1

data/app/views/json_ui/garage/views/fields_focus.json.jbuilder

@@ -11,44 +11,44 @@ page.body padding: glib_json_padding_body, childViews: ->(body) do
       method: 'post',
       width: 300,
       childViews: ->(form) do
-        res.fields_text id: 'first', name: 'user[full_name]', label: 'Full name', placeholder: 'Full name', width: 'matchParent'
-        res.spacer height: 4
-        res.fields_number id: 'second', name: 'user[age]', label: 'Age', placeholder: 'Age', width: 'matchParent'
-        res.spacer height: 4
-        res.fields_textarea id: 'third', name: 'user[boi]', label: 'Bio', placeholder: 'Bio', width: 'matchParent'
-        res.spacer height: 4
-        res.fields_date id: 'fourth', name: 'user[birth_date]', label: 'Birth date', placeholder: 'Birth date', width: 'matchParent'
-        res.spacer height: 4
-        res.panels_horizontal childViews: ->(hori) do
-          res.button text: 'focus1', onClick: ->(action) do
+        form.fields_text id: 'first', name: 'user[full_name]', label: 'Full name', placeholder: 'Full name', width: 'matchParent'
+        form.spacer height: 4
+        form.fields_number id: 'second', name: 'user[age]', label: 'Age', placeholder: 'Age', width: 'matchParent'
+        form.spacer height: 4
+        form.fields_textarea id: 'third', name: 'user[boi]', label: 'Bio', placeholder: 'Bio', width: 'matchParent'
+        form.spacer height: 4
+        form.fields_date id: 'fourth', name: 'user[birth_date]', label: 'Birth date', placeholder: 'Birth date', width: 'matchParent'
+        form.spacer height: 4
+        form.panels_horizontal childViews: ->(hori) do
+          hori.button text: 'focus1', onClick: ->(action) do
             action.fields_focus targetId: 'first'
           end
-          res.spacer width: 4
-          res.button text: 'focus2', onClick: ->(action) do
+          hori.spacer width: 4
+          hori.button text: 'focus2', onClick: ->(action) do
             action.fields_focus targetId: 'second'
           end
-          res.spacer width: 4
-          res.button text: 'focus3', onClick: ->(action) do
+          hori.spacer width: 4
+          hori.button text: 'focus3', onClick: ->(action) do
             action.fields_focus targetId: 'third'
           end
-          res.spacer width: 4
-          res.button text: 'focus4', onClick: ->(action) do
+          hori.spacer width: 4
+          hori.button text: 'focus4', onClick: ->(action) do
             action.fields_focus targetId: 'fourth'
           end
-          res.spacer width: 4
-          res.button text: 'blur', onClick: ->(action) do
+          hori.spacer width: 4
+          hori.button text: 'blur', onClick: ->(action) do
             action.fields_focus targetId: 'first', onFocus: ->(saction) do
               saction.timeouts_set interval: 1000, onTimeout: ->(ssaction) { ssaction.fields_blur }
             end
           end
-          res.spacer width: 4
-          res.button text: 'reset', onClick: ->(action) do
+          hori.spacer width: 4
+          hori.button text: 'reset', onClick: ->(action) do
             action.fields_reset targetIds: ['first', 'second', 'third', 'fourth'], onReset: ->(saction) do
               saction.snackbars_alert styleClasses: ['success'], message: 'Reset full name!'
             end
           end
-          res.spacer width: 4
-          res.fields_submit text: 'submit'
+          hori.spacer width: 4
+          hori.fields_submit text: 'submit'
         end
       end
 

data/lib/glib/json_crawler/router.rb

@@ -8,20 +8,20 @@ module Glib
       attr_reader :http_actions
       attr_accessor :host, :skip_similar_page
 
-      def log(action, url, response = nil)
-        if url.present?
-          url = remove_params(url, [:__glib_permission_test])
+      def log(action, key_data, response = nil)
+        # Sometimes `key_data` may not be an actual URL, e.g. in the context of dialogs_alert,
+        # it is the alert message.
+        if key_data&.start_with?('http://', 'https://')
+          key_data = remove_params(key_data, [:__glib_permission_test])
         end
 
         @last_log = [
           action,
           response.present? ? response.code : nil,
-          url
+          key_data
         ].compact.join(
           ' :: '
-                    )
-
-        # puts @last_log
+        )
 
         @logger += '  ' * @depth + @last_log + "\n"
       end
@@ -172,24 +172,27 @@ module Glib
         crawler_actions.each do |crawler_action|
           action, url, params = crawler_action
 
-          if url.present?
-            url = add_params(url, __glib_permission_test: true)
-          end
-
-          params = JSON.parse(params) if params.is_a?(String)
-          params ||= {}
-
-          case action.to_s.downcase
-          when 'http/post-v1', 'forms/post'
-            http.post(url, action, params)
-          when 'http/patch-v1', 'forms/patch'
-            http.patch(url, action, params)
-          when 'http/put-v1', 'forms/put'
-            http.put(url, action, params)
-          when 'http/delete-v1'
-            http.delete(url, action, params)
+          # In full mode, wrap each action in a transaction that gets rolled back
+          # to ensure database state is reset between each URL check (prevent database contamination)
+          if ENV['GLIB_DISABLE_PERMISSION_TEST_SKIP'] == 'true'
+            # This solution is important for permissions tests (not as much in the crawler tests),
+            # because in permission tests, the user hits every single available URLs with a single purpose
+            # of checking the permission of every URL, meaning that one incorrect result (e.g. 403 instead of 200 due to
+            # side effect from previous URL requests) cannot be tolerated.
+            #
+            # On the other hand, crawler tests are expected to cover only one scenario anyway, so
+            # having the scenario changed (due to side effects) is fine. We decided it's better not
+            # to apply this solution for crawler tests out of performance considerations.
+            ActiveRecord::Base.transaction do
+              execute_crawler_action(http, action, url, params)
+              raise ActiveRecord::Rollback
+            end
           else
-            http.get(url, action, params)
+            # In skip mode, add the permission test parameter
+            if url.present?
+              url = add_params(url, __glib_permission_test: true)
+            end
+            execute_crawler_action(http, action, url, params)
           end
         end
       end
@@ -224,6 +227,24 @@ module Glib
       end
 
       private
+        def execute_crawler_action(http, action, url, params)
+          params = JSON.parse(params) if params.is_a?(String)
+          params ||= {}
+
+          case action.to_s.downcase
+          when 'http/post-v1', 'forms/post'
+            http.post(url, action, params)
+          when 'http/patch-v1', 'forms/patch'
+            http.patch(url, action, params)
+          when 'http/put-v1', 'forms/put'
+            http.put(url, action, params)
+          when 'http/delete-v1'
+            http.delete(url, action, params)
+          else
+            http.get(url, action, params)
+          end
+        end
+
         def add_params(url, new_params)
           uri = URI(url)
           existing = URI.decode_www_form(uri.query || '')

data/lib/glib/rubocop/cops/json_ui/base_nested_parameter.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Glib
+      module JsonUi
+        # Base class for checking nested block parameter violations in JsonUi templates.
+        # Handles both parameter shadowing and incorrect usage of outer variables.
+        class BaseNestedParameter < Base
+          extend AutoCorrector
+
+          MSG_OUTER_VAR = 'Use the immediate block parameter `%<immediate>s` instead of outer variable `%<outer>s`.'
+
+          def on_block(node)
+            check_nested_block(node)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def check_nested_block(node)
+            block_param = extract_block_param(node)
+            return unless block_param
+            return unless relevant_block?(node)
+
+            parent_blocks = find_parent_relevant_blocks(node)
+            return if parent_blocks.empty?
+
+            parent_params = parent_blocks.filter_map { |b| extract_block_param(b) }
+
+            # Check for parameter shadowing
+            check_shadowing(node, block_param, parent_params)
+
+            # Check for incorrect usage of outer variables
+            check_send_nodes_in_body(node.body, block_param, parent_params)
+          end
+
+          def check_shadowing(node, block_param, parent_params)
+            parent_params.each do |parent_param|
+              next unless block_param == parent_param
+
+              param_node = node.arguments.children.first
+              suggested_name = suggest_param_name(parent_param)
+
+              add_offense(
+                param_node,
+                message: shadowing_message(parent_param, suggested_name)
+              ) do |corrector|
+                corrector.replace(param_node, suggested_name)
+                replace_param_usages(corrector, node.body, parent_param, suggested_name)
+              end
+            end
+          end
+
+          def check_send_nodes_in_body(body_node, current_param, parent_params)
+            return unless body_node
+
+            body_node.each_child_node do |child|
+              if child.send_type? || child.csend_type?
+                check_send_node(child, current_param, parent_params)
+              elsif !child.block_type? && !child.numblock_type?
+                # Recurse into non-block nodes
+                check_send_nodes_in_body(child, current_param, parent_params)
+              end
+            end
+          end
+
+          def check_send_node(send_node, current_param, parent_params)
+            receiver = send_node.receiver
+            return unless receiver&.lvar_type?
+
+            receiver_name = receiver.children.first
+
+            parent_params.each do |parent_param|
+              next unless receiver_name == parent_param.to_sym
+
+              add_offense(
+                receiver,
+                message: format(MSG_OUTER_VAR, immediate: current_param, outer: parent_param)
+              ) do |corrector|
+                corrector.replace(receiver, current_param.to_s)
+              end
+              break
+            end
+          end
+
+          def extract_block_param(node)
+            return nil unless node.block_type? || node.numblock_type?
+            return nil if node.numblock_type? # Numbered blocks not supported
+
+            args = node.arguments
+            return nil if args.children.empty?
+
+            args.children.first.children.first
+          end
+
+          def find_parent_relevant_blocks(node)
+            blocks = []
+            current = node.parent
+
+            while current
+              if (current.block_type? || current.numblock_type?) && current != node
+                blocks << current if relevant_block?(current)
+              end
+              current = current.parent
+            end
+
+            blocks
+          end
+
+          def lambda_block?(block_node)
+            block_node.block_type? && block_node.send_node.method_name == :lambda
+          end
+
+          def hash_pair_parent(block_node)
+            current = block_node.parent
+            current if current&.pair_type?
+          end
+
+          def replace_param_usages(corrector, body_node, old_name, new_name)
+            return unless body_node
+
+            body_node.each_descendant(:lvar) do |lvar_node|
+              corrector.replace(lvar_node, new_name) if lvar_node.children.first == old_name.to_sym
+            end
+          end
+
+          def suggest_param_name(parent_param)
+            parent_param.to_s.start_with?('sub') ? "#{parent_param}2" : "sub#{parent_param}"
+          end
+
+          def shadowing_message(parent_param, suggested_name)
+            "Avoid shadowing the outer parameter `#{parent_param}`. Use a different name like `#{suggested_name}`."
+          end
+
+          # To be implemented by subclasses
+          def relevant_block?(_block_node)
+            raise NotImplementedError, "#{self.class} must implement #relevant_block?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glib/rubocop/cops/json_ui/nested_action_parameter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'base_nested_parameter'
+
+module RuboCop
+  module Cop
+    module Glib
+      module JsonUi
+        # Enforces using the immediate block parameter instead of outer block variables
+        # in nested action blocks (onClick, onClose, onChange, etc.) in JsonUi templates.
+        #
+        # @example
+        #   # bad - parameter shadowing
+        #   button onClick: ->(action) do
+        #     action.dialogs_alert onClose: ->(action) do  # shadows outer 'action'
+        #       action.snackbars_alert message: 'Closed'
+        #     end
+        #   end
+        #
+        #   # good
+        #   button onClick: ->(action) do
+        #     action.dialogs_alert onClose: ->(subaction) do
+        #       subaction.snackbars_alert message: 'Closed'
+        #     end
+        #   end
+        #
+        #   # bad - using outer variable
+        #   button onClick: ->(action) do
+        #     action.dialogs_alert onClose: ->(subaction) do
+        #       action.forms_submit  # using 'action' instead of 'subaction'
+        #     end
+        #   end
+        #
+        #   # good
+        #   button onClick: ->(action) do
+        #     action.dialogs_alert onClose: ->(subaction) do
+        #       subaction.forms_submit
+        #     end
+        #   end
+        class NestedActionParameter < BaseNestedParameter
+          private
+
+          def relevant_block?(block_node)
+            return false unless lambda_block?(block_node)
+
+            pair = hash_pair_parent(block_node)
+            return false unless pair
+
+            pair.key.sym_type? && pair.key.value.to_s.start_with?('on')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glib/rubocop/cops/json_ui/nested_block_parameter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base_nested_parameter'
+
+module RuboCop
+  module Cop
+    module Glib
+      module JsonUi
+        # Enforces using the immediate block parameter instead of outer block variables
+        # in nested view blocks (childViews, content) in JsonUi templates.
+        #
+        # @example
+        #   # bad - using outer variable
+        #   scroll.panels_form childViews: ->(form) do
+        #     scroll.label text: 'TEST'  # using 'scroll' instead of 'form'
+        #   end
+        #
+        #   # good
+        #   scroll.panels_form childViews: ->(form) do
+        #     form.label text: 'TEST'
+        #   end
+        #
+        #   # bad - parameter shadowing
+        #   scroll.panels_form childViews: ->(form) do
+        #     form.panels_responsive childViews: ->(form) do  # shadows outer 'form'
+        #       form.fields_text name: 'user[field]'
+        #     end
+        #   end
+        #
+        #   # good
+        #   scroll.panels_form childViews: ->(form) do
+        #     form.panels_responsive childViews: ->(res) do
+        #       res.fields_text name: 'user[field]'
+        #     end
+        #   end
+        class NestedBlockParameter < BaseNestedParameter
+          private
+
+          def relevant_block?(block_node)
+            return false unless lambda_block?(block_node)
+
+            pair = hash_pair_parent(block_node)
+            return false unless pair
+
+            pair.key.sym_type? && [:childViews, :content].include?(pair.key.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glib/rubocop/cops/multiline_method_call_style.rb

@@ -37,6 +37,7 @@ module RuboCop
           return unless multi_line_call_with_args?(node)
           return if proper_parentheses_style?(node)
           return if proper_backslash_style?(node) && allow_backslash?
+          return if inside_correctable_parent?(node)
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -122,12 +123,28 @@ module RuboCop
           args
         end
 
+        def inside_correctable_parent?(node)
+          # Check if this node is inside a block that belongs to a multi-line call
+          # that will also be corrected. If so, skip this node to avoid conflicts.
+          current = node.parent
+
+          while current
+            if current.send_type? || current.csend_type?
+              if multi_line_call_with_args?(current) && !proper_parentheses_style?(current)
+                return true
+              end
+            end
+            current = current.parent
+          end
+
+          false
+        end
+
         def autocorrect(corrector, node)
           method_end_pos = node.loc.selector.end_pos
 
-          # Find the indentation of the method call
-          line_begin_pos = processed_source.buffer.line_range(node.loc.line).begin_pos
-          base_indent = node.source_range.begin_pos - line_begin_pos
+          # Calculate indentation based on the node's actual column position
+          base_indent = node.loc.column
           arg_indent = ' ' * (base_indent + 2)
 
           # Build the new argument list
@@ -137,7 +154,9 @@ module RuboCop
 
             if arg.hash_type?
               arg.pairs.each do |pair|
-                arg_parts << pair.source
+                # Re-indent pair if it contains a block
+                pair_source = reindent_pair_with_block(pair, arg_indent)
+                arg_parts << pair_source
               end
             else
               arg_parts << arg.source
@@ -151,7 +170,7 @@ module RuboCop
 
             # If there's a block, add it on the last argument line
             if node.block_literal?
-              block_source = node.block_literal.source
+              block_source = reindent_block(node.block_literal, arg_indent)
               replacement += " #{block_source}"
             end
 
@@ -175,6 +194,56 @@ module RuboCop
 
           corrector.replace(range, replacement)
         end
+
+        def reindent_pair_with_block(pair, base_indent)
+          # Check if the pair's value is a block
+          return pair.source unless pair.value.block_type?
+
+          # Format: "key: ->(param) do ... end"
+          key_source = pair.key.source
+          block_source = reindent_block(pair.value, base_indent)
+
+          "#{key_source}: #{block_source}"
+        end
+
+        def reindent_block(block_node, base_indent)
+          # Get block source lines
+          source = block_node.source
+          lines = source.lines
+
+          return source if lines.length == 1 # Single line block, no reindent needed
+
+          # Find the current indentation of the block's first line
+          # (this is usually where "do" appears)
+          first_line = lines[0]
+
+          # Process the block:
+          # Line 0: "->(param) do" - keep as is
+          # Lines 1..-2: block body - re-indent to base_indent + 2
+          # Last line: "end" - indent to base_indent
+
+          result_lines = []
+          block_body_indent = base_indent + ' ' * 2
+
+          lines.each_with_index do |line, index|
+            if index == 0
+              # First line: "->(param) do"
+              result_lines << line.rstrip
+            elsif index == lines.length - 1
+              # Last line: "end"
+              result_lines << "#{base_indent}#{line.strip}"
+            else
+              # Body lines: re-indent
+              # Remove existing indentation and add new indentation
+              stripped = line.lstrip
+              next if stripped.empty? # Skip blank lines
+
+              result_lines << "#{block_body_indent}#{stripped.rstrip}"
+            end
+          end
+
+          result_lines.join("\n")
+        end
       end
     end
   end

data/lib/glib/rubocop.rb

@@ -1,2 +1,5 @@
 require_relative 'rubocop/cops/localize'
 require_relative 'rubocop/cops/multiline_method_call_style'
+require_relative 'rubocop/cops/json_ui/base_nested_parameter'
+require_relative 'rubocop/cops/json_ui/nested_block_parameter'
+require_relative 'rubocop/cops/json_ui/nested_action_parameter'

data/lib/glib/test/parallel_coverage.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Glib
+  module Test
+    # ParallelCoverage configures Rails parallel testing to work properly with SimpleCov.
+    #
+    # Without this configuration, SimpleCov reports inaccurate coverage (often very low, like 1-2%)
+    # when running tests with parallelization enabled, because it only captures data from one worker
+    # instead of merging results from all parallel workers.
+    #
+    # Usage:
+    #   class ActiveSupport::TestCase
+    #     include Glib::Test::ParallelCoverage
+    #   end
+    #
+    # This will:
+    # - Enable parallel test execution using all available processors
+    # - Configure SimpleCov to track each worker separately
+    # - Automatically merge coverage results from all workers
+    module ParallelCoverage
+      extend ActiveSupport::Concern
+
+      included do
+        # Set threshold for force parallelization.
+        parallelize(workers: :number_of_processors, threshold: 1)
+
+        # Configure SimpleCov to properly merge coverage from parallel workers
+        parallelize_setup do |worker|
+          SimpleCov.command_name "#{SimpleCov.command_name}-#{worker}"
+        end
+
+        parallelize_teardown do |_worker|
+          SimpleCov.result
+        end
+      end
+    end
+  end
+end

data/lib/glib/test_helpers.rb

@@ -83,6 +83,18 @@ module Glib
       "http://#{HOST}/users/sign_out.json"
     end
 
+    def glib_travel(*args, &block)
+      Timecop.travel(*args, &block)
+    end
+
+    def glib_travel_freeze(*args, &block)
+      Timecop.freeze(*args, &block)
+    end
+
+    def glib_travel_back
+      Timecop.return
+    end
+
     private
       def __execute_crawler(user, inspect_http:, log_file: nil, &block)
         auth_token = login user

data/lib/glib-web.rb

@@ -8,6 +8,7 @@ require 'glib/json_crawler'
 
 require 'glib/dynamic_text'
 require 'glib/test_helpers'
+require 'glib/test/parallel_coverage'
 require 'glib/integration_test'
 
 require 'glib/time_freezable_mailer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glib-web
 version: !ruby/object:Gem::Version
-  version: 4.39.0
+  version: 4.39.1
 platform: ruby
 authors:
 - ''
@@ -376,6 +376,7 @@ files:
 - app/views/json_ui/garage/test_page/form.json.jbuilder
 - app/views/json_ui/garage/test_page/form_dynamic.json.jbuilder
 - app/views/json_ui/garage/test_page/lifecycle.json.jbuilder
+- app/views/json_ui/garage/test_page/logics_set.json.jbuilder
 - app/views/json_ui/garage/test_page/multiupload.json.jbuilder
 - app/views/json_ui/garage/test_page/selectable.json.jbuilder
 - app/views/json_ui/garage/test_page/window.json.jbuilder
@@ -442,9 +443,13 @@ files:
 - lib/glib/json_crawler/router.rb
 - lib/glib/mailer_tester.rb
 - lib/glib/rubocop.rb
+- lib/glib/rubocop/cops/json_ui/base_nested_parameter.rb
+- lib/glib/rubocop/cops/json_ui/nested_action_parameter.rb
+- lib/glib/rubocop/cops/json_ui/nested_block_parameter.rb
 - lib/glib/rubocop/cops/localize.rb
 - lib/glib/rubocop/cops/multiline_method_call_style.rb
 - lib/glib/snapshot.rb
+- lib/glib/test/parallel_coverage.rb
 - lib/glib/test_helpers.rb
 - lib/glib/time_freezable_mailer.rb
 - lib/glib/time_returning_mailer.rb