scriptty 0.5.0-java

data/lib/scriptty/util/fsm/definition_parser.rb

@@ -0,0 +1,111 @@
+# = FSM definition parser
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'treetop'
+
+Treetop.load File.join(File.dirname(__FILE__), "scriptty_fsm_definition.treetop")
+
+module ScripTTY # :nodoc:
+  module Util # :nodoc:
+    class FSM
+      class DefinitionParser
+        # Returns an array of hashes representing the state transition table
+        # for a given FSM definition.
+        #
+        # Each table entry has the following keys:
+        # [:state]
+        #   The state to which the entry applies.  State 1 is the starting state.
+        # [:input]
+        #   The input used to match this entry, or the symbol :any.  The :any
+        #   input represents any input that does not match a more specific entry.
+        # [:event_name]
+        #   The name to be passed to the callback when this entry is reached.
+        #   May be nil.
+        # [:next_state]
+        #   The next state to move to after the callback is invoked.
+        #   Note that the callback might modify this variable.
+        def parse(definition)
+          parser = ScripTTYFSMDefinitionParser.new
+          parse_tree = parser.parse(definition + "\n")    # The grammar requires a newline at the end of the file, so make sure it's there.
+          raise ArgumentError.new(parser.failure_reason) unless parse_tree
+          state_transition_table = []
+          load_recursive(state_transition_table, parse_tree, :start, {})
+          normalize_state_transition_table(state_transition_table)
+          state_transition_table
+        end
+
+        private
+
+        def load_recursive(ttable, t, state, dupcheck_hash)  # :nodoc:
+          t.rules.each do |rule|
+            # Use object_id to identify the state.  This will be replaced in
+            # normalize_state_transition_table() by something more readable and
+            # consistent.
+            next_state = rule.sub_list ? rule.sub_list.object_id : :start
+            if rule.lhs.respond_to? :cc_values
+              # Character class (multiple equivalent inputs)
+              rule.lhs.cc_values.each do |value|
+                dup_check(dupcheck_hash, rule, state, value)
+                ttable << {:state => state, :input => value, :next_state => next_state, :event_name => rule.event_name}
+              end
+            else
+              # Single input
+              dup_check(dupcheck_hash, rule, state, rule.lhs.value)
+              ttable << {:state => state, :input => rule.lhs.value, :next_state => next_state, :event_name => rule.event_name}
+            end
+            if next_state != :start
+              load_recursive(ttable, rule.sub_list, next_state, dupcheck_hash)
+            end
+          end
+          nil
+        end
+
+        def normalize_state_transition_table(ttable)
+          states = {}
+          n = 0
+          normalize_state = Proc.new {|s|
+            if states[s]
+              states[s]
+            else
+              states[s] = (n += 1)
+            end
+          }
+          normalize_state.call(:start)    # Assign state 1 to the initial state
+          ttable.each do |row|
+            row[:state] = normalize_state.call(row[:state]) if row[:state]
+            row[:next_state] = normalize_state.call(row[:next_state]) if row[:next_state]
+          end
+          nil
+        end
+
+        def dup_check(dupcheck_hash, rule, state, input)  # :nodoc:
+          k = [state, input]
+          current_linenum = rule.input[0,rule.lhs.interval.first].split("\n", -1).length
+          current_line = rule.input[rule.interval].chomp
+          prev_linenum, prev_line = dupcheck_hash[k]
+          if prev_linenum
+            # Calculate the line number
+            raise ArgumentError.new("rule conflict\nline #{prev_linenum}: #{prev_line}\nline #{current_linenum}: #{current_line}")
+          end
+          dupcheck_hash[k] = [current_linenum, current_line]
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/scriptty/util/fsm/scriptty_fsm_definition.treetop

@@ -0,0 +1,189 @@
+# = Treetop grammar for ScripTTY::Util::FSM::DefinitionParser
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+grammar ScripTTYFSMDefinition
+  rule list
+    ( mapping_line / EOL )* {
+      def rules
+        elements.select { |e| e.respond_to? :lhs }
+      end
+    }
+  end
+
+  rule mapping_line
+    WS* lhs _cn:( WS* "=>" WS* event_name )? _bl:( WS* "=>" WS* braced_list )? EOL {
+      def event_name
+        if _cn.nonterminal?
+          _cn.elements[3].text_value
+        else
+          nil
+        end
+      end
+      def sub_list
+        if _bl.nonterminal?
+          _bl.braced_list.list
+        else
+          nil
+        end
+      end
+    }
+  end
+
+  rule lhs
+    string / char / char_class / other
+  end
+
+  rule event_name
+    [a-z0-9_]+
+  end
+
+  rule braced_list
+    '{' WS* list WS* '}'
+  end
+
+  rule string
+    '"' v:( str_unescaped / str_octal / str_hex / str_single )* '"' {
+      def value
+        v.elements.map{|e| e.to_s}.join
+      end
+    }
+  end
+
+  rule char
+    "'" v:( str_unescaped / str_octal / str_hex / str_single ) "'" {
+      def value
+        v.to_s
+      end
+    }
+  end
+
+  rule char_class
+    '[' carat:'^'? cc_char_or_range+ ']' {
+      def cc_values
+        retval = []
+        chars_or_ranges = elements[2].elements
+        chars_or_ranges.each do |cr|
+          if cr.last_char
+            fchar = cr.first_char.to_s.unpack("C*")[0]
+            lchar = cr.last_char.to_s.unpack("C*")[0]
+            (fchar..lchar).each do |c|
+              retval << c.chr
+            end
+          else
+            retval << cr.first_char.to_s
+          end
+        end
+        unless carat.empty?
+          # The leading carat is present, so we want all the characters *not* specified.
+          retval = (0..255).map{ |c| c.chr } - retval
+        end
+        retval.uniq
+      end
+    }
+  end
+
+  # A single character or range of characters
+  rule cc_char_or_range
+    first_char:cc_char r:( '-' last_char:cc_char )? {
+      def last_char
+        if r.empty?
+          nil
+        else
+          r.last_char
+        end
+      end
+    }
+  end
+
+  rule cc_char
+    cc_unescaped / str_octal / str_hex / str_single
+  end
+
+  rule other
+    '*' {
+      def value
+        :other
+      end
+    }
+  end
+
+  rule cc_unescaped
+    [^\\\-\^\[\]\t\r\n] {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule str_unescaped
+    [^"\\\t\r\n] {
+      def to_s
+        text_value
+      end
+    }
+  end
+
+  rule str_octal
+    "\\" [0-7] [0-7] [0-7] {
+      def to_s
+        text_value[1..-1].to_i(8).chr
+      end
+    }
+  end
+
+  rule str_hex
+    "\\" [Xx] [0-9A-Fa-f] [0-9A-Fa-f] {
+      def to_s
+        text_value[2..-1].to_i(16).chr
+      end
+    }
+  end
+
+  rule str_single
+    "\\" [enrt"'\\] {
+      def to_s
+        case text_value[1..-1]
+        when 'e'
+          "\e"
+        when 'n'
+          "\n"
+        when 'r'
+          "\r"
+        when 't'
+          "\t"
+        when '"'
+          '"'
+        when "'"
+          "'"
+        when "\\"
+          "\\"
+        end
+      end
+    }
+  end
+
+  # whitespace
+  rule WS
+    [ \t]
+  end
+
+  # trailing whitespace (optional), comment (optional), newline
+  rule EOL
+    WS* ('#' [^\r\n]* )? ( "\n" / "\r\n" )
+  end
+end

data/lib/scriptty/util/fsm.rb

@@ -0,0 +1,177 @@
+# = Finite state machine for terminal emulation
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+module ScripTTY # :nodoc:
+  module Util # :nodoc:
+    class FSM
+      # Exception for no matching state
+      class NoMatch < ArgumentError
+        attr_reader :input_sequence, :state
+        def initialize(message, input_sequence, state)
+          @input_sequence = input_sequence
+          @state = state
+          super(message)
+        end
+      end
+
+      # The current (or previous) input.
+      attr_reader :input
+
+      # An array of inputs received since the initial state.
+      #
+      # This allows a callback to get the contents of a complete escape
+      # sequence.
+      attr_reader :input_sequence
+
+      # The current state
+      attr_reader :state
+
+      # The next state
+      attr_reader :next_state
+
+      # Object that will receive named events.
+      #
+      # When processing reaches a named event, the FSM will invoke the method
+      # specified by the callback_method attribute (by default, "call"),
+      # passing it the name of the event and the FSM object.
+      attr_accessor :callback
+
+      # The name of the method to invoke on the callback object. (default: :call)
+      attr_accessor :callback_method
+
+      # When not nil, all inputs are redirected, bypassing normal processing
+      # (but input_sequence is still updated).
+      #
+      # If redirect is a symbol, then the specified method is called on the
+      # callback object (this implies that the callback object can't be an
+      # ordinary Proc in this case).  Otherwise, the "call" method on the
+      # redirect object is invoked.
+      #
+      # The redirect function will be passed a reference to the FSM, which it
+      # can use to access methods such as input, input_sequence, reset!, etc.
+      #
+      # If the redirect function returns true, the process method returns
+      # immediately.  If the redirect function returns false, the redirection
+      # is removed and the current input is processed normally.
+      attr_accessor :redirect
+
+      # Initialize a FSM
+      #
+      # The following options are supported:
+      # [:definition]
+      #   FSM definition, as a string
+      # [:callback]
+      #   See the documentation for the callback attribute.
+      #   A block may be given to the new method instead of being passed as an
+      #   option.
+      # [:callback_method]
+      #   See the documentation for the callback_method attribute.
+      def initialize(options={}, &block)
+        @redirect = nil
+        @input_sequence = []
+        @callback = options[:callback] || block
+        @callback_method = (options[:callback_method] || :call).to_sym
+        load_definition(options[:definition])
+        reset!
+      end
+
+      # Set state and next_state to 1, and clear the redirect.
+      def reset!
+        @state = 1
+        @next_state = 1
+        @redirect = nil
+        nil
+      end
+
+      # Return true if we are at the initial state (i.e. @state == 1 and !@redirect)
+      def initial_state?
+        @state == 1 && !@redirect
+      end
+
+      # Invoke the callback for the specified event.
+      def fire_event(event)
+        @callback.__send__(@callback_method, event.to_sym, self) if @callback
+      end
+
+      # Process the specified input.
+      #
+      # If there is no matching entry in the state transition table,
+      # ScripTTY::Util::FSM::NoMatch is raised.
+      def process(input)
+        # Switch to @next_state
+        @state = @next_state
+
+        # Reset @input_sequence if we are at the initial state.  Otherwise,
+        # append the current input to @input_sequence.
+        if initial_state?
+          @input_sequence = [input]
+        else
+          @input_sequence << input
+        end
+
+        # Set @input and call the redirect object (if necessary)
+        @input = input
+        if @redirect
+          if @redirect.is_a?(Symbol)
+            result = @callback.send(@redirect, self)
+          else
+            result = @redirect.call(self)
+          end
+          return true if result
+          @redirect = nil
+        end
+
+        # The redirect function might invoke the reset! method, so fix
+        # @input_sequence for that case.
+        @input_sequence = [input] if @state == 1
+
+        # Look up for a state transition for the specified input
+        t = @state_transitions[@state][input]
+        t ||= @state_transitions[@state][:other]
+        raise NoMatch.new("No matching transition for input_sequence=#{input_sequence.inspect} (state=#{state.inspect})", input_sequence, state) unless t
+
+        # Set next_state and invoke the callback, if any is specified for this state transition.
+        @next_state = t[:next_state]
+        fire_event(t[:event]) if t[:event]
+
+        # Return true
+        true
+      end
+
+      private
+
+      # Load the specified FSM definition
+      def load_definition(definition)
+        # NB: We convert the specified state transition table into nested hashes (for faster lookups).
+        transitions = {}
+        DefinitionParser.new.parse(definition).each do |e|
+          state = e.delete(:state)
+          input = e.delete(:input)
+          raise "BUG" if !state or !input
+          e[:event] = e.delete(:event_name).to_sym if e[:event_name]   # Replace string event_name with symbol
+          transitions[e[:next_state]] ||= {} if e[:next_state]
+          transitions[state] ||= {}
+          transitions[state][input] = e
+        end
+        @state_transitions = transitions
+      end
+    end
+  end
+end
+
+require 'scriptty/util/fsm/definition_parser'

data/lib/scriptty/util/transcript/reader.rb

@@ -0,0 +1,96 @@
+# = Transcript reader
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'strscan'
+
+module ScripTTY
+  module Util
+    module Transcript
+      # Reader for transcript files
+      #
+      # === Example
+      #
+      #  File.open("transcript", "r") do |file|
+      #    reader = ScripTTY::Util::Transcript::Reader.new
+      #    file.each_line do |line|
+      #      timestamp, type, args = reader.parse_line(line)
+      #      # ... do stuff here ...
+      #    end
+      #  end
+      #
+      class Reader
+
+        OP_TYPES = {
+          "Copen" => :client_open,  # client connection opened
+          "Sopen" => :server_open,  # server connection opened
+          "C" => :from_client,  # bytes from client
+          "S" => :from_server,  # bytes from server
+          "*" => :info,   # informational message
+          "Sx" => :server_close,  # server closed connection
+          "Cx" => :client_close,  # server closed connection
+          "Sp" => :server_parsed,  # parsed escape sequence from server
+          "Cp" => :client_parsed,  # parsed escape sequence from client
+        }
+
+        def initialize(io=nil)
+          @current_line = 0
+          @io = io
+        end
+
+        def next_entry
+          raise TypeError.new("no I/O object associated with this reader") unless @io
+          return nil if @io.eof?
+          line = @io.readline
+          return nil unless line
+          parse_line(line)
+        end
+
+        def close
+          @io.close if @io
+        end
+
+        def parse_line(line)
+          @current_line += 1
+          unless line =~ /^\[([\d]+(?:\.[\d]+)?)\] (\S+)((?: "(?:[\x20-\x21\x23-\x5b\x5d-\x7e]|\\[0-3][0-7][0-7])*")*)$/
+            raise ArgumentError.new("line #{@current_line}: Unable to parse basic structure")
+          end
+          timestamp, op, raw_args = [$1, $2, $3]
+          timestamp = timestamp.to_f
+          args = []
+          s = StringScanner.new(raw_args.strip)
+          until s.eos?
+            m = s.scan(/ +/) # skip whitespace between args
+            next if m
+            m = s.scan /"[^"]*"/
+            raise ArgumentError.new("line #{@current_line}: Unable to parse arguments") unless m
+            arg = m[1..-2].gsub(/\\[0-7][0-7][0-7]/) { |m| [m[1..-1].to_i(8)].pack("C*") }    # strip quotes and unescape string
+            args << arg
+          end
+          type = OP_TYPES[op]
+          raise ArgumentError.new("line #{@current_line}: Unrecognized opcode #{op}") unless type
+          if [:client_open, :server_open].include?(type)
+            raise ArgumentError.new("line #{@current_line}: Bad port #{args[1].inspect}") unless args[1] =~ /\A(\d+)\Z/m
+            args[1] = args[1].to_i
+          end
+          [timestamp, type, args]
+        end
+      end
+    end
+  end
+end
+

data/lib/scriptty/util/transcript/writer.rb

@@ -0,0 +1,111 @@
+# = Transcript writer
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+module ScripTTY
+  module Util
+    module Transcript
+      class Writer
+
+        # Set this to non-nil to force the next record to have a specific timestamp
+        attr_accessor :override_timestamp
+
+        def initialize(io)
+          @io = io
+          @start_time = Time.now
+          @override_timestamp = nil
+          if block_given?
+            begin
+              yield self
+            ensure
+              close
+            end
+          end
+        end
+
+        def close
+          @io.close
+        end
+
+        # Client connection opened
+        def client_open(host, port)
+          write_event("Copen", host, port.to_s)
+        end
+
+        # Server connection opened
+        def server_open(host, port)
+          write_event("Sopen", host, port.to_s)
+        end
+
+        # Log bytes from the client
+        def from_client(bytes)
+          write_event("C", bytes)
+        end
+
+        # Log bytes from the server
+        def from_server(bytes)
+          write_event("S", bytes)
+        end
+
+        # Log event from the client (i.e. bytes parsed into an escape sequence, with an event fired)
+        def client_parsed(event, bytes)
+          write_event("Cp", event.to_s, bytes)
+        end
+
+        # Log event from the server (i.e. bytes parsed into an escape sequence, with an event fired)
+        def server_parsed(event, bytes)
+          write_event("Sp", event.to_s, bytes)
+        end
+
+        # Log server connection close
+        def server_close(message)
+          write_event("Sx", message)
+        end
+
+        # Log client connection close
+        def client_close(message)
+          write_event("Cx", message)
+        end
+
+        # Log informational message
+        def info(*args)
+          write_event("*", *args)
+        end
+
+        private
+
+          def write_event(type, *args)
+            t = @override_timestamp ? @override_timestamp.to_f : (Time.now - @start_time)
+            encoded_args = args.map{|a| encode_string(a)}.join(" ")
+            @io.write sprintf("[%.03f] %s %s", t, type, encoded_args) + "\n"
+            @io.flush if @io.respond_to?(:flush)
+            nil
+          end
+
+          def encode_string(bytes)
+            escaped = bytes.gsub(/\\|"|[^\x20-\x7e]*/mn) { |m|
+              m.unpack("C*").map{ |c|
+                sprintf("\\%03o", c)
+              }.join
+            }
+            '"' + escaped + '"'
+          end
+      end
+    end
+  end
+end
+