monocle-print 1.0.0

data/lib/monocle-print/graphics.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+
+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
+  NAMED_STYLES = Hash.new { |h, k| h[ DEFAULT_STYLE ].dup  }
+  
+  def self.styles
+    NAMED_STYLES.keys
+  end
+  
+  def self.define( name, *parts )
+    parts.map! { | p | Line( p ).freeze }
+    NAMED_STYLES[ name.to_s ] = new( *parts ).freeze
+  end
+  
+  define :blank, '', '', '', '', '', '', '', '', '', '', '', '', ''
+  define :ascii, '-', '|', '+', '+', '+', '+', '+', '+', '+', '+', '+', '|', '`'
+  define :single_line, '─', '│', '┌', '┐', '┘', '└', '├', '┤', '┴', '┬', '┼', '├', '└'
+  define :double_line, '═', '║', '╔', '╗', '╝', '╚', '╠', '╣', '╩', '╦', '╬', '╠', '╚'
+  
+  default_style = ENV.fetch( 'MONOCLE_PRINT_STYLE', 'ascii' )
+  unless styles.include?( default_style )
+    message = <<-END.gsub!( /^\s*\| ?/, '' ).strip!.gsub!( /\s+/, ' ' )
+    | cannot set MonoclePrint's default graphics style
+    | from the MONOCLE_PRINT_STYLE environment variable as `%p'
+    | is not a known style; defaulting to `ascii'
+    END
+    warn( message % default_style )
+    default_style = 'ascii'
+  end
+  
+  DEFAULT_STYLE = default_style
+  
+  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/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