glib-web 4.43.0 → 4.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db591bcb286cb6cbc0b6f8d036dc33632bfabe83e5b066f7dc0e24de9267cd37
-  data.tar.gz: 84fd46bb7f734f1d66548b885bf129dc716d8fd575fee606d4272e0e5d39140c
+  metadata.gz: a7ef76ca5c9787ab9598a9396f376fb2f336470583724c9980a1ba3c89b4a3fa
+  data.tar.gz: 74f73601b2d7f5225ec3b4f7c6f5b555c5262f3bfbf481b5126c93cc7ad5f99a
 SHA512:
-  metadata.gz: bb3a999815d9c8e5f09c3fd76e66199e961fb232b02e115471aee887ede2e86e427464a89fa34a1674f9eb8fa8bbe9bf1a40ba0659934eab355824a897cf954e
-  data.tar.gz: bb9d26d2660054524bc578f1ba39a238a1c4eea5522dc553fb5803ff47f88b3955abfcb32a128d3d816c42c522c86e4c7f9f54529ceb2cc7d34102fcf4b553d0
+  metadata.gz: 195f04ced5dd0cede880f1b097f9602e7a9aed3d4dd1d59fa24e035e38bf3aee781ca85c78eed0fd8a0e35b01f74ded30e416f5d1c0e0017d8d9557bbe366efb
+  data.tar.gz: af5383c804394f9e00f2f848f61b69e825f3385d9dd90b18b2f3d3c513a647ab3d2923d1ce7f936dc9c94b8ff4b9df1a0a82e3c65788292d7d4457ec818dc737

data/app/helpers/glib/json_ui/view_builder/fields.rb

@@ -333,6 +333,24 @@ class Glib::JsonUi::ViewBuilder
       end
     end
 
+    # Hidden field that captures URL fragment (hash) value.
+    #
+    # Extracts the fragment portion of the URL (everything after #) and
+    # populates it as the field value. Useful for secure data passing
+    # where the fragment is not sent to the server in HTTP requests.
+    #
+    # @example Capture URL fragment and auto-submit form
+    #   form.fields_urlFragment \
+    #     name: 'url_fragment',
+    #     onPopulateValue: ->(action) do
+    #       action.forms_submit
+    #     end
+    class UrlFragment < Hidden
+      # Action triggered after the URL fragment value is populated.
+      # Typically used to auto-submit the form with the captured value.
+      action :onPopulateValue
+    end
+
     # Timer/stopwatch field for time tracking.
     #
     # Can count up (stopwatch mode) or down (countdown timer mode).

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/rubocop/cops/multiline_method_call_style.rb

@@ -38,6 +38,7 @@ module RuboCop
           return if proper_parentheses_style?(node)
           return if proper_backslash_style?(node) && allow_backslash?
           return if inside_correctable_parent?(node)
+          return if assignment_method?(node)
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -52,6 +53,13 @@ module RuboCop
           node.multiline? && node.arguments.any?
         end
 
+        def assignment_method?(node)
+          # Skip setter methods (e.g., response.body=, foo.bar=)
+          # These are written as assignments (response.body = ...) and shouldn't
+          # be converted to method call style (response.body(...))
+          node.method_name.to_s.end_with?('=')
+        end
+
         def allow_backslash?
           # Allow backslash style without warnings when configured
           # Set to true to allow both styles (but auto-correct will still convert to parentheses)

data/lib/tasks/db.rake

@@ -64,6 +64,7 @@ namespace :db do
           entries.each do |a|
             attrs = Hash[a.attributes.sort]
             attrs.delete_if { |k, v| v.nil? }
+            # attrs.delete_if { |k, v| v.nil? }
 
             id = if attrs.include?('id')
               [a.id]

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: glib-web
 version: !ruby/object:Gem::Version
-  version: 4.43.0
+  version: 4.44.0
 platform: ruby
 authors:
 - ''
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2019-10-04 00:00:00.000000000 Z
@@ -136,7 +136,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: ''
 executables: []
 extensions: []
@@ -471,6 +471,7 @@ files:
 - lib/glib-web.rb
 - lib/glib/all_helpers.rb
 - lib/glib/crypt/utils.rb
+- lib/glib/doc_generator.rb
 - lib/glib/dynamic_text.rb
 - lib/glib/dynamic_text/config.rb
 - lib/glib/engine.rb
@@ -506,10 +507,10 @@ files:
 - lib/glib/version.rb
 - lib/tasks/db.rake
 - lib/tasks/docs.rake
-homepage: 
+homepage:
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -525,7 +526,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: ''
 test_files: []