hiiro 0.1.0

data/lib/hiiro.rb

@@ -0,0 +1,389 @@
+require "fileutils"
+require "yaml"
+
+require_relative "hiiro/version"
+
+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
+
+    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

data/plugins/notify.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+module Notify
+  def self.load(hiiro)
+    hiiro.log "Plugin loaded: #{name}"
+
+    hiiro.load_plugin(Tmux)
+    attach_methods(hiiro)
+    add_subcommands(hiiro)
+  end
+
+  def self.add_subcommands(hiiro)
+    hiiro.add_subcmd(:notify) do |message, link=nil, title=nil, command=nil|
+      hiiro.notify(message, title:, link:, command:)
+    end
+  end
+
+  def self.attach_methods(hiiro)
+    hiiro.instance_eval do
+      def notify(message, title: nil, link: nil, command: nil)
+        args = ['terminal-notifier', '-message', message]
+        args += ['-title', title] if title
+        args += ['-open', link] if link
+        args += ['-execute', command] if command
+
+        system(*args) if system('which', 'terminal-notifier')
+      end
+    end
+  end
+end

data/plugins/pins.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+module Pins
+  def self.load(hiiro)
+    hiiro.log "Plugin loaded: #{name}"
+
+    attach_methods(hiiro)
+    add_subcommands(hiiro)
+  end
+
+  def self.add_subcommands(hiiro)
+    hiiro.add_subcmd(:pin) do |*args|
+      pins = hiiro.pins
+
+      case args
+      in [] then pins.pins.each {|k,v| puts "#{k} => #{v.inspect}" }
+      in ['all'] then pins.pins.each {|k,v| puts "#{k} => #{v.inspect}" }
+      in ['get', name] then puts pins.get(name)
+      in [name] then puts pins.get(name)
+      in ['rm', name] then puts pins.remove_and_save(name)
+      in ['remove', name] then puts pins.remove_and_save(name)
+      in ['set', name, value] then pins.set_and_save(name, value)
+      in [name, value] then pins.set_and_save(name, value)
+      in [name, *values] then pins.set_and_save(name, values.join(' '))
+      else
+        puts "No matching pin subcommand for #{args.inspect}"
+      end
+    end
+  end
+
+  def self.attach_methods(hiiro)
+    hiiro.instance_eval do
+      def pins
+        @pins ||= Pin.new(self)
+      end
+    end
+  end
+
+  class Pin
+    attr_reader :hiiro
+
+    def initialize(hiiro) = @hiiro = hiiro
+
+    def get(name)
+      pins[find(name)]
+    end
+
+    def set(name, value)
+      pins[name.to_s] = value
+    end
+
+    def set_and_save(name, value)
+      set(name, value)
+      save_pins
+      value
+    end
+
+    def find(partial)
+      pins.keys.map(&:to_s).find do |pin_name|
+        pin_name.start_with?(partial)
+      end
+    end
+
+    def find_all(partial)
+      pins.keys.map(&:to_s).select do |pin_name|
+        pin_name.start_with?(partial)
+      end
+    end
+
+    def remove(name)
+      all_matches = find_all(name)
+
+      if all_matches.count > 1
+        puts "Unable to remove pin.  Multiple matches: #{all_matches.inspect}"
+        return
+      end
+
+      pin_name = all_matches.first
+
+      pins.delete(pin_name.to_s)
+    end
+
+    def remove_and_save(name)
+      remove(name)
+      save_pins
+      pins
+    end
+
+    def pin_filename = hiiro.bin_name
+    def pin_dir = Hiiro::Config.config_dir('pins').tap {|dir| FileUtils.mkdir_p(dir) }
+    def pin_file = File.join(pin_dir, pin_filename)
+    def pins
+      return @pins if @pins
+
+      unless File.exist?(pin_file)
+        File.write(pin_file, YAML.dump({}, stringify_names: true))
+      end
+
+      @pins = YAML.safe_load_file(pin_file)
+    end
+
+    def save_pins(pins = nil)
+      pins = pins || @pins || {}
+
+      File.write(pin_file, YAML.dump(pins, stringify_names: true))
+    end
+
+    def pins!
+      @pins = nil
+      pins
+    end
+  end
+end

data/plugins/project.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+module Project
+  def self.load(hiiro)
+    hiiro.log "Plugin loaded: #{name}"
+
+    hiiro.load_plugin(Tmux)
+    attach_methods(hiiro)
+    add_subcommands(hiiro)
+  end
+
+  def self.add_subcommands(hiiro)
+    hiiro.add_subcmd(:project) do |project_name|
+      re = /#{project_name}/i
+
+      conf_matches = hiiro.projects_from_config.select{|k,v| k.match?(re) }
+      dir_matches = hiiro.project_dirs.select{|proj, path| proj.match?(re) }
+
+      puts(conf_matches:,dir_matches:)
+      matches = dir_matches.merge(conf_matches)
+      if matches.count > 1
+        matches = matches.select{|name, path| name == project_name }
+      end
+
+      puts matches_two: matches
+      case matches.count
+      when 0
+        name = 'proj'
+        path = File.join(Dir.home, 'proj')
+
+        unless Dir.exist?(path)
+          puts "Error: #{path.inspect} does not exist"
+          exit 1
+        end
+
+        puts "changing dir: #{path}"
+        Dir.chdir(path)
+
+        hiiro.start_tmux_session(name)
+      when 1
+        name, path = matches.first
+
+        puts "changing dir: #{path}"
+        Dir.chdir(path)
+
+        hiiro.start_tmux_session(name)
+      when (2..)
+        puts "ERROR: Multiple matches found"
+        puts
+        puts "Matches:"
+        matches.each { |name, path|
+          puts format("  %s: %s", name, path)
+        }
+      end
+    end
+  end
+
+  def self.attach_methods(hiiro)
+    hiiro.instance_eval do
+      def project_dirs
+        Dir.glob(File.join(Dir.home, 'proj', '*/')).map { |path|
+          [File.basename(path), path]
+        }.to_h
+      end
+
+      def projects_from_config
+        projects_file = File.join(Dir.home, '.config/hiiro', 'projects.yml')
+
+        return {} unless File.exist?(projects_file)
+
+        YAML.safe_load_file(projects_file)
+      end
+    end
+  end
+end