ansi-sys 0.2.0

data/lib/ansisys.rb

@@ -0,0 +1,595 @@
+#
+# = ansisys.rb
+# ANSI terminal emulator
+# based on http://en.wikipedia.org/wiki/ANSI_escape_code
+#
+# Copyright:: Copyright (C) 2007 zunda <zunda at freeshell.org>
+# License:: GPL - GPL3 or later
+#
+require 'webrick'
+
+module AnsiSys
+	module VERSION	#:nodoc:
+		MAJOR = 0
+		MINOR = 2
+		TINY = 0
+
+		STRING = [MAJOR, MINOR, TINY].join('.')
+	end
+
+	module CSSFormatter
+		def hash_to_styles(hash, separator = '; ')
+			unless hash.empty?
+				return hash.map{|e| "#{e[0]}: #{e[1].join(' ')}"}.join(separator)
+			else
+				return nil
+			end
+		end
+		module_function :hash_to_styles
+	end
+
+	class AnsiSysError < StandardError; end
+
+	class Lexer
+		# Control Sequence Introducer and following code
+		PARAMETER_AND_LETTER = /\A([\d;]*)([[:alpha:]])/o
+		CODE_EQUIVALENT = {
+			"\r" => ['B'],
+			"\n" => ['E'],
+		}
+
+		attr_reader :buffer
+
+		def initialize(csis = ["\x1b["])	# CSI can also be "\x9B"
+			@code_start_re = Regexp.union(*(CODE_EQUIVALENT.keys + csis))
+			@buffer = ''
+		end
+
+		def push(string)
+			@buffer += string
+		end
+
+		# returns array of tokens while deleting the tokenized part of the string
+		def lex!
+			r = Array.new
+			@buffer.gsub!(/(?:\r\n|\n\r)/, "\n")
+			while @code_start_re =~ @buffer
+				r << [:string, $`] unless $`.empty?
+				if CODE_EQUIVALENT.has_key?($&)
+					CODE_EQUIVALENT[$&].each do |c|
+						r << [:code, c]
+					end
+					@buffer = $'
+				else
+					csi = $&
+					residual = $'
+					if PARAMETER_AND_LETTER =~ residual
+						r << [:code, $&]
+						@buffer = $'
+					else
+						@buffer = csi + residual
+						return r
+					end
+				end
+			end
+			r << [:string, @buffer] unless @buffer.empty?
+			@buffer = ''
+			return r
+		end
+	end
+
+	class Characters
+		WIDTHS = {
+			"\t" => 8,
+		}
+
+		attr_reader :string
+		attr_reader :sgr
+		attr_reader :initial_cursor
+
+		def initialize(string, sgr)
+			@string = string
+			@sgr = sgr
+		end
+
+		def echo_on(screen, cursor)
+			each_char do |c|
+				w = width(c)
+				screen.write(c, w, cursor.cur_col, cursor.cur_row, @sgr.dup)
+				cursor.advance!(w)
+			end
+			return self
+		end
+
+		private
+		def each_char(&block)
+			@string.scan(/./).each do |c|
+				yield(c)
+			end
+		end
+
+		def width(char)
+			if WIDTHS.has_key?(char)
+				return WIDTHS[char]
+			end
+			case char.size	# expecting number of bytes
+			when 1
+				return 1
+			else
+				return 2
+			end
+		end
+	end
+
+	class Cursor
+		CODE_LETTERS = %w(A B C D E F G H f)
+
+		attr_reader :cur_col
+		attr_reader :cur_row
+		attr_accessor :max_col
+		attr_accessor :max_row
+
+		def initialize(cur_col = 1, cur_row = 1, max_col = 80, max_row = 25)
+			@cur_col = cur_col
+			@cur_row = cur_row
+			@max_col = max_col
+			@max_row = max_row
+		end
+
+		def apply_code!(args)
+			letter = args.pop
+			pars = args.map do |arg|
+				case arg
+				when nil
+					nil
+				when ''
+					nil
+				else
+					Integer(arg)
+				end
+			end
+			case letter
+			when 'A'
+				@cur_row -= pars[0] ? pars[0] : 1
+				@cur_row = @max_row if @max_row and @cur_row > @max_row
+			when 'B'
+				@cur_row += pars[0] ? pars[0] : 1
+				@cur_row = @max_row if @max_row and @cur_row > @max_row
+			when 'C'
+				@cur_col += pars[0] ? pars[0] : 1
+			when 'D'
+				@cur_col -= pars[0] ? pars[0] : 1
+			when 'E'
+				@cur_row += pars[0] ? pars[0] : 1
+				@cur_col = 1
+				@max_row = @cur_row if @max_row and @cur_row > @max_row
+			when 'F'
+				@cur_row -= pars[0] ? pars[0] : 1
+				@cur_col = 1
+				@max_row = @cur_row if @max_row and @cur_row > @max_row
+			when 'G'
+				@cur_col = pars[0] ? pars[0] : 1
+			when 'H'
+				@cur_row = pars[0] ? pars[0] : 1
+				@cur_col = pars[1] ? pars[1] : 1
+				@max_row = @cur_row if @max_row and @cur_row > @max_row
+			when 'f'
+				@cur_row = pars[0] ? pars[0] : 1
+				@cur_col = pars[1] ? pars[1] : 1
+				@max_row = @cur_row if @max_row and @cur_row > @max_row
+			end
+			if @cur_row < 1
+				@cur_row = 1
+			end
+			if @cur_col < 1
+				@cur_col = 1
+			elsif @cur_col > @max_col
+				@cur_col = @max_col
+			end
+			return self
+		end
+
+		def advance!(width = 1)
+			r = nil
+			@cur_col += width
+			if @cur_col > @max_col
+				r = "\n"
+				@cur_col = 1
+				@cur_row += 1
+			end
+			return r
+		end
+
+	end
+
+	# Select Graphic Rendition
+	class SGR
+		extend CSSFormatter
+
+		CODE_LETTERS = %w(m)
+
+		attr_reader :intensity	# :normal, :bold, or :faint
+		attr_reader :italic	# :off or :on
+		attr_reader :underline	# :none, :single, or :double
+		attr_reader :blink	# :off, :slow, or :rapid
+		attr_reader :image	# :positive or :negative
+		attr_reader :conceal	# :off or :on
+		attr_reader :foreground	# :black, :red, :green, :yellow, :blue, :magenta, :cyan, or :white
+		attr_reader :background	# :black, :red, :green, :yellow, :blue, :magenta, :cyan, or :white
+
+		def initialize
+			reset!
+		end
+
+		def ==(other)
+			instance_variables.each do |ivar|
+				return false unless instance_eval(ivar) == other.instance_eval(ivar)
+			end
+			return true
+		end
+
+		def reset!
+			apply_code!(%w(0 m))
+		end
+
+		def apply_code!(args = %w(0 m))
+			letter = args.pop
+			raise AnsiSysError, "Invalid code for SGR" unless 'm' == letter
+			pars = args.map{|arg| arg.to_i}
+			pars = [0] if pars.empty?
+			pars.each do |code|
+				case code
+				when 0
+					@intensity = :normal
+					@italic = :off
+					@underline = :none
+					@blink = :off
+					@image = :positive
+					@conceal = :off
+					@foreground = :white
+					@background = :black
+				when 1..28
+					apply_code_table!(code)
+				when 30..37
+					@foreground = COLOR[code - 30]
+					@intensity = :normal
+				when 39
+					reset!
+				when 40..47
+					@background = COLOR[code - 40]
+					@intensity = :normal
+				when 49
+					reset!
+				when 90..97
+					@foreground = COLOR[code - 90]
+					@intensity = :bold
+				when 99
+					reset!
+				when 100..107
+					@background = COLOR[code - 100]
+					@intensity = :bold
+				when 109
+					reset!
+				else
+					raise AnsiSysError, "Invalid SGR code #{code.inspect}" unless CODE.has_key?(code)
+				end
+			end
+			return self
+		end
+
+		def render(format = :html, position = :prefix, colors = Screen.default_css_colors)
+			case format
+			when :html
+				case position
+				when :prefix
+					style_code = css_style(colors)
+					if style_code
+						return %Q|<span style="#{style_code}">|
+					else
+						return ''
+					end
+				when :postfix
+					style_code = css_style(colors)
+					if style_code
+						return '</span>'
+					else
+						return ''
+					end
+				end
+			when :text
+				return ''
+			end
+		end
+
+		def css_style(colors = Screen.default_css_colors)
+			return CSSFormatter.hash_to_styles(css_styles(colors))
+		end
+
+		def css_styles(colors = Screen.default_css_colors)
+			r = Hash.new{|h, k| h[k] = Array.new}
+			# intensity is not (yet) implemented
+			r['font-style'] << 'italic' if @italic == :on
+			r['text-decoration'] << 'underline' unless @underline == :none
+			r['text-decoration'] << 'blink' unless @blink == :off
+			case @image
+			when :positive
+				fg = @foreground
+				bg = @background
+			when :negative
+				fg = @background
+				bg = @foreground
+			end
+			fg = bg if @conceal == :on
+			r['color'] << colors[@intensity][fg] unless fg == :white
+			r['background-color'] << colors[@intensity][bg] unless bg == :black
+			return r
+		end
+
+		private
+		def apply_code_table!(code)
+			raise AnsiSysError, "Invalid SGR code #{code.inspect}" unless CODE.has_key?(code)
+			ivar, value = CODE[code]
+			instance_variable_set("@#{ivar}", value)
+			return self
+		end
+
+		CODE = {
+			1 => [:intensity, :bold],
+			2 => [:intensity, :faint],
+			3 => [:italic, :on],
+			4 => [:underline, :single],
+			5 => [:blink, :slow],
+			6 => [:blink, :rapid],
+			7 => [:image, :negative],
+			8 => [:conceal, :on],
+			21 => [:underline, :double],
+			22 => [:intensity, :normal],
+			24 => [:underline, :none],
+			25 => [:blink, :off],
+			27 => [:image, :positive],
+			28 => [:conceal, :off],
+		}
+
+		COLOR = {
+			0 => :black,
+			1 => :red,
+			2 => :green,
+			3 => :yellow,
+			4 => :blue,
+			5 => :magenta,
+			6 => :cyan,
+			7 => :white,
+		}
+
+	end
+
+	class Screen
+		CODE_LETTERS = %w()
+
+		def self.default_foreground; :white; end
+		def self.default_background; :black; end
+
+		# intensity -> color
+		def self.default_css_colors(inverted = false, bright = false)
+			r = {
+				:normal => {
+					:black => 'black',
+					:red => 'maroon',
+					:green => 'green',
+					:yellow => 'olive',
+					:blue => 'navy',
+					:magenta => 'purple',
+					:cyan => 'teal',
+					:white => 'silver',
+				},
+				:bold => {
+					:black => 'gray',
+					:red => 'red',
+					:green => 'lime',
+					:yellow => 'yellow',
+					:blue => 'blue',
+					:magenta => 'fuchsia',
+					:cyan => 'cyan',
+					:white => 'white'
+				},
+				:faint => {
+					:black => 'black',
+					:red => 'maroon',
+					:green => 'green',
+					:yellow => 'olive',
+					:blue => 'navy',
+					:magenta => 'purple',
+					:cyan => 'teal',
+					:white => 'silver',
+				},
+			}
+
+			if bright
+				r[:bold][:black] = 'black'
+				[:normal, :faint].each do |i|
+					r[i] = r[:bold]
+				end
+			end
+
+			if inverted
+				r.each_key do |i|
+					r[i][:black], r[i][:white] = r[i][:white], r[i][:black]
+				end
+			end
+
+			return r
+		end
+
+		def self.css_styles(colors = Screen.default_css_colors, max_col = nil, max_row = nil)
+			h = {
+				'color' => [colors[:normal][:white]],
+				'background-color' => [colors[:normal][:black]],
+				'padding' => ['0.5em'],
+			}
+			h['width'] = ["#{Float(max_col)/2}em"] if max_col
+			#h['height'] = ["#{max_row}em"] if max_row	# could not find appropriate unit
+			return h
+		end
+
+		def self.css_style(*args)
+			return "pre.screen {\n\t" + CSSFormatter.hash_to_styles(self.css_styles(*args), ";\n\t") + ";\n}\n"
+		end
+
+		def initialize(colors = Screen.default_css_colors, max_col = nil, max_row = nil)
+			@colors = colors
+			@max_col = max_col
+			@max_row = max_row
+			@lines = Hash.new{|hash, key| hash[key] = Hash.new}
+		end
+
+		def css_style
+			self.class.css_style(@colors, @max_col, @max_row)
+		end
+
+		def write(char, char_width, col, row, sgr)
+			@lines[Integer(row)][Integer(col)] = [char, char_width, sgr.dup]
+		end
+
+		def render(format = :html, css_class = 'screen', css_style = nil)
+			result = case format
+			when :text
+				''
+			when :html
+				%Q|<pre#{css_class ? %Q[ class="#{css_class}"] : ''}#{css_style ? %Q| style="#{css_style}"| : ''}>\n|
+			else
+				raise AnsiSysError, "Invalid format option to render: #{format.inspect}"
+			end
+
+			unless @lines.keys.empty?
+				prev_sgr = nil
+				max_row = @lines.keys.max
+				(1..max_row).each do |row|
+					if @lines.has_key?(row) and not @lines[row].keys.empty?
+						col = 1
+						while col <= @lines[row].keys.max
+							if @lines[row].has_key?(col) and @lines[row][col]
+								char, width, sgr = @lines[row][col]
+								if prev_sgr != sgr
+									result += prev_sgr.render(format, :postfix, @colors) if prev_sgr
+									result += sgr.render(format, :prefix, @colors)
+									prev_sgr = sgr
+								end
+								case format
+								when :text
+									result += char
+								when :html
+									result += WEBrick::HTMLUtils.escape(char)
+								end
+								col += width
+							else
+								result += ' '
+								col += 1
+							end
+						end
+					end
+					result += "\n" if row < max_row
+				end
+				result += prev_sgr.render(format, :postfix, @colors) if prev_sgr
+			end
+
+			result += case format
+			when :text
+				''
+			when :html
+				'</pre>'
+			end
+			return result
+		end
+
+		def apply_code!(args)	# TODO - some codes
+			return self
+		end
+	end
+
+	class Terminal
+		CODE_LETTERS = []	# TODO - make a new screen
+
+		def initialize(csis = ["\x1b["])
+			@lexer = Lexer.new(csis)
+			@stream = Array.new
+		end
+
+		def echo(data)
+			@lexer.push(data)
+			return self
+		end
+
+		def css_style(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors)
+			case format
+			when :html
+				Screen.css_style(colors, max_col, max_row)
+			when :text
+				''
+			end
+		end
+
+		def render(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, css_class = 'screen', css_style = nil)
+			screens = populate(format, max_col, max_row, colors)
+			separator = case format
+			when :html
+				"\n"
+			when :text
+				"\n---\n"
+			end
+			return screens.map{|screen| screen.render(format, css_class, css_style)}.join(separator)
+		end
+
+		private
+		def populate(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors)
+			cursor = Cursor.new(1, 1, max_col, max_row)
+			screens = [Screen.new(colors, max_col, max_row)]
+			sgr = SGR.new
+			@stream += @lexer.lex!
+			@stream.each do |type, payload|
+				case type
+				when :string
+					Characters.new(payload, sgr).echo_on(screens[-1], cursor)
+				when :code
+					unless Lexer::PARAMETER_AND_LETTER =~ payload
+						raise AnsiSysError, "Invalid code: #{payload.inspect}"
+					end
+					parameters = $1
+					letter = $2
+					args = parameters.split(/;/) + [letter]
+					applied = false
+					[sgr, cursor, screens[-1], self].each do |recv|
+						if recv.class.const_get(:CODE_LETTERS).include?(letter)
+							recv.apply_code!(args)
+							applied = true
+						end
+					end
+					raise AnsiSysError, "Invalid code or not implemented: #{payload.inspect}" unless applied
+				end
+			end
+			return screens
+		end
+
+		def apply_code!(args) # TODO - make a new screen
+			return self
+		end
+	end
+end
+
+if defined?(Hiki) and Hiki::Plugin == self.class
+	def ansi_screen(file_name, max_row = 80, invert = false, bright = true, page = @page)
+		return '' unless file_name =~ /\.(txt|rd|rb|c|pl|py|sh|java|html|htm|css|xml|xsl|sql|yaml)\z/i 
+		page_file_name = "#{page.untaint.escape}/#{file_name.untaint.escape}"
+		path = "#{@conf.cache_path}/attach/#{page_file_name}"
+		unless File.exists?(path)
+			raise PluginError, "No such file:#{page_file_name}"
+		end
+		data = File.open(path){|f| f.read}
+
+		colors = AnsiSys::Screen.default_css_colors(invert, bright)
+		styles = AnsiSys::CSSFormatter.hash_to_styles(AnsiSys::Screen.css_styles(colors, max_row, nil), '; ')
+
+		terminal = AnsiSys::Terminal.new
+		terminal.echo(data)
+		return terminal.render(:html, max_row, nil, colors, 'screen', styles) + "\n"
+	end
+end