fatty 0.99.0

data/lib/fatty/help.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# require "redcarpet"
+# require_relative "ansi_renderer"
+
+# module Fatty
+#   module Help
+#     def self.path
+#       File.expand_path("config_files/help.md", __dir__)
+#     end
+
+#     def self.render(width: 80)
+#       renderer = Fatty::AnsiRenderer.new(width: width)
+#       markdown = Redcarpet::Markdown.new(
+#         renderer,
+#         tables: true,
+#         fenced_code_blocks: true,
+#         autolink: true,
+#       )
+#       markdown.render(text)
+#     end
+
+#     def self.text
+#       File.read(path)
+#     end
+#   end
+# end
+
+# frozen_string_literal: true
+
+module Fatty
+  module Help
+    def self.path
+      File.expand_path("config_files/help.md", __dir__)
+    end
+
+    def self.text
+      File.read(path)
+    end
+  end
+end

data/lib/fatty/history/entry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Fatty
+  class History
+    class Entry
+      attr_reader :text, :kind, :ctx, :stamp
+
+      def initialize(text:, kind: :command, ctx: nil, stamp: nil)
+        @text  = text.to_s
+        @kind  = kind.to_sym
+        @ctx   = normalize_ctx(ctx)
+        @stamp = stamp || Time.now
+      end
+
+      def to_h
+        {
+          "text" => text,
+          "kind" => kind.to_s,
+          "ctx" => ctx,
+          "stamp" => stamp.iso8601
+        }
+      end
+
+      def command?
+        kind == :command
+      end
+
+      def search?
+        kind == :search_string || kind == :search_regex
+      end
+
+      def ctx_fetch(key, default = nil)
+        ctx.fetch(key.to_s, default)
+      end
+
+      def self.from_h(hash)
+        hash = hash.transform_keys(&:to_s)
+
+        new(
+          text:  hash.fetch("text", ""),
+          kind:  hash.fetch("kind", "command").to_sym,
+          ctx:   History.normalize_ctx(hash["ctx"]),
+          stamp: parse_stamp(hash["stamp"]),
+        )
+      end
+
+      def self.parse_stamp(value)
+        case value
+        when Time
+          value
+        when String
+          Time.iso8601(value)
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      private_class_method :parse_stamp
+
+      private
+
+      def normalize_ctx(value)
+        return {} unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, val), out|
+          out[key.to_s] = val
+        end
+      end
+    end
+  end
+end

data/lib/fatty/history.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require_relative "history/entry"
+
+module Fatty
+  class History
+    DEFAULT_HISTORY_FILE = File.expand_path("~/.fatty_history")
+    DEFAULT_HISTORY_MAX = 10_000
+
+    attr_reader :entries
+
+    def initialize(path: nil, max: nil)
+      @path =
+        case path
+        when :default
+          Config.config.dig(:history, :file) || DEFAULT_HISTORY_FILE
+        when nil, false
+          nil
+        else
+          path
+        end
+      @path = File.expand_path(@path) if @path
+      @max = max&.to_i || Config.config.dig(:history, :max)&.to_i || DEFAULT_HISTORY_MAX
+      @entries = []
+      @cursors = {}
+
+      if @path
+        Fatty.info("History loaded from #{@path}")
+        load
+      else
+        Fatty.info("In-memory History only: no path")
+      end
+    end
+
+    # A global default History object available to all sessions.  Sets a class
+    # instance variable.
+    def self.default
+      for_path(:default)
+    end
+
+    def self.for_path(path = :default)
+      @instances ||= {}
+      @instances[path] ||= new(path: path)
+    end
+
+    def self.reset_instances!
+      @instances = {}
+    end
+
+    def self.default
+      for_path(:default)
+    end
+
+    ###################################################################################
+    # Accessing History items from a consuming application
+    ###################################################################################
+
+    include Enumerable
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      @entries.each(&block)
+    end
+
+    def for(kind: nil, ctx: nil)
+      return enum_for(:for, kind: kind, ctx: ctx) unless block_given?
+
+      each do |entry|
+        next if kind && entry.kind != kind.to_sym
+        next if ctx && !ctx_match?(entry, ctx)
+
+        yield entry
+      end
+    end
+
+    def recent(kind: nil, ctx: nil, limit: nil)
+      rows = self.for(kind: kind, ctx: ctx).to_a
+      rows = rows.last(limit) if limit
+      rows.reverse
+    end
+
+    ###################################################################################
+    # Manipulating History
+    ###################################################################################
+
+    def add(text, kind: :command, ctx: nil, stamp: nil, persist: true)
+      text = text.to_s
+      return if text.strip.empty?
+
+      kind = kind.to_sym
+      ctx = normalize_ctx(ctx)
+      entry = Entry.new(text: text, kind: kind, ctx: ctx, stamp: stamp)
+
+      @entries.reject! do |old_entry|
+        old_entry.text == text &&
+          old_entry.kind == kind &&
+          old_entry.ctx == ctx
+      end
+
+      @entries << entry
+      truncate!
+      append_to_file(entry) if persist
+      reset_cursor_for(kind, ctx: ctx)
+      text
+    end
+
+    def previous(current)
+      previous_for(:command, current: current)
+    end
+
+    def next
+      next_for(:command)
+    end
+
+    def reset_cursor
+      reset_cursor_for(:command)
+    end
+
+    def previous_for(*kinds, current:, ctx: nil)
+      ctx = normalize_ctx(ctx)
+      cursor = cursor_for(*kinds, ctx: ctx)
+      prefix = cursor[:prefix]
+
+      if cursor[:index].nil?
+        cursor[:scratch] = current.to_s
+        cursor[:prefix] = current.to_s
+        prefix = cursor[:prefix]
+      end
+
+      the_entries = entries_for(*kinds, ctx: ctx, prefix: prefix)
+      return current.to_s if the_entries.empty?
+
+      if cursor[:index].nil?
+        cursor[:index] = the_entries.length - 1
+        return the_entries[cursor[:index]].text
+      end
+
+      cursor[:index] -= 1 if cursor[:index].positive?
+      the_entries[cursor[:index]].text
+    end
+
+    def next_for(*kinds, ctx: nil)
+      ctx = normalize_ctx(ctx)
+      cursor = cursor_for(*kinds, ctx: ctx)
+      the_entries = entries_for(*kinds, ctx: ctx, prefix: cursor[:prefix])
+      return "" if the_entries.empty? || cursor[:index].nil?
+
+      if cursor[:index] < the_entries.length - 1
+        cursor[:index] += 1
+        the_entries[cursor[:index]].text
+      else
+        scratch = cursor[:scratch]
+        reset_cursor_for(*kinds, ctx: ctx)
+        scratch || ""
+      end
+    end
+
+    def reset_cursor_for(*kinds, ctx: nil)
+      ctx = normalize_ctx(ctx)
+      cursor = cursor_for(*kinds, ctx: ctx)
+      cursor[:index] = nil
+      cursor[:prefix] = nil
+      cursor[:scratch] = nil
+    end
+
+    def suggest_for(*kinds, prefix:, ctx: nil)
+      text = prefix.to_s
+      return if text.empty?
+
+      wanted_ctx = normalize_ctx(ctx)
+
+      unless wanted_ctx.empty?
+        local = entries_for(*kinds, ctx: wanted_ctx, prefix: text)
+        return local.last.text unless local.empty?
+      end
+
+      global = entries_for(*kinds, prefix: text)
+      global.last&.text
+    end
+
+    def self.normalize_ctx(ctx)
+      return {} unless ctx.is_a?(Hash)
+
+      ctx.each_with_object({}) { |(key, value), memo|
+        memo[key.to_s] = value
+      }.sort.to_h
+    end
+
+    private
+
+    def normalize_kinds(*kinds)
+      kinds.flatten.map(&:to_sym).uniq.sort
+    end
+
+    def normalize_ctx(ctx)
+      self.class.normalize_ctx(ctx)
+    end
+
+    def ctx_match?(entry, ctx)
+      wanted = normalize_ctx(ctx)
+      return true if wanted.empty?
+
+      wanted.all? do |key, value|
+        entry.ctx_fetch(key) == value
+      end
+    end
+
+    def cursor_for(*kinds, ctx: nil)
+      ctx = normalize_ctx(ctx)
+      key = [normalize_kinds(*kinds), normalize_ctx(ctx)]
+      @cursors[key] ||= { index: nil, scratch: nil, prefix: nil }
+    end
+
+    def prefix_match?(entry, prefix)
+      text = prefix.to_s
+      return true if text.empty?
+
+      entry.text.start_with?(text)
+    end
+
+    def entries_for(*kinds, ctx: nil, prefix: nil)
+      ctx = normalize_ctx(ctx)
+      wanted = normalize_kinds(*kinds)
+
+      matches = select do |entry|
+        wanted.include?(entry.kind) && prefix_match?(entry, prefix)
+      end
+
+      fallback, preferred = matches.partition { |entry| !ctx_match?(entry, ctx) }
+      fallback + preferred
+    end
+
+    def load
+      @entries.clear
+      @cursors.clear
+      return unless File.exist?(@path)
+
+      File.foreach(@path) do |line|
+        line = line.chomp
+        next if line.empty?
+
+        entry = parse_history_line(line)
+        next unless entry
+
+        add(
+          entry.text,
+          kind: entry.kind,
+          ctx: entry.ctx,
+          stamp: entry.stamp,
+          persist: false,
+        )
+      end
+      truncate!
+    end
+
+    def parse_history_line(line)
+      hash = JSON.parse(line)
+      Entry.from_h(hash)
+    rescue JSON::ParserError
+      Entry.new(text: line, kind: :command)
+    rescue StandardError
+      nil
+    end
+
+    def append_to_file(entry)
+      return unless @path
+
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+      File.open(@path, "a") do |f|
+        f.puts(JSON.generate(entry.to_h))
+        f.flush
+        f.fsync
+      end
+    rescue => e
+      Fatty.error("History#append_to_file failed for #{@path}: #{e.class}: #{e.message}", tag: :history)
+    end
+
+    def truncate!
+      excess = @entries.length - @max
+      return if excess <= 0
+
+      @entries.shift(excess)
+      @cursors.clear
+    end
+  end
+end