appear 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d114dfa1bdcda18b13325f5d7961b296b09a8b2
-  data.tar.gz: 26fcebb685c8a0adcc5cac80c9bd1a7ce3153eef
+  metadata.gz: 67b9aebb07fd1277e44209ecc142ce4266b2a614
+  data.tar.gz: e234f31f3e772957cf50967eae4ceb633ee1951c
 SHA512:
-  metadata.gz: 12f5f608f578ae6042e987fd20a5082d70c4b8067bfaebaf3e033fcacf66ede064bec3892d1174bf3be16a3168a91b80095ec798354d63f79e067609ab577eef
-  data.tar.gz: 848a59a97371e61417851e9fe8cdf33436d1e4e5ccf9a5d9ec9af0618c091d197babf493c48332ec0f5b975408acda7f0b02513582cf9b929334d74afb345a96
+  metadata.gz: 0caad8654c99c2d4b98fe759fb37ad8919443ce332d638af1459494f3614887336ecaf38550ba733bd4a85558c0672e479e2762d16dd1e0619c6b70d1d5ee2d7
+  data.tar.gz: 3c98564f230a8a7271920b122d583628155411fa76c0e62b2a49efc9fa677b36b8c49f9ba4dcb30f1a2e6f75f65ed372ec08a7ee4521fa0ec87ef55d003274e0

data/.doc-coverage

@@ -1 +1 @@
-80.43
+100.0

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 1.2.0
+
+- new experimental feature: `appear --edit nvim FILES...` to edit files in Nvim inside Tmux
+  inside iTerm2. Support is limited.
+- refactors of many core components:
+  - Tmux service
+  - MacRevealers were split into Terminal services
+- new handy Utils classes in appear/util, including the very handy
+  `Appear::Util::CommandBuilder`, and the slightly less useful
+  `Appear::Util::Memoizer`.
+
 ## 1.1.1
 
 - passing in a PID was broken.

data/README.md

@@ -55,7 +55,7 @@ GNU Screen support is a non-goal. It's time for screen users to switch to tmux.
 
 ## system requirements
 
- - `ruby` >= 2
+ - `ruby` >= 1.9.3
  - `lsof` command
  - `ps` command
  - `pgrep` command

data/bin/appear

@@ -1,6 +1,12 @@
 #!/usr/bin/env ruby
 require 'pathname'
 
+# require pry in development
+begin
+  require 'pry'
+rescue LoadError
+end
+
 begin
   require 'appear/command'
 rescue LoadError

data/lib/appear/command.rb

@@ -1,6 +1,7 @@
 require 'appear/constants'
 require 'appear/config'
 require 'appear/instance'
+require 'appear/editor'
 require 'optparse'
 
 module Appear
@@ -34,6 +35,11 @@ module Appear
           @config.record_runs = flag
         end
 
+        o.on('-e', '--edit [EDITOR]', "instead of revealing a PID, edit a file the given editor. Editors: #{::Appear::Editor::ALL.map {|c| c.name}}") do |flag|
+          @config.edit_file = true
+          @config.editor = flag
+        end
+
         o.on('--version', 'show version information, then exit') do
           puts "appear #{Appear::VERSION}"
           puts "  author: Jake Teton-Landis"
@@ -60,6 +66,16 @@ module Appear
     def execute(all_args)
       argv = option_parser.parse(*all_args)
 
+      if @config.edit_file
+        return execute_edit(argv)
+      else
+        return execute_pid(argv)
+      end
+    end
+
+    private
+
+    def execute_pid(argv)
       if argv.empty?
         pid = Process.pid
         start_message = "STARTING. pid: #{pid} (current process pid)"
@@ -83,5 +99,17 @@ module Appear
         exit 2
       end
     end
+
+    def execute_edit(argv)
+      raise ArgumentError.new("no file passed") if argv.empty?
+
+      revealer = Appear::Instance.new(@config)
+      # this is a sin, for now
+      # TODO: remove instance_variable_get, use a real API
+      services = revealer.instance_variable_get('@all_services')
+      ide = ::Appear::Editor::TmuxIde.new(services)
+      ide.call(*argv)
+    end
+
   end
 end

data/lib/appear/config.rb

@@ -15,10 +15,17 @@ module Appear
     # @return [Boolean] default false
     attr_accessor :record_runs
 
+    # @return [Boolean] default false
+    attr_accessor :edit_file
+
+    # @return [String, nil] default nil
+    attr_accessor :editor
+
     # sets defaults
     def initialize
       self.silent = true
       self.record_runs = false
+      self.edit_file = false
     end
   end
 end

data/lib/appear/constants.rb

@@ -2,14 +2,11 @@ require 'pathname'
 
 module Appear
   # the version of Appear
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 
   # root error for our library; all other errors inherit from this one.
   class Error < StandardError; end
 
-  # we also put common constants in here because it's a good spot.
-  # Should we rename this file to 'appear/constants' ?
-
   # the root of the Appear project directory
   MODULE_DIR = Pathname.new(__FILE__).realpath.join('../../..')
 

data/lib/appear/editor/nvim.rb

@@ -0,0 +1,251 @@
+require 'appear/util/command_builder'
+require 'appear/util/value_class'
+require 'yaml'
+require 'pathname'
+
+module Appear
+  module Editor
+    # Raised if we have problems interacting with Nvim.
+    class NvimError < ::Appear::Error
+      attr_reader :from_err
+      # @param msg [String]
+      # @param from_err [Exception] pass in another error to wrap it in an
+      #   NvimError.
+      def initialize(msg, from_err = nil)
+        super(msg)
+        @from_err = from_err
+      end
+    end
+
+    # Wraps nvim-remote to implement basic nvim support.
+    # @see https://github.com/mhinz/neovim-remote
+    #
+    # I put this in my zshrc:
+    # `export NVIM_LISTEN_ADDRESS="$HOME/.vim/sockets/vim-zsh-$$.sock"`
+    # this opens a seperate nvim socket for each new Zsh shell. You'll still
+    # get nvims trying to open the same socket if you use ctrl-z and fg and
+    # stuff to manage 'em, but overall this solves needing command a bunch of
+    # different things.
+    class Nvim < Service
+      # the `neovim-remote` command name
+      NVR = 'nvr'.freeze
+      # the `nvim` command name
+      NEOVIM = 'nvim'.freeze
+
+      # the value to use for Vim buffers with no name. This is the UI value
+      # that Vim usually shows.
+      NO_NAME = "[No Name]".freeze
+
+      # value class describing a vim pane.
+      class Pane < Util::ValueClass
+        # @return [Fixnum] vim tab number
+        property :tab
+
+        # @return [Fixnum] vim window number
+        property :window
+
+        # @return [Fixnum] vim buffer number
+        property :buffer
+
+        # @return [Hash<Symbol, String>] data about the buffer
+        property :buffer_info
+      end
+
+      delegate :run, :runner
+
+      # This constant maps logical name to a string of filename-modifiers, for
+      # the vim fnamemodify() function. When we collect information about
+      # buffers, we get each of these expansions applied to the buffer name.
+      #
+      # This mapping was copied from the BufExplorer vim plugin.
+      BUFFER_FILENAME_EXPANSIONS = {
+        :name => '',
+        :absolute_path => ':p',
+        :dirname => ':p:h',
+        :relative_path => ':~:.',
+        :relative_dirname => ':~:.:h',
+        :shortname => ':t'
+      }.freeze
+      # order in which we pass these to vim.
+      BUFFER_FILENAME_ORDER = BUFFER_FILENAME_EXPANSIONS.keys.freeze
+
+      # @return [#to_s] path to the unix socket used to talk to Nvim
+      attr_reader :socket
+
+
+      # List all the sockets found in ~/.vim/sockets.
+      # I put this in my zshrc to make this work:
+      # `export NVIM_LISTEN_ADDRESS="$HOME/.vim/sockets/vim-zsh-$$.sock"`
+      # @return [Array<Pathname>]
+      def self.sockets
+        Dir.glob(File.expand_path('~/.vim/sockets/*.sock'))
+      end
+
+      # Spawn a new NVIM instance, then connect to its socket.
+      def self.edit_command(filename)
+        ::Appear::Util::CommandBuilder.new(NEOVIM).args(filename)
+      end
+
+      # @param socket [#to_s] UNIX socket to use to talk to Nvim.
+      def initialize(socket, svc = {})
+        super(svc)
+        @socket = socket
+        @expr_memo = ::Appear::Util::Memoizer.new
+      end
+
+      # evaluate a Vimscript expression
+      #
+      # @param vimstring [String] the expression, eg "fnamemodify('~', ':p')"
+      # @return [Object] expression result, parsed as YAML.
+      def expr(vimstring)
+        @expr_memo.call(vimstring) do
+          parse_output_as_yaml(run(command.flag('remote-expr', vimstring).to_a))
+        end
+      end
+
+      # Perform a Vim command
+      #
+      # @param vimstring [String] the command, eg ":buffers"
+      def cmd(vimstring)
+        run(command.flag('c', vimstring).to_a)
+      end
+
+      # PID of the remote vim session
+      #
+      # @return [Fixnum]
+      def pid
+        expr('getpid()')
+      end
+
+      # Working directory of the remote vim session
+      #
+      # @return [Pathname]
+      def cwd
+        expr('getcwd()')
+      end
+
+      # Get all the Vim panes in all tabs.
+      #
+      # @return [Array<Pane>] data
+      def panes
+        @expr_memo.call(nil, 'panes') do
+          all_buffers = get_buffers
+          all_panes = []
+          get_windows.each_with_index do |wins, tab_idx|
+            wins.each_with_index do |buffer, win_idx|
+              all_panes << Pane.new(
+                # in Vim, tabs and windows start indexing at 1
+                :tab => tab_idx + 1,
+                :window => win_idx + 1,
+                :buffer => buffer,
+                :buffer_info => all_buffers[buffer - 1]
+              )
+            end
+          end
+          all_panes
+        end
+      end
+
+      # Find the buffer for a given filename.
+      #
+      # @param filename [String]
+      # @return [Hash, nil] buffer info, nil if not found
+      def find_buffer(filename)
+        p = File.expand_path(filename)
+        get_buffers.find do |buffer|
+          buffer[:absolute_path] == p
+        end
+      end
+
+      # Find the pane for a given filename.
+      #
+      # @param filename [String]
+      # @return [Pane, nil] nil if not found
+      def find_pane(filename)
+        p = Pathname.new(filename).expand_path.to_s
+        panes.find do |pane|
+          buff = pane.buffer_info
+          buff[:absolute_path] == p
+        end
+      end
+
+      # Open a file in vim, or focus a window editing this file, if it's
+      # already open. Vim has a command a lot like this, but I can't get it to
+      # work in either of [vim,nvim] the way the docs say it should. That's why
+      # it's re-implemented here.
+      #
+      # @param filename [String]
+      def drop(filename)
+        # not using find_buffer because we care about panes; we'll have to open
+        # a new one if one doesn't exist anyways.
+        pane = find_pane(filename)
+
+        if pane
+          reveal_pane(pane)
+          return pane
+        end
+
+        # TODO: consider options other than vsplit
+        # TODO: such as opening in the main window with :edit if the main
+        # window is an empty [NoName] buffer, from a new vim maybe?
+        cmd("vertical split #{filename.shellescape}")
+        find_pane(filename)
+      end
+
+      # Reveal a pane in Nvim
+      #
+      # @param pane [Pane]
+      def reveal_pane(pane)
+        # go to tab
+        cmd("tabnext #{pane.tab}")
+        # go to window
+        cmd("#{pane.window} . wincmd w")
+      end
+
+      # Description of this Neovim socket and session.
+      # @return [String]
+      def to_s
+        "#<#{self.class.name}:0x#{'%x' % (object_id << 1)} in #{cwd.inspect}>"
+      end
+
+      private
+
+      def command
+        ::Appear::Util::CommandBuilder.new(NVR).flags(:servername => @socket.to_s)
+      end
+
+      # Vimscript return values look vaguely like YAML, so parse them with
+      # YAML.
+      # @param output [String]
+      def parse_output_as_yaml(output)
+        begin
+          return YAML.load(output)
+        rescue => err
+          raise NvimError.new(output, err)
+        end
+      end
+
+      def get_windows
+        expr(%Q[map( range(1, tabpagenr('$')), "tabpagebuflist(v:val)" )])
+      end
+
+      def get_buffers
+        cmd = BUFFER_FILENAME_ORDER.map do |type|
+          "fnamemodify(bufname(v:val), '#{BUFFER_FILENAME_EXPANSIONS[type]}')"
+        end.join(', ')
+
+        as_a = expr(%Q(map( range(1, bufnr('$')), "[v:val, #{cmd} ]" )))
+        as_a.map do |row|
+          row = row.dup
+          buf = {:buffer => row.shift}
+          row.each_with_index do |it, i|
+            buf[BUFFER_FILENAME_ORDER[i]] = it
+          end
+          buf[:name] = NO_NAME if buf[:name].empty?
+          buf
+        end
+      end
+
+    end
+  end
+end

data/lib/appear/editor.rb

@@ -0,0 +1,262 @@
+require 'appear/util/command_builder'
+require 'appear/util/join'
+
+module Appear
+  # Appear::Editor is a sub-library of Appear, for appearing files, instead of
+  # processes. Appear::Editor's job is to open a given file in an existing
+  # editor session, or start a new session editing that file.
+  #
+  # Appear::Editor should feature drivers for many editors in the future, but
+  # for now only drives Neovim via [neovim-remote][nvr]. We should also support
+  # treating `tmux` as an editor, and launching tmux sessions and creating
+  # windows and splits as such.
+  #
+  # @example define my editor
+  #
+  # [nvr]: https://github.com/mhinz/neovim-remote
+  module Editor
+    # TmuxIde is an editor that treasts a collection of Tmux splits holding an
+    # Nvim process as an IDE. A "session" is a Tmux window that at least
+    # contains an Nvim instance, although new sessions are split like this:
+    # -------------
+    # |           |
+    # |   nvim    |
+    # |           |
+    # |-----------|
+    # |$    |$    |
+    # |     |     |
+    # |-----------|
+    class TmuxIde < Service
+
+      require_service :revealer
+      require_service :processes
+      require_service :tmux
+      require_service :runner # needed for sub-services
+      require_service :lsof # needed for sub-services
+      require_service :terminals
+
+      def initialize(svcs = {})
+        super(svcs)
+        @tmux_memo = ::Appear::Util::Memoizer.new
+      end
+
+      # Check if a child path is contained by a parent path.
+      # @param parent [String]
+      # @param child [String]
+      # @return [Boolean]
+      #
+      # as dumb as they come
+      # TODO: use a real path_contains algorithm.
+      def path_contains?(parent, child)
+        p, c = Pathname.new(parent), Pathname.new(child)
+        c.expand_path.to_s.start_with?(p.expand_path.to_s)
+      end
+
+      # Find the appropriate Nvim session for a given filename. First, we try
+      # to find a session actually editing this file. If none exists, we find
+      # the session with the deepest CWD that contains the filename.
+      #
+      # @param filename [String]
+      # @return [::Appear::Editor::Nvim, nil]
+      def find_nvim_for_file(filename)
+        update_nvims
+        cwd_to_nvim = {}
+
+        @nvims.each do |_, nvim|
+          return nvim if nvim.find_buffer(filename)
+        end
+
+        match = @cwd_by_depth.find { |cwd| path_contains?(cwd, filename) }
+        return nil unless match
+        @cwd_to_nvim[match]
+      end
+
+      # find the tmux pane holding an nvim editor instance.
+      #
+      # @param nvim [Appear::Editor::Nvim]
+      # @return [Appear::Tmux::Pane, nil] the pane, or nil if not found
+      def find_tmux_pane(nvim)
+        @tmux_memo.call(nvim) do
+          tree = services.processes.process_tree(nvim.pid)
+          tmux_server = tree.find { |p| p.name == 'tmux' }
+          next nil unless tmux_server
+
+          # the first join should be the tmux pane holding our
+          # nvim session.
+          proc_and_panes = Util::Join.join(:pid, services.tmux.panes, tree)
+          pane_join = proc_and_panes.first
+          next nil unless pane_join
+
+          # new method on join: let's you get an underlying
+          # object out of the join if it matches a predicate.
+          next pane_join.unjoin do |o|
+            o.is_a? ::Appear::Tmux::Pane
+          end
+        end
+      end
+
+      # Find or create an IDE, then open this file in it.
+      #
+      # @param filename [String]
+      def find_or_create_ide(filename)
+        nvim = find_nvim_for_file(filename)
+        return nvim, find_tmux_pane(nvim) unless nvim.nil?
+        create_ide(filename)
+      end
+
+      # Create a new IDE instance editing `filename`
+      #
+      # @param filename [String]
+      def create_ide(filename)
+        dir = project_root(filename)
+
+        # find or create session
+        tmux_session = services.tmux.sessions.sort_by { |s| s.windows.length }.last
+        tmux_session ||= services.tmux.new_session(
+          # -c: current directory
+          :c => dir
+        )
+
+        # find or create window
+        window = tmux_session.windows.find do |win|
+          win.panes.first.current_path == dir
+        end
+
+        window ||= tmux_session.new_window(
+          # -c: current directory
+          :c => dir,
+          # -d: do not focus
+          :d => true,
+        )
+
+        # remember our pid list
+        existing_nvims = services.processes.pgrep(Nvim::NEOVIM)
+
+        # split window across the middle, into a big and little pane
+        main = window.panes.first
+        main.send_keys([Nvim.edit_command(filename).to_s, "\n"], :l => true)
+        left = main.split(:p => 30, :v => true, :c => dir)
+        # cut the smaller bottom pane in half
+        right = left.split(:p => 50, :h => true, :c => dir)
+        # put a vim in the top pane, and select it
+        #[left, right].each_with_index do |pane, idx|
+          #pane.send_keys(["bottom pane ##{idx}"], :l => true)
+        #end
+
+        # Hacky way to wait for nvim to launch! This should take at most 2
+        # seconds, otherwise your vim is launching too slowley ;)
+        wait_until(2) { (services.processes.pgrep(Nvim::NEOVIM) - existing_nvims).length >= 1 }
+
+        nvim = find_nvim_for_file(filename)
+        return nvim, find_tmux_pane(nvim)
+      end
+
+      def wait_until(max_duration, sleep = 0.1)
+        raise ArgumentError.new("no block given") unless block_given?
+        start = Time.new
+        limit = start + max_duration
+        iters = 0
+        while Time.new < limit
+          if yield
+            log("wait_until(max_duration=#{max_duration}, sleep=#{sleep}) slept #{iters} times, took #{Time.new - start}s")
+            return true
+          end
+          iters = iters + 1
+          sleep(sleep)
+        end
+        false
+      end
+
+      # reveal files in an existing or new IDE session
+      #
+      # @param filenames [Array<String>]
+      def call(*filenames)
+        nvims = []
+        nvim_to_session = {}
+
+        filenames.each do |filename|
+          filename = File.expand_path(filename)
+          nvim, pane = find_or_create_ide(filename)
+          # focuses the file in the nvim instance, or start editing it.
+          Thread.new { nvim.drop(filename) }
+          nvims << nvim unless nvims.include?(nvim)
+          nvim_to_session[nvim] = pane.session
+        end
+
+        nvims.map do |nvim|
+          Thread.new do
+            # go ahead and reveal our nvim
+            next true if services.revealer.call(nvim.pid)
+
+            session = nvim_to_session[nvim]
+            # if we didn't return, we need to create a Tmux client for our
+            # session.
+            command = services.tmux.attach_session_command(session)
+            terminal = services.terminals.get
+            term_pane = terminal.new_window(command.to_s)
+            terminal.reveal_pane(term_pane)
+          end
+        end.each(&:join)
+
+        log "#{self.class}: finito."
+      end
+
+      # Guess the project root for a given path by inspecting its parent
+      # directories for certain markers like git roots.
+      #
+      # @param filename [String]
+      # @return [String] some path
+      def project_root(filename)
+        # TODO: a real constant? Some internet-provided list?
+        # these are files that indicate the root of a project
+        markers = %w(.git .hg Gemfile package.json setup.py README README.md)
+        p = Pathname.new(filename).expand_path
+        p.ascend do |path|
+          is_root = markers.any? do |marker|
+            path.join(marker).exist?
+          end
+
+          return path if is_root
+        end
+
+        # no markers were found
+        return p.to_s if p.directory?
+        return p.dirname.to_s
+      end
+
+      private
+
+      # creates a cached mapping of Nvim-related information for maximum lookup
+      # speed.
+      def update_nvims
+        @nvims ||= {}
+        @nvim_to_cwd ||= {}
+        @cwd_to_nvim ||= {}
+        new_nvims = false
+
+        Nvim.sockets.each do |sock|
+          next if @nvims[sock]
+
+          new_nvims = true
+          nvim = Nvim.new(sock, services)
+          @nvims[sock] = nvim
+          cwd = nvim.cwd
+          @nvim_to_cwd[nvim] = cwd
+          @cwd_to_nvim[cwd] = nvim
+        end
+
+        if new_nvims
+          @cwd_by_depth = @cwd_to_nvim.keys.sort_by { |d| Pathname.new(d).each_filename.to_a.length }
+        end
+      end
+
+    end
+
+    # List of all editors. In the future, we should provide more editor support
+    # and extend this list, and then allow the user to choose the editor to
+    # Appear in.
+    ALL = [TmuxIde]
+  end
+end
+
+require 'appear/editor/nvim'

data/lib/appear/instance.rb

@@ -32,6 +32,10 @@ module Appear
       @all_services[:lsof] = Appear::Lsof.new(@all_services)
       @all_services[:mac_os] = Appear::MacOs.new(@all_services)
       @all_services[:tmux] = Appear::Tmux.new(@all_services)
+      @all_services[:terminals] = Appear::Terminals.new([
+        Appear::Terminal::Iterm2.new(@all_services),
+        Appear::Terminal::TerminalApp.new(@all_services),
+      ])
 
       # make sure we can use our processes service, and log stuff.
       super(@all_services)