hiiro 0.1.56 → 0.1.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0db0a8fd9d54e542cb2b5951197e2250a1d199a66278b31bab5c003b50d8f39f
-  data.tar.gz: bee3a32c0dc9e68379aee3963bb11b15041a9cd21715379dbbc086bff59eba17
+  metadata.gz: 7f55785ca9b54838e9b0e0eefe8e1e829f85ad1b1d9a1ed6b961305b847f1828
+  data.tar.gz: cda5ec5bdc86b4210e4870d88bca437c9cc7dbac3857ae3e264a66ba0b054675
 SHA512:
-  metadata.gz: b59060b23668b9f6fc2818884628dccae6a95e84a5554d9666b9ce79d9bfc45f231c486039121c6a33cc8e97b144e1579cbd637131d8ca5cd0f196bfcdb4e9ff
-  data.tar.gz: 5918af1c725ce23f22a17d273def7f656118c1a54f9fd13ee7fe0be708e82f8c8146c7a4b4c7860482c5fb85a5c8a86910c5412062a96d9c37ce9901b527bee7
+  metadata.gz: 8d8e719178da0355245154216264edb4c292fb5ccc62dc561e8529bf7b67f4a94d85a5db3516e1406f5cf7464f61454dc3c07f7dc26530a44a895577b7082c12
+  data.tar.gz: 28a570aba442cb90419feaf3edd4ef4135773fc2f971401df942bb09617f17c7466c3ba32dbfc2edd1849895d973cdada07f80b8edd2932685e8f21bc00f29d4

data/Rakefile

@@ -1,3 +1,10 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
 
-task default: :build
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/h-plugin

@@ -24,7 +24,7 @@ o.add_subcmd(:edit) { |*args|
     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) }.uniq
+    plugins = args.flat_map { |arg| pm.find_all(arg).matches.map(&:item) }.uniq
 
     if plugins.none?
       puts "No matching plugins found for: #{args.map(&:inspect).join(' ')}"

data/exe/h

@@ -4,7 +4,7 @@ require "hiiro"
 require "fileutils"
 require "pry"
 
-Hiiro.run(*ARGV, cwd: Dir.pwd, plugins: [:Tasks]) do
+Hiiro.run(*ARGV, cwd: Dir.pwd, plugins: [Tasks]) do
   add_subcommand(:version) { |*args|
     puts Hiiro::VERSION
   }

data/hiiro.gemspec

@@ -27,4 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "pry", "~> 0.14"
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
 end

data/lib/hiiro/prefix_matcher.rb

@@ -1,5 +1,136 @@
 class Hiiro
   class PrefixMatcher
+    class Item
+      attr_reader :item, :extracted_item, :key, :block
+
+      def initialize(item:, extracted_item:, key: nil, block: nil)
+        @item = item
+        @extracted_item = extracted_item
+        @key = key
+        @block = block
+      end
+    end
+
+    class Result
+      attr_reader :matcher, :all_items, :key, :block, :prefix
+
+      def initialize(matcher:, all_items:, prefix:, key: nil, block: nil)
+        @matcher = matcher
+        @all_items = all_items
+        @prefix = prefix
+        @key = key
+        @block = block
+      end
+
+      def matches
+        @matches ||= all_items.select { |item| item.extracted_item.to_s.start_with?(prefix.to_s) }
+      end
+
+      def count
+        matches.count
+      end
+
+      def ambiguous?
+        count > 1
+      end
+
+      def exact_match
+        all_items.find { |item| item.extracted_item == prefix }
+      end
+
+      def match
+        one? ? matches.first : nil
+      end
+
+      def match?
+        matches.any?
+      end
+
+      def exact?
+        !exact_match.nil?
+      end
+
+      def one?
+        count == 1
+      end
+
+      # Returns item for resolve semantics: exact match, or single match, otherwise nil
+      def resolved
+        exact_match || match
+      end
+
+      # Returns the first matching item (for find semantics)
+      def first
+        matches.first
+      end
+    end
+
+    class PathResult
+      attr_reader :matcher, :all_items, :key, :block, :prefix
+
+      def initialize(matcher:, all_items:, prefix:, key: nil, block: nil)
+        @matcher = matcher
+        @all_items = all_items
+        @prefix = prefix
+        @key = key
+        @block = block
+      end
+
+      def matches
+        @matches ||= begin
+          prefixes = prefix.to_s.split('/')
+
+          items_with_paths = all_items.map { |item|
+            [item, item.extracted_item.to_s.split('/')]
+          }
+
+          prefixes.each_with_index do |seg, i|
+            items_with_paths = items_with_paths.select { |_, path| path[i]&.start_with?(seg) }
+          end
+
+          items_with_paths.map(&:first)
+        end
+      end
+
+      def count
+        matches.count
+      end
+
+      def ambiguous?
+        count > 1
+      end
+
+      def exact_match
+        all_items.find { |item| item.extracted_item == prefix }
+      end
+
+      def match
+        one? ? matches.first : nil
+      end
+
+      def match?
+        matches.any?
+      end
+
+      def exact?
+        !exact_match.nil?
+      end
+
+      def one?
+        count == 1
+      end
+
+      # Returns item for resolve semantics: exact match, or single match, otherwise nil
+      def resolved
+        exact_match || match
+      end
+
+      # Returns the first matching item (for find semantics)
+      def first
+        matches.first
+      end
+    end
+
     class << self
       def find(items, prefix, key: nil, &block)
         new(items, key, &block).find(prefix)
@@ -34,69 +165,69 @@ class Hiiro
       @block = block
     end
 
-    def items(key = nil, &block)
-      if key.nil? && !block_given?
-        @items ||= original_items.map { |item| extract(item, @key, &@block) }
-      else
-        original_items.map { |item| extract(item, key, &block) }
-      end
+    def all_items(key = nil, &block)
+      use_key = key.nil? && !block_given? ? @key : key
+      use_block = key.nil? && !block_given? ? @block : block
+
+      @all_items_cache ||= {}
+      cache_key = [use_key, use_block].hash
+
+      @all_items_cache[cache_key] ||= original_items.map { |item|
+        Item.new(
+          item: item,
+          extracted_item: extract(item, use_key, &use_block),
+          key: use_key,
+          block: use_block
+        )
+      }
     end
 
-    def extracted_items(key = nil, &block)
-      original_items.zip(items(key, &block))
+    def search(prefix, key = nil, &block)
+      Result.new(
+        matcher: self,
+        all_items: all_items(key, &block),
+        prefix: prefix,
+        key: key || @key,
+        block: block || @block
+      )
     end
 
     def find(prefix, key = nil, &block)
-      extracted_items(key, &block).find { |_, extracted| matches?(extracted, prefix) }&.first
+      search(prefix, key, &block)
     end
 
     def find_all(prefix, key = nil, &block)
-      extracted_items(key, &block).select { |_, extracted| matches?(extracted, prefix) }.map(&:first)
+      search(prefix, key, &block)
     end
 
     def resolve(prefix, key = nil, &block)
-      pairs = extracted_items(key, &block)
-
-      exact = pairs.find { |_, extracted| extracted == prefix }
-      return exact.first if exact
-
-      matches = pairs.select { |_, extracted| matches?(extracted, prefix) }
-      matches.one? ? matches.first.first : nil
+      search(prefix, key, &block)
     end
 
     def find_path(prefix, key = nil, &block)
-      matching_path_pairs(prefix, key, &block).first&.first
+      search_path(prefix, key, &block)
     end
 
     def find_all_paths(prefix, key = nil, &block)
-      matching_path_pairs(prefix, key, &block).map(&:first)
+      search_path(prefix, key, &block)
     end
 
     def resolve_path(prefix, key = nil, &block)
-      matches = matching_path_pairs(prefix, key, &block)
-      return nil if matches.empty?
-      return matches.first.first if matches.one?
+      search_path(prefix, key, &block)
+    end
 
-      exact = matches.find { |_, path| path == prefix }
-      exact&.first
+    def search_path(prefix, key = nil, &block)
+      PathResult.new(
+        matcher: self,
+        all_items: all_items(key, &block),
+        prefix: prefix,
+        key: key || @key,
+        block: block || @block
+      )
     end
 
     private
 
-    def matching_path_pairs(prefix, key = nil, &block)
-      prefixes = prefix.to_s.split('/')
-
-      pairs = extracted_items(key, &block).map { |item, extracted|
-        [item, extracted.to_s.split('/')]
-      }
-
-      prefixes.each_with_index do |seg, i|
-        pairs = pairs.select { |_, path| path[i]&.start_with?(seg) }
-      end
-
-      pairs.map { |item, path| [item, path.join('/')] }
-    end
-
     def matches?(item, prefix)
       item.to_s.start_with?(prefix.to_s)
     end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.56"
+  VERSION = "0.1.57"
 end

data/plugins/pins.rb

@@ -53,23 +53,27 @@ module Pins
       value
     end
 
-    def find(partial)
+    def search(partial)
       Hiiro::PrefixMatcher.find(pins.keys.map(&:to_s), partial)
     end
 
+    def find(partial)
+      search(partial).match&.item
+    end
+
     def find_all(partial)
-      Hiiro::PrefixMatcher.find_all(pins.keys.map(&:to_s), partial)
+      search(partial).matches.map(&:item)
     end
 
     def remove(name)
-      all_matches = find_all(name)
+      result = search(name)
 
-      if all_matches.count > 1
-        puts "Unable to remove pin.  Multiple matches: #{all_matches.inspect}"
+      if result.ambiguous?
+        puts "Unable to remove pin.  Multiple matches: #{result.matches.map(&:item).inspect}"
         return
       end
 
-      pin_name = all_matches.first
+      pin_name = result.match&.item
 
       pins.delete(pin_name.to_s)
     end

data/plugins/tasks.rb

@@ -209,33 +209,33 @@ class Environment
     # Try path-based matching first (handles "parent/child" patterns)
     if abbreviated.include?('/')
       result = task_matcher.resolve_path(abbreviated)
-      return result if result
+      return result.resolved&.item if result.match?
 
       # "main" refers to the parent task itself
       parent_prefix, child_prefix = abbreviated.split('/', 2)
       if 'main'.start_with?(child_prefix)
-        return task_matcher.find(parent_prefix)
+        return task_matcher.find(parent_prefix).first&.item
       end
 
       nil
     else
-      task_matcher.find(abbreviated)
+      task_matcher.find(abbreviated).first&.item
     end
   end
 
   def find_tree(abbreviated)
     return nil if abbreviated.nil?
-    tree_matcher.find(abbreviated)
+    tree_matcher.find(abbreviated).first&.item
   end
 
   def find_session(abbreviated)
     return nil if abbreviated.nil?
-    session_matcher.find(abbreviated)
+    session_matcher.find(abbreviated).first&.item
   end
 
   def find_app(abbreviated)
     return nil if abbreviated.nil?
-    app_matcher.find(abbreviated)
+    app_matcher.find(abbreviated).first&.item
   end
 end
 
@@ -277,15 +277,15 @@ class TaskManager
     return slash_lookup(name) if name.include?('/')
 
     key = (scope == :subtask) ? :short_name : :name
-    Hiiro::PrefixMatcher.new(tasks, key).find(name)
+    Hiiro::PrefixMatcher.new(tasks, key).find(name).first&.item
   end
 
   def task_by_tree(tree_name)
-    environment.task_matcher.resolve(tree_name, :tree_name)
+    environment.task_matcher.resolve(tree_name, :tree_name).resolved&.item
   end
 
   def task_by_session(session_name)
-    environment.task_matcher.resolve(session_name, :session_name)
+    environment.task_matcher.resolve(session_name, :session_name).resolved&.item
   end
 
   def current_task
@@ -549,19 +549,19 @@ class TaskManager
       return
     end
 
-    matches = environment.app_matcher.find_all(app_name)
+    result = environment.app_matcher.find_all(app_name)
 
-    case matches.count
+    case result.count
     when 0
       puts "ERROR: No matches found"
       puts
       puts "Possible Apps:"
       environment.all_apps.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
     when 1
-      print matches.first.resolve(tree_root)
+      print result.first.item.resolve(tree_root)
     else
       puts "Multiple matches found:"
-      matches.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
+      result.matches.each { |m| puts format("  %-20s => %s", m.item.name, m.item.relative_path) }
     end
   end
 
@@ -623,9 +623,9 @@ class TaskManager
     tree = environment.find_tree(task.tree_name)
     tree_root = tree ? tree.path : File.join(WORK_DIR, task.tree_name)
 
-    matches = environment.app_matcher.find_all(app_name)
+    result = environment.app_matcher.find_all(app_name)
 
-    case matches.count
+    case result.count
     when 0
       # Fallback: directory discovery
       exact = File.join(tree_root, app_name)
@@ -638,15 +638,15 @@ class TaskManager
       list_apps
       nil
     when 1
-      app = matches.first
+      app = result.first.item
       [app.name, app.resolve(tree_root)]
     else
-      exact = matches.find { |a| a.name == app_name }
+      exact = result.matches.find { |m| m.item.name == app_name }
       if exact
-        [exact.name, exact.resolve(tree_root)]
+        [exact.item.name, exact.item.resolve(tree_root)]
       else
         puts "ERROR: '#{app_name}' matches multiple apps:"
-        matches.each { |a| puts "  #{a.name}" }
+        result.matches.each { |m| puts "  #{m.item.name}" }
         nil
       end
     end
@@ -696,7 +696,7 @@ class TaskManager
       data = load_tasks
       data['tasks'] ||= []
       data['tasks'].reject! { |t| t['name'] == task.name }
-      data['tasks'] << task.to_h
+      data['tasks'] << task.to_h.transform_keys(&:to_s)
       save_tasks(data)
     end
 

data/script/test

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+bundle exec rake test "$@"
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.56
+  version: 0.1.57
 platform: ruby
 authors:
 - Joshua Toyota
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 description: Build multi-command CLI tools with subcommand dispatch, abbreviation
   matching, and a plugin system. Similar to git or docker command structure.
 email:
@@ -92,6 +120,7 @@ files:
 - script/install
 - script/publish
 - script/sync
+- script/test
 - script/update
 homepage: https://github.com/unixsuperhero/hiiro
 licenses: