glimmer-dsl-libui 0.5.18 → 0.5.21

data/lib/glimmer/libui/control_proxy/menu_item_proxy/radio_menu_item_proxy.rb

@@ -41,7 +41,7 @@ module Glimmer
               super
               if Glimmer::LibUI.integer_to_boolean(value, allow_nil: false) != Glimmer::LibUI.integer_to_boolean(@last_checked, allow_nil: false)
                 if Glimmer::LibUI.integer_to_boolean(value)
-                  (@parent_proxy.children - [self]).select {|c| c.is_a?(MenuItemProxy)}.each do |menu_item|
+                  (@parent_proxy.children - [self]).select {|c| c.is_a?(RadioMenuItemProxy)}.each do |menu_item|
                     menu_item.checked = false
                   end
                 end

data/lib/glimmer/libui/custom_control/code_area.rb

@@ -1,65 +1,94 @@
-class CodeArea
-  class << self
-    def languages
-      require 'rouge'
-      Rouge::Lexer.all.map {|lexer| lexer.tag}.sort
-    end
-    
-    def lexers
-      require 'rouge'
-      Rouge::Lexer.all.sort_by(&:title)
-    end
-  end
-  
-  include Glimmer::LibUI::CustomControl
-  
-  REGEX_COLOR_HEX6 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/
-  
-  option :language, default: 'ruby'
-  option :theme, default: 'glimmer'
-  option :code
-  
-  body {
-    area {
-      rectangle(0, 0, 8000, 8000) {
-        fill :white
-      }
-      text {
-        default_font family: OS.mac? ? 'Consolas' : 'Courier', size: 13, weight: :medium, italic: :normal, stretch: :normal
+# Copyright (c) 2021-2022 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'glimmer/libui/custom_control'
+
+module Glimmer
+  module LibUI
+    module CustomControl
+      class CodeArea
+        class << self
+          def languages
+            require 'rouge'
+            Rouge::Lexer.all.map {|lexer| lexer.tag}.sort
+          end
+          
+          def lexers
+            require 'rouge'
+            Rouge::Lexer.all.sort_by(&:title)
+          end
+        end
+        
+        include Glimmer::LibUI::CustomControl
+        
+        REGEX_COLOR_HEX6 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/
         
-        syntax_highlighting(code).each do |token|
-          style_data = Rouge::Theme.find(theme).new.style_for(token[:token_type])
-         
-          string(token[:token_text]) {
-            color style_data[:fg] || :black
-            background style_data[:bg] || :white
+        option :language, default: 'ruby'
+        option :theme, default: 'glimmer'
+        option :code
+        
+        body {
+          area {
+            rectangle(0, 0, 8000, 8000) {
+              fill :white
+            }
+            text {
+              default_font family: OS.mac? ? 'Consolas' : 'Courier', size: 13, weight: :medium, italic: :normal, stretch: :normal
+              
+              syntax_highlighting(code).each do |token|
+                style_data = Rouge::Theme.find(theme).new.style_for(token[:token_type])
+               
+                string(token[:token_text]) {
+                  color style_data[:fg] || :black
+                  background style_data[:bg] || :white
+                }
+              end
+            }
           }
+        }
+        
+        def lexer
+          require 'rouge'
+          require 'glimmer-dsl-libui/ext/rouge/theme/glimmer'
+          # TODO Try to use Rouge::Lexer.find_fancy('guess', code) in the future to guess the language or otherwise detect it from file extension
+          @lexer ||= Rouge::Lexer.find_fancy(language)
+          @lexer ||= Rouge::Lexer.find_fancy('ruby') # default to Ruby if no lexer is found
+        end
+        
+        def syntax_highlighting(text)
+          return [] if text.to_s.strip.empty?
+          @syntax_highlighting ||= {}
+          unless @syntax_highlighting.keys.include?(text)
+            lex = lexer.lex(text).to_a
+            text_size = 0
+            @syntax_highlighting[text] = lex.map do |pair|
+              {token_type: pair.first, token_text: pair.last}
+            end.each do |hash|
+              hash[:token_index] = text_size
+              text_size += hash[:token_text].size
+            end
+          end
+          @syntax_highlighting[text]
         end
-      }
-    }
-  }
-  
-  def lexer
-    require 'rouge'
-    require 'glimmer-dsl-libui/ext/rouge/theme/glimmer'
-    # TODO Try to use Rouge::Lexer.find_fancy('guess', code) in the future to guess the language or otherwise detect it from file extension
-    @lexer ||= Rouge::Lexer.find_fancy(language)
-    @lexer ||= Rouge::Lexer.find_fancy('ruby') # default to Ruby if no lexer is found
-  end
-  
-  def syntax_highlighting(text)
-    return [] if text.to_s.strip.empty?
-    @syntax_highlighting ||= {}
-    unless @syntax_highlighting.keys.include?(text)
-      lex = lexer.lex(text).to_a
-      text_size = 0
-      @syntax_highlighting[text] = lex.map do |pair|
-        {token_type: pair.first, token_text: pair.last}
-      end.each do |hash|
-        hash[:token_index] = text_size
-        text_size += hash[:token_text].size
       end
     end
-    @syntax_highlighting[text]
   end
 end

data/lib/glimmer/libui/custom_control/refined_table.rb

@@ -1,173 +1,270 @@
-class RefinedTable
-  include Glimmer::LibUI::CustomControl
-  
-  option :model_array, default: []
-  option :table_columns, default: []
-  option :table_editable, default: false
-  option :per_page, default: 10
-  option :page, default: 1
-  option :visible_page_count, default: false
-  
-  attr_accessor :filtered_model_array, :filter_query, :filter_query_page_stack, :paginated_model_array
-  
-  before_body do
-    @filter_query = ''
-    @filter_query_page_stack = {}
-    @filtered_model_array = model_array.dup
-    @filtered_model_array_stack = {@filter_query => @filtered_model_array}
-    self.page = correct_page(page)
-    paginate_model_array
-  end
-  
-  body {
-    vertical_box {
-      table_filter
+# Copyright (c) 2021-2022 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-      table_paginator if page_count > 1
-      
-      @table = table {
-        table_columns.each do |column_name, column_details|
-          editable_value = on_clicked_value = nil
-          if column_details.is_a?(Symbol) || column_details.is_a?(String)
-            column_type = column_details
-          elsif column_details.is_a?(Hash)
-            column_type = column_details.keys.first
-            editable_value = column_details.values.first[:editable] || column_details.values.first['editable']
-            on_clicked_value = column_details.values.first[:on_clicked] || column_details.values.first['on_clicked']
+require 'csv'
+require 'facets/string/underscore'
+
+require 'glimmer/libui/custom_control'
+
+module Glimmer
+  module LibUI
+    module CustomControl
+      class RefinedTable
+        include Glimmer::LibUI::CustomControl
+        
+        FILTER_DEFAULT = lambda do |row_hash, query|
+          text = row_hash.values.map(&:downcase).join(' ')
+          if query != @last_query
+            @last_query = query
+            @query_words = []
+            query_text = query.strip
+            until query_text.empty?
+              exact_term_double_quoted_regexp = /"[^"]+"/
+              specific_column_double_quoted_column_name_regexp = /"[^":]+":[^": ]+/
+              specific_column_double_quoted_column_value_regexp = /[^": ]+:"[^":]+"/
+              specific_column_double_quoted_column_name_and_value_regexp = /"[^":]+":"[^":]+"/
+              single_word_regexp = /\S+/
+              query_match = (query_text + ' ').match(/^(#{exact_term_double_quoted_regexp}|#{specific_column_double_quoted_column_name_regexp}|#{specific_column_double_quoted_column_value_regexp}|#{specific_column_double_quoted_column_name_and_value_regexp}|#{single_word_regexp})\s+/)
+              if query_match && query_match[1]
+                query_word = query_match[1]
+                query_text = query_text.sub(query_word, '').strip
+                query_word = query_word.sub(/^"/, '').sub(/"$/, '') if query_word.start_with?('"') && query_word.end_with?('"') && !query_word.include?(':')
+                @query_words << query_word
+              end
+            end
           end
-          
-          send("#{column_type}_column", column_name) {
-            editable editable_value unless editable_value.nil?
-            on_clicked(&on_clicked_value) unless on_clicked_value.nil?
-          }
-        end
-  
-        editable table_editable
-        cell_rows <=> [self, :paginated_model_array]
-      }
-    }
-  }
-  
-  def table_filter
-    search_entry {
-      stretchy false
-      text <=> [self, :filter_query,
-        before_write: ->(new_filter_query) {
-          if new_filter_query != filter_query
-            if !@filtered_model_array_stack.key?(new_filter_query)
-              @filtered_model_array_stack[new_filter_query] = model_array.dup.filter do |model|
-                @table.expand([model])[0].any? do |attribute_value|
-                  attribute_value.to_s.downcase.include?(new_filter_query.downcase)
+          @query_words.all? do |word|
+            if word.include?(':')
+              column_name, column_value = word.split(':')
+              column_value = column_value.to_s
+              column_name = column_name.sub(/^"/, '').sub(/"$/, '') if column_name.start_with?('"') && column_name.end_with?('"')
+              column_value = column_value.sub(/^"/, '').sub(/"$/, '') if column_value.start_with?('"') && column_value.end_with?('"')
+              column_human_name = row_hash.keys.find do |table_column_name|
+                table_column_name.underscore.start_with?(column_name.underscore)
+              end
+              if column_human_name
+                column_value_words = [column_value.downcase.split].flatten
+                column_value_words.all? do |column_value_word|
+                  row_hash[column_human_name].downcase.include?(column_value_word)
                 end
+              else
+                text.downcase.include?(word.downcase)
               end
+            else
+              text.downcase.include?(word.downcase)
             end
-            @filtered_model_array = @filtered_model_array_stack[new_filter_query]
-            if new_filter_query.size > filter_query.size
-              @filter_query_page_stack[filter_query] = page
-            end
-            self.page = @filter_query_page_stack[new_filter_query] || correct_page(page)
-            paginate_model_array
           end
-        }
-      ]
-    }
-  end
-  
-  def table_paginator
-    horizontal_box {
-      stretchy false
-      
-      button('<<') {
-        enabled <= [self, :page, on_read: ->(val) {val > 1}]
+        end
         
-        on_clicked do
-          unless self.page == 0
-            self.page = 1
-            paginate_model_array
-          end
+        option :model_array, default: []
+        option :table_columns, default: []
+        option :table_editable, default: false
+        option :per_page, default: 10
+        option :page, default: 1
+        option :visible_page_count, default: false
+        option :filter_query, default: ''
+        option :filter, default: FILTER_DEFAULT
+        
+        attr_accessor :filtered_model_array # filtered model array (intermediary, non-paginated)
+        attr_accessor :refined_model_array # paginated filtered model array
+        attr_reader :table_proxy
+        
+        before_body do
+          init_model_array
         end
-      }
-      
-      button('<') {
-        enabled <= [self, :page, on_read: ->(val) {val > 1}]
         
-        on_clicked do
-          unless self.page == 0
-            self.page = [page - 1, 1].max
-            paginate_model_array
+        after_body do
+          filter_model_array
+          
+          observe(self, :model_array) do
+            init_model_array
+          end
+          
+          observe(self, :filter_query) do
+            filter_model_array
           end
         end
-      }
-      
-      entry {
-        text <=> [self, :page,
-                  on_read: :to_s,
-                  on_write: ->(val) { correct_page(val.to_i) },
-                  after_write: ->(val) { paginate_model_array },
-                 ]
-      }
+        
+        body {
+          vertical_box {
+            table_filter
       
-      if visible_page_count
-        label {
-          text <= [self, :paginated_model_array, on_read: ->(val) {"of #{page_count} pages"}]
+            table_paginator if page_count > 1
+            
+            @table_proxy = table {
+              table_columns.each do |column_name, column_details|
+                editable_value = on_clicked_value = nil
+                if column_details.is_a?(Symbol) || column_details.is_a?(String)
+                  column_type = column_details
+                elsif column_details.is_a?(Hash)
+                  column_type = column_details.keys.first
+                  editable_value = column_details.values.first[:editable] || column_details.values.first['editable']
+                  on_clicked_value = column_details.values.first[:on_clicked] || column_details.values.first['on_clicked']
+                end
+                
+                send("#{column_type}_column", column_name) {
+                  editable editable_value unless editable_value.nil?
+                  on_clicked(&on_clicked_value) unless on_clicked_value.nil?
+                }
+              end
+        
+              editable table_editable
+              cell_rows <=> [self, :refined_model_array]
+            }
+          }
         }
-      end
-      
-      button('>') {
-        enabled <= [self, :page, on_read: ->(val) {val < page_count}]
         
-        on_clicked do
-          unless self.page == 0
-            self.page = [page + 1, page_count].min
-            paginate_model_array
+        def table_filter
+          search_entry {
+            stretchy false
+            text <=> [self, :filter_query]
+          }
+        end
+        
+        def table_paginator
+          horizontal_box {
+            stretchy false
+            
+            button('<<') {
+              enabled <= [self, :page, on_read: ->(val) {val > 1}]
+              
+              on_clicked do
+                unless self.page == 0
+                  self.page = 1
+                  paginate_model_array
+                end
+              end
+            }
+            
+            button('<') {
+              enabled <= [self, :page, on_read: ->(val) {val > 1}]
+              
+              on_clicked do
+                unless self.page == 0
+                  self.page = [page - 1, 1].max
+                  paginate_model_array
+                end
+              end
+            }
+            
+            entry {
+              text <=> [self, :page,
+                        on_read: :to_s,
+                        on_write: ->(val) { correct_page(val.to_i) },
+                        after_write: ->(val) { paginate_model_array },
+                       ]
+            }
+            
+            if visible_page_count
+              label {
+                text <= [self, :refined_model_array, on_read: ->(val) {"of #{page_count} pages"}]
+              }
+            end
+            
+            button('>') {
+              enabled <= [self, :page, on_read: ->(val) {val < page_count}]
+              
+              on_clicked do
+                unless self.page == 0
+                  self.page = [page + 1, page_count].min
+                  paginate_model_array
+                end
+              end
+            }
+            
+            button('>>') {
+              enabled <= [self, :page, on_read: ->(val) {val < page_count}]
+              
+              on_clicked do
+                unless self.page == 0
+                  self.page = page_count
+                  paginate_model_array
+                end
+              end
+            }
+          }
+        end
+        
+        def init_model_array
+          @last_filter_query = nil
+          @filter_query_page_stack = {}
+          @filtered_model_array = model_array.dup
+          @filtered_model_array_stack = {'' => @filtered_model_array}
+          self.page = correct_page(page)
+          filter_model_array if @table_proxy
+        end
+        
+        def filter_model_array
+          return unless (@last_filter_query.nil? || filter_query != @last_filter_query)
+          if !@filtered_model_array_stack.key?(filter_query)
+            table_column_names = @table_proxy.columns.map(&:name)
+            @filtered_model_array_stack[filter_query] = model_array.dup.filter do |model|
+              row_values = @table_proxy.expand([model])[0].map(&:to_s)
+              row_hash = Hash[table_column_names.zip(row_values)]
+              filter.call(row_hash, filter_query)
+            end
+          end
+          @filtered_model_array = @filtered_model_array_stack[filter_query]
+          if @last_filter_query.nil? || filter_query.size > @last_filter_query.size
+            @filter_query_page_stack[filter_query] = correct_page(page)
           end
+          self.page = @filter_query_page_stack[filter_query] || correct_page(page)
+          paginate_model_array
+          @last_filter_query = filter_query
+        end
+        
+        def paginate_model_array
+          self.refined_model_array = filtered_model_array[index, limit]
+        end
+        
+        def index
+          [per_page * (page - 1), 0].max
+        end
+        
+        def limit
+          [(filtered_model_array.count - index), per_page].min
+        end
+        
+        def page_count
+          (filtered_model_array.count.to_f / per_page.to_f).ceil
+        end
+        
+        def correct_page(page)
+          [[page, 1].max, page_count].min
+        end
+        
+        # Ensure proxying properties to @table_proxy if body_root (vertical_box) doesn't support them
+        
+        def respond_to?(method_name, *args, &block)
+          super || @table_proxy&.respond_to?(method_name, *args, &block)
         end
-      }
-      
-      button('>>') {
-        enabled <= [self, :page, on_read: ->(val) {val < page_count}]
         
-        on_clicked do
-          unless self.page == 0
-            self.page = page_count
-            paginate_model_array
+        def method_missing(method_name, *args, &block)
+          if @table_proxy&.respond_to?(method_name, *args, &block)
+            @table_proxy&.send(method_name, *args, &block)
+          else
+            super
           end
         end
-      }
-    }
-  end
-  
-  def paginate_model_array
-    self.paginated_model_array = filtered_model_array[index, limit]
-  end
-  
-  def index
-    [per_page * (page - 1), 0].max
-  end
-  
-  def limit
-    [(filtered_model_array.count - index), per_page].min
-  end
-  
-  def page_count
-    (filtered_model_array.count.to_f / per_page.to_f).ceil
-  end
-  
-  def correct_page(page)
-    [[page, 1].max, page_count].min
-  end
-  
-  # Ensure proxying properties to @table if body_root (vertical_box) doesn't support them
-  
-  def respond_to?(method_name, *args, &block)
-    super || @table&.respond_to?(method_name, *args, &block)
-  end
-  
-  def method_missing(method_name, *args, &block)
-    if @table&.respond_to?(method_name, *args, &block)
-      @table&.send(method_name, *args, &block)
-    else
-      super
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-libui
 version: !ruby/object:Gem::Version
-  version: 0.5.18
+  version: 0.5.21
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-04 00:00:00.000000000 Z
+date: 2022-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glimmer
@@ -275,6 +275,8 @@ files:
 - VERSION
 - bin/girb
 - bin/girb_runner.rb
+- docs/examples/GLIMMER-DSL-LIBUI-ADVANCED-EXAMPLES.md
+- docs/examples/GLIMMER-DSL-LIBUI-BASIC-EXAMPLES.md
 - examples/area_based_custom_controls.rb
 - examples/area_gallery.rb
 - examples/area_gallery2.rb