monocle-print 1.0.0

data/lib/monocle-print/progress.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+class Progress < OutputDevice
+
+  attr_accessor :position, :total, :bar_color
+  attr_reader :output, :title
+  attr_writer :width
+
+  def self.enumerate( collection, method = :each, *args )
+    block_given? or return enum_for( :enumerate, collection, method, *args )
+    #options = Hash === args.last ? args.pop : {}
+
+    #method = options.fetch( :method, nil )
+    #if method.nil? and Symbol === args.first
+    #  method, *args = args
+    #else
+    #  method ||= :each
+    #end
+
+    #size = options[ :size ]
+    #size ||= options.fetch( :length ) do
+    #  collection.length rescue collection.size
+    #end
+    size = collection.length rescue collection.size
+
+    enum = collection.enum_for( method, *args )
+    run( size ) do | bar |
+      for item in enum
+        v = yield( item, bar )
+        bar.step
+        v
+      end
+    end
+  end
+
+  def self.run( total, options = {} )
+    bar = new( total, options )
+    yield( bar )
+  ensure
+    bar.clear_line
+  end
+
+  def initialize( total, options = {} )
+    @total      = Utils.at_least( total.to_i, 1 )
+    @position   = 0
+    @title      = Line( options[ :title ].to_s )
+    @limit      = @width = @time = @next_time = nil
+    @bar_color  = options.fetch( :bar_color, :red )
+    @text_color = options.fetch( :text_color, :black )
+    @progress   = -1
+    @draw       = true
+    super( options.fetch( :output, $stderr ), options )
+  end
+
+  def stage( title, limit = @total - @position, absolute = false )
+    limit += @position unless absolute
+    self.title = title
+    limit( limit ) do
+      return( yield( self ) )
+    end
+  end
+
+  def step( inc = 1 )
+    limit = @limit || @total
+    @position = Utils.at_most( @position + inc, limit )
+    draw? and display
+  end
+
+  def draw?
+    progress = @position * 100 / @total
+    if @progress != progress
+      @progress = progress
+      @draw = true
+    end
+
+    return @draw
+  end
+
+  def limit( l = nil )
+    unless l.nil?
+      begin
+        before, @limit = @limit, Utils.at_most( l.to_i, @total )
+        yield( self )
+      ensure
+        self.limit = before
+      end
+    end
+    return( @limit )
+  end
+
+  def limit=( l )
+    @limit = Utils.at_most( l.to_i, @total )
+  end
+
+  def start_time
+    @start_time ||= Time.now
+  end
+
+  def duration
+    Time.now - start_time
+  end
+
+  def title= t
+    title = Line( t.to_s )
+    if title != @title
+      @title = title
+      @draw = true
+    end
+  end
+
+  def display
+    return!
+
+    hour, r  = time_remaining.divmod( 3600 )
+    min, sec = r.divmod( 60 )
+    sec = sec.round
+    eta = Line( ' %02i:%02i:%02i' % [ hour, min, sec ] )
+
+    center_width = 6
+    right_width  = ( width - center_width ) / 2
+    left_width   = width - center_width - right_width
+
+    center = ( @progress.to_s << '%' ).center( 6 ) # " ___% "
+    left   = title.align( :left, left_width ).truncate!( left_width, '...' )
+    right  = eta.align( :right, right_width )
+
+    bar = left << center << right
+
+    color_code = ''
+    @bar_color  and color_code << ansi_color( ?b, @bar_color )
+    @text_color and color_code << ansi_color( ?f, @text_color )
+
+    unless color_code.empty?
+      fill_point = bar.char_byte( width * @position / @total )
+      bar.insert( fill_point, "\e[0m" )
+      bar.insert( 0, color_code )
+    end
+
+    print( bar )
+    @draw = false
+    self
+  end
+
+  def title_width
+    width * 0.3
+  end
+
+  def reset
+    @position = 0
+    @limit = nil
+    @start_time = nil
+  end
+
+  def to_s
+    title_width = ( width * 0.4 ).round
+    title = @title.align( :center, title_width )[ 0, title_width ]
+
+    hour, r  = time_remaining.divmod( 3600 )
+    min, sec = r.divmod( 60 )
+    sec = sec.round
+    eta = '%02i:%02i:%02i' % [ hour, min, sec ]
+
+    fill_width = width - title_width - eta.length - 9
+    filled = ( fill_width * @position / @total ).round
+    title << ' |' << ( '*' * filled ).ljust( fill_width ) <<
+      '| ' << ( '%3i%% ' % progress ) << eta
+  end
+
+  def progress
+    @position * 100 / @total
+  end
+
+  def time_remaining
+    @position < 2 and return( 0 )
+    sec_per_step = duration / @position
+    ( @total - @position ) * sec_per_step
+  end
+
+  alias wipe clear_line
+
+  def hide
+    wipe
+    return yield
+  ensure
+    display
+  end
+
+
+end
+end

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