tkwrapper 1.0.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e1126683452c2dd03b54c3124209059f410687463dcd744fd4df487257c1cc3
-  data.tar.gz: 907c939b56d93cab3b67b3809fe2edc174007f9dfa1337922fe6ed0f835c85b6
+  metadata.gz: 957efe49807e9800759aa22439bc99f5ea4ef0ec620bc7ea0b7d549474839a7a
+  data.tar.gz: f654e23817c14ce6e59d67e7893f55c33c9168686faf66cbf0a96f955f4e7c6e
 SHA512:
-  metadata.gz: bc7baa1364b076cc1e0e8385f77af22aeaf3349511fc01c0a49eefcb89a0aca71aa7ecd7eec4858bca64be522c203d715959240b099a8c7b5a9f4ad5c3f92a58
-  data.tar.gz: 495495ea6e4ca6a8a061f3614d4bc85b095523fd8ead30bde2e08f151f4d8bfa73330162ae2e26ad67d25cc148853bcd6b84f7500176b8eea281af3d9d779ec6
+  metadata.gz: 4891b05ca78bff3d2119b6b4d8ba0be178836d1cdd7475e07ddc3be19100d766e0ca0d9878d4afc9be330ffbf3ea008914d4f4432b0e3eff2df8cc02534b74f4
+  data.tar.gz: 3ece495be24159cefde0ca65899c3022b181a3bb0d92e40727a9cbc2ca4494d376504a58313190a94fbf4dc8751949873753ec1c2313d9db4cc28fb29174a466

data/lib/util/hash_recursive.rb

@@ -19,12 +19,9 @@ module Util
     end
   end
 
-  def self.recursive_transform_key_value!(hash, &block)
-    hash.transform_keys! do |key|
-      value = hash[key]
-      next recursive_transform_key_value!(value, &block) if value.is_a?(Hash)
-
-      block.call(key, value)
+  def self.clone_recursive(hash)
+    hash.transform_values do |value|
+      value.is_a?(Hash) ? clone_recursive(value) : value
     end
   end
 end

data/lib/util/tk/cell.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Cell
+  def initialize(widget)
+    @widget = widget
+  end
+
+  # returns the bounding box of the tk_widget
+  def bbox
+    return unless (container = container_parent)
+
+    grid_info = TkGrid.info(@widget.tk_widget)
+    start_col = grid_info['column']
+    end_col = start_col + grid_info['columnspan'] - 1
+    start_row = grid_info['row']
+    end_row = start_row + grid_info['rowspan'] - 1
+
+    TkGrid.bbox(container.tk_widget, start_col, start_row, end_col, end_row)
+  end
+
+  private
+
+  # the first parent, which contains a tk_widget, which is really different
+  # from self.tk_widget
+  def container_parent
+    container = @widget.parent
+    while container.tk_widget == @widget.tk_widget
+      return unless container.parent # not in a grid?
+
+      container = container.parent
+    end
+    container
+  end
+end

data/lib/util/tk/finder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/widgets/base/manager"
+require "#{LIB_DIR}/widgets/base/matcher"
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Finder
+  Matcher = TkWrapper::Widgets::Base::Matcher
+
+  def initialize(widgets: nil)
+    @widgets = widgets
+  end
+
+  def each_widget_match(widgets, matchers, &block)
+    widgets.each do |widget|
+      widget.ids.each do |id|
+        matchers.each do |matcher|
+          (match = matcher.match(id, widget)) && block.call(match)
+        end
+      end
+    end
+  end
+
+  def find_widget(comparators, widgets = @widgets)
+    matchers = create_value_matchers(comparators)
+
+    each_widget_match(widgets, matchers) do |match|
+      return match.widget if match
+    end
+  end
+
+  def find_all_widgets(comparators, widgets = @widgets)
+    matchers = create_value_matchers(comparators)
+    matches = TkWrapper::Widgets::Base::Matches.new
+
+    each_widget_match(widgets, matchers) do |match|
+      matches.push(match)
+    end
+
+    matches
+  end
+
+  private
+
+  def create_value_matchers(comparators)
+    comparators = [comparators] unless comparators.is_a?(Array)
+    comparators.map { |comparator| Matcher.new(comparator: comparator) }
+  end
+end

data/lib/util/tk/font.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'tk'
+require 'forwardable'
+
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Font
+  def initialize(tk_widget)
+    @tk_widget = tk_widget
+  end
+
+  %i[family size weight slant underline overstrike].each do |option|
+    define_method("#{option}=") do |value, **args|
+      load unless @config
+      args[:update] ||= false
+      @config[option] = value
+      update if args[:update]
+    end
+
+    define_method(option) do
+      load unless @config
+      @config[option]
+    end
+  end
+
+  def with_update(&block)
+    block.call(self)
+    update
+  end
+
+  def method_missing(method, *args)
+    if TkFont.respond_to?(method)
+      TkFont.send(method, @tk_widget.font, *args)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, *)
+    TkFont.respond_to?(method) || super
+  end
+
+  def load
+    @config = TkFont.actual(@tk_widget.font).to_h.transform_keys(&:to_sym)
+  end
+
+  def update
+    @tk_widget.font = TkFont.new(@config)
+  end
+end

data/lib/util/tk/tk.rb

@@ -0,0 +1,8 @@
+module TkWrapper
+  module Util
+    module Tk
+    end
+  end
+end
+
+require_relative 'font'

data/lib/widgets/auto_resize_entry.rb

@@ -4,10 +4,10 @@ class TkWrapper::Widgets::AutoResizeEntry < TkWrapper::Widgets::Entry
   # auto resizes on user input, only works if in the grid geometry manager of tk
   attr_accessor :min_width, :add_width
 
-  def initialize(config: {}, childs: [])
-    @min_width = config.delete(:min_width) || 0
-    @add_width = config.delete(:add_width) || 0
-    super(config: config, childs: childs)
+  def initialize(config: {}, childs: [], id: nil)
+    @min_width = config[:min_width] || 0
+    @add_width = config[:add_width] || 0
+    super(config: config, childs: childs, id: id)
   end
 
   def build(parent, configure: true)
@@ -18,43 +18,17 @@ class TkWrapper::Widgets::AutoResizeEntry < TkWrapper::Widgets::Entry
     resize
   end
 
-  def config_for_dummy_label
-    grid_info = TkGrid.info(tk_widget)
-    { config: { grid: {
-      row: grid_info['row'],
-      column: grid_info['column'],
-      columnspan: grid_info['columnspan'],
-      sticky: 'nw'
-    } } }
+  def value=(value)
+    tk_widget.textvariable.value = value
   end
 
-  def create_dummy_label_with_same_size(&block)
-    label = Label.new(**config_for_dummy_label)
-    label.build(@parent)
-    label.tk_widget.text = tk_widget.textvariable.value
-    label.tk_widget.lower
-    result = block.call(label)
-    label.tk_widget.destroy
-    result
-  end
-
-  def text_width_in_pixel
-    create_dummy_label_with_same_size do |label|
-      @parent.tk_widget.update
-      label.tk_widget.winfo_width
-    end
-  end
-
-  def textwidth_and_maxwidth_in_pixel
-    create_dummy_frame_with_same_size_label do |frame, label|
-      { text_width: label.tk_widget.winfo_width,
-        max_width: frame.tk_widget.winfo_width }
-    end
+  def value
+    tk_widget.textvariable.value
   end
 
   def resize
-    max_width = cell_bbox[2]
-    text_width = text_width_in_pixel
+    max_width = @cell.bbox[2]
+    text_width = @font.measure(value)
     new_width = [[@min_width, text_width + @add_width].max, max_width].min
     tk_widget.width = 0
     tk_widget.grid(ipadx: new_width / 2.0)

data/lib/widgets/base/base.rb

@@ -5,3 +5,4 @@ module TkWrapper::Widgets::Base end
 require_relative 'widget'
 require_relative 'manager'
 require_relative 'configuration'
+require_relative 'matches'

data/lib/widgets/base/comparator_item_store.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'matcher'
+
+class TkWrapper::Widgets::Base::ComparatorItemStore
+  Matcher = TkWrapper::Widgets::Base::Matcher
+
+  def initialize
+    @key_map = {}        # for fast lookup
+    @comparator_map = {} # for lookup using comparisons by Matcher class
+  end
+
+  def push(key, *items)
+    if [String, Symbol].include?(key)
+      (@key_map[key] ||= []).concat(items)
+    else
+      (@comparator_map[key] ||= []).concat(items)
+    end
+  end
+
+  # returns [{items: [...], match: Match}, {items: [...]}, ...]
+  def items_and_matches_for_widget(widget)
+    widget.ids.reduce([]) do |items, id|
+      items + items_from_key_map(id) + items_from_comparator_map(id, widget)
+    end
+  end
+
+  private
+
+  def items_from_key_map(id)
+    (items = @key_map[id]) ? [{ items: items }] : []
+  end
+
+  def items_from_comparator_map(id, widget)
+    matcher = Matcher.new(value: id)
+
+    @comparator_map.filter_map do |(comparator, items)|
+      (m = matcher.match(comparator, widget)) && { items: items, match: m }
+    end
+  end
+end

data/lib/widgets/base/configuration.rb

@@ -5,7 +5,7 @@ require "#{LIB_DIR}/util/hash_recursive.rb"
 require_relative 'base'
 
 class TkWrapper::Widgets::Base::Configuration
-  attr_accessor :config
+  attr_reader :config
 
   GRID_SPECIAL_VALUES = {
     onecell: {
@@ -20,32 +20,24 @@ class TkWrapper::Widgets::Base::Configuration
     }
   }.freeze
 
-  NON_TK_OPTIONS = %i[id tk_class tearoff weights menu].freeze
+  NON_TK_OPTIONS = %i[
+    id tk_class tearoff weights menu min_width add_width
+  ].freeze
 
   def initialize(config)
-    @config = parse!(config)
+    @config = parse_and_clone(config)
   end
 
-  def merge!(*configurations)
+  def merge(*configurations)
     configurations = configurations.map do |configuration|
-      next configuration.config if configuration.is_a?(self.class)
+      configuration = configuration.config if configuration.is_a?(self.class)
 
-      parse!(configuration)
+      parse_and_clone(configuration)
     end
 
     Util.merge_recursive!(@config, *configurations)
   end
 
-  def parse!(config)
-    Util.each_recursive(config) do |hash, key, value|
-      next if value.is_a?(Hash)
-
-      hash[key] = parse_value(key, value)
-    end
-
-    config
-  end
-
   def [](key)
     key = key.to_sym
     return self.class.new(@config[key]) if @config[key].is_a?(Hash)
@@ -55,7 +47,13 @@ class TkWrapper::Widgets::Base::Configuration
 
   def []=(key, value)
     key = key.to_sym
-    @config[key] = parse_value(key, value)
+    @config[key] = parse_and_clone(value, key)
+  end
+
+  def parse_and_clone(value, key = nil)
+    return parse_value(key, value) unless value.is_a?(Hash)
+
+    value.each_with_object({}) { |(k, v), h| h[k] = parse_and_clone(v, k) }
   end
 
   def parse_value(key, value)
@@ -114,6 +112,6 @@ class TkWrapper::Widgets::Base::Configuration
   end
 
   def merge_global_configurations(manager, widget)
-    merge!(*manager.configurations(widget))
+    merge(*manager.configurations(widget))
   end
 end

data/lib/widgets/base/manager.rb

@@ -1,32 +1,40 @@
 # frozen_string_literal: true
 
-# manages widgets and their global configurations
+require_relative 'comparator_item_store'
+
 class TkWrapper::Widgets::Base::Manager
+  ComparatorItemStore = TkWrapper::Widgets::Base::ComparatorItemStore
+
   def initialize
-    @configurations = []
-    @modifications = []
+    @configurations = ComparatorItemStore.new
+    @modifications = ComparatorItemStore.new
   end
 
-  def add_configuration(matcher, configuration)
-    @configurations.push([matcher, configuration])
+  def add_configurations(matcher = nil, configuration = nil, **configurations)
+    add_configuration(matcher, configuration) if configuration
+
+    configurations.each { |mat, cfg| add_configuration(mat, cfg) }
+  end
+
+  def add_configuration(comparator, configuration)
+    @configurations.push(comparator, configuration)
   end
 
   def add_modification(matcher, &callback)
-    @modifications.push([matcher, callback])
+    @modifications.push(matcher, callback)
   end
 
   def configurations(widget)
-    @configurations.filter_map do |(matcher, config)|
-      config if widget.check_match(matcher)
-    end
+    config_list = @configurations.items_and_matches_for_widget(widget)
+    config_list.map { |configs| configs[:items] }.flatten(1)
   end
 
   def execute_modifications(widget)
-    @modifications.each do |(matcher, callback)|
-      next unless (match = widget.check_match(matcher))
-
-      arguments = match.is_a?(MatchData) ? [widget, match] : [widget]
-      callback.call(*arguments)
+    item_list = @modifications.items_and_matches_for_widget(widget)
+    item_list.each do |items|
+      items[:items].each do |callback|
+        callback.call(widget, items[:match])
+      end
     end
   end
 end

data/lib/widgets/base/match.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# single 'match' as part of a Matches object
+class TkWrapper::Widgets::Base::Match
+  attr_reader :key, :widget, :match
+
+  def initialize(value, cls: nil, match: nil, widget: nil)
+    @key = match&.[](0) || value
+    @widget = widget
+    @match = match
+    @cls = cls
+    @value = value
+  end
+
+  def tk_widget
+    @widget&.tk_widget
+  end
+end

data/lib/widgets/base/matcher.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/widgets/base/match"
+
+class TkWrapper::Widgets::Base::Matcher
+  Match = TkWrapper::Widgets::Base::Match
+
+  def initialize(value: nil, comparator: nil)
+    @match_function = curry_match_function(value, comparator)
+  end
+
+  # args:
+  #   []                if widget and matcher were provided on initialization
+  #   [widget]          if matcher was provided on initialization
+  #   [matcher]         if widget was provided on initialization
+  #   [widget, matcher] if neither widget nor matcher were provided on initial.
+  def match(*args)
+    @match_function.call(*args)
+  end
+
+  private
+
+  def match_regex(value, comparator, widget)
+    (match = comparator.match(value)) &&
+      Match.new(value, match: match, widget: widget)
+  end
+
+  def match_string(value, comparator, widget)
+    value == comparator && Match.new(value, widget: widget)
+  end
+
+  def match_class(value, comparator, widget)
+    widget.is_a?(comparator) &&
+      Match.new(value, cls: comparator, widget: widget)
+  end
+
+  def match_f(value, comparator, widget)
+    case comparator
+    when String, Symbol then match_string(value, comparator, widget)
+    when Regexp         then match_regex(value, comparator, widget)
+    when Class          then match_class(value, comparator, widget)
+    when nil            then Match(value, { widget: widget })
+    else                     false
+    end
+  end
+
+  def curry_match_function(value, comparator)
+    if value && comparator
+      ->(widget)                        { match_f(value, comparator, widget) }
+    elsif value
+      ->(x_comparator, widget)          { match_f(value, x_comparator, widget) }
+    elsif comparator
+      ->(x_value, widget)               { match_f(x_value, comparator, widget) }
+    else
+      ->(x_value, x_comparator, widget) { match_f(x_value, x_comparator, widget) }
+    end
+  end
+end

data/lib/widgets/base/matches.rb

@@ -0,0 +1,34 @@
+require_relative 'match'
+
+# matches widgets against conditions and stores matching widgets and matches
+class TkWrapper::Widgets::Base::Matches
+  include Enumerable
+
+  def initialize
+    @matches = {}
+  end
+
+  def push(match)
+    (@matches[match.key] ||= []).push(match)
+  end
+
+  def concat(matches)
+    matches.each { |match| push(match) }
+  end
+
+  def each(&block)
+    @matches.each do |(key, matches_for_key)|
+      matches_for_key.each do |match|
+        block.call([match.widget, key, match.match, match])
+      end
+    end
+  end
+
+  def [](key)
+    case @matches[key].size
+    when 0 then nil
+    when 1 then @matches[key][0]
+    else        @matches[key]
+    end
+  end
+end

data/lib/widgets/base/widget.rb

@@ -3,14 +3,22 @@
 require 'tk'
 
 require "#{LIB_DIR}/tk_extensions"
+require "#{LIB_DIR}/util/tk/font"
+require "#{LIB_DIR}/util/tk/cell"
+require "#{LIB_DIR}/util/tk/finder"
 
 require_relative 'base'
 
 class TkWrapper::Widgets::Base::Widget
+  extend Forwardable
   include TkExtensions
+  include Enumerable
+
+  def_delegator :@finder, :find_widget, :find
+  def_delegator :@finder, :find_all_widgets, :find_all
 
   attr_accessor :config
-  attr_reader :parent, :childs
+  attr_reader :parent, :ids, :cell, :childs
 
   def tk_class() end
 
@@ -18,8 +26,8 @@ class TkWrapper::Widgets::Base::Widget
     @manager ||= TkWrapper::Widgets::Base::Manager.new
   end
 
-  def self.config(matcher, configuration)
-    manager.add_configuration(matcher, configuration)
+  def self.config(matcher = nil, configuration = nil, **configurations)
+    manager.add_configurations(matcher, configuration, **configurations)
   end
 
   def self.modify(matcher, &callback)
@@ -30,10 +38,30 @@ class TkWrapper::Widgets::Base::Widget
     TkWrapper::Widgets::Base::Widget.manager
   end
 
-  def initialize(config: {}, childs: [])
+  def each(&block)
+    nodes_to_walk = [self]
+    until nodes_to_walk.empty?
+      node = nodes_to_walk.pop
+      block.call(node)
+      nodes_to_walk = node.childs + nodes_to_walk
+    end
+  end
+
+  def initialize(config: {}, childs: [], id: nil)
+    @cell = TkWrapper::Util::Tk::Cell.new(self)
+    @finder = TkWrapper::Util::Tk::Finder.new(widgets: self)
     @config = TkWrapper::Widgets::Base::Configuration.new(config)
     @childs = childs.is_a?(Array) ? childs : [childs]
-    @id = config[:id]
+    @ids = []
+    add_ids(id)
+    add_ids(config[:id])
+  end
+
+  def add_ids(ids)
+    return unless ids
+
+    ids = [ids] unless ids.is_a?(Array)
+    @ids.concat(ids)
   end
 
   def create_tk_widget(parent)
@@ -55,76 +83,38 @@ class TkWrapper::Widgets::Base::Widget
   def build(parent, configure: true)
     @parent = parent
     tk_widget # creates the widget if possible and not yet created
+    @font = TkWrapper::Util::Tk::Font.new(tk_widget)
     self.configure if configure
     manager.execute_modifications(self)
     @childs.each { |child| child.build(self) }
   end
 
+  def push(child)
+    @childs.push(child)
+    child.build(self)
+  end
+
   def configure
     @config.merge_global_configurations(manager, self)
     @config.configure_tk_widget(tk_widget)
     @config.configure_tearoff
   end
 
-  def check_match(matcher)
-    case matcher
-    when Regexp
-      matcher.match(@id)
-    when String, Symbol
-      matcher == @id
-    when nil
-      true
-    else
-      is_a?(matcher)
-    end
-  end
-
-  def find(matcher)
-    nodes_to_scan = [self]
-    until nodes_to_scan.empty?
-      node = nodes_to_scan.pop
-      return node if node.check_match(matcher)
+  def modify(matchers, &callback)
+    items = find_all(matchers)
 
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
+    callback.call(items)
   end
 
-  def find_all(matcher)
-    found_nodes = []
-    nodes_to_scan = [self]
-
-    until nodes_to_scan.empty?
-      node = nodes_to_scan.pop
-      found_nodes.push(node) if node.check_match(matcher)
-
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
+  def modify_each(matchers, &callback)
+    items = find_all(matchers)
 
-    found_nodes
-  end
-end
+    return unless items
 
-# the first parent, which contains a tk_widget, which is really different
-# from self.tk_widget
-def get_container_parent
-  container = @parent
-  while container.tk_widget == tk_widget
-    return unless container.parent # not in a grid?
+    with_match = items[0].is_a?(Array)
 
-    container = container.parent
+    items.each do |item|
+      with_match ? callback.call(item[0], item[1]) : callback.call(item)
+    end
   end
-  container
-end
-
-# returns the bounding box of the tk_widget
-def cell_bbox
-  return unless (container = get_container_parent)
-
-  grid_info = TkGrid.info(tk_widget)
-  start_col = grid_info['column']
-  end_col = start_col + grid_info['columnspan'] - 1
-  start_row = grid_info['row']
-  end_row = start_row + grid_info['rowspan'] - 1
-
-  TkGrid.bbox(container.tk_widget, start_col, start_row, end_col, end_row)
 end

data/lib/widgets/grid.rb

@@ -4,12 +4,14 @@
 class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
   attr_reader :parent, :matrix
 
+  Widget = TkWrapper::Widgets::Base::Widget
+
   def tk_class
     TkWidgets::Frame
   end
 
-  def initialize(config: {}, childs: [])
-    super(config: config, childs: childs)
+  def initialize(config: {}, childs: [], id: nil)
+    super(config: config, childs: childs, id: id)
     @childs.map! { |row| row.is_a?(Array) ? row : [row] }
     configure_cells_for_grid
     @childs.flatten! && @childs.select! { |cell| cell.is_a?(Widget) }
@@ -20,7 +22,7 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
       row.each_with_index do |cell, col_i|
         next unless cell.is_a?(Widget)
 
-        (cell.config[:grid] ||= {}).merge!({ row: row_i, column: col_i })
+        cell.config.merge({ grid: { row: row_i, column: col_i } })
 
         configure_colspan(cell, row_i, col_i)
         configure_rowspan(cell, row_i, col_i)
@@ -33,7 +35,7 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
     colspan = cols_after_cell.reduce(1) do |span, content|
       content == :right ? span + 1 : (break span)
     end
-    (cell.config[:grid] ||= {}).merge!({ columnspan: colspan })
+    cell.config.merge({ grid: { columnspan: colspan } })
   end
 
   def configure_rowspan(cell, row_i, col_i)
@@ -41,6 +43,6 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
     rowspan = rows_after_cell.reduce(1) do |span, row|
       row[col_i] == :bottom ? span + 1 : (break span)
     end
-    (cell.config[:grid] ||= {}).merge!({ rowspan: rowspan })
+    cell.config.merge({ grid: { rowspan: rowspan } })
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tkwrapper
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Benjamin Schnitzler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-12 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies: []
 description:
 email: reception@e.mail.de
@@ -19,13 +19,20 @@ files:
 - lib/tk_extensions.rb
 - lib/tkwrapper.rb
 - lib/util/hash_recursive.rb
+- lib/util/tk/cell.rb
+- lib/util/tk/finder.rb
+- lib/util/tk/font.rb
+- lib/util/tk/tk.rb
 - lib/util/virtual_methods.rb
 - lib/widgets/auto_resize_entry.rb
 - lib/widgets/base/base.rb
+- lib/widgets/base/comparator_item_store.rb
 - lib/widgets/base/configuration.rb
 - lib/widgets/base/manager.rb
+- lib/widgets/base/match.rb
+- lib/widgets/base/matcher.rb
+- lib/widgets/base/matches.rb
 - lib/widgets/base/widget.rb
-- lib/widgets/base/widgets.rb
 - lib/widgets/entry.rb
 - lib/widgets/frame.rb
 - lib/widgets/grid.rb

data/lib/widgets/base/widgets.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class TkWrapper::Widgets::Base::Widgets
-  def initialize
-    @configurations = []
-    @modifications = []
-  end
-
-  def add_configuration(matcher, configuration)
-    @configurations.push(matcher, configuration)
-  end
-
-  def add_modification(matcher, &callback)
-    @modifications.push(matcher, callback)
-  end
-
-  def configurations(widget)
-    @configurations.filter_map do |(matcher, config)|
-      config if widget.check_match(matcher)
-    end
-  end
-
-  def execute_modifications(widget)
-    @modifications.each do |(matcher, callback)|
-      next unless (match = widget.check_match(matcher))
-
-      arguments = match.is_a?(MatchData) ? [widget, match] : [widget]
-      callback.call(*arguments)
-    end
-  end
-end