glib-web 4.41.0 → 4.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3c5782b7132ed122204cc3314927ada0e3804ea47ee795c34d6311a959580b6
-  data.tar.gz: ca30770101141a9388bb11ef182a6c554ada7cc1ba88b068f7e3e0ef130425f6
+  metadata.gz: 0fd0f52f48d55fef27f49ae004e3f2c59e730963cecaddd6af5cb5fe962b6323
+  data.tar.gz: aebd337997b0b656fac64f72a0c53322bd58815bdf2052aef4b15243d1e06e96
 SHA512:
-  metadata.gz: eef32c78bfbd00ae4082fbd0069b7a92045d253411dc70cd2a82a6218f6b59984362652e63c9ad64bbad0d26bef567a23f7e9d3edfca125d97eb8cd2e6379529
-  data.tar.gz: 84039000106e73c327d049234261c182d099e5f66412138ea7e5cd3abe4921898c5ba4c72640acc2cbf7036955d0a6c6b9994c66b7ca77b3512693ca9f3418b1
+  metadata.gz: 7dfa32067ee2a2be6dd8095bf8fce2b5da301cff44fdc93f1e80eba7fe9562ae12bae8f7edab9902c16e6ace86af262d028052fb30b644f2bb54957d61302571
+  data.tar.gz: e5d068af18a7f8908ae82aac1d5f74225aacdbd58eac2db8b0b78b07f9a5cb4e037d49f32aa11fb2278bc5341ce8c374a89fac4650f5b97f4227eb618606c136

data/app/helpers/glib/json_ui/list_builders.rb

@@ -59,7 +59,7 @@ module Glib
           # menu :leftOuterButtons
           int :imageSize
 
-          panels_builder :content, :header, :footer, :right
+          panels_builder :content, :header, :footer, :right, :left
         end
 
         class Editable < Standard

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

@@ -578,6 +578,7 @@ class Glib::JsonUi::ViewBuilder
 
       # To override the default behaviour
       bool :useChips
+      int :maxChipLines
 
       def options(value)
         @_options = value

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

@@ -274,10 +274,17 @@ module Glib
           @size = value
         end
 
+        def family(value)
+          @family = value.to_s
+        end
+
         # Override
         def created
           if @name
-            json.material do
+            icon_type = @family == 'fontawesome' ? 'fa' :
+                        @family == 'custom' ? 'custom' : 'material'
+
+            json.set!(icon_type) do
               json.name @name
               json.size @size if @size
             end

data/app/views/json_ui/garage/lists/old_edit_mode.json.jbuilder

@@ -0,0 +1,84 @@
+page = json_ui_page json
+
+json.title 'Lists'
+
+render "#{@path_prefix}/nav_menu", json: json, page: page
+
+tab_index = params[:tab].to_i
+
+page.header(
+  childViews: ->(header) do
+    # Allow navigating to another "edit mode" page to test reuse issues.
+    header.tabBar(
+      buttons: ->(menu) do
+        ['FIRST', 'SECOND'].each_with_index do |text, index|
+          menu.button(
+            text: text,
+            disabled: tab_index == index,
+            onClick: ->(action) do
+              action.windows_reload url: json_ui_garage_url(path: 'lists/edit_mode', tab: index)
+            end
+          )
+        end
+      end
+    )
+  end
+)
+
+page.form(
+  width: 'matchParent',
+  url: json_ui_garage_url(path: 'forms/generic_post'),
+  method: 'post',
+  padding: glib_json_padding_body,
+  childViews: ->(form) do
+    form.panels_list(
+      fieldPrefix: 'user[items]',
+      fieldTitleName: 'name',
+      width: 'matchParent',
+      sections: [
+    ->(section) do
+      section.header(
+        padding: glib_json_padding_list,
+        childViews: ->(header) do
+          header.panels_horizontal(
+            childViews: ->(horizontal) do
+              horizontal.fields_check name: 'user[check_all]', label: 'All', checkValue: true
+              horizontal.spacer width: 20
+              # header.fields_text width: 'matchParent', styleClass: 'outlined', name: 'user[new_name]', label: 'Item name'
+              statuses = [:pending, :active]
+              horizontal.fields_select(
+                styleClass: 'outlined',
+                name: 'user[status]',
+                width: 'matchParent',
+                label: 'Status',
+                options: statuses.map { |status| { value: status, text: status.to_s.humanize } }
+              )
+              horizontal.spacer width: 20
+              horizontal.fields_submit text: 'Update'
+            end
+          )
+        end
+      )
+      section.rows(
+        builder: ->(row) do
+          batch_count = 20
+          batch_count.times do |index|
+            id = (batch_count * tab_index) + index
+            # row.editable title: "Item #{id}", recordId: "PK_#{id}"
+            row.thumbnail title: "Item #{id}", recordId: "PK_#{id}"
+          end
+        end
+      )
+    end
+    ],
+      fieldCheckValueIf: {
+    "==": [
+    {
+    "var": 'user[check_all]'
+    },
+    true
+    ]
+    }
+    )
+  end
+)

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

@@ -3,52 +3,80 @@ json.title 'Views'
 page = json_ui_page json
 render "#{@path_prefix}/nav_menu", json: json, page: page
 
-page.form padding: glib_json_padding_body, childViews: ->(scroll) do
-  scroll.h2 text: 'Icon'
-  # scroll.icon spec: { name: 'home' }
-  scroll.icon name: 'home'
-
-  scroll.spacer height: 20
-  scroll.h2 text: 'Icon with color'
-  scroll.fields_select \
-    name: 'input_icon',
-    value: 'verified',
-    options: ['pending', 'verified', 'cancel'].map { |icon_name| { text: icon_name, value: icon_name } }
-  scroll.button text: 'update', onClick: ->(action) do
-    action.logics_set \
-      targetId: 'icon1',
-      conditionalData: {
-        'material.name': { "var": 'input_icon' },
-        'tooltip.text': { "var": 'input_icon' },
+page.form(
+  padding: glib_json_padding_body,
+  childViews: ->(scroll) do
+    scroll.h2 text: 'Icon'
+    # scroll.icon spec: { name: 'home' }
+    scroll.icon name: 'home'
+    scroll.spacer height: 20
+    scroll.h2 text: 'Icon with color'
+    scroll.fields_select(
+      name: 'input_icon',
+      value: 'verified',
+      options: ['pending', 'verified', 'cancel'].map { |icon_name| { text: icon_name, value: icon_name } }
+    )
+    scroll.button(
+      text: 'update',
+      onClick: ->(action) do
+        action.logics_set(
+          targetId: 'icon1',
+          conditionalData: {
+          'material.name': { "var": 'input_icon' },
+          'tooltip.text': { "var": 'input_icon' },
+          'tooltip.placement': 'bottom'
+          }
+        )
+      end
+    )
+    scroll.icon id: 'icon1', name: 'home', color: '#9370DB'
+    scroll.icon(
+      name: 'home',
+      color: '#9370DB80',
+      onClick: ->(action) do
+        action.snackbars_alert message: 'Icon clicked!'
+      end
+    )
+    scroll.spacer height: 20
+    scroll.h2 text: 'Icon with badge'
+    scroll.icon name: 'home', badge: { text: '22', backgroundColor: '#00ff00' }
+    scroll.spacer height: 20
+    scroll.h2 text: 'Icon with styleClasses'
+    scroll.icon id: 'icon2', name: 'home', styleClasses: ['small']
+    scroll.button(
+      text: 'Hide icon',
+      onClick: ->(action) do
+        action.logics_set(
+          targetId: 'icon2',
+          data: {
+        displayed: false
+        }
+        )
+      end
+    )
+    scroll.spacer height: 20
+    scroll.h2 text: 'Icon with onLoad'
+    scroll.icon(
+      id: 'icon3',
+      name: 'home',
+      onLoad: ->(action) do
+        action.logics_set(
+          targetId: 'icon3',
+          data: {
+        'material.name': 'info',
+        'tooltip.text': 'TEST123',
         'tooltip.placement': 'bottom'
-      }
-  end
-  scroll.icon id: 'icon1', name: 'home', color: '#9370DB'
-  scroll.icon name: 'home', color: '#9370DB80', onClick: ->(action) do
-    action.snackbars_alert message: 'Icon clicked!'
-  end
-
-  scroll.spacer height: 20
-  scroll.h2 text: 'Icon with badge'
-  scroll.icon name: 'home', badge: { text: '22', backgroundColor: '#00ff00' }
-
-  scroll.spacer height: 20
-  scroll.h2 text: 'Icon with styleClasses'
-  scroll.icon id: 'icon2', name: 'home', styleClasses: ['small']
-
-  scroll.button text: 'Hide icon', onClick: ->(action) do
-    action.logics_set targetId: 'icon2', data: {
-      displayed: false
-    }
-  end
+        }
+        )
+      end
+    )
 
-  scroll.spacer height: 20
-  scroll.h2 text: 'Icon with onLoad'
-  scroll.icon id: 'icon3', name: 'home', onLoad: ->(action) do
-    action.logics_set targetId: 'icon3', data: {
-      'material.name': 'info',
-      'tooltip.text': 'TEST123',
-      'tooltip.placement': 'bottom'
-    }
+    # scroll.spacer height: 20
+    # scroll.h2 text: 'Icon using Font Awesome'
+    # scroll.icon(
+    #   id: 'icon4',
+    #   name: 'fa-solid fa-home',
+    #   family: 'fontawesome'
+    # )
   end
-end
+)

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/tasks/db.rake

@@ -63,7 +63,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.41.0
+  version: 4.42.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: []
@@ -317,6 +317,7 @@ files:
 - app/views/json_ui/garage/lists/edit_mode.json.jbuilder
 - app/views/json_ui/garage/lists/fab.json.jbuilder
 - app/views/json_ui/garage/lists/index.json.jbuilder
+- app/views/json_ui/garage/lists/old_edit_mode.json.jbuilder
 - app/views/json_ui/garage/lists/reordering.json.jbuilder
 - app/views/json_ui/garage/lists/templating.json.jbuilder
 - app/views/json_ui/garage/multistep_form/step1.json.jbuilder
@@ -427,6 +428,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
@@ -462,10 +464,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
@@ -481,7 +483,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: []