ohboyohboyohboy-monocle-print 1.1.1

data/lib/monocle-print/table/column.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class Table
+class Column
+  include MonoclePrint
+
+  def initialize( table, index )
+    @table        = table
+    @index        = index
+    @wrap         = false
+    @flow         = false
+    @alignment    = :left
+    @fixed_width  = nil
+    @cached_width = nil
+  end
+
+  attr_reader   :table, :index
+  attr_accessor :alignment
+
+  for m in %w( wrap flow )
+    attr_accessor( m )
+    alias_method( "#{m}?", m )
+    undef_method( m )
+  end
+
+  def malleable?
+    @wrap and @flow
+  end
+
+  def malleable=( bool )
+    @wrap = @flow = bool
+  end
+
+  def fixed?
+    not malleable?
+  end
+
+  def fixed=( bool )
+    self.malleable = !bool
+  end
+
+  def title
+    @table.titles[ @index ]
+  end
+
+  def cells
+    @table.grep( Row ) { | row | row[ @index ] || Line( '' ) }
+  end
+
+  def previous_column
+    @index.zero? ? nil : @table.columns[ @index - 1 ]
+  end
+
+  def next_column
+    @table.columns[ @index + 1 ]
+  end
+
+  def first?
+    @index.zero?
+  end
+
+  def last?
+    @index == (table.columns.length - 1)
+  end
+
+  def prepare( cell_text )
+    cell_text = cell_text ? cell_text.dup : Text( ' ' )
+    @flow and cell_text.reflow!( false )
+    @wrap and cell_text = cell_text.wrap( width - 1 )
+    cell_text.align!( @alignment, width )
+  end
+
+  def width=( w )
+    @fixed_width = Utils.at_least( w.to_i, 1 )
+  end
+
+  def width
+    @fixed_width or @cached_width or calculate_width
+  end
+
+  def calculate_metrics
+    @cached_width = @fixed_width || calculate_width
+  end
+
+  def clear_metrics
+    @cached_width = nil
+  end
+
+protected
+
+  def calculate_width
+    @table.grep( Row ) { |r| c = r[ @index ] and c.width or 0 }.max || 0
+  end
+end
+end
+end

data/lib/monocle-print/table/members.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class Table
+class Member
+  include MonoclePrint
+  include Enumerable
+
+  class << self
+    attr_reader :member_name
+    def define( member_name, sup = self, &body )
+      klass =
+        Class.new( sup ) do
+          @member_name = member_name
+          class_eval( &body )
+        end
+
+      define_method( "#{ member_name }!" ) do |*args|
+        klass.new( @table, *args ) { |m| link( m ) }.tail
+      end
+      return( klass )
+    end
+  end
+
+  attr_reader :table
+  attr_accessor :before, :after
+  protected :before=, :after=
+
+  def initialize( table, *args )
+    @table    = table
+    @before   = nil
+    @after    = nil
+    @disabled = false
+    block_given? and yield( self )
+    initialize!( *args )
+  end
+
+  def initialize!( * )
+    # do nothing
+  end
+
+  def inspect( *args )
+    content = args.map! { |a| a.inspect }.join(', ')
+    "#{self.class.member_name}(#{content})"
+  end
+
+  def each
+    block_given? or return( enum_for( __method__ ) )
+    node = self
+    begin
+      yield( node )
+      node = node.after
+    end while( node )
+  end
+
+  def disable
+    @disabled = true
+  end
+
+  def enable
+    @disabled = false
+  end
+
+  def enabled?
+    not disabled?
+  end
+
+  def disabled?
+    @disabled
+  end
+
+  def first?
+    @before.nil?
+  end
+
+  def last?
+    @after.nil?
+  end
+
+  def link( item )
+    after, @after, item.before = @after, item, self
+    after ? item.link( after ) : item
+  end
+
+  def unlink
+    @before and @before.after = nil
+    @before = nil
+    return( self )
+  end
+
+  def render( out, style )
+    render!( out, style ) unless disabled?
+  end
+
+  def columns
+    table.columns
+  end
+
+  def tail
+    @after ? @after.tail : self
+  end
+end
+
+Blank =
+  Member.define( 'blank' ) do
+    def render!( * )
+    end
+  end
+
+Row =
+  Member.define( 'row' ) do
+    def initialize!( *content )
+      @cells = [ content ].flatten!.map! { | c | Text( c ) }
+      @table.expand_columns( @cells.length )
+    end
+
+    def []( index )
+      @cells[ index ]
+    end
+
+    def []=(index, value)
+      @cells[ index ] = value
+    end
+
+    def cells
+      @table.columns.zip( @cells ).
+        map! { | col, cell | col.prepare( cell ) }
+    end
+
+    def height
+      cells.map! { | c | c.height }.max
+    end
+
+    def render!( out, style )
+      cells =
+        @table.columns.zip( @cells ).map! do | col, cell |
+          col.prepare( cell )
+        end
+
+      height = cells.map { | col, cell | cell ? cell.height : 1 }.max
+
+      joint = style.format( ' <v> ' )
+      left  = style.format( '<v> ' )
+      right = style.format( ' <v>' )
+
+      result = cells.inject { | result, cell | result.juxtapose( cell, joint ) }
+      result.each do | line |
+        out.put!( left + line + right )
+      end
+      return( out )
+    end
+
+    def inspect
+      super( *cells )
+    end
+
+  private
+
+    def prepare
+      height = cells.map { | c | c.height }.max
+      if height > 1
+        cell_lines.zip( @table.columns ) do | lines, col |
+          if lines.length < height
+            blank = col.fill_text( ' ' )
+            lines.fill( blank, lines.length, height - lines.length )
+          end
+        end
+      end
+      return( cell_lines )
+    end
+
+    def pad
+      n = @table.columns.length
+      m = @cells.length
+      @cells.fill( Text(' '), m, n - m ) if n > m
+    end
+  end
+
+TitleRow =
+  Member.define( 'title_row', Row ) do
+    def initialize!( *content )
+      super
+      divider!( :title )
+    end
+  end
+
+Divider =
+  Member.define( 'divider' ) do
+    attr_accessor :type
+
+    def initialize!( type )
+      @type = type.to_sym
+    end
+
+    def render( out, style )
+      super( out, style ) unless @after.is_a?( Divider )
+    end
+
+    def inspect( *args )
+      super( @type, *args )
+    end
+
+    def render!( out, style )
+      fills = @table.columns.map { | c | "<h:#{ c.width + 2 }>" }
+      template =
+        case @type
+        when :row, :title
+          '<nse>' << fills.join( '<hv>' ) << '<nsw>'
+        when :section_open
+          '<nse>' << fills.join( '<hs>' ) << '<nsw>'
+        when :section_close
+          '<nse>' << fills.join( '<hn>' ) << '<nsw>'
+        when :head
+          '<se>' << fills.join( '<hs>' ) << '<sw>'
+        when :foot
+          '<ne>' << fills.join( '<hn>' ) << '<nw>'
+        end
+      out.puts( style.format( template ) )
+    end
+  end
+
+SectionTitle =
+  Member.define( 'section' ) do
+    attr_accessor :title, :alignment
+
+    def initialize!( title, options = {} )
+      @title = Text( title )
+      @alignment = options.fetch( :align, :left )
+      @before.divider!( :section_close )
+      divider!( :section_open )
+    end
+
+    def inspect
+      super( @title, @alignment )
+    end
+
+    def render!( out, style )
+      w     = @table.inner_width
+      title = @title.width > w ? @title.wrap( w ) : @title
+      left  = style.format( '<v> ' )
+      right = style.format( ' <v>' )
+
+      for line in title.align( @alignment, w )
+        out.puts(  left + line + right )
+      end
+    end
+
+  end
+
+end
+end

data/lib/monocle-print/table/segments.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class Table
+
+Segments = Struct.new(
+  :head, :title_row, :title_divider, :row, :row_divider,
+  :section, :section_close, :section_open, :foot
+)
+
+class Segments
+  include MonoclePrint
+  
+  def self.default_filling( style )
+    fill = style.new.dup
+    new( fill, nil, fill, nil, fill, nil, fill, fill, fill )
+  end
+  
+  def self.default_joints( style )
+    head = style.format( "<h><hd><h>" )
+    row  = style.format( " <v> " )
+    div  = style.format( "<h><hv><h>" )
+    foot = style.format( "<h><hu><h>" )
+    
+    new( head, row, div, row, div, nil, foot, head, foot )
+  end
+  
+  def self.default_left_edge( style )
+    head = style.format( "<dr><h>" )
+    row  = style.format( "<v> " )
+    div  = style.format( "<vr><h>" )
+    foot = style.format( "<ur><h>" )
+    new( head, row, div, row, div, row, div, div, foot )
+  end
+  
+  def self.default_right_edge( style )
+    head = style.format( "<h><dl>" )
+    row  = style.format( " <v>" )
+    div  = style.format( "<h><vl>" )
+    foot = style.format( "<h><ul>" )
+    new( head, row, div, row, div, row, div, div, foot )
+  end
+  
+  def mask( inclusion_settings )
+    masked = self.class.new
+    each_pair do | name, text |
+      if text and inclusion_settings[ name ]
+        masked[ name ] = text
+      end
+    end
+    return( masked )
+  end
+  
+  def width( inclusion_mask = nil )
+    inclusion_mask and return( self.mask( inclusion_mask ).width )
+    return( map { |text| text ? text.width : 0 }.max )
+  end
+end
+
+end
+end

data/lib/monocle-print/terminal-escapes.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+#require 'termios'
+#require 'terminfo'
+
+module MonoclePrint
+module TerminalEscapes
+  ANSI_COLORS = {
+    :blue => 4,   :white => 7,  :magenta => 5,
+    :yellow => 3, :green => 2,  :black => 0,
+    :red => 1,    :cyan => 6
+  }
+  ANSI_COLOR_NAMES = ANSI_COLORS.keys.freeze
+
+  ANSI_MODIFIERS =
+    {
+      :bold      => 1,
+      :underline => 4,
+      :blink     => 5,
+      :reverse   => 7,
+      :conceal   => 8
+    }
+  ANSI_MODIFIER_NAMES = ANSI_MODIFIERS.keys.freeze
+
+  module_function
+
+  #def term_info
+  #  @term_info ||= TermInfo.new
+  #end
+
+  def ansi_color( type, color, bold = nil )
+    offset =
+      case type
+      when ?f then 30  # foreground
+      when ?b then 40  # background
+      end
+    code = offset + ANSI_COLORS.fetch( color.to_sym ) do
+      raise( ArgumentError, "unknown color name `%s'" % color )
+    end
+    "\e[#{ '1;' if bold }#{ code }m"
+  end
+
+  def xterm_color( type, color_index, bold = nil )
+    prefix =
+      case type
+      when ?f then 38  # foreground
+      when ?b then 48  # background
+      end
+    "\e[#{ prefix };5;#{ color_index }m"
+  end
+
+  def konsole_color( type, r, g, b, bold = nil)
+    prefix =
+      case type
+      when ?f then 38  # foreground
+      when ?b then 48  # background
+      end
+    "\e[#{ prefix };2;#{ r };#{ g };#{ b }m"
+  end
+
+  def ansi_modifier( name )
+    code =
+      ANSI_MODIFIERS.fetch( name.to_sym ) do
+        fail ArgumentError, "unknown modifier name `%s'" % name
+      end
+    "\e[#{ code }m"
+  end
+
+  def clear_attr
+    "\e[0m"
+  end
+
+  def bold
+    "\e[1m"
+  end
+
+  def underline
+    "\e[4m"
+  end
+
+  def blink
+    "\e[5m"
+  end
+
+  def reverse
+    "\e[7m"
+  end
+
+  def conceal
+    "\e[8m"
+  end
+
+  def set_cursor( line = 0, column = 0 )
+    "\e[%i;%iH" % [ line, column ]
+  end
+
+  def cursor_up( lines = 1 )
+    "\e[%iA" % lines
+  end
+
+  def cursor_down( lines = 1 )
+    "\e[%iB" % lines
+  end
+
+  def cursor_forward( columns = 1 )
+    "\e[%iC" % columns
+  end
+
+  def cursor_backward( columns = 1 )
+    "\e[%iD" % columns
+  end
+
+  def save_cursor
+    "\e[s"
+  end
+
+  def restore_cursor
+    "\e[u"
+  end
+
+  #def clear_line
+  #  "\e[K"
+  #end
+
+  # VT100 escapes
+  def double_height_top
+    "\e#3"
+  end
+
+  def dobule_height_bottom
+    "\e#4"
+  end
+
+  def single_width
+    "\e#5"
+  end
+
+  def double_width
+    "\e#6"
+  end
+
+  def clear_right
+    "\e[0K"
+  end
+
+  def clear_left
+    "\e[1K"
+  end
+
+  def clear_line
+    "\e[2K"
+  end
+
+  def clear_down
+    "\e[0J"
+  end
+
+  def clear_up
+    "\e[1J"
+  end
+
+  def clear_screen
+    "\e[2J"
+  end
+
+end
+end
+
+if __FILE__ == $0
+
+  TE = MonoclePrint::TerminalEscapes
+  for attr in %w[ bold underline blink reverse conceal ]
+    print( "This should be #{ attr }:".ljust( 30 ) )
+    printf( "%swhateva\e[0m\n", TE.send( attr ) )
+  end
+
+  colors = TE::ANSI_COLORS.keys.map(&:to_s).sort!
+  for color in colors
+    print( "This should be #{ color }:".ljust( 30 ) )
+    printf( "%swhateva\e[0m\t", TE.ansi_color( ?f, color ) )
+    printf( "%swhateva\e[0m\t", TE.ansi_color( ?b, color ) )
+    printf( "%sbright_whateva\e[0m\n", TE.ansi_color( ?f, color, true ) )
+  end
+
+  for dir in %w( left right line )
+    name = "clear_#{ dir }"
+    code = TE.send( name )
+    puts
+    puts("[ Clear Code: #{ name } ]")
+    puts
+    puts("at start")
+    printf("%s<= %-14s\n", code, name)
+    puts("in middle")
+    printf("%-14s =>%s<= %-14s\n", name, code, name)
+    puts("at end")
+    printf("%-14s =>%s\n", name, code, name)
+  end
+
+  puts( "[ Tabs ]" )
+  puts( "     \eHx              \eHx      \eHx ")
+  puts( "one\ttwo\tthree\tfour" )
+  puts( "\e[3g" )
+  puts( "one\ttwo\tthree\tfour" )
+end