ohboyohboyohboy-monocle-print 1.1.1

data/lib/monocle-print/geometry.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+Pair = Struct.new( :x, :y )
+class Pair
+  alternate_names =
+    {
+      :x => %w( width column left ),
+      :y => %w( height line right )
+    }
+
+  alternate_names.each do | field, name_list |
+    name_list.each do | name |
+      alias_method( name, field )
+      alias_method( "#{ name }=", "#{ field }=" )
+    end
+  end
+
+  def initialize( x = 0, y = 0 )
+    super
+  end
+
+  def +@
+    self.column = 0
+    self.line += 1
+    self
+  end
+
+  def ~
+    self.column = 0
+    self
+  end
+
+  def -@
+    self.column = 0
+    self.line -= 1
+    self
+  end
+
+  def +( n )
+    self.column += n
+    self
+  end
+
+  def -( n )
+    self.column -= n
+    self
+  end
+end
+
+Rectangle = Struct.new( :left, :top, :right, :bottom )
+class Rectangle
+  def self.create( params )
+    left   = params.fetch( :left, 0 )
+    right  = params.fetch( :right, left )
+    top    = params.fetch( :top, left )
+    bottom = params.fetch( :bottom, top )
+    new( left, top, right, bottom )
+  end
+
+  def initialize( left = 0, top = left, right = left, bottom = top )
+    super( left, top, right, bottom )
+  end
+end
+end

data/lib/monocle-print/graphics.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'monocle-print/graphics/registry'
+
+module MonoclePrint
+Graphics =
+  Struct.new(
+    :ew,  # west east - horizontal line
+    :ns,  # north south - vertical line
+    :es,  # north west - top right corner
+    :sw,  # north east
+    :nw,  # south east
+    :en,  # south west
+    :ens, # north south east
+    :nsw, # north south west
+    :enw, # east north west
+    :esw, # east south west
+    :ensw, # east north south west - intersection of horiz & vertical lines
+    :tree_fork,
+    :tree_tail,
+    :blank
+  )
+
+class Graphics
+  include MonoclePrint
+  extend GraphicsRegistry
+
+  define :blank, '', '', '', '', '', '', '', '', '', '', '', '', ''
+  define :ascii, '-', '|', '+', '+', '+', '+', '+', '+', '+', '+', '+', '|', '`'
+  define :single_line, '─', '│', '┌', '┐', '┘', '└', '├', '┤', '┴', '┬', '┼', '├', '└'
+  define :double_line, '═', '║', '╔', '╗', '╝', '╚', '╠', '╣', '╩', '╦', '╬', '╠', '╚'
+
+  def format( description )
+    out = Line( description )
+    out.gsub!( /<([nsewlrtbudhv]+)(?::(\d+))?>/i ) do
+      box_bit = resolve_name( $1 )
+      $2 ? box_bit.tile( $2.to_i ) : box_bit
+    end
+    return( out )
+  end
+
+  def horizontal_line( width )
+    ew.tile( width )
+  end
+
+  def box_top( width )
+    format( "<se><ew:#{ width }><sw>" )
+  end
+
+  def box_bottom( width )
+    format( "<ne><ew:#{ width }><nw>" )
+  end
+
+  def table_top( *column_widths )
+    nw + line_with_joints( esw, column_widths ) + ne
+  end
+
+  def table_divide( *column_widths )
+    ens + line_with_joints( ensw, column_widths ) + nsw
+  end
+
+  def table_bottom( *column_widths )
+    sw + line_with_joints( enw, column_widths ) + se
+  end
+
+  def line_with_joints( joint, *widths )
+    widths.map { | w | horizontal_line( w ) }.join( joint )
+  end
+
+  alias h ew
+  alias v ns
+
+  private
+
+  def resolve_name( name )
+    name.downcase!
+    name.tr!( 'lrtbud', 'wensns' )
+    name.gsub!( 'h', 'ew' )
+    name.gsub!( 'v', 'ns' )
+    chars = name.chars.to_a.sort!
+    chars.uniq!
+    self[ chars.join('') ]
+  end
+end
+end

data/lib/monocle-print/graphics/registry.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#
+# author: Kyle Yetter
+#
+
+module MonoclePrint
+module GraphicsRegistry
+  ENV_KEY        = "MONOCLE_PRINT_STYLE"
+  FALLBACK_STYLE = "single_line"
+
+  attr_accessor :default_style
+
+  def named_styles
+    @named_styles ||= Hash.new { |h, k| h[ default_style ].dup }
+  end
+
+  def style?( name )
+    named_styles.key?( name.to_s )
+  end
+
+  def style( name )
+    named_styles[ name.to_s ]
+  end
+
+  def styles
+    named_styles.keys
+  end
+
+  def default_style
+    @default_style ||= detect_style_from_env
+  end
+
+  def default
+    style( default_style )
+  end
+
+  def define( name, *parts )
+    parts.map! { | p | Line( p ).freeze }
+    name       = name.to_s
+    definition = new( *parts ).freeze
+    named_styles.store( name, definition )
+    define_singleton_method( name ) { style( name ) }
+    definition
+  end
+
+  private
+
+  def detect_style_from_env
+    default_style = ENV.fetch( ENV_KEY, FALLBACK_STYLE )
+    unless style?( default_style )
+      message = <<-END.gsub!( /^\s*\| ?/, '' ).strip!.gsub!( /\s+/, ' ' )
+      | cannot set MonoclePrint's default graphics style
+      | from the MONOCLE_PRINT_STYLE environment variable as `%s'
+      | is not a known style; defaulting to `%s'
+      END
+      warn( message % [ default_style, FALLBACK_STYLE ] )
+      default_style = FALLBACK_STYLE
+    end
+    default_style
+  end
+end
+end

data/lib/monocle-print/layout.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class Layout < Array
+  include Presentation
+  
+  def initialize( options = nil )
+    initialize_view( options )
+    super( 0 )
+    block_given? and yield( self )
+  end
+end
+
+class Horizontal < Layout
+  
+  def width
+    inject( 0 ) do | width, view |
+      width + view.width
+    end
+  end
+  
+  def height
+    empty? ? 0 : collect { | view | view.height }.max
+  end
+  
+  def render
+    map { | i | i.render }.inject do | out, text |
+      out.juxtapose!( text )
+    end
+  end
+  
+end
+
+class Vertical < Layout
+  
+  def width
+    empty? ? 0 : collect { | view | view.width }.max
+  end
+  
+  def height
+    inject( 0 ) do | height, view |
+      height + view.height
+    end
+  end
+  
+  def render
+    map { | i | i.render }.inject do | out, text |
+      out.concat( text )
+    end.fix!
+  end
+  
+end
+
+class Flow < Layout
+  
+end
+end

data/lib/monocle-print/list.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class List
+  include Presentation
+
+  def initialize( *items )
+    @spacer = nil
+    @columns = nil
+
+    items = [ items ].flatten!
+    options = items.last.is_a?( Hash ) ? items.pop : nil
+    initialize_view( options )
+
+    @items = items.map! { | item | SingleLine.new( item ) }
+    @sorted = nil
+
+    if options
+      value = options[ :column_spacer ] and self.column_spacing = value
+      value = options[ :columns ] and self.columns = value
+    end
+    block_given? and yield( self )
+  end
+
+  def spacer( value = nil )
+    value and self.column_spacer = value
+    @spacer or SingleLine.new( '  ' )
+  end
+
+  def spacer= value
+    @spacer =
+      case value
+      when nil, SingleLine then value
+      else SingleLine.new( value )
+      end
+  end
+
+  def spacing( n )
+    self.spacing = n
+    spacer.width
+  end
+
+  def spacing= width
+    self.spacer = ' ' * Utils.at_least( width.to_i,  0 )
+  end
+
+  def columns( n = nil )
+    n and self.columns = n
+    @columns or optimize_columns
+  end
+
+  def columns= n
+    @columns =
+      case n
+      when nil then n
+      else Utils.at_least( n.to_i, 1 )
+      end
+  end
+
+private
+
+  def render_content( output )
+    unless columns = @columns
+      @sorted = sorted
+      columns = optimize_columns
+      @sorted = nil
+    end
+
+    widths = calculate_columns( columns )
+    number_of_rows = ( @items.length.to_f / columns ).ceil
+
+    each_column = @items.each_slice( number_of_rows )
+    columns = each_column.zip( widths ).map do | cells, width |
+      if cells.length < number_of_rows
+        cells.fill( SingleLine.new( '' ), cells.length,
+                    number_of_rows - cells.length )
+      end
+      cells.map! { | cell | cell.align( alignment, width ) }
+    end
+
+    for row in columns.transpose
+      output.puts( row.join( spacer ) )
+    end
+    return( output )
+  end
+
+  def sorted
+    @sorted or @items.each_with_index.sort_by { | item, index | -item.width }
+  end
+
+  def optimize_columns
+    limit = max_width
+    @items.empty? and return( nil )
+    c, rem = @items.length.divmod( 2 )
+    rem.zero? or c += 1
+    column_spacing = spacer.width
+
+    best_columns = 1
+    for number_of_rows in ( 1 .. c )
+      number_of_columns = ( @items.length.to_f / number_of_rows ).ceil
+      columns = calculate_columns( number_of_columns )
+      total_width = columns.inject( ( number_of_columns - 1 ) * column_spacing, :+ )
+      if total_width <= limit
+        best_columns = number_of_columns
+        break
+      end
+    end
+    return( best_columns )
+  end
+
+  #
+  # create a fixed number of columns, calculating respsective
+  # widths and indices within the list
+  #
+  def calculate_columns( n )
+    rows, rem = @items.length.divmod( n )
+    rem.zero? or rows += 1
+    columns = Array.new( n )
+    items = sorted.dup
+    # items is now ordered from widest to thinnest, along with respective indices
+
+    # collect n columns and their respective width metrics,
+    # working through items from widest down
+    n.times do
+      # if a column has already been marked with a width,
+      # repeat this block
+      begin
+        item, index = items.shift
+        column_number = index / rows
+      end while columns[ column_number ]
+      columns[ column_number ] = item.width
+    end
+    return( columns )
+  end
+
+end
+end

data/lib/monocle-print/output-device.rb

@@ -0,0 +1,529 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+
+module MonoclePrint
+class OutputDevice < DelegateClass( IO )
+  include MonoclePrint
+  include TerminalEscapes
+
+  def self.open( path, options = {} )
+    File.open( path, options.fetch( :mode, 'w' ) ) do | file |
+      return( yield( new( file, options ) ) )
+    end
+  end
+
+  def self.buffer( options = {} )
+    case options
+    when Numeric then options = { :width => options }
+    when nil then options = {}
+    end
+
+    buffer = StringIO.new( '', options.fetch( :mode, 'w' ) )
+    out = new( buffer, options )
+    if block_given?
+      begin
+        yield( out )
+        return( out.string )
+      ensure
+        out.close
+      end
+    else
+      return out
+    end
+  end
+
+  def self.stdout( options = {} )
+    device = new( $stdout, options )
+    block_given? ? yield( device ) : device
+  end
+
+  def self.stderr( options = {} )
+    device = new( $stderr, options )
+    block_given? ? yield( device ) : device
+  end
+
+  DEFAULT_SIZE     = Pair.new( 80, 22 ).freeze
+  IO_PRINT_METHODS = %w( puts print printf putc )
+  SIZE_IOCTL       = 0x5413
+  SIZE_STRUCT      = [ 0, 0, 0, 0 ].pack( "SSSS" ).freeze
+
+  private :reopen
+  attr_reader :device
+  attr_accessor :style
+
+  def initialize( output, options = {} )
+    @device =
+      case output
+      when String then File.open( output, options.fetch( :mode, 'w' ) )
+      when IO then output
+      else
+        if IO_PRINT_METHODS.all? { | m | output.respond_to?( m ) }
+          output
+        else
+          msg = "%s requires an IO-like object, but was given: %p" % [ self.class, output ]
+          raise( ArgumentError, msg )
+        end
+      end
+
+    super( @device )
+
+    @background_stack = []
+    @foreground_stack = []
+    @modifier_stack   = []
+
+    @background       = @foreground = @modifier = nil
+    @use_color        = options.fetch( :use_color, tty? )
+
+    @cursor           = Pair.new( 0, 0 )
+    @tab_width        = options.fetch( :tab_width, 8 )
+    @margin           = Pair.new( 0, 0 )
+
+    @newline          = options.fetch( :newline, $/ )
+
+    case margin = options.fetch( :margin, 0 )
+    when Numeric then @margin.left = @margin.right = margin.to_i
+    else
+      @margin.left = margin[ :left ].to_i
+      @margin.right = margin[ :right ].to_i
+    end
+
+    @tabs          = {}
+    @screen_size   = nil
+    @forced_width  = options[ :width ]
+    @forced_height = options[ :height ]
+    @alignment     = options.fetch( :alignment, :left )
+    @style         = Style( options[ :style ] )
+  end
+
+  def foreground( color = nil )
+    color or return( @foreground_stack.last )
+    begin
+      @foreground_stack.push( color )
+      yield
+    ensure
+      @foreground_stack.pop
+    end
+  end
+
+  def colors( fg, bg )
+    foreground( fg ) { background( bg ) { yield } }
+  end
+
+  def background( color = nil )
+    color or return( @background_stack.last )
+    begin
+      @background_stack.push( color )
+      yield
+    ensure
+      @background_stack.pop
+    end
+  end
+
+  alias on background
+
+  def modifier( name = nil )
+    name or return( @modifier_stack.last )
+    begin
+      @modifier_stack.push( name )
+      yield
+    ensure
+      @modifier_stack.pop
+    end
+  end
+
+  for color in ANSI_COLOR_NAMES
+    class_eval( <<-END, __FILE__, __LINE__ )
+      def #{ color }
+        foreground( :#{ color } ) { yield }
+      end
+
+      def on_#{ color }
+        background( :#{ color } ) { yield }
+      end
+    END
+  end
+
+  for modifier in ANSI_MODIFIER_NAMES
+    class_eval( <<-END, __FILE__, __LINE__ )
+      def #{ modifier }
+        modifier( :#{ modifier } ) { yield }
+      end
+    END
+  end
+
+  def use_color?
+    @use_color
+  end
+
+  def use_color( v = nil )
+    v.nil? or self.use_color = v
+    return( @use_color )
+  end
+
+  def use_color= v
+    @use_color = !!v
+  end
+
+  def margin= n
+    self.left_margin = self.right_margin = Utils.at_least( n.to_i, 0 )
+  end
+
+  def indent( n = 0, m = 0 )
+    n, m = n.to_i, m.to_i
+    self.left_margin  += n
+    self.right_margin += m
+    if block_given?
+      begin
+        yield
+      ensure
+        self.left_margin  -= n
+        self.right_margin -= m
+      end
+    else
+      self
+    end
+  end
+
+  def outdent( n )
+    self.left_margin -= n.to_i
+    block_given? and
+      begin yield
+      ensure self.left_margin += n.to_i
+      end
+  end
+
+  def left_margin
+    @margin.left
+  end
+
+  def right_margin
+    @margin.right
+  end
+
+  def left_margin= n
+    @margin.left = n.to_i
+  end
+
+  def right_margin= n
+    @margin.right = n.to_i
+  end
+
+  def reset!
+    @fg_stack.clear
+    @bg_stack.clear
+    @margin = Pair.new( 0, 0 )
+    @cursor = Pair.new( 0, 0 )
+    @screen_size = nil
+  end
+
+  alias use_color? use_color
+
+  def list( *args )
+    List.new( *args ) do | list |
+      list.output = self
+      block_given? and yield( list )
+      list.render
+    end
+    return( self )
+  end
+
+  def table( *args )
+    Table.new( *args ) do | t |
+      block_given? and yield( t )
+      t.render( self )
+    end
+  end
+
+  def column_layout( *args )
+    ColumnLayout.new( *args ) do | t |
+      block_given? and yield( t )
+      t.render( self )
+    end
+  end
+
+  def leger( char = '<h>', w = width )
+    puts( @style.format( char ).tile( w ) )
+  end
+
+  def print( *objs )
+    text = Text( [ objs ].flatten!.join )
+    @use_color or text.bleach!
+    last_line = text.pop
+    for line in text
+      put!( line )
+    end
+    fill( @margin.left )
+
+    @device.print( color_code )
+    @cursor + last_line.width
+    @device.print( last_line )
+    @device.print( clear_attr )
+    
+    self
+  end
+
+  def puts( *objs )
+    text = Text( [ objs ].flatten!.join( @newline ) )
+    ( text.empty? or text.last.empty? ) and text << Line( '' )
+    for line in text
+      put( line )
+      newline!
+    end
+    self
+  end
+
+  def printf( fmt, *args )
+    print( sprintf( fmt, *args ) )
+  end
+
+  def putsf( fmt, *args )
+    puts( sprintf( fmt, *args ) )
+  end
+
+  for m in %w( left right center )
+    class_eval( <<-END, __FILE__, __LINE__ + 1 )
+      def #{ m }
+        prior, @alignment = @alignment, :#{ m }
+        yield
+      ensure
+        @alignment = prior
+      end
+    END
+  end
+
+  def close
+    @device.close rescue nil
+  end
+
+  def height
+    screen_size.height
+  end
+
+  def full_width
+    screen_size.width
+  end
+
+  def width
+    screen_size.width - @margin.left - @margin.right
+  end
+
+  def put( str, options = nil )
+    if options
+      fill  = @style.format( options.fetch( :fill, ' ' ) )
+      align = options.fetch( :align, @alignment )
+    else
+      fill, align = ' ', @alignment
+    end
+
+    str = SingleLine.new( str ).align!( align, width, fill )
+    code = color_code
+    str.gsub!( /\e\[0m/ ) { "\e[0m" << code }
+
+    fill( @margin.left )
+    @device.print( code )
+    @device.print( str )
+    @cursor + str.width
+    @device.print( clear_attr )
+    fill( screen_size.width - @cursor.column )
+    self
+  end
+
+  def put!( str, options = nil )
+    put( str, options )
+    newline!
+  end
+
+  def return!
+    ~@cursor
+    @device.print("\r")
+    @device.flush
+  end
+
+  def fill( width, char = ' ' )
+    width =
+      case width
+      when Symbol, String
+        distance_to( width )
+      when Fixnum
+        Utils.at_least( width, 0 )
+      end
+    if width > 0
+      fill_str =
+        if char.length > 1 and ( char = SingleLine( char ) ).width > 1
+          char.tile( width )
+        else
+          char * width
+        end
+      @cursor.column += width
+      @device.print( fill_str )
+    end
+    self
+  end
+
+  def newline!
+    +@cursor
+    @device.print( @newline )
+    @device.flush
+    self
+  end
+
+  def space( n_lines = 1 )
+    n_lines.times do
+      put( '' )
+      newline!
+    end
+    self
+  end
+
+  def column
+    @cursor.column
+  end
+
+  def line
+    @cursor.line
+  end
+
+  def clear
+    @cursor.line = @cursor.column = 0
+    @device.print( set_cursor( 0, 0 ), clear_screen )
+    @device.flush
+    return( self )
+  end
+
+  def clear_line
+    @device.print( super )
+    @device.flush
+    return!
+  end
+
+  for m in %w( horizontal_line box_top box_bottom )
+    class_eval( <<-END, __FILE__, __LINE__ + 1 )
+      def #{ m }
+        put( @style.#{ m }( width ) )
+        newline!
+      end
+    END
+  end
+
+  def color_code
+    @use_color or return ''
+    code = ''
+
+    case fg = @foreground_stack.last
+    when Fixnum then code << xterm_color( ?f, fg )
+    when String, Symbol then code << ansi_color( ?f, fg )
+    end
+
+    case bg = @background_stack.last
+    when Fixnum then code << xterm_color( ?b, bg )
+    when String, Symbol then code << ansi_color( ?b, bg )
+    end
+
+    case mod = @modifier_stack.last
+    when String, Symbol then code << ansi_modifier( mod )
+    end
+
+    code
+  end
+
+private
+
+  def abs( col )
+    col < 0 and col += width
+    Utils.bound( col, 0, width - 1 )
+  end
+
+
+  def distance_to( tab )
+    Utils.at_least( abs( @tabs[ tab ] ) - @cursor.columm, 0 )
+  end
+
+  def screen_size
+    @screen_size ||=
+      begin
+        if device.respond_to?( :winsize )
+          detected_height, detected_width = device.winsize
+        elsif data = SIZE_STRUCT.dup and device.ioctl( SIZE_IOCTL, data ) >= 0
+          detected_height, detected_width = data.unpack( "SS" )
+        else
+          size = default_size
+          detected_height, detected_width = size.height, size.width
+        end
+        Pair.new(
+          @forced_width  || detected_width,
+          @forced_height || detected_height
+        )
+      rescue Exception
+        default_size
+      end
+  end
+
+  def default_size
+    Pair.new( default_width, default_height )
+  end
+
+  def default_height
+    ( @forced_height || ENV[ 'LINES' ] || DEFAULT_SIZE.height ).to_i
+  end
+
+  def default_width
+    ( @forced_width || ENV[ 'COLUMNS' ] || DEFAULT_SIZE.width ).to_i
+  end
+end
+
+class Pager < OutputDevice
+  unless pager_command = ENV['PAGER']
+    pagers = %w( most less more )
+    system_path = ENV[ "PATH" ].split( File::PATH_SEPARATOR )
+    pager_command = pagers.find do | cmd |
+      system_path.find { | dir | test( ?x, File.join( dir, cmd ) ) }
+    end
+  end
+  PAGER_COMMAND = pager_command
+
+  def self.open( options = {} )
+    unless PAGER_COMMAND
+      message = <<-END.gsub!( /\s+/, ' ' ).strip!
+      unable to locate a pager program on the system's PATH or from
+      the environmental variable, PAGER
+      END
+      raise( IOError, message )
+    end
+
+    options.fetch( :use_color ) { options[ :use_color ] = true }
+
+    if block_given?
+      IO.popen( PAGER_COMMAND, 'w' ) do | pager |
+        pager = new( pager, options )
+        return yield( pager )
+      end
+    else
+      return new( IO.popen( PAGER_COMMAND, 'w' ), options )
+    end
+  end
+
+private
+
+  def screen_size
+    @screen_size ||=
+      begin
+        if STDOUT.respond_to?( :winsize )
+          detected_height, detected_width = STDOUT.winsize
+        elsif data = SIZE_STRUCT.dup and STDOUT.ioctl( SIZE_IOCTL, data ) >= 0
+          detected_height, detected_width = data.unpack( "SS" )
+        else
+          size = default_size
+          detected_height, detected_width = size.height, size.width
+        end
+        Pair.new(
+          @forced_height || detected_height,
+          @forced_width  || detected_width
+        )
+      rescue Exception
+        default_size
+      end
+  end
+end
+
+end