aslakhellesoy-bcat 0.6.0.1

data/lib/bcat/ansi.rb

@@ -0,0 +1,170 @@
+class Bcat
+
+  # Converts ANSI color sequences to HTML.
+  #
+  # The ANSI module is based on code from the following libraries:
+  #
+  # ansi2html.sh:
+  #   http://github.com/pixelb/scripts/blob/master/scripts/ansi2html.sh
+  #
+  # HTML::FromANSI:
+  #   http://cpansearch.perl.org/src/NUFFIN/HTML-FromANSI-2.03/lib/HTML/FromANSI.pm
+  class ANSI
+    ESCAPE = "\x1b"
+
+    # Linux console palette
+    STYLES = {
+      'ef0'  => 'color:#000',
+      'ef1'  => 'color:#A00',
+      'ef2'  => 'color:#0A0',
+      'ef3'  => 'color:#A50',
+      'ef4'  => 'color:#00A',
+      'ef5'  => 'color:#A0A',
+      'ef6'  => 'color:#0AA',
+      'ef7'  => 'color:#AAA',
+      'ef8'  => 'color:#555',
+      'ef9'  => 'color:#F55',
+      'ef10' => 'color:#5F5',
+      'ef11' => 'color:#FF5',
+      'ef12' => 'color:#55F',
+      'ef13' => 'color:#F5F',
+      'ef14' => 'color:#5FF',
+      'ef15' => 'color:#FFF',
+      'eb0'  => 'background-color:#000',
+      'eb1'  => 'background-color:#A00',
+      'eb2'  => 'background-color:#0A0',
+      'eb3'  => 'background-color:#A50',
+      'eb4'  => 'background-color:#00A',
+      'eb5'  => 'background-color:#A0A',
+      'eb6'  => 'background-color:#0AA',
+      'eb7'  => 'background-color:#AAA',
+      'eb8'  => 'background-color:#555',
+      'eb9'  => 'background-color:#F55',
+      'eb10' => 'background-color:#5F5',
+      'eb11' => 'background-color:#FF5',
+      'eb12' => 'background-color:#55F',
+      'eb13' => 'background-color:#F5F',
+      'eb14' => 'background-color:#5FF',
+      'eb15' => 'background-color:#FFF'
+    }
+
+    ##
+    # The default xterm 256 colour palette
+
+    (0..5).each do |red|
+      (0..5).each do |green|
+        (0..5).each do |blue|
+          c = 16 + (red * 36) + (green * 6) + blue
+          r = red   > 0 ? red   * 40 + 55 : 0
+          g = green > 0 ? green * 40 + 55 : 0
+          b = blue  > 0 ? blue  * 40 + 55 : 0
+          STYLES["ef#{c}"] = "color:#%2.2x%2.2x%2.2x" % [r, g, b]
+          STYLES["eb#{c}"] = "background-color:#%2.2x%2.2x%2.2x" % [r, g, b]
+        end
+      end
+    end
+
+    (0..23).each do |gray|
+      c = gray+232
+      l = gray*10 + 8
+      STYLES["ef#{c}"] = "color:#%2.2x%2.2x%2.2x" % [l, l, l]
+      STYLES["eb#{c}"] = "background-color:#%2.2x%2.2x%2.2x" % [l, l, l]
+    end
+
+    def initialize(input)
+      @input =
+        if input.respond_to?(:to_str)
+          [input]
+        elsif !input.respond_to?(:each)
+          raise ArgumentError, "input must respond to each"
+        else
+          input
+        end
+      @stack = []
+    end
+
+    def to_html
+      buf = []
+      each { |chunk| buf << chunk }
+      buf.join
+    end
+
+    def each
+      buf = ''
+      @input.each do |chunk|
+        buf << chunk
+        tokenize(buf) do |tok, data|
+          case tok
+          when :text
+            yield data
+          when :display
+            case code = data
+            when 0        ; yield reset_styles if @stack.any?
+            when 1        ; yield push_tag("b") # bright
+            when 2        ; #dim
+            when 3, 4     ; yield push_tag("u")
+            when 5, 6     ; yield push_tag("blink")
+            when 7        ; #reverse
+            when 8        ; yield push_style("display:none")
+            when 9        ; yield push_tag("strike")
+            when 30..37   ; yield push_style("ef#{code - 30}")
+            when 40..47   ; yield push_style("eb#{code - 40}")
+            when 90..97   ; yield push_style("ef#{8 + code - 90}")
+            when 100..107 ; yield push_style("eb#{8 + code - 100}")
+            end 
+          end
+        end
+      end
+      yield buf if !buf.empty?
+      yield reset_styles if @stack.any?
+      self
+    end
+
+    def push_tag(tag, style=nil)
+      style = STYLES[style] if style && !style.include?(':')
+      @stack.push tag
+      [ "<#{tag}",
+        (" style='#{style}'" if style),
+        ">"
+      ].join
+    end
+
+    def push_style(style)
+      push_tag "span", style
+    end
+
+    def reset_styles
+      stack, @stack = @stack, []
+      stack.reverse.map { |tag| "</#{tag}>" }.join
+    end
+
+    def tokenize(text)
+      tokens = [
+        # characters to remove completely
+        [/\A\x08+/, lambda { |m| '' }],
+
+        # ansi escape sequences that mess with the display
+        [/\A\x1b\[((?:\d{1,3};?)+|)m/, lambda { |m|
+          m = '0' if m.strip.empty?
+          m.chomp(';').split(';').
+          each { |code| yield :display, code.to_i };
+          '' }],
+
+        # malformed sequences
+        [/\A\x1b\[?[\d;]{0,3}/, lambda { |m| '' }],
+
+        # real text
+        [/\A([^\x1b\x08]+)/m, lambda { |m| yield :text, m; '' }]
+      ]
+
+      while (size = text.size) > 0
+        tokens.each do |pattern, sub|
+          while text.sub!(pattern) { sub.call($1) }
+          end
+        end
+        break if text.size == size
+      end
+    end
+
+  end
+end

data/lib/bcat/browser.rb

@@ -0,0 +1,68 @@
+class Bcat
+  class Browser
+    ENVIRONMENT =
+      case `uname`
+      when /Darwin/       ; 'Darwin'
+      when /Linux/, /BSD/ ; 'X11'
+      else                  'X11'
+      end
+
+    # browser name -> command mappings
+    COMMANDS = {
+      'Darwin' => {
+        'default'     => "open",
+        'safari'      => "open -a Safari",
+        'firefox'     => "open -a Firefox",
+        'chrome'      => "open -a Google\\ Chrome",
+        'chromium'    => "open -a Chromium",
+        'opera'       => "open -a Opera",
+        'curl'        => "curl -s"
+      },
+
+      'X11'  => {
+        'default'     => "xdg-open",
+        'firefox'     => "firefox",
+        'chrome'      => "google-chrome",
+        'chromium'    => "chromium",
+        'mozilla'     => "mozilla",
+        'epiphany'    => "epiphany",
+        'curl'        => "curl -s"
+      }
+    }
+
+    # alternative names for browsers
+    ALIASES = {
+      'google-chrome' => 'chrome',
+      'google chrome' => 'chrome',
+      'gnome'         => 'epiphany'
+    }
+
+    def initialize(browser, command=ENV['BCAT_COMMAND'])
+      @browser = browser
+      @command = command
+    end
+
+    def open(url)
+      fork do
+        $stdin.close
+        exec "#{command} #{shell_quote(url)}"
+        exit! 128
+      end
+    end
+
+    def command
+      @command || browser_command
+    end
+
+    def browser_command(browser=@browser)
+      browser ||= 'default'
+      browser = browser.downcase
+      browser = ALIASES[browser] || browser
+      COMMANDS[ENVIRONMENT][browser]
+    end
+
+    def shell_quote(argument)
+      '"' + argument.to_s.gsub(/([\\"`$])/) { "\\" + $1 } + '"'
+    end
+  end
+end

data/lib/bcat/html.rb

@@ -0,0 +1,106 @@
+class Bcat
+
+  # Parses HTML until the first displayable body character and provides methods
+  # for accessing head and body contents.
+  class HeadParser
+    attr_accessor :buf
+
+    def initialize
+      @buf = ''
+      @head = []
+      @body = nil
+      @html = nil
+    end
+
+    # Called to parse new data as it arrives.
+    def feed(data)
+      if complete?
+        @body << data
+      else
+        @buf << data
+        parse(@buf)
+      end
+      complete?
+    end
+
+    # Truthy once the first displayed character of the body has arrived.
+    def complete?
+      !@body.nil?
+    end
+
+    # Determine if the input is HTML. This is nil before the first non-whitespace
+    # character is received, true if the first non-whitespace character is a
+    # '<', and false if the first non-whitespace character is something other
+    # than '<'.
+    def html?
+      @html
+    end
+
+    # The head contents without any DOCTYPE, <html>, or <head> tags. This should
+    # consist of only <style>, <script>, <link>, <meta>, <base>, and <title> tags.
+    def head
+      @head.join.gsub(/<\/?(?:html|head|!DOCTYPE).*?>/mi, '')
+    end
+
+    # The current body contents. The <body> tag is guaranteed to be present. If
+    # a <body> was included in the input, it's preserved with original
+    # attributes; otherwise, a <body> tag is inserted. The inject argument can
+    # be used to insert a string as the immediate descendant of the <body> tag.
+    def body(inject=nil)
+      if @body =~ /\A\s*(<body.*?>)(.*)/mi
+        [$1, inject, $2].compact.join("\n")
+      else
+        ["<body>", inject, @body].compact.join("\n")
+      end
+    end
+
+    HEAD_TOKS = [
+      /\A(<!DOCTYPE.*?>)/m,
+      /\A(<title.*?>.*?<\/title>)/mi,
+      /\A(<script.*?>.*?<\/script>)/mi,
+      /\A(<style.*?>.*?<\/style>)/mi,
+      /\A(<(?:html|head|meta|link|base).*?>)/mi,
+      /\A(<\/(?:html|head|meta|link|base|script|style|title)>)/mi,
+      /\A(<!--(.*?)-->)/m
+    ]
+
+    BODY_TOKS = [
+      /\A[^<]/,
+      /\A<(?!html|head|meta|link|base|script|style|title).*?>/
+    ]
+
+    # Parses buf into head and body parts. Basic approach is to eat anything
+    # possibly body related until we hit text or a body element.
+    def parse(buf=@buf)
+      if @html.nil?
+        if buf =~ /\A\s*[<]/m
+          @html = true
+        elsif buf =~ /\A\s*[^<]/m
+          @html = false
+        end
+      end
+
+      while !buf.empty?
+        buf.sub!(/\A(\s+)/m) { @head << $1 ; '' }
+        matched =
+          HEAD_TOKS.any? do |tok|
+            buf.sub!(tok) do
+              @head << $1
+              ''
+            end
+          end
+        break unless matched
+      end
+
+
+      if buf.empty?
+        buf
+      elsif BODY_TOKS.any? { |tok| buf =~ tok }
+        @body = buf
+        nil
+      else
+        buf
+      end
+    end
+  end
+end

data/lib/bcat/reader.rb

@@ -0,0 +1,102 @@
+require 'rack/utils'
+
+class Bcat
+  # ARGF style multi-file streaming interface. Input is read with IO#readpartial
+  # to avoid buffering.
+  class Reader
+    attr_reader :is_command
+    attr_reader :args
+    attr_reader :fds
+
+    def initialize(is_command, args=[])
+      @is_command = is_command
+      @args = args
+    end
+
+    def open
+      @fds = is_command ? open_command : open_files
+      @buf = []
+    end
+
+    def open_command
+      [IO.popen(args.join(' '), 'rb')]
+    end
+
+    def open_files
+      args.map do |f|
+        if f == '-'
+          $stdin
+        else
+          File.open(f, 'rb')
+        end
+      end
+    end
+
+    def each
+      yield @buf.shift while @buf.any?
+      while fd = fds.first
+        fds.shift and next if fd.closed?
+        fd.sync = true
+        begin
+          while buf = fd.readpartial(4096)
+            yield buf
+          end
+        rescue EOFError
+          fd.close
+        end
+        fds.shift
+      end
+    end
+
+    def sniff
+      @format ||=
+        catch :detect do
+          each do |chunk|
+            @buf << chunk
+            case chunk
+            when /\A\s*</m
+              throw :detect, 'html'
+            when /\A\s*[^<]/m
+              throw :detect, 'text'
+            end
+          end
+          throw :detect, 'text'
+        end
+    end
+  end
+
+  # Like Reader but writes all input to an output IO object in addition to
+  # yielding to the block.
+  class TeeFilter
+    def initialize(source, out=$stdout)
+      @source = source
+      @out = out
+    end
+
+    def each
+      @source.each do |chunk|
+        yield chunk
+        @out.write chunk
+      end
+    end
+  end
+
+  class TextFilter
+    include Rack::Utils
+
+    def initialize(source, force=false)
+      @source = source
+      @force = force
+    end
+
+    def each
+      yield "<pre>"
+      @source.each do |chunk|
+        chunk = escape_html(chunk)
+        chunk = "<span>#{chunk}</span>" if !chunk.gsub!(/\n/, "<br>")
+        yield chunk
+      end
+      yield "</pre>"
+    end
+  end
+end

data/lib/bcat/server.rb

@@ -0,0 +1,113 @@
+require 'socket'
+require 'stringio'
+require 'rack/utils'
+
+class Bcat
+  # Simple Rack handler based largely on Scott Chacon's kidgloves library:
+  # http://github.com/schacon/kidgloves
+  class Server
+    attr_accessor :app
+
+    def self.run(app, options={}, &block)
+      new(app, options).listen(&block)
+    end
+
+    def initialize(app, options={})
+      @app = app
+      @host = options[:Host] || '0.0.0.0'
+      @port = options[:Port] || 8089
+    end
+
+    def bind(host, port)
+      TCPServer.new(host, port)
+    rescue Errno::EADDRINUSE
+      port += 1
+      retry
+    end
+
+    def listen
+      server = TCPServer.new(@host, @port)
+
+      yield server if block_given?
+
+      loop do
+        socket = server.accept
+        socket.sync = true
+        log "#{socket.peeraddr[2]} (#{socket.peeraddr[3]})"
+        begin
+          req = {}
+
+          # parse the request line
+          request = socket.gets
+          method, path, version = request.split(" ", 3)
+          req["REQUEST_METHOD"] = method
+          info, query = path.split("?")
+          req["PATH_INFO"] = info
+          req["QUERY_STRING"] = query
+
+          # parse the headers
+          while (line = socket.gets)
+            line.strip!
+            break if line.size == 0
+            key, val = line.split(": ")
+            key = key.upcase.gsub('-', '_')
+            key = "HTTP_#{key}" if !%w[CONTENT_TYPE CONTENT_LENGTH].include?(key)
+            req[key] = val
+          end
+
+          # parse the body
+          body =
+            if len = req['CONTENT_LENGTH']
+              socket.read(len.to_i)
+            else
+              ''
+            end
+
+          # process the request
+          process_request(req, body, socket)
+        ensure
+          socket.close if not socket.closed?
+        end
+      end
+    end
+
+    def log(message)
+      # $stderr.puts message
+    end
+
+    def status_message(code)
+      Rack::Utils::HTTP_STATUS_CODES[code]
+    end
+
+    def process_request(request, input_body, socket)
+      env = {}.replace(request)
+      env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+      env["QUERY_STRING"] ||= ""
+      env["SCRIPT_NAME"] = ""
+
+      rack_input = StringIO.new(input_body)
+      rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+      env.update(
+        "rack.version"      => [1,0],
+        "rack.input"        => rack_input,
+        "rack.errors"       => $stderr,
+        "rack.multithread"  => true,
+        "rack.multiprocess" => true,
+        "rack.run_once"     => false,
+        "rack.url_scheme"   => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+      )
+      status, headers, body = app.call(env)
+      begin
+        socket.write("HTTP/1.1 #{status} #{status_message(status)}\r\n")
+        headers.each do |k, vs|
+          vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
+        end
+        socket.write("\r\n")
+        body.each { |s| socket.write(s) }
+      ensure
+        body.close if body.respond_to? :close
+      end
+    end
+  end
+end