hiiro 0.1.91 → 0.1.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c42d526a575f0e00f889398f3234702eef7e085318f5116640137cb2820297e
-  data.tar.gz: 70ad61a7eb3fafd34c61edd0717a64657dae811fe06277c089039f93003abbb9
+  metadata.gz: a225754bf06275debc8ce5bad696541103d1a062a2d4a5565f2b3ce34d628983
+  data.tar.gz: 4c7d7f4c88694b90a05254908558eabe0cd54f944b7fe0ba8c76ff0baba64a15
 SHA512:
-  metadata.gz: 6aaa00221469f74ae885b654356297b56475940411222197145822b74997f50ff8d51928a733fff175a5c249fe499b7233f2e1577858b366b2d48fe8622559db
-  data.tar.gz: ffbc0cf565fb236f97cd93a742cdbf07efa10feed5766cbbb7e7e6b1fb29959bc9b87d4094ba98503ee889a87f7120672dcccdd760e38fada07fc06128aebc19
+  metadata.gz: 381d57d3d69d3da9a47dedf7ed379b0b81706902523e2bb8158593e5240dddc69f00f460b41f4a8ec3d3294a5d91c117ecd689df845e7576122934466e2a12a7
+  data.tar.gz: e1ee7670dd9b3d3f580eeb76c5f6032e9e9dd48afe0ebaa6e8510488c3bba81a99457e5ad1d2d1ea39488ca1630ffc33d46dbbf9fb84d1c14ccd24ff8a988dba

data/CLAUDE.md

@@ -161,23 +161,35 @@ Instance methods available in subcommand blocks:
 - `attach_method(name, &block)` - Add methods to hiiro instance dynamically
 - `make_child(subcmd, *args)` - Create nested Hiiro for sub-subcommands
 
-### Hiiro::PrefixMatcher (lib/hiiro/prefix_matcher.rb)
+### Hiiro::Matcher (lib/hiiro/matcher.rb)
 
-Handles abbreviation matching for commands and items:
+Handles pattern matching for commands and items with prefix and substring matching:
 
 ```ruby
-matcher = Hiiro::PrefixMatcher.new(items, :name)
-result = matcher.find("pre")     # Find items where name starts with "pre"
+matcher = Hiiro::Matcher.new(items, :name)
+
+# Prefix matching - find items where name starts with pattern
+result = matcher.by_prefix("pre")
 result.match?                     # Any matches?
 result.one?                       # Exactly one match?
 result.ambiguous?                 # Multiple matches?
 result.first&.item                # Get first matching item
 result.resolved&.item             # Get exact or single match
 
+# Substring matching - find items where name contains pattern anywhere
+result = matcher.by_substring("abc")
+result.matches.map(&:item)        # All matching items
+
 # Path-based matching for hierarchical names (e.g., "task/subtask")
 result = matcher.resolve_path("t/s")
+
+# Class methods for one-off matching
+Hiiro::Matcher.by_prefix(items, "pre", key: :name)
+Hiiro::Matcher.by_substring(items, "abc", key: :name)
 ```
 
+Note: `Hiiro::PrefixMatcher` is aliased to `Hiiro::Matcher` for backward compatibility.
+
 ### Hiiro::Git (lib/hiiro/git.rb)
 
 Git operations wrapper with submodules for branches, worktrees, remotes, and PRs:
@@ -235,7 +247,7 @@ History.by_session("work")                      # Filter by tmux session
 - `bin/h-*` - External subcommands (tmux wrappers, video operations)
 - `plugins/*.rb` - Reusable plugin modules (Pins, Project, Task, Tmux, Notify)
 - `lib/hiiro.rb` - Main Hiiro class and Runners
-- `lib/hiiro/*.rb` - Supporting classes (Git, PrefixMatcher, Fuzzyfind, Todo, History)
+- `lib/hiiro/*.rb` - Supporting classes (Git, Matcher, Fuzzyfind, Todo, History)
 
 ## External Dependencies
 

data/bin/h-plugin

@@ -23,8 +23,8 @@ o.add_subcmd(:edit) { |*args|
   if args.none?
     system(ENV['EDITOR'] || 'safe_nvim', __FILE__)
   else
-    pm = Hiiro::PrefixMatcher.new(plugin_files) { |f| File.basename(f) }
-    plugins = args.flat_map { |arg| pm.find_all(arg).matches.map(&:item) }.uniq
+    pm = Hiiro::Matcher.new(plugin_files) { |f| File.basename(f) }
+    plugins = args.flat_map { |arg| pm.by_prefix(arg).matches.map(&:item) }.uniq
 
     if plugins.none?
       puts "No matching plugins found for: #{args.map(&:inspect).join(' ')}"

data/lib/hiiro/{prefix_matcher.rb → matcher.rb}

@@ -1,16 +1,17 @@
 class Hiiro
-  class PrefixMatcher
+  class Matcher
     class << self
+      # Prefix matching class methods
       def find(items, prefix, key: nil, &block)
-        new(items, key, &block).find(prefix)
+        new(items, key, &block).by_prefix(prefix)
       end
 
       def find_all(items, prefix, key: nil, &block)
-        new(items, key, &block).find_all(prefix)
+        new(items, key, &block).by_prefix(prefix)
       end
 
       def resolve(items, prefix, key: nil, &block)
-        new(items, key, &block).resolve(prefix)
+        new(items, key, &block).by_prefix(prefix)
       end
 
       def find_path(items, prefix, key: nil, &block)
@@ -24,6 +25,16 @@ class Hiiro
       def resolve_path(items, prefix, key: nil, &block)
         new(items, key, &block).resolve_path(prefix)
       end
+
+      # Substring matching class methods
+      def by_substring(items, substring, key: nil, &block)
+        new(items, key, &block).by_substring(substring)
+      end
+
+      # Prefix matching class methods (explicit)
+      def by_prefix(items, prefix, key: nil, &block)
+        new(items, key, &block).by_prefix(prefix)
+      end
     end
 
     attr_reader :original_items, :key, :block
@@ -51,28 +62,48 @@ class Hiiro
       }
     end
 
-    def search(prefix, key = nil, &block)
+    # Primary prefix matching method
+    def by_prefix(prefix, key = nil, &block)
       Result.new(
         matcher: self,
         all_items: all_items(key, &block),
-        prefix: prefix,
+        pattern: prefix,
+        match_type: :prefix,
         key: key || @key,
         block: block || @block
       )
     end
 
+    # Primary substring matching method
+    def by_substring(substring, key = nil, &block)
+      Result.new(
+        matcher: self,
+        all_items: all_items(key, &block),
+        pattern: substring,
+        match_type: :substring,
+        key: key || @key,
+        block: block || @block
+      )
+    end
+
+    # Legacy method aliases for backward compatibility
+    def search(prefix, key = nil, &block)
+      by_prefix(prefix, key, &block)
+    end
+
     def find(prefix, key = nil, &block)
-      search(prefix, key, &block)
+      by_prefix(prefix, key, &block)
     end
 
     def find_all(prefix, key = nil, &block)
-      search(prefix, key, &block)
+      by_prefix(prefix, key, &block)
     end
 
     def resolve(prefix, key = nil, &block)
-      search(prefix, key, &block)
+      by_prefix(prefix, key, &block)
     end
 
+    # Path-based matching
     def find_path(prefix, key = nil, &block)
       search_path(prefix, key, &block)
     end
@@ -119,18 +150,33 @@ class Hiiro
     end
 
     class Result
-      attr_reader :matcher, :all_items, :key, :block, :prefix
+      attr_reader :matcher, :all_items, :key, :block, :pattern, :match_type
 
-      def initialize(matcher:, all_items:, prefix:, key: nil, block: nil)
+      def initialize(matcher:, all_items:, pattern:, match_type: :prefix, key: nil, block: nil)
         @matcher = matcher
         @all_items = all_items
-        @prefix = prefix
+        @pattern = pattern
+        @match_type = match_type
         @key = key
         @block = block
       end
 
+      # Alias for backward compatibility
+      def prefix
+        pattern
+      end
+
       def matches
-        @matches ||= all_items.select { |item| item.extracted_item.to_s.start_with?(prefix.to_s) }
+        @matches ||= all_items.select { |item|
+          case match_type
+          when :prefix
+            item.extracted_item.to_s.start_with?(pattern.to_s)
+          when :substring
+            item.extracted_item.to_s.include?(pattern.to_s)
+          else
+            item.extracted_item.to_s.start_with?(pattern.to_s)
+          end
+        }
       end
 
       def count
@@ -142,7 +188,7 @@ class Hiiro
       end
 
       def exact_match
-        all_items.find { |item| item.extracted_item == prefix }
+        all_items.find { |item| item.extracted_item == pattern }
       end
 
       def match
@@ -238,4 +284,7 @@ class Hiiro
       end
     end
   end
+
+  # Backward compatibility alias
+  PrefixMatcher = Matcher
 end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.91"
+  VERSION = "0.1.92"
 end

data/lib/hiiro.rb

@@ -4,7 +4,7 @@ require "shellwords"
 require "pry"
 
 require_relative "hiiro/version"
-require_relative "hiiro/prefix_matcher"
+require_relative "hiiro/matcher"
 require_relative "hiiro/git"
 require_relative "hiiro/options"
 require_relative "hiiro/notification"

data/plugins/pins.rb

@@ -54,7 +54,7 @@ module Pins
     end
 
     def search(partial)
-      Hiiro::PrefixMatcher.find(pins.keys.map(&:to_s), partial)
+      Hiiro::Matcher.by_prefix(pins.keys.map(&:to_s), partial)
     end
 
     def find(partial)

data/plugins/tasks.rb

@@ -178,19 +178,19 @@ class Environment
   end
 
   def tree_matcher
-    @tree_matcher ||= Hiiro::PrefixMatcher.new(all_trees, :name)
+    @tree_matcher ||= Hiiro::Matcher.new(all_trees, :name)
   end
 
   def session_matcher
-    @session_matcher ||= Hiiro::PrefixMatcher.new(all_sessions, :name)
+    @session_matcher ||= Hiiro::Matcher.new(all_sessions, :name)
   end
 
   def app_matcher
-    @app_matcher ||= Hiiro::PrefixMatcher.new(all_apps, :name)
+    @app_matcher ||= Hiiro::Matcher.new(all_apps, :name)
   end
 
   def task_matcher
-    @task_matcher ||= Hiiro::PrefixMatcher.new(all_tasks, :name)
+    @task_matcher ||= Hiiro::Matcher.new(all_tasks, :name)
   end
 
   def task
@@ -286,7 +286,7 @@ class TaskManager
     return slash_lookup(name) if name.include?('/')
 
     key = (scope == :subtask) ? :short_name : :name
-    Hiiro::PrefixMatcher.new(tasks, key).find(name).first&.item
+    Hiiro::Matcher.new(tasks, key).by_prefix(name).first&.item
   end
 
   def task_by_tree(tree_name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.91
+  version: 0.1.92
 platform: ruby
 authors:
 - Joshua Toyota
@@ -103,9 +103,9 @@ files:
 - lib/hiiro/git/remote.rb
 - lib/hiiro/git/worktree.rb
 - lib/hiiro/git/worktrees.rb
+- lib/hiiro/matcher.rb
 - lib/hiiro/notification.rb
 - lib/hiiro/options.rb
-- lib/hiiro/prefix_matcher.rb
 - lib/hiiro/shell.rb
 - lib/hiiro/todo.rb
 - lib/hiiro/version.rb