tmux-ruby 0.0.2

data/lib/tmux/server.rb

@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+module Tmux
+  class Server
+    include Comparable
+
+    # Creates a new session
+    #
+    # @option args [Boolean] :attach (false) Attach to the new session?
+    # @option args [String] :name (nil) Name of the new session. Will
+    #   be automatically generated of nil.
+    # @option args [String] :window_name (nil) Name of the initial
+    #   window. Cannot be used when grouping sessions.
+    # @option args [Session] :group_with (nil) Group with this
+    #   session, sharing all windows.
+    # @option args [String] :command (nil) Execute this command in the
+    #   initial window. Cannot be used when grouping sessions.
+    #
+    # @return [Session, nil] Returns the new {Session session} if a
+    #   `:name` has been given and if `:attach` is false
+    #
+    # @raise [ArgumentError] if combining `:group_with` and `:window_name`
+    #   or :command
+    #
+    # @tmuxver >=1.4
+    def create_session(args = {})
+      check_for_version!("1.4")
+
+      if args[:group_with] && (args[:window_name] || args[:command])
+        raise ArgumentError, "Cannot combine :group_with and :window_name or :command"
+      end
+
+      # FIXME shell escape names
+      flags = []
+      flags << "-d" unless args[:attach]
+      flags << "-n '#{args[:window_name]}'"     if args[:window_name]
+      flags << "-s '#{args[:name]}'"            if args[:name]
+      flags << "-t '#{args[:group_with].name}'" if args[:group_with]
+      flags << args[:command]                   if args[:command]
+
+      command = "new-session #{flags.join(" ")}"
+
+      ret = invoke_command(command, true)
+      if ret.start_with?("duplicate session:")
+        raise RuntimeError, ret
+      elsif ret.start_with?("sessions should be nested with care.")
+        raise Exception::InTmux("new-session")
+      else
+        if args[:name] and !args[:attach]
+          return Session.new(self, args[:name])
+        end
+      end
+    end
+
+    # @return  [String]
+    attr_reader :socket
+    # @return [OptionsList]
+    attr_reader :options
+    # @param [String] socket A socket *name*.
+    def initialize(socket = "default")
+      @socket = socket
+      @options = OptionsList.new(:server, self, false)
+    end
+
+    # @return [-1, 0, 1]
+    def <=>(other)
+      return nil unless other.is_a?(Server)
+      @socket <=> other.socket
+    end
+
+    # @return [Server] Returns self. This is useful for other classes
+    #   which can operate on Server, {Session}, {Window}, {Pane} and so
+    #   on
+    attr_reader :server
+    undef_method "server"
+    def server
+      self
+    end
+
+    # Invokes a tmux command.
+    #
+    # @param [String] command The command to invoke
+    # @return [void]
+    def invoke_command(command, unset_tmux = false)
+      Tmux.invoke_command("-L #@socket #{command}", unset_tmux)
+    end
+
+    # Kills a server and thus all {Session sessions}, {Window windows} and {Client clients}.
+    #
+    # @tmux kill-server
+    # @return [void]
+    def kill
+      invoke_command "kill-server"
+    end
+
+    # Sources a file, that is load and evaluate it in tmux.
+    #
+    # @param [String] file Name of the file to source
+    # @tmux source-file
+    # @return [void]
+    def source_file(file)
+      invoke_command "source-file #{file}"
+    end
+    alias_method :load, :source_file
+
+    # @tmux list-sessions
+    # @param [Hash] search Filters the resulting hash using {FilterableHash#filter}
+    # @return [Hash] A hash with information for all sessions
+    def sessions_information(search = {})
+      hash = {}
+      output = invoke_command "list-sessions"
+      output.each_line do |session|
+        params = session.match(/^(?<name>\w+?): (?<num_windows>\d+) windows \(created (?<creation_time>.+?)\) \[(?<width>\d+)x(?<height>\d+)\](?: \((?<attached>attached)\))?$/)
+
+        name          = params[:name]
+        num_windows   = params[:num_windows].to_i
+        creation_time = Date.parse(params[:creation_time])
+        width         = params[:width].to_i
+        height        = params[:height].to_i
+        attached      = !!params[:attached]
+
+        hash[name] = {
+          :name          => name,
+          :num_windows   => num_windows,
+          :creation_time => creation_time,
+          :width         => width,
+          :height        => height,
+          :attached      => attached,
+        }
+      end
+      hash.extend FilterableHash
+      hash.filter(search)
+    end
+
+    # @tmux list-sessions
+    # @return [Array<Session>] All {Session sessions}
+    attr_reader :sessions
+    undef_method "sessions"
+    def sessions(search = {})
+      sessions_information(search).map do |name, information|
+        Session.new(self, name)
+      end
+    end
+
+    # @return [Session] The first {Session session}. This is
+    #   especially useful if working with a server that only has one
+    #   {Session session}.
+    attr_reader :session
+    undef_method "session"
+    def session
+      sessions.first
+    end
+
+    # @tmux list-clients
+    # @param [Hash] search Filters the resulting hash using {FilterableHash#filter}
+    # @return [Hash] A hash with information for all clients
+    def clients_information(search = {})
+      clients = invoke_command "list-clients"
+      hash = {}
+      clients.each_line do |client|
+        params  = client.match(/^(?<device>.+?): (?<session>\d+) \[(?<width>\d+)x(?<height>\d+) (?<term>.+?)\](?: \((?<utf8>utf8)\))?$/)
+        device  = params[:device]
+        session = sessions[params[:session].to_i]
+        width   = params[:width].to_i
+        height  = params[:height].to_i
+        term    = params[:term]
+        utf8    = !!params[:utf8]
+
+        hash[device] = {
+          :device => device,
+          :session => session,
+          :width => width,
+          :height => height,
+          :term => term,
+          :utf8 => utf8,
+        }
+      end
+      hash.extend FilterableHash
+      hash.filter(search)
+    end
+
+    # @tmux list-clients
+    # @return [Array<Client>]
+    attr_reader :clients
+    undef_method "clients"
+    def clients(search = {})
+      clients_information(search).map { |device, information|
+        Client.new(self, device)
+      }
+    end
+
+    # @tmux server-info
+    # @return [String] Information about the server
+    attr_reader :info
+    undef_method "info"
+    def info
+      invoke_command "server-info"
+    end
+
+    # @return [String] Version of the tmux server
+    attr_reader :version
+    undef_method "version"
+    def version
+      @version ||= info.lines.first.split(",").first[/([.\d]+)/]
+    end
+
+    # Checks if a version requirement is being met
+    #
+    # @param [String] required The version at least required
+    # @raise [Exception::UnsupportedVersion] Raised if a version requirement isn't met
+    # @return [void]
+    def check_for_version!(required)
+      if required > version
+        raise Exception::UnsupportedVersion, required
+      end
+    end
+  end
+end

data/lib/tmux/session.rb

@@ -0,0 +1,312 @@
+module Tmux
+  # A session is a single collection of pseudo terminals under the
+  # management of {Tmux tmux}. Each session has one or more {Window
+  # windows} linked to it. A {Window window} occupies the entire
+  # screen and may be split into rectangular {Pane panes}, each of
+  # which is a separate pseudo terminal (the pty(4) manual page
+  # documents the technical details of pseudo terminals). Any number
+  # of tmux instances may connect to the same session, and any number
+  # of {Window windows} may be present in the same session. Once all
+  # sessions are {Session#kill killed}, tmux exits.
+  class Session
+    include Comparable
+
+    # @return [Options]
+    def self.options(session)
+      OptionsList.new(:session, session, true)
+    end
+
+    # Creates a new {Window window}.
+    #
+    # @option args [Boolean] :after_number (false) If true, the new
+    #   {Window window} will be inserted at the next index up from the
+    #   specified number (or the {Client#current_window current}
+    #   {Window window}), moving {Window windows} up if necessary
+    # @option args [Boolean] :kill_existing (false) Kill an existing
+    #   {Window window} if it conflicts with a desired number
+    # @option args [Boolean] :make_active (true) Switch to the newly
+    #   generated {Window window}
+    # @option args [String] :name Name of the new {Window window}
+    #   (optional)
+    # @option args [Number] :number Number of the new {Window window}
+    #   (optional)
+    # @option args [String] :command Command to run in the new {Window
+    #   window} (optional)
+    #
+    # @tmux new-window
+    # @return [Window] The newly created {Window window}
+    def create_window(args = {})
+      args = {
+        :kill_existing => false,
+        :make_active   => true,
+        :after_number  => false,
+      }.merge(args)
+
+      flags = []
+      # flags << "-d" unless args[:make_active]
+      flags << "-a" if args[:after_number]
+      flags << "-k" if args[:kill_existing]
+      flags << "-n '#{args[:name]}'" if args[:name] # FIXME escaping
+      flags << "-t #{args[:number]}" if args[:number]
+      flags << args[:command] if args[:command]
+
+      @server.invoke_command "new-window #{flags.join(" ")}"
+      new_window = current_window
+      unless args[:make_active]
+        select_last_window
+      end
+      # return Window.new(self, num)
+      return new_window
+    end
+
+    # @see Client#current_window
+    # @return (see Client#current_window)
+    attr_reader :current_window
+    undef_method "current_window"
+    def current_window
+      any_client.current_window
+    end
+
+    # @see Client#current_pane
+    # @return (see Client#current_pane)
+    attr_reader :current_pane
+    undef_method "current_pane"
+    def current_pane
+      any_client.current_pane
+    end
+
+    # Returns a {Client client} that is displaying the session.
+    #
+    # @return [Client, nil] A {Client client} that is displaying the session.
+    def any_client
+      @server.clients({:session => self}).first
+    end
+
+    # @return [Boolean]
+    def ==(other)
+      self.class == other.class && @server == other.server && @name == other.name
+    end
+
+    # @return [Number]
+    def hash
+      [@server.hash, @number].hash
+    end
+
+    # @return [Boolean]
+    def eql?(other)
+      self == other
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Session)
+      [@server, @name] <=> [other.server, other.name]
+    end
+
+    # @overload name
+    #   @return [String]
+    # @overload name=(new_name)
+    #   Renames the session.
+    #
+    #   @todo escape name
+    #   @return [String]
+    #   @tmux rename-session
+    # @return [String]
+    attr_accessor :name
+    undef_method "name="
+    # @return [Server]
+    attr_reader :server
+    # @return [OptionsList]
+    attr_reader :options
+    # @return [StatusBar]
+    attr_reader :status_bar
+    def initialize(server, name)
+      @server, @name = server, name
+      @status_bar = StatusBar.new(self)
+      @options = OptionsList.new(:session, self, false)
+    end
+
+    def name=(new_name)
+      raise ArgumentError if new_name.to_s.strip.empty?
+      ret = @server.invoke_command("rename-session -t #{identifier} '#{new_name}'")
+
+      if ret.start_with?("duplicate session:")
+        raise RuntimeError, ret
+      end
+
+      @name = new_name
+    end
+
+    # @return [String]
+    attr_reader :identifier
+    undef_method "identifier"
+    def identifier
+      @name
+    end
+
+    # Locks the session.
+    #
+    # @tmux lock-session
+    # @return [void]
+    # @tmuxver &gt;=1.1
+    def lock
+      @server.check_for_version!("1.1")
+
+      @server.invoke_command "lock-session -t #{identifier}"
+    end
+
+    # @return [Integer]
+    attr_reader :num_windows
+    undef_method "num_windows"
+    def num_windows
+      @server.sessions_information[@name][:num_windows]
+    end
+
+    # @return [Time]
+    attr_reader :creation_time
+    undef_method "creation_time"
+    def creation_time
+      @server.sessions_information[@name][:creation_time]
+    end
+    alias_method :created_at, :creation_time
+
+    # @return [Integer]
+    attr_reader :width
+    undef_method "width"
+    def width
+      @server.sessions_information[@name][:width]
+    end
+
+    # @return [Integer]
+    attr_reader :height
+    undef_method "height"
+    def height
+      @server.sessions_information[@name][:height]
+    end
+
+    # @return [Boolean]
+    attr_reader :attached
+    undef_method "attached"
+    def attached
+      @server.sessions_information[@name][:attached]
+    end
+    alias_method :attached?, :attached
+
+    # @return [Array<Client>] All {Client clients}
+    attr_reader :clients
+    undef_method "clients"
+    def clients
+      @server.clients({:session => self})
+    end
+
+    # Attach to a session. Replaces the ruby process.
+    #
+    # @return [void]
+    # @tmux attach
+    def attach
+      exec "#{Tmux::BINARY} attach -t #{identifier}"
+    end
+
+    # Kills the session.
+    #
+    # @tmux kill-session
+    # @return [void]
+    def kill
+      @server.invoke_command "kill-session -t #{identifier}"
+    end
+
+    # @tmux list-windows
+    # @tmuxver &gt;=1.1
+    # @param [Hash] search Filters the resulting hash using {FilterableHash#filter}
+    # @return [Hash] A hash with information for all windows
+    # @return [Hash]
+    def windows_information(search = {})
+      @server.check_for_version!("1.1")
+
+      hash = {}
+      output = @server.invoke_command "list-windows -t #{identifier}"
+      output.each_line do |session|
+        params = session.match(/^(?<num>\d+): (?<name>.+?) \[(?<width>\d+)x(?<height>\d+)\]$/)
+        next if params.nil? # >=1.3 displays layout information in indented lines
+        num    = params[:num].to_i
+        name   = params[:name]
+        width  = params[:width].to_i
+        height = params[:height].to_i
+
+        hash[num] = {:num => num, :name => name, :width => width, :height => height}
+      end
+      hash.extend FilterableHash
+      hash.filter(search)
+    end
+
+    # @tmux list-windows
+    # @return [Hash{Number => Window}] All {Window windows}
+    # @tmuxver &gt;=1.1
+    attr_reader :windows
+    undef_method "windows"
+    def windows
+      hash = {}
+      @server.check_for_version!("1.1")
+
+      windows_information.each do |num, information|
+        hash[num] = Window.new(self, num)
+      end
+      hash
+    end
+
+    # @param [Hash] search Filters the resulting hash using {FilterableHash#filter}
+    # @return [Hash] A hash with information for all buffers
+    # @tmux list-buffers
+    def buffers_information(search = {})
+      hash = {}
+      buffers = @server.invoke_command "list-buffers -t #{identifier}"
+      buffers.each_line do |buffer|
+        num, size = buffer.match(/^(\d+): (\d+) bytes/)[1..2]
+        hash[num] = {:size => size}
+      end
+      hash.extend FilterableHash
+      hash.filter(search)
+    end
+
+    # @tmux list-buffers
+    # @return [Array<Buffer>] All {Buffer buffers}
+    attr_reader :buffers
+    undef_method "buffers"
+    def buffers
+      buffers_information.map do |num, information|
+        Buffer.new(num, self)
+      end
+    end
+
+    # @group Selecting
+
+    # Select the last (previously selected) window.
+    #
+    # @return [Window]
+    def select_last_window
+      @server.invoke_command "last-window -t #{identifier}"
+      current_window
+    end
+
+    # Selects the next (higher index) window
+    #
+    # @param [Number] num How many windows to move
+    # @tmuxver &gt;=1.3
+    # @return [Window]
+    def select_next_window(num = 1)
+      @server.invoke_command "select-window -t #{identifier}:+#{num}"
+      current_window
+    end
+
+    # Selects the previous (lower index) window
+    #
+    # @param [Number] num How many windows to move
+    # @tmuxver &gt;=1.3
+    # @return [Window]
+    def select_previous_window(num = 1)
+      @server.invoke_command "select-window -t:-#{num}"
+      current_window
+    end
+
+    # @endgroup
+  end
+end