working_set 1.0.1

data/lib/set_builder_adapter.rb

@@ -0,0 +1,2 @@
+module SetBuilderAdapter
+end

data/lib/set_builder_adapter/ag.rb

@@ -0,0 +1,132 @@
+require 'open3'
+
+module SetBuilderAdapter
+  class Ag
+
+    class ParserError < StandardError; end
+
+    class Parser
+      attr_accessor :input, :parsed_items, :current_item
+
+      def initialize(input)
+        self.input = input
+        self.parsed_items = []
+      end
+
+      def parse
+        input.split("\n").each do |line|
+          parse_line line
+        end
+        record_existing_item
+        parsed_items
+      end
+
+      def learn(key, value)
+        self.current_item[key] = value
+      end
+
+      def add(list_key, value)
+        self.current_item[list_key] ||= []
+        self.current_item[list_key].push value
+      end
+
+      def record_existing_item
+        if current_item
+          parsed_items << current_item
+        end
+      end
+
+      def new_item_with_file_path(file_path)
+        record_existing_item
+        self.current_item = { }
+        learn :file_path, file_path
+      end
+
+      def parse_line(line)
+        # A new item is started when the current item has no path, or if the
+        # path for the current result line doesn't match the current item's file
+        # path.
+        if current_item == nil or (line != "--" and line != "" and not line.start_with?(current_item[:file_path]))
+          line =~ /^(.*?):\d/
+          new_item_with_file_path $1
+        end
+
+        # The line can be either a pre or post match for the current item
+        if line =~ /^(.*?):(\d+)-(.*)/
+          if current_item[:match_line]
+            add :post_match_lines, $3
+          else
+            add :pre_match_lines, $3
+          end
+
+        # The line can be the actual match itself
+        elsif line =~ /^(.*?):(\d+):(\d+):(.*)/ # match line
+          if current_item[:match_line]
+            new_item_with_file_path current_item[:file_path]
+          end
+          learn :row, $2
+          learn :column, $3
+          learn :match_line, $4
+
+        # Finally, the item can be the inter-file match separator
+        elsif line =~ /--/
+          new_item_with_file_path current_item[:file_path]
+
+        # Weird exception: a blank line will be ignored.
+        elsif line == ""
+
+        # Otherwise big fat fail.
+        else
+          debug_message "Parse failed for:"
+          debug_message line.inspect
+          raise ParserError.new("parse_line failed for: #{line.inspect}")
+        end
+      end
+
+    end
+
+    def command_bin
+      "ag"
+    end
+
+    def command_options(options)
+      %W(--search-files -C#{$CONTEXT_LINES} --numbers --column --nogroup --literal) + map_external_options(options)
+    end
+
+    def map_external_options(options)
+      [].tap do |ary|
+        ary << "--word-regexp" if options["whole_word"]
+      end
+    end
+
+    def command_parts(search_term, options)
+      [ command_bin, *command_options(options), "--", search_term ]
+    end
+
+    def parse_results(results)
+      debug_message "Ag Results:\n#{results}"
+      Parser.new(results).parse
+    rescue ParserError => e
+      STDERR.puts e
+      raise e
+    end
+
+    def build_working_set(search, options)
+      debug_message "search command: #{command_parts(search, options)}"
+
+      stdout, stderr, status = Open3.capture3(*command_parts(search, options))
+
+      # Ag exits 0 when results found
+      # Ag exits 1 when zero results found
+      # ... It also exits 1 when there's a problem with options.
+      if status.exitstatus == 0 || status.exitstatus == 1
+        WorkingSet.new search, options, parse_results(stdout)
+      else
+        raise "ag command failed: #{stdout} #{stderr}"
+        # raise "ag command failed with status #{$?.exitstatus.inspect}: #{stdout}"
+      end
+
+    end
+
+  end
+end

data/lib/set_viewer_actor.rb

@@ -0,0 +1,146 @@
+class SetViewerActor
+  include BasicActor
+
+  def initialize
+    subscribe "tell_selected_item", :tell_selected_item
+    subscribe "copy_selected_item", :copy_selected_item
+    subscribe "tell_selected_item_content", :tell_selected_item_content
+    subscribe "set_build_finished", :refresh_view
+    subscribe "set_build_failed", :show_error
+    subscribe "scroll_changed", :scroll
+    subscribe "context_lines_changed", :update_context_lines
+    subscribe "refresh", :refresh
+    subscribe "show_match_lines_toggled", :toggle_match_lines
+    subscribe "select_next_file", :select_next_file
+    subscribe "select_prev_file", :select_prev_file
+    subscribe "select_next_item", :select_next_item
+    subscribe "select_prev_item", :select_prev_item
+    subscribe "welcome_user", :welcome_user
+    subscribe "display_help", :display_help
+    subscribe "display_working_set", :display_working_set
+    welcome_user
+  end
+
+  def welcome_user(_=nil)
+    debug_message "displaying welcome_user!"
+    View::WelcomeUser.render
+  end
+
+  def display_help(_)
+    debug_message "displaying help!"
+    View::Help.render
+  end
+
+  def display_working_set(_)
+    debug_message "displaying working_set!"
+    @working_set_view&.render
+  end
+
+  def refresh_view(_, working_set)
+    prev_wsv = @working_set_view
+    @working_set_view = View::WorkingSet.new(working_set)
+    if prev_wsv&.working_set&.search == working_set.search
+      @working_set_view.restore_selection_state(prev_wsv)
+    end
+    @working_set_view.render
+  end
+
+  def items_present?
+    (@working_set_view&.working_set&.items&.size || 0) > 0
+  end
+
+  def scroll(_, delta)
+    return unless items_present?
+    @working_set_view.scroll(delta)
+  end
+
+  def update_context_lines(_, delta)
+    $CONTEXT_LINES += delta
+    $CONTEXT_LINES = 0 if $CONTEXT_LINES < 0
+    debug_message "context lines set to #{$CONTEXT_LINES}"
+    refresh
+  end
+
+  def refresh(_=nil)
+    return unless @working_set_view
+    # triggers search again without changing search term
+    ws = @working_set_view.working_set
+
+    publish "search_changed", ws.search, ws.options
+  end
+
+  def toggle_match_lines(_)
+    return unless items_present?
+    @working_set_view.toggle_match_lines
+  end
+
+  def select_next_file(_)
+    return unless items_present?
+    @working_set_view.select_next_file
+    unless @working_set_view.selected_item_in_view?
+      publish "scroll_changed", @working_set_view.selected_item_scroll_delta
+    end
+  end
+
+  def select_prev_file(_)
+    return unless items_present?
+    @working_set_view.select_prev_file
+    unless @working_set_view.selected_item_in_view?
+      publish "scroll_changed", @working_set_view.selected_item_scroll_delta
+    end
+  end
+
+  def select_next_item(_)
+    return unless items_present?
+    @working_set_view.select_next_item
+    unless @working_set_view.selected_item_in_view?
+      publish "scroll_changed", @working_set_view.selected_item_scroll_delta
+    end
+  end
+
+  def select_prev_item(_)
+    return unless items_present?
+    @working_set_view.select_prev_item
+    unless @working_set_view.selected_item_in_view?
+      publish "scroll_changed", @working_set_view.selected_item_scroll_delta
+    end
+  end
+
+  def tell_selected_item(_)
+    if items_present?
+      item = @working_set_view.selected_item
+      publish "respond_client", "selected_item", {
+        file_path: item.file_path,
+        row: item.row,
+        column: item.column
+      }
+    end
+  end
+
+  def tell_selected_item_content(_)
+    if items_present?
+      item = @working_set_view.selected_item
+      publish "respond_client", "selected_item_content", {
+        data: item.match_line
+      }
+    end
+  end
+
+  def copy_selected_item(_, include_context=false)
+    if items_present?
+      item = @working_set_view.selected_item
+      if include_context
+        Clipboard.copy item.full_body
+      else
+        Clipboard.copy item.match_line
+      end
+    end
+  end
+
+  def show_error(_, error)
+    debug_message error
+    # Ncurses.stdscr.mvaddstr 0, 0, "SetViewerActor#show_error: #{error.backtrace}"
+    # Ncurses.stdscr.refresh
+  end
+
+end

data/lib/user_input_actor.rb

@@ -0,0 +1,177 @@
+class UserInputActor
+  include BasicActor
+
+  finalizer :clean_up
+
+  DEFAULT_SCROLL_STEP = 5
+
+  def self.user_input_mode
+    @user_input_mode
+  end
+
+  def self.prev_user_input_modes
+    @prev_user_input_modes ||= []
+  end
+
+  def self.set_user_input_mode(mode)
+    debug_message "set input mode: #{mode.inspect}"
+    push_mode(mode)
+  end
+
+  def self.push_mode(mode)
+    prev_user_input_modes << @user_input_mode if @user_input_mode
+    @user_input_mode = mode
+  end
+
+  def self.pop_mode
+    @user_input_mode = prev_user_input_modes.pop
+  end
+
+  def user_input_mode
+    self.class.user_input_mode
+  end
+
+  def pop_mode
+    self.class.pop_mode
+  end
+
+  def initialize
+    async.watch_input
+  end
+
+  def watch_input
+
+    # Creating this otherwise unused window so that I can run getch() without
+    # the implicit call to stdscr.refresh that it apparently precipitates.
+    trash_win = Ncurses.newwin(1, 1, 0, 0)
+    trash_win.keypad(true)
+
+    catch(:shutdown) do
+      while(ch = trash_win.getch)
+        debug_message "getch: #{ch}"
+        handle_modal_input(ch)
+      end
+    end
+    debug_message "Caught :shutdown"
+    $supervisor.do_shutdown
+  end
+
+  def handle_modal_input(ch)
+    case user_input_mode
+    when :welcome_user then handle_welcome_user_input(ch)
+    when :help         then handle_help_input(ch)
+    when :working_set  then handle_working_set_input(ch)
+    else
+      debug_message "Uncrecognized mode: #{user_input_mode.inspect}"
+      throw :shutdown
+    end
+  end
+
+  def handle_help_input(ch)
+    case ch
+    when ?q.ord
+      mode = pop_mode
+      case mode
+      when :welcome_user then publish "welcome_user"
+      when :working_set  then publish "display_working_set"
+      else
+        debug_message "Unrecognized mode from pop: #{mode.inspect}"
+        throw :shutdown
+      end
+    else
+      debug_message "Unhandled user input: #{ch}"
+    end
+  end
+
+  def handle_welcome_user_input(ch)
+    case ch
+    when ?q.ord
+      throw :shutdown
+    when ??.ord
+      publish "display_help"
+    else
+      debug_message "Unhandled user input: #{ch}"
+    end
+  end
+
+  USER_INPUT_MAPPINGS = {
+    "?" => {
+      desc: "display help",
+      action: -> { publish "display_help" }
+    },
+    "q" => {
+      desc: "quit",
+      action: -> { throw :shutdown }
+    },
+    "j" => {
+      desc: "select next match",
+      action: -> { publish "select_next_item" }
+    },
+    "k" => {
+      desc: "select previous match",
+      action: -> { publish "select_prev_item" }
+    },
+    14 => {
+      key_desc: "ctrl-n",
+      desc: "select first match in next file",
+      action: -> { publish "select_next_file" }
+    },
+    16 => {
+      key_desc: "ctrl-p",
+      desc: "select first match in previous file",
+      action: -> { publish "select_prev_file" }
+    },
+    13 => {
+      key_desc: "enter",
+      desc: "Tell editor to jump to match",
+      action: -> { publish "tell_selected_item" }
+    },
+    Ncurses::KEY_DOWN => {
+      key_desc: "down arrow",
+      desc: "scroll down without changing selection",
+      action: -> { publish "scroll_changed", DEFAULT_SCROLL_STEP }
+    },
+    Ncurses::KEY_UP => {
+      key_desc: "up arrow",
+      desc: "scroll up without changing selection",
+      action: -> { publish "scroll_changed", DEFAULT_SCROLL_STEP * -1 }
+    },
+    "r" => {
+      desc: "refresh search results",
+      action: -> { publish "refresh" }
+    },
+    "[" => {
+      desc: "decrease context lines",
+      action: -> { publish "context_lines_changed", -1 }
+    },
+    "]" => {
+      desc: "increase context lines",
+      action: -> { publish "context_lines_changed", 1 }
+    },
+    "z" => {
+      desc: "toggle showing match lines vs just matched files",
+      action: -> { publish "show_match_lines_toggled" }
+    },
+    "y" => {
+      desc: "copy selected match to system clipboard",
+      action: -> { publish "copy_selected_item" }
+    },
+    "Y" => {
+      desc: "copy selected match + context to system clipboard",
+      action: -> { publish "copy_selected_item", true }
+    },
+  }
+
+  def handle_working_set_input(ch)
+    mapping = USER_INPUT_MAPPINGS[ch] || USER_INPUT_MAPPINGS[ch.chr]
+    if mapping
+      instance_exec(&mapping[:action])
+    end
+  rescue RangeError # ignore when .chr is out of range.  Just means it's not input we care about anyways.
+  end
+
+  def clean_up
+    debug_message "done user input"
+  end
+
+end