ohboyohboyohboy-monocle-print 1.1.1

data/lib/monocle-print/presentation.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module MonoclePrint
+module Presentation
+  include MonoclePrint
+  ALIGNMENTS = [ :left, :right, :center ]
+
+  def self.included( klass )
+    super
+    klass.extend( ClassMethods )
+  end
+
+  attr_accessor :owner
+  protected :owner=
+
+  for attr in %w( margin padding border )
+    class_eval( <<-END, __FILE__, __LINE__ + 1 )
+      def #{ attr }( value = nil )
+        value and self.#{ attr } = value
+        @#{ attr } ||= default_#{ attr }
+        block_given? ? yield( @#{ attr } ) : @#{ attr }
+      end
+
+      def #{ attr }= value
+        @#{ attr } = Rectangle( value )
+      end
+    END
+  end
+
+  def alignment( value = nil )
+    value and self.alignment = value
+    @alignment or @owner ? @owner.alignment : :left
+  end
+
+  def alignment= value
+    ALIGNMENTS.member?( value = value.to_sym ) or
+      raise( ArgumentError, "unkown alignment: %p" % value )
+    @alignment = value
+  end
+
+  def style( value = nil )
+    value and self.style = value
+    @style or @owner ? @owner.style : Graphics.default
+  end
+
+  def style= value
+    @style = Style( value )
+  end
+
+  def render( output = @output )
+    if output
+      render_content( output )
+      return output
+    else
+      OutputDevice.buffer do | out |
+        render_content( out )
+      end
+    end
+  end
+
+  def to_s
+    OutputDevice.buffer do | out |
+      render_content( out )
+    end
+  end
+
+  def height
+    @height or calculate_height
+  end
+
+  def width
+    @width or calculate_width
+  end
+
+  attr_writer :max_width
+
+  def max_width
+    @max_width or @owner && @owner.max_width or output.width
+  end
+
+  def output
+    @output ||= ( @owner and @owner.output or OutputDevice.stdout )
+  end
+
+  def output=( io )
+    @output = io.nil? ? io : Output( io )
+  end
+
+private
+
+  def initialize_view( options = nil, owner = nil )
+    @max_width = @width = @height = nil
+    @margin = @padding = @alignment = @style = nil
+    @output = @foreground = @background = nil
+
+    if options
+      val = options[ :width ]   and self.width     = val
+      val = options[ :align ]   and self.alignment = val
+      val = options[ :style ]   and self.style     = val
+      val = options[ :padding ] and self.padding   = val
+      val = options[ :margin ]  and self.margin    = val
+      val = options[ :output ]  and self.output    = val
+    end
+
+    @owner = owner
+  end
+
+  def default_margin
+    Rectangle.new( 0, 0, 0, 0 )
+  end
+
+  def default_padding
+    Rectangle.new( 0, 0, 0, 0 )
+  end
+
+  def default_border
+    Rectangle.new( false, false, false, false )
+  end
+
+end
+
+module Presentation::ClassMethods
+  def default( property, value = nil, &dynamic )
+    if dynamic
+      define_method( :"default_#{property}", &dynamic )
+    else
+      define_method( :"default_#{property}" ) { value }
+    end
+  end
+end
+end

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.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/ruby
+
+require 'monocle-print/table/segments'
+require 'monocle-print/table/members'
+require 'monocle-print/table/column'
+
+module MonoclePrint
+class Table
+  include MonoclePrint
+  include Presentation
+  include Enumerable
+  
+  def self.build( *args )
+    table = new( *args ) do | table |
+      block_given? and yield( table )
+    end
+    return( table.render )
+  end
+  
+  
+  def initialize( columns, options = {} )
+    initialize_view( options )
+    
+    @titles = nil
+    @item = @head = Divider.new( self, :head )
+    @foot = Divider.new( self, :foot )
+    @columns = []
+    @body = []
+    
+    case columns
+    when Fixnum
+      expand_columns( columns )
+    when Array
+      title_row( *columns )
+    end
+    
+    block_given? and yield( self )
+  end
+  
+  def render_content( out )
+    style = @style || out.style
+    lock do
+      width > out.width and resize( out.width )
+      each { | member | member.render( out, style ) }
+    end
+  end
+  
+  def each
+    block_given? or return( enum_for( :each ) )
+    for item in @head
+      yield( item )
+    end
+  end
+  
+  attr_reader :columns, :titles
+  
+  def row( *members )
+    @item = @item.row!( *members )
+  end
+  
+  def title_row( *members )
+    @titles = @item = @item.title_row!( *members )
+    while @titles
+      if TitleRow === @titles
+        @titles = @titles.cells.map { | c | c.to_s }
+        break
+      end
+      @titles = @titles.before
+    end
+    self
+  end
+  
+  def rows( *list_of_rows )
+    for row in list_of_rows do row( *row ) end
+    self
+  end
+  
+  def section( title, options = {} )
+    @item = @item.section!( title, options )
+  end
+  
+  def divider( type = :row_divider )
+    @item = @item.divider!( type )
+  end
+  
+  def fixed_columns( *column_indicies )
+    for column_index in column_indicies
+      if c = column( column_indicies )
+        if Array === c then c.each { | i | i.fixed = true }
+        else c.fixed = true
+        end
+      end
+    end
+  end
+  
+  def malleable_columns( *column_indicies )
+    for column_index in column_indicies
+      if c = column( column_index )
+        if Array === c then c.each { | i | i.malleable = true }
+        else c.malleable = true
+        end
+      end
+    end
+  end
+  
+  def column( name_or_index )
+    case name_or_index
+    when Integer, Range then @columns[ name_or_index ]
+    else
+      @columns.find do | col |
+        name_or_index === col.title
+      end
+    end
+  end
+  
+  def resize( new_size )
+    resizable = @columns.select { | c | c.malleable? }
+    if resizable.empty?
+      warn( "cannot resize #{ self.inspect } as all columns are fixed" )
+      return( self )
+    end
+    
+    lock do
+      difference = new_size - @width
+      resize_columns( difference, resizable )
+    end
+    
+    return( self )
+  end
+  
+
+  
+  def inner_width
+    @inner_width or calculate_inner_width
+  end
+  
+  def width
+    @width or calculate_width
+  end
+  
+  def expand_columns(new_size)
+    new_size.zero? and return
+    
+    until @columns.length >= new_size
+      @columns << Column.new( self, @columns.length )
+    end
+  end
+
+private
+  
+  def resize_columns( amount, columns )
+    leftover = amount
+    resizable_area = columns.inject( 0 ) do | sz, c |
+      sz + c.width
+    end
+    
+    for column in columns
+      proportion = ( column.width.to_f / resizable_area )
+      delta = ( proportion * amount ).round
+      column.width += delta
+      leftover -= delta
+    end
+    
+    columns.last.width += leftover
+  end
+  
+  def expand( amount, columns )
+    leftover = amount
+    resizable_area = columns.inject( 0 ) do | sz, c |
+      sz + c.width
+    end
+    
+    for column in columns
+      proportion = ( column.width.to_f / resizable_area )
+      delta = ( proportion * amount ).round
+      column.width += delta
+      leftover -= delta
+    end
+    
+    columns.last.width += leftover
+  end
+  
+  
+  
+  def lock
+    calculate_metrics
+    @item.link( @foot )
+    yield
+  ensure
+    @foot.unlink
+    clear_metrics
+  end
+  
+  def calculate_metrics
+    @columns.each { | c | c.calculate_metrics }
+    @inner_width = calculate_inner_width
+    @width = calculate_width
+  end
+  
+  def clear_metrics
+    @columns.each { | c | c.clear_metrics }
+    @inner_width = nil
+    @width = nil
+  end
+  
+  def calculate_inner_width
+    w = @columns.inject( 0 ) { | w, c | w + c.width }
+    w + ( @columns.length - 1 ) * 3
+  end
+  
+  def calculate_width
+    calculate_inner_width + 4
+  end
+  
+end
+
+class ColumnLayout < Table
+  def initialize( columns, options = {} )
+    super( columns, options ) do
+      @item  = @head = Blank.new( self )
+      @foot  = Blank.new( self )
+      @style = Style( :blank )
+      block_given? and yield( self )
+    end
+  end
+end
+
+end
+