hiiro 0.1.0

data/bin/h

@@ -0,0 +1,415 @@
+#!/usr/bin/env ruby
+
+require "pry"
+
+# Use the gem if installed, otherwise define inline
+begin
+  require "hiiro"
+rescue LoadError
+  require "fileutils"
+  require "yaml"
+end
+
+class Hiiro
+  def self.init(*args, plugins: [], logging: false, **values, &block)
+    args = $ARGV if args.empty?
+
+    new($0, *args, logging: logging, **values).tap do |hiiro|
+      hiiro.load_plugins(*plugins)
+
+      hiiro.add_subcmd(:edit, **values) { |*args|
+        system(ENV['EDITOR'] || 'nvim', hiiro.bin)
+      }
+
+      block.call(hiiro) if block
+    end
+  end
+
+  def self.load_env
+    Config.plugin_files.each do |plugin_file|
+      require plugin_file
+    end
+  end
+
+  attr_reader :bin, :bin_name, :all_args
+  attr_reader :subcmd, :args
+  attr_reader :loaded_plugins
+  attr_reader :logging
+  attr_reader :global_values
+
+  def initialize(bin, *args, logging: false, **values)
+    @bin = bin
+    @bin_name = File.basename(bin)
+    @all_args = args
+    @subcmd, *@args = args # normally i would never do this
+    @loaded_plugins = []
+    @logging = logging
+    @global_values = values
+  end
+
+  def run
+    result = runner.run(*args)
+
+    handle_result(result)
+    
+    exit 1
+  rescue => e
+    puts "ERROR: #{e.message}"
+    puts e.backtrace
+    exit 1
+  end
+
+  def handle_result(result)
+    exit 0 if result.nil? || result
+
+    exit 1
+  end
+
+  def runnable?
+    runner
+  end
+
+  def runner
+    runners.runner || runners.default_subcommand
+  end
+
+  def runners
+    @runners ||= Runners.new(self)
+  end
+
+  def add_default(**values, &handler)
+    runners.add_subcommand(:DEFAULT, handler, **global_values, **values)
+  end
+
+  def add_subcommand(name, **values, &handler)
+    runners.add_subcommand(name, handler, **global_values, **values)
+  end
+  alias add_subcmd add_subcommand
+
+  def full_name
+    runner&.full_name || [bin_name, subcmd].join(?-)
+  end
+
+  def subcommand_names
+    runners.subcommand_names
+  end
+
+  def pins = @pins ||= Pin.new(self)
+
+  def load_plugins(*plugins)
+    plugins.flatten.each { |plugin| load_plugin(plugin) }
+  end
+
+  def load_plugin(plugin_const)
+    return if @loaded_plugins.include?(plugin_const)
+
+    plugin_const.load(self)
+    @loaded_plugins.push(plugin_const)
+  end
+
+  def help
+    ambiguous = runners.ambiguous_matches
+
+    if ambiguous.any?
+      puts "Ambiguous subcommand #{subcmd.inspect}!"
+      puts ""
+      puts "Did you mean one of these?"
+      list_runners(ambiguous)
+    else
+      subcmd_msg = "Subcommand required!"
+      subcmd_msg = "Subcommand #{subcmd.inspect} not found!" if subcmd
+
+      puts subcmd_msg
+      puts ""
+      puts "Possible subcommands:"
+      list_runners(runners.all_runners)
+    end
+  end
+
+  def list_runners(list)
+    max_name = list.map { |r| r.subcommand_name.length }.max || 0
+    max_type = list.map { |r| r.type.to_s.length }.max || 0
+    max_params = list.map { |r| r.params_string.to_s.length }.max || 0
+
+    list.each do |r|
+      name = r.subcommand_name.ljust(max_name)
+      type = "(#{r.type})".ljust(max_type + 2)
+      params = r.params_string
+      params_col = params ? params.ljust(max_params) : ''.ljust(max_params)
+      location = r.location
+      puts "  #{name}  #{params_col}  #{type}  #{location}"
+    end
+  end
+
+  def log(message)
+    return unless logging
+
+    puts "[Hiiro: #{bin_name} #{(runner&.subcommand_name || subcmd).inspect}]: #{message}"
+  end
+
+  def parsed_args
+    i = Args.new(*args)
+  end
+
+  def get_value(name)
+    runner&.values&.[](name)
+  end
+
+  class Config
+    class << self
+      def plugin_files
+        Dir.glob(File.join(plugin_dir, '*'))
+      end
+
+      def plugin_dir
+        config_dir('plugins')
+      end
+
+      def config_dir(subdir=nil)
+        File.join(Dir.home, '.config/hiiro', *[subdir].compact).tap do |config_path|
+          FileUtils.mkdir_p(config_path) unless Dir.exist?(config_path)
+        end
+      end
+    end
+  end
+
+  class Runners
+    attr_reader :hiiro, :bin_name, :subcmd, :subcommands
+
+    def initialize(hiiro)
+      @hiiro = hiiro
+      @bin_name = hiiro.bin_name
+      @subcmd = hiiro.subcmd
+      @subcommands = {}
+    end
+
+    def runner
+      return default_subcommand if subcmd.to_s == ''
+
+      exact_runner || unambiguous_runner
+    end
+
+    def default_subcommand
+      Subcommand.new(bin_name, :default, lambda { hiiro.help; false })
+    end
+
+    def subcommand_names
+      all_runners.map(&:subcommand_name)
+    end
+
+    def all_runners
+      [*all_bins, *subcommands.values]
+    end
+
+    def paths
+      @paths ||= ENV['PATH'].split(?:).uniq
+    end
+
+    def all_bins
+      pattern = format('{%s}/%s-*', paths.join(?,), bin_name)
+
+      Dir.glob(pattern).map { |path| Bin.new(bin_name, path) }
+    end
+
+    def add_subcommand(name, handler, **values)
+      @subcommands[name] = Subcommand.new(bin_name, name, handler, values)
+    end
+
+    def exact_runner
+      all_runners.find { |r| r.exact_match?(subcmd) }
+    end
+
+    def unambiguous_runner
+      return nil if subcmd.nil?
+
+      matches = matching_runners
+      return matches.first if matches.count == 1
+
+      nil
+    end
+
+    def ambiguous_matches
+      return [] if subcmd.nil?
+
+      matches = matching_runners
+      return matches if matches.count > 1
+
+      []
+    end
+
+    def matching_runners
+      remove_child_runners(all_matching_runners)
+    end
+
+    def all_matching_runners
+      all_runners.select { |r| r.match?(subcmd) }
+    end
+
+    def remove_child_runners(list)
+      list.reject do |r|
+        list.any? { |other| r != other && r.full_name.start_with?(other.full_name + ?-) }
+      end
+    end
+
+    # if i wanted to reduce the lines of code, i could combine Bin/Subcommand
+    # but i would have to introduce a new attr and arg to the constructor: @type
+    # then for methods like #full_name and #run i would have to branch off of
+    # @type
+    class Bin
+      attr_reader :bin_name, :path, :name
+      alias full_name name
+
+      def initialize(bin_name, path)
+        @bin_name = bin_name
+        @path = path
+        @name = File.basename(path)
+      end
+
+      def run(*args)
+        system(path, *args)
+      end
+
+      def exact_match?(subcmd)
+        subcommand_name == subcmd.to_s
+      end
+
+      def match?(subcmd)
+        subcommand_name.start_with?(subcmd.to_s)
+      end
+
+      def subcommand_name
+        name.sub("#{bin_name}-", '')
+      end
+
+      def values
+        {}
+      end
+
+      def type
+        :bin
+      end
+
+      def location
+        path
+      end
+
+      def params_string
+        nil
+      end
+    end
+
+    class Subcommand
+      attr_reader :bin_name, :name, :handler, :values
+      alias subcommand_name name
+
+      def initialize(bin_name, name, handler, values={})
+        @bin_name = bin_name
+        @name = name.to_s
+        @handler = handler
+        @values = values || {}
+      end
+
+      def run(*args)
+        handler.call(*args)
+      end
+
+      def exact_match?(subcmd)
+        name == subcmd.to_s
+      end
+
+      def match?(subcmd)
+        name.start_with?(subcmd.to_s)
+      end
+
+      def full_name
+        [bin_name, name].join(?-)
+      end
+
+      def type
+        :subcommand
+      end
+
+      def location
+        handler.source_location&.join(':')
+      end
+
+      def params_string
+        return nil unless handler.respond_to?(:parameters)
+
+        params = handler.parameters
+        return nil if params.empty?
+        return nil if params == [[:rest]] || params == [[:rest, :args]]
+
+        params.map { |type, name|
+          case type
+          when :req then "<#{name}>"
+          when :opt then "[#{name}]"
+          when :rest then "[*#{name}]" if name
+          when :keyreq then "<#{name}:>"
+          when :key then "[#{name}:]"
+          when :keyrest then "[**#{name}]" if name
+          when :block then "[&#{name}]" if name
+          end
+        }.compact.join(' ')
+      end
+    end
+  end
+
+  class Args
+    attr_reader :raw_args
+
+    def initialize(*raw_args)
+      @raw_args = raw_args
+    end
+
+    def flags
+      @flags ||= proc {
+        raw_args.select { |arg|
+          arg.match?(/^-[^-]/)
+        }.flat_map { |arg|
+          arg.sub(/^-/, '').chars
+        }
+      }.call
+    end
+
+    def flag?(flag)
+      flags.include?(flag)
+    end
+
+    def flag_value(flag)
+      found_flag = false
+      raw_args.each do |arg|
+        if found_flag
+          return arg
+        end
+
+        if arg.match?(/^-\w*#{flag}/)
+          found_flag = true
+        end
+      end
+
+      nil
+    end
+
+    def values
+      raw_args.reject do |arg|
+        arg.match?(/^-/)
+      end
+    end
+  end
+end
+
+Hiiro.load_env
+
+
+# only run the runner if being called from the commandline
+if __FILE__ == $0
+  hiiro = Hiiro.init(*ARGV, plugins: [Pins, Project, Task], cwd: Dir.pwd)
+
+  hiiro.add_subcommand(:ping) { |*args|
+    puts "pong"
+  }
+
+  hiiro.run
+end
+

data/bin/h-buffer

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+load File.join(Dir.home, 'bin', 'h')
+
+o = Hiiro.init(*ARGV, plugins: [Pins])
+
+o.add_subcmd(:ls) { |*args|
+  system('tmux', 'list-buffers', *args)
+}
+
+o.add_subcmd(:show) { |*args|
+  system('tmux', 'show-buffer', *args)
+}
+
+o.add_subcmd(:save) { |*args|
+  system('tmux', 'save-buffer', *args)
+}
+
+o.add_subcmd(:load) { |*args|
+  system('tmux', 'load-buffer', *args)
+}
+
+o.add_subcmd(:set) { |*args|
+  system('tmux', 'set-buffer', *args)
+}
+
+o.add_subcmd(:paste) { |*args|
+  system('tmux', 'paste-buffer', *args)
+}
+
+o.add_subcmd(:delete) { |*args|
+  system('tmux', 'delete-buffer', *args)
+}
+
+o.add_subcmd(:choose) { |*args|
+  system('tmux', 'choose-buffer', *args)
+}
+
+o.add_subcmd(:clear) { |*args|
+  # Delete all buffers
+  buffers = `tmux list-buffers -F '\#{buffer_name}'`.strip.split("\n")
+  buffers.each { |buf| system('tmux', 'delete-buffer', '-b', buf) }
+  puts "Cleared #{buffers.count} buffers"
+}
+
+o.run

data/bin/h-pane

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+load File.join(Dir.home, 'bin', 'h')
+
+o = Hiiro.init(*ARGV, plugins: [Pins])
+
+o.add_subcmd(:ls) { |*args|
+  system('tmux', 'list-panes', *args)
+}
+
+o.add_subcmd(:lsa) { |*args|
+  system('tmux', 'list-panes', '-a', *args)
+}
+
+o.add_subcmd(:split) { |*args|
+  system('tmux', 'split-window', *args)
+}
+
+o.add_subcmd(:splitv) { |*args|
+  system('tmux', 'split-window', '-v', *args)
+}
+
+o.add_subcmd(:splith) { |*args|
+  system('tmux', 'split-window', '-h', *args)
+}
+
+o.add_subcmd(:kill) { |*args|
+  system('tmux', 'kill-pane', *args)
+}
+
+o.add_subcmd(:swap) { |*args|
+  system('tmux', 'swap-pane', *args)
+}
+
+o.add_subcmd(:zoom) { |*args|
+  system('tmux', 'resize-pane', '-Z', *args)
+}
+
+o.add_subcmd(:capture) { |*args|
+  system('tmux', 'capture-pane', *args)
+}
+
+o.add_subcmd(:select) { |*args|
+  system('tmux', 'select-pane', *args)
+}
+
+o.add_subcmd(:move) { |*args|
+  system('tmux', 'move-pane', *args)
+}
+
+o.add_subcmd(:break) { |*args|
+  system('tmux', 'break-pane', *args)
+}
+
+o.add_subcmd(:join) { |*args|
+  system('tmux', 'join-pane', *args)
+}
+
+o.add_subcmd(:resize) { |*args|
+  system('tmux', 'resize-pane', *args)
+}
+
+o.run

data/bin/h-plugin

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'json'
+
+load File.join(Dir.home, 'bin', 'h')
+
+BASE_DIR = File.join(Dir.home, '.config/hiiro/plugins')
+o = Hiiro.init(*ARGV, plugins: [Tmux, Pins], dir: BASE_DIR)
+
+def plugin_files
+  Dir.glob(File.join(BASE_DIR, '**/*'))
+end
+
+o.add_subcmd(:path) { |*args|
+  print o.get_value(:dir)
+}
+
+o.add_subcmd(:ls) { |*args|
+  puts plugin_files
+}
+
+o.add_subcmd(:edit) { |*args|
+  if args.none?
+    system(ENV['EDITOR'] || 'safe_nvim', __FILE__)
+  else
+    plugins = plugin_files.select{|f| args.any?{|arg| File.basename(f).start_with?(arg) } }
+
+    if plugins.none?
+      puts "No matching plugins found for: #{args.map(&:inspect).join(' ')}"
+    else
+      system(ENV['EDITOR'] || 'safe_nvim', *plugins)
+    end
+  end
+}
+
+o.add_subcmd(:rg) { |*args|
+  Dir.chdir(o.get_value(:dir))
+  system('rg', '-S', *args)
+}
+
+o.add_subcmd(:rgall) { |*args|
+  Dir.chdir(o.get_value(:dir))
+  system('rg', '-S', '--no-ignore-vcs', *args)
+}
+
+begin
+  o.run
+rescue => e
+  binding.pry
+end
+

data/bin/h-session

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+load File.join(Dir.home, 'bin', 'h')
+
+o = Hiiro.init(*ARGV, plugins: [Pins])
+
+o.add_subcmd(:ls) { |*args|
+  system('tmux', 'list-sessions', *args)
+}
+
+o.add_subcmd(:new) { |*args|
+  system('tmux', 'new-session', *args)
+}
+
+o.add_subcmd(:kill) { |*args|
+  system('tmux', 'kill-session', *args)
+}
+
+o.add_subcmd(:attach) { |*args|
+  system('tmux', 'attach-session', *args)
+}
+
+o.add_subcmd(:rename) { |*args|
+  system('tmux', 'rename-session', *args)
+}
+
+o.add_subcmd(:switch) { |*args|
+  system('tmux', 'switch-client', *args)
+}
+
+o.add_subcmd(:detach) { |*args|
+  system('tmux', 'detach-client', *args)
+}
+
+o.add_subcmd(:has) { |*args|
+  system('tmux', 'has-session', *args)
+}
+
+o.add_subcmd(:info) { |*args|
+  system('tmux', 'display-message', '-p', '#{session_name}: #{session_windows} windows, #{session_attached} attached', *args)
+}
+
+o.run