heytmux 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb566cb530c83ebd00f2dcfb707eb0e992593ee7
-  data.tar.gz: a0a6b6a585a503d1d5ceab93752345b897c125b2
+  metadata.gz: 53af5daf1e2193c29b0a85affdb4fc72b739b536
+  data.tar.gz: 76fe05372f8e0252556ae26cbcb98f40579dca4c
 SHA512:
-  metadata.gz: 3e768bf1f0f205cfe32546253338856ca6d0a6d6742cf8f6ab9244e146be6cf2978823114517cad0554a10ea94e7fbd65e8f54fdeda84a85ed04135a23b4632d
-  data.tar.gz: 2df1f6fcff06149be16865c6991238519f5163bebaca3180c2a410a7dbf764edcadfd404c56b84642599d5cd335848d739037f3f7bc5f544d5bbc41a1decafc4
+  metadata.gz: 80b1a5981d257825a5ac9478c2e0dc089f4898a2ad17e49eb78d189227f3e46348fefe196b1b79b061237a28f1ee6730a5ccb5c22f7bf536d7f22cd37d64a0e8
+  data.tar.gz: b19c74aa98d105879a6374e9d92639906338d0dca952055c07d1af8f974421a69894d4d82e97c46136a68b8a6c209e4b107fddb2c4715e28655e16b752147529

data/README.md

@@ -1,6 +1,8 @@
 Hey tmux!
 =========
 
+[![travis-ci](https://travis-ci.org/junegunn/heytmux.svg?branch=master)](https://travis-ci.org/junegunn/heytmux) [![Coverage Status](https://coveralls.io/repos/github/junegunn/heytmux/badge.svg?branch=master)](https://coveralls.io/github/junegunn/heytmux?branch=master)
+
 Tmux scripting made easy.
 
 Installation
@@ -25,7 +27,9 @@ Plug 'junegunn/heytmux'
 ```
 
 - Registers `:Heytmux` command
-- No need to install Gem
+- No need to install Gem if you only use Heytmux inside Vim
+    - But if you want it to be globally available,
+      `Plug 'junegunn/heytmux', { 'do': 'gem install heytmux' }`
 
 Usage
 -----
@@ -252,7 +256,7 @@ following example will not work as expected.
 ```
 
 With `expect` construct, you can make Heytmux wait until a certain regular
-expression pattern appears on the the pane (a la [Expect][expect]).
+expression pattern appears on the pane (a la [Expect][expect]).
 
 [expect]: https://en.wikipedia.org/wiki/Expect
 
@@ -265,6 +269,23 @@ expression pattern appears on the the pane (a la [Expect][expect]).
     - uptime
 ```
 
+#### Special commands
+
+In addition to `expect`, Heytmux also supports `sleep` and `keys` commands.
+`sleep` suspends the execution for a given time period. It's useful when the
+shell on the target pane is non-interactive so you can't send `sleep` command
+to it. `keys` command is for sending special keys, such as `c-c` (CTRL-C)
+using `tmux send-keys` command. To send multiple keys, specify the keys as
+a YAML list (e.g. `[c-c, c-l]`).
+
+```yaml
+- servers:
+  - server 1:
+    - vmstat 2 | tee log
+    - sleep: 3
+    - keys: c-c
+```
+
 Vim plugin
 ----------
 

data/lib/heytmux.rb

@@ -13,8 +13,6 @@ module Heytmux
     'pane-border-format' => '#{pane_title}'
   }.freeze
 
-  SUPPORTED_ACTIONS = %w[expect].to_set.freeze
-
   WINDOWS_KEY = 'windows'
   LAYOUT_KEY = 'layout'
   PANES_KEY = 'panes'
@@ -28,5 +26,10 @@ end
 
 require 'heytmux/version'
 require 'heytmux/validations'
+require 'heytmux/pane_action'
+require 'heytmux/pane_actions/paste'
+require 'heytmux/pane_actions/expect'
+require 'heytmux/pane_actions/sleep'
+require 'heytmux/pane_actions/keys'
 require 'heytmux/tmux'
 require 'heytmux/core'

data/lib/heytmux/core.rb

@@ -69,33 +69,18 @@ module Heytmux
     end
   end
 
+  # Finds appropriate PaneActions for the commands and processes them
   def process_command!(window_index, pane)
     pane_index, item, commands = pane.values_at(:index, :item, :command)
-    [*commands].each do |command|
-      case command
-      when Hash
-        _action, regex = command.first
-        regex = Regexp.compile(regex.to_s)
-        wait_until do
-          content = Tmux.capture(window_index, pane_index)
-          content =~ regex
-        end
-      else
-        command = command.gsub(ITEM_PAT, item) if item
-        Tmux.paste(window_index, pane_index, command)
+    [*commands].compact.each do |command|
+      label, body = command.is_a?(Hash) ? command.first : [:paste, command]
+      PaneAction.for(label).process(window_index, pane_index, body) do |source|
+        string = source.to_s
+        item ? string.gsub(ITEM_PAT, item) : string
       end
     end
   end
 
-  def wait_until
-    timeout = Time.now + EXPECT_TIMEOUT
-    loop do
-      sleep EXPECT_SLEEP_INTERVAL
-      return if yield
-      raise 'Timed out' if Time.now > timeout
-    end
-  end
-
   # Groups entities by the group key and extracts unique, sorted indexes and
   # returns stateful indexer that issues index number for the given group key
   def indexer(entities, group_key, index_key)

data/lib/heytmux/pane_action.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Heytmux
+  # Base class for pane actions. To implement a new type of action that is
+  # applied to a designated pane, one should write a class that derives from
+  # this class. Use register class method to associate the class with one or
+  # more labels.
+  class PaneAction
+    # Validation method to be overridden. Throw ArgumentError if body is
+    # invalid.
+    def validate(_body)
+      nil
+    end
+
+    # Defines the behavior of the action. Should be implemented by the
+    # subclasses. When the method is called, a block is passed that is for
+    # replacing {{ item }} in the body. One may or may not want to use it on
+    # body depending on the use case.
+    def process(_window_index, _pane_index, _body)
+      raise NotImplementedError
+    end
+
+    class << self
+      # Registers a PaneAction class with the label
+      def register(*labels, klass)
+        instance = klass.new
+        (@actions ||= {}).merge!(
+          Hash[labels.map { |label| [label, instance] }]
+        )
+      end
+
+      # Finds PaneAction class for the label
+      def for(label)
+        @actions[label.to_sym]
+      end
+
+      def inherited(klass)
+        def klass.register(*labels)
+          PaneAction.register(*labels, self)
+        end
+      end
+    end
+  end
+end

data/lib/heytmux/pane_actions/expect.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Heytmux
+  module PaneActions
+    # Pastes the command onto the pane
+    class Expect < PaneAction
+      register :expect
+
+      def validate(body)
+        raise ArgumentError, 'Expect condition is empty' if body.to_s.empty?
+      end
+
+      def process(window_index, pane_index, body)
+        regex = Regexp.compile(yield(body))
+        wait_until do
+          content = Tmux.capture(window_index, pane_index)
+          raise 'Failed to capture pane content' unless $CHILD_STATUS.success?
+          content =~ regex
+        end
+      end
+
+      private
+
+      def wait_until
+        timeout = Time.now + EXPECT_TIMEOUT
+        loop do
+          sleep EXPECT_SLEEP_INTERVAL
+          return if yield
+          raise 'Timed out' if Time.now > timeout
+        end
+      end
+    end
+  end
+end

data/lib/heytmux/pane_actions/keys.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Heytmux
+  module PaneActions
+    # Send keys using tmux send-keys command
+    class Keys < PaneAction
+      register :keys, :key
+
+      def validate(body)
+        body = body.is_a?(Array) ? body : [body]
+        body.each do |key|
+          unless Validations.valid_string?(key)
+            raise ArgumentError, 'Keys must be given as a string or a list'
+          end
+        end
+      end
+
+      def process(window_index, pane_index, body)
+        Tmux.tmux('send-keys', Tmux.target(window_index, pane_index), body)
+      end
+    end
+  end
+end

data/lib/heytmux/pane_actions/paste.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heytmux
+  module PaneActions
+    # Waits for a certain regular expression pattern appears
+    class Paste < PaneAction
+      register :paste
+
+      def validate(body)
+        case body
+        when Hash, Array
+          raise ArgumentError, "Invalid command: #{body}"
+        end
+      end
+
+      def process(window_index, pane_index, body)
+        Tmux.paste(window_index, pane_index, yield(body))
+      end
+    end
+  end
+end

data/lib/heytmux/pane_actions/sleep.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Heytmux
+  module PaneActions
+    # Sleeps for the given duration
+    class Sleep < PaneAction
+      register :sleep
+
+      def validate(body)
+        raise ArgumentError, 'Sleep expects positive number' if body.to_f <= 0
+      end
+
+      def process(_window_index, _pane_index, body)
+        sleep(body.to_f)
+      end
+    end
+  end
+end

data/lib/heytmux/validations.rb

@@ -65,29 +65,28 @@ module Heytmux
     # - command_string
     # - [command_strings_or_hashes...]
     def validate_commands(commands)
-      return if commands.is_a?(String)
       message = "Invalid command: #{commands.inspect}"
-      case commands
-      when Array
-        hashes, strings = commands.partition { |command| command.is_a?(Hash) }
-        hashes.each do |command|
+      commands = commands.is_a?(Array) ? commands : [commands]
+      commands.each do |command|
+        case command
+        when Hash
           raise ArgumentError, message unless single_spec?(command)
-          action, condition = command.first
-          unless SUPPORTED_ACTIONS.include?(action)
-            raise ArgumentError, "Unsupported action: #{action}"
-          end
-          raise ArgumentError, message unless valid_name?(condition)
-          Regexp.compile(condition.to_s)
+          label, body = command.first
+          validate_action(label, body)
+        else
+          raise ArgumentError, message unless valid_string?(command)
         end
-        strings.each do |command|
-          raise ArgumentError, message unless valid_name?(command)
-        end
-      else
-        raise ArgumentError, message unless valid_name?(commands)
       end
       nil
     end
 
+    # Checks if the action is currently supported
+    def validate_action(label, body)
+      action = PaneAction.for(label)
+      raise ArgumentError, "Unsupported action: #{label}" unless action
+      action.validate(body)
+    end
+
     # Checks if the given hash only contains one mapping from a string to
     # a hash
     def single_spec?(spec, *klasses)
@@ -95,11 +94,13 @@ module Heytmux
       second.nil? && !key.to_s.empty? &&
         (klasses.empty? || klasses.any? { |k| value.is_a?(k) })
     end
-    private_class_method :single_spec?
+
+    def valid_string?(value)
+      !(value.is_a?(Array) || value.is_a?(Hash))
+    end
 
     def valid_name?(value)
-      !(value.nil? || value.is_a?(Array) || value.to_s.empty?)
+      valid_string?(value) && !value.to_s.empty?
     end
-    private_class_method :valid_name?
   end
 end

data/lib/heytmux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Heytmux
-  VERSION = '0.0.0'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heytmux
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Junegunn Choi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-03 00:00:00.000000000 Z
+date: 2017-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -110,6 +110,11 @@ files:
 - heytmux.gemspec
 - lib/heytmux.rb
 - lib/heytmux/core.rb
+- lib/heytmux/pane_action.rb
+- lib/heytmux/pane_actions/expect.rb
+- lib/heytmux/pane_actions/keys.rb
+- lib/heytmux/pane_actions/paste.rb
+- lib/heytmux/pane_actions/sleep.rb
 - lib/heytmux/tmux.rb
 - lib/heytmux/validations.rb
 - lib/heytmux/version.rb
@@ -132,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Hey tmux!