ttycoke 0.2.0

data/lib/ttycoke/ansi.rb

@@ -0,0 +1,127 @@
+# -*- encoding: utf-8 -*-
+module TTYCoke
+  module ANSI
+    # Most of this section was taken from:
+    # https://github.com/flori/term-ansicolor
+    ATTRIBUTES = [
+      [ :clear              ,   0 ], # String#clear is already used to empty string.
+      [ :reset              ,   0 ], # synonym for :clear
+      [ :bold               ,   1 ],
+      [ :dark               ,   2 ],
+      [ :italic             ,   3 ], # not widely implemented
+      [ :underline          ,   4 ],
+      [ :underscore         ,   4 ], # synonym for :underline
+      [ :blink              ,   5 ],
+      [ :rapid_blink        ,   6 ], # not widely implemented
+      [ :negative           ,   7 ], # no reverse because of String#reverse
+      [ :concealed          ,   8 ],
+      [ :strikethrough      ,   9 ], # not widely implemented
+      [ :black              ,  30 ],
+      [ :red                ,  31 ],
+      [ :green              ,  32 ],
+      [ :yellow             ,  33 ],
+      [ :blue               ,  34 ],
+      [ :magenta            ,  35 ],
+      [ :cyan               ,  36 ],
+      [ :white              ,  37 ],
+      [ :on_black           ,  40 ],
+      [ :on_red             ,  41 ],
+      [ :on_green           ,  42 ],
+      [ :on_yellow          ,  43 ],
+      [ :on_blue            ,  44 ],
+      [ :on_magenta         ,  45 ],
+      [ :on_cyan            ,  46 ],
+      [ :on_white           ,  47 ],
+      [ :intense_black      ,  90 ], # High intensity, aixterm (OS X)
+      [ :intense_red        ,  91 ],
+      [ :intense_green      ,  92 ],
+      [ :intense_yellow     ,  93 ],
+      [ :intense_blue       ,  94 ],
+      [ :intense_magenta    ,  95 ],
+      [ :intense_cyan       ,  96 ],
+      [ :intense_white      ,  97 ],
+      [ :on_intense_black   , 100 ], # High intensity background, aixterm (OS X)
+      [ :on_intense_red     , 101 ],
+      [ :on_intense_green   , 102 ],
+      [ :on_intense_yellow  , 103 ],
+      [ :on_intense_blue    , 104 ],
+      [ :on_intense_magenta , 105 ],
+      [ :on_intense_cyan    , 106 ],
+      [ :on_intense_white   , 107 ]
+    ]
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+
+    # Returns true if TTYCoke::ANSIColor supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    def self.coloring?
+      @coloring
+    end
+
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  TTYCoke::ANSI::coloring = STDOUT.isatty
+    def self.coloring=(val)
+      @coloring = val
+    end
+    self.coloring = true
+
+    ATTRIBUTES.each do |c, v|
+      eval <<-EOT
+        def #{c}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if TTYCoke::ANSI.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if TTYCoke::ANSI.coloring?
+          result
+        end
+      EOT
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolored(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(COLORED_REGEXP, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    module_function
+
+    # Returns an array of all TTYCoke::ANSIColor attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/ttycoke/cli.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require 'optparse'
+module TTYCoke
+  class CLI
+    include TTYCoke::Log
+
+    def parse_options argv
+      log_rescue(self, __method__, caller) {
+        @opts=nil
+        @opts = OptionParser.new do |o|
+          o.banner = "Usage: ttycoke [-v] [-h] command [<args>]"
+          o.separator ""
+          o.on("-h", "--help", "Print this help.") {
+            return $stderr.puts(@opts)
+          }
+          o.on("-v", "--version", "Print version.") {
+            return $stderr.puts(TTYCoke::Version::STRING)
+          }
+          o.on("-d", "--debug", "Enable debug output.") {
+            $DEBUG = true
+          }
+          o.separator ""
+        end
+        @opts.parse!(argv) rescue return $stderr.puts(@opts)
+        if argv.empty?
+          $stderr.puts(@opts)
+        else
+          TTYCoke::Run.new(argv)
+        end
+      }
+    end
+  end
+end

data/lib/ttycoke/config.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+require 'yaml'
+
+module TTYCoke
+  class Config
+    include TTYCoke::Log
+
+    def initialize(config_file=ENV['HOME'] + "/.ttycokerc")
+      log_rescue(self, __method__, caller, TTYCoke::Errors::YamlSyntaxError) {
+        @files = {
+          init: config_file,
+          tty_coke: File.dirname(__FILE__) + '/../../config/config.yaml'
+        }
+        raw_yaml = YAML::load(File.open(File.expand_path(file)))
+        paths = raw_yaml.fetch('import')
+        importer = File.dirname(file)
+        @config = TTYCoke::Import.import(raw_yaml, paths, {}, importer)
+      }
+    end
+
+    def find_program prgm
+      if @config.keys.include?(prgm)
+        @config.fetch(prgm)
+      else
+        false
+      end
+    end
+
+    def file
+      log_rescue(self, __method__, caller) {
+        if FileTest.exist?(@files.fetch(:init))
+          @files.fetch(:init)
+        else
+          @files.fetch(:tty_coke)
+        end
+      }
+    end
+  end
+end

data/lib/ttycoke/errors.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+module TTYCoke
+  module Errors
+    class TTYCokeError < StandardError
+      @@used_codes = []
+
+      def self.status_code code = nil
+        if code
+          raise "Status code already in use: #{code}"  if @@used_codes.include?(code)
+          @@used_codes << code
+        end
+        define_method(:status_code) { code }
+      end
+    end
+
+    class FallbackError < TTYCokeError
+      status_code(55)
+      def initialize(error)
+        super "TTYCoke was not able to fallback to provided program." +
+          "Parent error class ::#{error.class.name} (#{error.message})."
+      end
+    end
+
+    class ProgramNotFoundError < TTYCokeError
+      status_code(58)
+      def initialize(error)
+        super "Program does not exist." +
+          "Parent error class ::#{error.class.name} (#{error.message})."
+      end
+    end
+
+    class YamlSyntaxError < TTYCokeError
+      status_code(57)
+      def initialize(error)
+        super "Maybe a yaml or regex syntax error. " +
+          "Parent error class ::#{error.class.name} (#{error.message})."
+      end
+    end
+  end
+end

data/lib/ttycoke/import.rb

@@ -0,0 +1,72 @@
+module TTYCoke
+  module Import
+    extend self
+
+    def import result, paths, origins={}, importer=$0
+      Array(paths).each do |path|
+        begin
+          data = YAML.load_file(importer + path)
+        rescue => error
+          error.message << ' when importing %s into %s' %
+            [path, importer].map(&:inspect)
+          raise error
+        end
+        mark_origin data, path, origins
+        merge result, data, path, origins
+      end
+      result
+    end
+
+    def merge dst_hash, src_hash, src_file, origins={}, backtrace=[]
+      src_hash.each do |key, src_val|
+        backtrace.push key
+
+        catch :merged do
+          if dst_hash.key? key
+            dst_val = dst_hash[key]
+
+            dst_file = origins[dst_val]
+            section = backtrace.join(':')
+
+            if src_val.nil?
+              LOG.warn 'empty section %s in %s removes value %s from %s' %
+                [section, src_file, dst_val, dst_file].map(&:inspect)
+
+              dst_hash.delete key
+              throw :merged
+
+            elsif dst_val.is_a? Hash and src_val.is_a? Hash
+              merge dst_val, src_val, src_file, origins, backtrace
+              throw :merged
+
+            elsif dst_val.is_a? Array
+              dst_val.concat Array(src_val)
+              throw :merged
+
+            else
+              LOG.warn 'value %s from %s overrides %s from %s in section %s' %
+                [src_val, src_file, dst_val, dst_file, section].map(&:inspect)
+              # fall through
+            end
+          end
+          dst_hash[key] = src_val
+        end
+        backtrace.pop
+      end
+      dst_hash
+    end
+
+    private
+
+    def mark_origin data, origin, result
+      result[data] = origin
+      if data.respond_to? :each
+        data.each do |*values|
+          values.each do |value|
+            mark_origin value, origin, result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ttycoke/log.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+require 'logger'
+
+module TTYCoke
+  class TTYCokeLogFormat < ::Logger::Formatter
+    def call severity, time, program_name, message
+      case severity
+      when "DEBUG"
+        datetime      = time.strftime("%Y-%m-%d %H:%M")
+        print_message = "DEBUG".yellow + "--- (#{datetime})\n#{String(message)}"
+        [print_message].join("\n") + "\n\n"
+      when "ERROR"
+        datetime      = time.strftime("%Y-%m-%d %H:%M")
+        print_message = "ERROR".red + " --- (#{datetime})\n#{String(message)}"
+        [print_message].join("\n") + "\n\n"
+      else
+        super
+      end
+    end
+  end
+
+  module Log
+
+    $TEST              ||= nil
+    @@logger           ||= Logger.new($stderr)
+    @@logger.formatter = TTYCokeLogFormat.new
+    @@logger.level     = Logger::INFO
+
+    def log_debug cls, mth, cllr, file, line, ivrs={}, lvrs={}
+      # return unless $TEST
+      msg = "#{cls.class.name}##{mth}".magenta     +
+        "\nCaller => " + "#{cllr[0][/`.*'/][1..-2]}".green +
+        "\n---Instance Vars---"
+      ivrs.each { |v| msg += "#{v}=".yellow  + eval("#{v}") }
+      msg += "\n---local Vars---"
+      lvrs.each { |v| msg += "#{v}=".yellow  + eval("#{v}") }
+      msg += "\n#{file}:#{line}"
+      @@logger.debug(msg)
+    end
+
+    def log_error cls, mthd, cllr, e, vars={}
+      # return unless $TEST
+      status_code = e.status_code if e.respond_to?(:status_code)
+      msg = "#{cls.class.name}##{mthd}".magenta     +
+        "\nCaller => " + "#{cllr[0][/`.*'/][1..-2]}".green        +
+        "\ne.inspect: " + "#{e.inspect}".green                    +
+        "\ne.message: " + "#{e.message}".green                    +
+        "\ne.status_code: " + "#{status_code}".green              +
+        "\n---backtrace---\n"                                     +
+        "#{e.backtrace.join("\n")}"                               +
+        "\n---Vars---"
+      vars.each { |name, value| msg += "\n#{name}: ".yellow + " #{value}" }
+      @@logger.error(msg)
+    end
+
+    def log_rescue cls, mthd, cllr, ex_type=nil, vars={}
+      begin
+        result = yield
+        status = $? || 0
+      rescue Exception => e
+        log_error(cls, mthd, cllr, e, vars.merge(status: status)) unless $TEST
+        if ex_type
+          raise ex_type.new(e)
+        else
+          raise TTYCoke::Errors::TTYCokeError.new(e)
+        end
+        exit e.status_code if e.respond_to?(:status_code)
+      end
+      result
+    end
+
+    def log_check_child_exit_status
+      result = yield
+      status = $? || 0
+      unless [0,172].include?(status)
+        raise ArgumentError
+        log_error(self, __method__, caller, e,
+            {status: status}) unless $TEST
+        exit e.respond_to?(:status_code) ? e.status_code : Errno::ENOENT::Errno
+      end
+      result
+    end
+  end
+end

data/lib/ttycoke/parser.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+module TTYCoke
+  class Parser
+    extend TTYCoke::Log
+
+    class << self
+      def coke! prgm, line
+        program = raw_config_parser(prgm, line)
+        if program[:exist]
+          parse(program[:match])
+        else
+          return line
+        end
+      end
+
+      private
+
+      def raw_config_parser prgm, line, program={}
+        if prgm.is_a?(Hash)
+          program.merge!(raw_config_to_hash(prgm, line))
+        elsif prgm.is_a?(Array)
+          prgm[0].each { |p| program.merge!(raw_config_to_hash(p[1], line)) }
+        else
+          program.merge!(exist: false)
+        end
+        program
+      end
+
+      def raw_config_to_hash prgm, line, program={}
+        if mch = prgm.fetch('regex').match(line)
+          program.merge!({
+              exist: true,
+              match: mch
+            })
+        end
+        program
+      end
+
+      def matchd_color mtch, current_match, color=''
+        mtch.names.each { |name|
+          color = name if mtch[name].to_s == current_match.to_s
+        }
+        color
+      end
+
+      def parse mtch, coked_str=''
+        (mtch.size - 1).times do |i|
+          color = matchd_color(mtch, mtch[i+1].to_s)
+          if color.empty? # ANSI fking bug!
+            coked_str << mtch[i+1]
+          else
+            coked_str << mtch[i+1].send(color.to_sym)
+          end
+        end
+        coked_str
+      end
+    end
+  end
+end

data/lib/ttycoke/platform.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require 'rbconfig'
+module TTYCoke
+  class Platform
+    class << self
+      def tiger?
+        platform.include?("darwin8")
+      end
+
+      def leopard?
+        platform.include?("darwin9")
+      end
+
+      [:darwin, :bsd, :freebsd, :linux].each do |type|
+        define_method("#{type}?") do
+          platform.include?(type.to_s)
+        end
+      end
+
+      def windows?
+        %W[mingw mswin].each do |text|
+          return true if platform.include?(text)
+        end
+
+        false
+      end
+
+      def platform
+        RbConfig::CONFIG["host_os"].downcase
+      end
+    end
+  end
+end

data/lib/ttycoke/run.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+module TTYCoke
+  class Run
+    def initialize argv={}
+      log_rescue(self, __method__, caller) {
+        @argv     = argv
+        @prog     = TTYCoke::Config.new.find_program(@argv.fetch(0))
+      }
+      start!
+    end
+
+    private
+
+    def start!
+      if @prog && $stdout.tty?
+        coke_it!
+      else
+        fallback!
+      end
+    end
+
+    def coke_it!
+      trap_signal(%w(HUP INT QUIT)) #TODO: handle CLD
+      log_check_child_exit_status {
+        IO.popen(single_quote_argv(@argv)) { |process|
+          until process.eof?
+            puts Parser.coke!(@prog, process.gets)
+          end
+        }
+      }
+    end
+
+    def fallback!
+      log_check_child_exit_status { exec(single_quote_argv(@argv)) }
+    end
+
+    def trap_signal signals
+      log_check_child_exit_status {
+        signals.each { |signal|
+          trap(signal) {
+            log_rescue(self, __method__, caller,
+                {signals: signals, signal: signal}) {
+              puts reset
+            }
+            log_rescue(self, __method__, caller,
+                {signals: signals, signal: signal}) {
+              Process.waitpid2(-1, Process::WNOHANG)
+            }
+          }
+        }
+      }
+    end
+
+    def single_quote_argv argv
+      argv.map! { |arg| arg.gsub(/'/, %q('"'"')) }
+      "'" << argv.join(%q(' ')) << "'"
+    end
+  end
+end

data/lib/ttycoke/version.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+module TTYCoke
+  module Version
+    extend self
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

data/lib/ttycoke.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+require 'ttycoke/ansi'
+include TTYCoke::ANSI
+
+module TTYCoke
+  autoload :CLI,      'ttycoke/cli'
+  autoload :Log,      'ttycoke/log'
+  autoload :Run,      'ttycoke/run'
+  autoload :Parser,   'ttycoke/parser'
+  autoload :Import,   'ttycoke/import'
+  autoload :Config,   'ttycoke/config'
+  autoload :Errors,   'ttycoke/errors'
+  autoload :Version,  'ttycoke/version'
+  autoload :Platform, 'ttycoke/platform'
+end

data/test/data/ansi_lines.yaml

@@ -0,0 +1,12 @@
+lsmod:
+  line: "i2c_algo_bit            4423  2 nouveau,i915"
+  exp: "\e[32mi2c_algo_bit\e[0m            \e[34m4423\e[0m  \e[33m2\e[0m\e[31m nouveau,i915\e[0m"
+
+tail_tork_logs:
+  -
+    results:
+      line: "Finished tests in 0.038402s, 52.0809 tests/s, 78.1214 assertions/s."
+      exp: "\e[4mFinished tests in 0.038402s, 52.0809 tests/s, 78.1214 assertions/s.\e[0m"
+    stats:
+      line: "2 tests, 2 assertions, 0 failures, 0 errors, 0 skips"
+      exp: "\e[37m2 tests, \e[0m\e[32m2 assertions, \e[0m\e[35m0 failures, \e[0m\e[31m0 errors, \e[0m\e[33m0 skips\e[0m"

data/test/data/config.yaml

@@ -0,0 +1,4 @@
+import:
+  - /ttycoke.d/lsmod.yaml
+  - /ttycoke.d/id.yaml
+  - /ttycoke.d/tail_tork_logs.yaml

data/test/data/syntax_error_config.yaml

@@ -0,0 +1,6 @@
+syntax_error:
+  clrs: 
+    - green
+    - magenta
+    - bold
+  regex: !ruby/regexp '/(\w,)\s(\[.+\])\s{2}(\w+)\

data/test/data/ttycoke.d/id.yaml

@@ -0,0 +1,4 @@
+id:
+  clrs: 
+  regex: !ruby/regexp 
+    /(?<green>\w+=)(?<yellow>\d+)/

data/test/data/ttycoke.d/lsmod.yaml

@@ -0,0 +1,3 @@
+lsmod:
+  regex: !ruby/regexp
+    /^(?<green>\w+)(?<uncolored>\s+)(?<blue>\d+)(?<uncolored>\s+)(?<yellow>\d+)(?<red>.+)/

data/test/data/ttycoke.d/tail_focus.yaml

@@ -0,0 +1,14 @@
+tail-focus.sh:
+  -
+    first:
+      regex: !ruby/regexp
+        /(?<red># \w+)/
+    second:
+      regex: !ruby/regexp
+        /(?<yellow>## \w+)/
+    third:
+      regex: !ruby/regexp
+        /(?<green>### \w+)/
+    fouth:
+      regex: !ruby/regexp
+        /(?<blue>#### \w+)/

data/test/data/ttycoke.d/tail_tork_logs.yaml

@@ -0,0 +1,26 @@
+tail_tork_logs:
+  -
+    results:
+      regex: !ruby/regexp 
+        /^(?<underscore>Finished.*)/
+    error:
+      regex: !ruby/regexp 
+        /(?<red>.+(Error|Failure):)/
+    expected:
+      regex: !ruby/regexp 
+        /(?<blue>--- expected)/
+    expected-string:
+      regex: !ruby/regexp 
+        /(?<blue>-\".+)/
+    actual:
+      regex: !ruby/regexp 
+        /(?<red>\++ actual)/
+    actual-string:
+      regex: !ruby/regexp 
+        /(?<red>\+\".+)/
+    at:
+      regex: !ruby/regexp 
+        /(?<on_yellow>@.+)/
+    stats:
+      regex: !ruby/regexp 
+        /(?<white>\d+ tests, )(?<green>\d+ assertions, )(?<magenta>\d+ failures, )(?<red>\d+ errors, )(?<yellow>\d+ skips)/

data/test/data/ttycoke.d/top.yaml

@@ -0,0 +1,8 @@
+top:
+  -
+    tasks: 
+      regex: !ruby/regexp 
+        /(?<green>Tasks:.*)/
+    tasks: 
+      regex: !ruby/regexp 
+        /(?<blue>CPU.*)/

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+if RUBY_VERSION < "1.9"
+  require 'test/unit'
+else
+  require 'test/unit'
+  require 'minitest/unit'
+end
+
+$TEST = true
+
+lib_dir  = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir, File.dirname(__FILE__)
+
+require 'ttycoke'