glib-web 4.39.0 → 4.39.2

data/lib/glib/doc_generator.rb

@@ -0,0 +1,386 @@
+require 'parser/current'
+require 'yaml'
+require 'fileutils'
+require 'time'
+
+module Glib
+  class DocGenerator
+    def initialize
+      @parser = Parser::CurrentRuby
+    end
+
+    # Generate YAML documentation for a single Ruby file
+    def generate_for_file(file_path, output_path)
+      unless File.exist?(file_path)
+        puts "Warning: File not found: #{file_path}"
+        return
+      end
+
+      source = File.read(file_path)
+      ast = @parser.parse(source)
+
+      components = extract_components(ast, source)
+
+      # Generate YAML
+      yaml_data = {
+        'meta' => {
+          'source_file' => file_path,
+          'generated_at' => Time.now.iso8601,
+          'generator_version' => '1.0.0'
+        },
+        'components' => components
+      }
+
+      # Ensure output directory exists
+      FileUtils.mkdir_p(File.dirname(output_path))
+
+      # Write YAML file
+      File.write(output_path, yaml_data.to_yaml)
+    end
+
+    private
+
+    # Extract component information from AST
+    def extract_components(node, source)
+      components = {}
+
+      traverse_ast(node, source) do |class_node, class_name, parent_class, comment|
+        next unless class_node.type == :class
+
+        # Parse YARD comment
+        yard_doc = parse_yard_comment(comment)
+
+        # Extract properties
+        properties = extract_properties(class_node, source)
+
+        # Build component hash
+        component_key = underscore(class_name)
+        components[component_key] = {
+          'class_name' => class_name,
+          'extends' => parent_class,
+          'description' => yard_doc[:description],
+          'properties' => properties,
+          'examples' => yard_doc[:examples],
+          'references' => yard_doc[:references],
+          'notes' => yard_doc[:notes],
+          'deprecated' => yard_doc[:deprecated]
+        }.compact
+      end
+
+      components
+    end
+
+    # Traverse AST and yield class nodes with their comments
+    def traverse_ast(node, source, &block)
+      return unless node.is_a?(Parser::AST::Node)
+
+      if node.type == :class
+        class_name = extract_class_name(node)
+        parent_class = extract_parent_class(node)
+        comment = extract_comment(node, source)
+
+        yield node, class_name, parent_class, comment
+      end
+
+      # Recursively traverse child nodes
+      node.children.each do |child|
+        traverse_ast(child, source, &block)
+      end
+    end
+
+    # Extract class name from class node
+    def extract_class_name(class_node)
+      const_node = class_node.children[0]
+      if const_node.type == :const
+        const_node.children[1].to_s
+      else
+        'Unknown'
+      end
+    end
+
+    # Extract parent class name
+    def extract_parent_class(class_node)
+      parent_node = class_node.children[1]
+      return nil unless parent_node
+
+      if parent_node.type == :const
+        parent_node.children[1].to_s
+      else
+        nil
+      end
+    end
+
+    # Extract comment before a node
+    def extract_comment(node, source)
+      return '' unless node.location
+
+      # Get all lines before the node
+      lines = source.lines
+      node_line = node.location.line - 1
+
+      # Walk backwards to collect comment lines
+      comment_lines = []
+      (node_line - 1).downto(0) do |i|
+        line = lines[i].strip
+        break unless line.start_with?('#') || line.empty?
+
+        if line.start_with?('#')
+          # Remove leading # and whitespace
+          comment_lines.unshift(line.sub(/^#\s?/, ''))
+        end
+      end
+
+      comment_lines.join("\n")
+    end
+
+    # Parse YARD comment into structured data
+    def parse_yard_comment(comment)
+      return {} if comment.empty?
+
+      result = {
+        description: '',
+        examples: [],
+        references: [],
+        notes: [],
+        deprecated: nil
+      }
+
+      current_section = :description
+      current_example = nil
+      description_lines = []
+
+      comment.lines.each do |line|
+        line = line.chomp
+
+        # Check for YARD tags
+        if line =~ /^@example\s*(.*)/
+          # Save current example if exists
+          result[:examples] << current_example if current_example
+
+          current_example = {
+            'label' => $1.strip,
+            'code' => ''
+          }
+          current_section = :example
+        elsif line =~ /^@see\s+(.*)/
+          reference = $1.strip
+          # Parse URL and description
+          if reference =~ /^(https?:\/\/\S+)\s+(.*)/
+            result[:references] << { 'url' => $1, 'description' => $2 }
+          elsif reference =~ /^(https?:\/\/\S+)/
+            result[:references] << { 'url' => $1 }
+          else
+            result[:references] << { 'text' => reference }
+          end
+          current_section = :description
+        elsif line =~ /^@note\s+(.*)/
+          result[:notes] << $1.strip
+          current_section = :description
+        elsif line =~ /^@deprecated\s*(.*)/
+          result[:deprecated] = $1.strip
+          result[:deprecated] = true if result[:deprecated].empty?
+          current_section = :description
+        else
+          # Regular content
+          if current_section == :example && current_example
+            # Remove leading spaces from example code (preserve relative indentation)
+            current_example['code'] += line + "\n"
+          elsif current_section == :description
+            description_lines << line unless line.strip.empty? && description_lines.empty?
+          end
+        end
+      end
+
+      # Save last example
+      result[:examples] << current_example if current_example
+
+      # Clean up example code (remove extra leading whitespace)
+      result[:examples].each do |example|
+        example['code'] = unindent(example['code'])
+      end
+
+      # Join description lines
+      result[:description] = description_lines.join("\n").strip
+
+      # Remove empty arrays/nils
+      result.delete(:examples) if result[:examples].empty?
+      result.delete(:references) if result[:references].empty?
+      result.delete(:notes) if result[:notes].empty?
+      result.delete(:deprecated) if result[:deprecated].nil?
+
+      result
+    end
+
+    # Extract properties from class body
+    def extract_properties(class_node, source)
+      properties = {}
+
+      class_body = class_node.children[2]
+      return properties unless class_body
+
+      traverse_class_body(class_body, source) do |method_name, args, comment|
+        # These are the DSL property definition methods
+        if [:string, :int, :bool, :float, :action, :views, :array, :hash,
+            :icon, :color, :length, :date, :date_time, :text, :any,
+            :panels_builder, :menu, :singleton_array].include?(method_name)
+
+          property_name = args.first
+          next unless property_name
+
+          # Parse property comment
+          prop_doc = parse_property_comment(comment)
+
+          # Extract options if present (for hash, singleton_array, etc.)
+          options = extract_property_options(args)
+
+          properties[property_name] = {
+            'type' => method_name.to_s,
+            'description' => prop_doc[:description],
+            'required' => options[:required] || false,
+            'options' => options[:options],
+            'examples' => prop_doc[:examples],
+            'notes' => prop_doc[:notes],
+            'deprecated' => prop_doc[:deprecated]
+          }.compact
+
+          # Remove empty arrays
+          properties[property_name].delete('examples') if properties[property_name]['examples']&.empty?
+          properties[property_name].delete('notes') if properties[property_name]['notes']&.empty?
+        end
+      end
+
+      properties
+    end
+
+    # Traverse class body to find method calls (property definitions)
+    def traverse_class_body(node, source, &block)
+      return unless node.is_a?(Parser::AST::Node)
+
+      if node.type == :send
+        receiver = node.children[0]
+        method_name = node.children[1]
+        args = node.children[2..-1].map { |arg| extract_symbol_or_string(arg) }
+        comment = extract_comment(node, source)
+
+        # Only process calls without a receiver (DSL methods)
+        yield method_name, args, comment if receiver.nil?
+      end
+
+      node.children.each do |child|
+        traverse_class_body(child, source, &block)
+      end
+    end
+
+    # Extract symbol or string value from AST node
+    def extract_symbol_or_string(node)
+      return nil unless node.is_a?(Parser::AST::Node)
+
+      case node.type
+      when :sym
+        node.children[0].to_s
+      when :str
+        node.children[0]
+      when :hash
+        extract_hash(node)
+      else
+        nil
+      end
+    end
+
+    # Extract hash from AST node
+    def extract_hash(node)
+      return nil unless node.type == :hash
+
+      result = {}
+      node.children.each do |pair|
+        next unless pair.type == :pair
+        key = extract_symbol_or_string(pair.children[0])
+        value = extract_symbol_or_string(pair.children[1]) || extract_array(pair.children[1])
+        result[key] = value if key
+      end
+      result
+    end
+
+    # Extract array from AST node
+    def extract_array(node)
+      return nil unless node.is_a?(Parser::AST::Node) && node.type == :array
+
+      node.children.map { |child| extract_symbol_or_string(child) }.compact
+    end
+
+    # Extract property options from arguments
+    def extract_property_options(args)
+      options = { required: false }
+
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          if arg['required']
+            options[:required] = true
+          end
+          if arg['optional']
+            options[:options] = { 'optional' => arg['optional'] }
+          end
+        end
+      end
+
+      options
+    end
+
+    # Parse property comment
+    def parse_property_comment(comment)
+      return {} if comment.empty?
+
+      result = {
+        description: '',
+        examples: [],
+        notes: [],
+        deprecated: nil
+      }
+
+      description_lines = []
+
+      comment.lines.each do |line|
+        line = line.chomp
+
+        if line =~ /^@example\s+(.*)/
+          result[:examples] << $1.strip
+        elsif line =~ /^@note\s+(.*)/
+          result[:notes] << $1.strip
+        elsif line =~ /^@deprecated\s*(.*)/
+          result[:deprecated] = $1.strip
+          result[:deprecated] = true if result[:deprecated].empty?
+        else
+          description_lines << line unless line.strip.empty? && description_lines.empty?
+        end
+      end
+
+      result[:description] = description_lines.join("\n").strip
+
+      result
+    end
+
+    # Convert CamelCase to snake_case
+    def underscore(string)
+      string.gsub(/::/, '_')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+
+    # Remove common leading whitespace from multi-line strings
+    def unindent(text)
+      return text if text.empty?
+
+      lines = text.lines
+      # Find minimum indentation (ignoring empty lines)
+      min_indent = lines
+        .reject { |line| line.strip.empty? }
+        .map { |line| line.match(/^(\s*)/)[1].length }
+        .min || 0
+
+      # Remove that amount of indentation from each line
+      lines.map { |line| line.strip.empty? ? line : line[min_indent..-1] }.join
+    end
+  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