monocle-print 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NGJjYTRhMWNiZWQ5OTJkYzM4MjgyMDc3MzcxM2RjZWZjMzBjYWNkZA==
+  data.tar.gz: !binary |-
+    OGU0OGYwZGMxY2VjOTM2ODdkNWI0OTY3MmUxMjRhNWQ2OWQ2MTI2Ng==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OWM5M2I5YjY1ZjIzMWYxYTUyM2U0MTFlYTk0MGRkZWQ5NjVhYWM4ZTkzNzU5
+    ZWIyYjZlN2FmMDlmNTNmNTc4NjM5ZGY2ZTk3NWQ4M2RlNGRiZTRiMWU2NTkw
+    ZGI5MGQ1OGVkZGJlMGI5MGFkNDM4YzMyZDRhNDA0NTdkY2M3MTE=
+  data.tar.gz: !binary |-
+    NzhiYThmYzNjYjJkY2VjNGRmMDM3MmRkNzU4OTA3YzM1MjMzNTZlNmY1ODhm
+    OTgxYTU5ODFlNjNkNjUzYzAyZmU5NDYxZjVkYzViNjFjMjc0MTI0Nzg5Yjk4
+    NTU0YjNjMDNmNzRmNThjMTcxZWEzODIxYjFmNDAzZmM5ZTYzZmE=

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2008-09-01
+
+* 1 major enhancement
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,19 @@
+lib/monocle-print.rb
+lib/monocle-print/layout.rb
+lib/monocle-print/table/segments.rb
+lib/monocle-print/table/members.rb
+lib/monocle-print/table/column.rb
+lib/monocle-print/output-device.rb
+lib/monocle-print/graphics.rb
+lib/monocle-print/table.rb
+lib/monocle-print/list.rb
+lib/monocle-print/progress.rb
+lib/monocle-print/presentation.rb
+lib/monocle-print/utils.rb
+lib/monocle-print/terminal-escapes.rb
+lib/monocle-print/geometry.rb
+lib/monocle-print/atomic.rb
+History.txt
+Manifest.txt
+README.txt
+Rakefile

data/README.txt

@@ -0,0 +1,40 @@
+= monocle-print
+
+* http://ohboyohboyohboy.org
+
+== DESCRIPTION:
+
+Fancy console output tools
+
+== REQUIREMENTS:
+
+* ruby (>= 1.8.7)
+
+== INSTALL:
+
+  sudo gem install monocle-print
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Kyle Yetter (kyley@inmotionhosting.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#
+# author: Kyle Yetter
+#
+
+$LOAD_PATH.unshift( "lib" )
+
+require 'rubygems'
+require 'hoe'
+require 'monocle-print'
+
+PACKAGE_NAME = File.basename( File.dirname( __FILE__ ) )
+
+Rake.application.options.ignore_deprecate = true
+
+Hoe.spec PACKAGE_NAME do
+  developer( PACKAGE_NAME, 'kyle@ohboyohboyohboy.org' )
+  self.version = MonoclePrint.version
+end
+

data/lib/monocle-print/atomic.rb

@@ -0,0 +1,462 @@
+#!/usr/bin/ruby
+# encoding: ascii
+#
+# author: Kyle Yetter
+#
+
+require 'monocle-print'
+
+module MonoclePrint
+  if RUBY_VERSION =~ /^1\.8/
+    MULTIBYTE_CHARACTER = %r<
+      [\xC2-\xDF][\x80-\xBF]
+    | [\xE0-\xEF][\x80-\xBF]{2}
+    | [\xF0-\xF4][\x80-\xBF]{3}
+    >x
+
+    ONE_BYTE    = 0x20 .. 0x7E
+    TWO_BYTES   = 0xC2 .. 0xDF
+    THREE_BYTES = 0xE0 .. 0xEF
+    FOUR_BYTES  = 0xF0 .. 0xF4
+  end
+
+  COLOR_ESCAPE = /\e\[[\d:;]*?m/
+
+  class SingleLine < ::String
+    include MonoclePrint
+
+    def self.clear_cache
+      @@width.clear
+      @@invisible_size.clear
+      return( self )
+    end
+
+    @@width = {}
+    @@invisible_size = {}
+
+    if RUBY_VERSION =~ /^1\.8/
+
+      def char_byte( n )
+        n.zero? and return( 0 )
+        seen = byte = 0
+        while c = self[ byte ] and seen < n
+          step =
+            case c
+            when ONE_BYTE then seen += 1; 1
+            when ?\e
+              self[ byte, size ] =~ /^#{COLOR_ESCAPE}/ ? $~.end(0) : 1
+            when TWO_BYTES then seen += 1; 2
+            when THREE_BYTES then seen += 1; 3
+            when FOUR_BYTES then seen += 1; 4
+            else 1
+            end
+          byte += step
+        end
+        return( byte )
+      end
+
+      def width
+        @@width[ hash ] ||= begin
+          (temp = bleach).gsub!( MULTIBYTE_CHARACTER, ' ' )
+          temp.size
+        end
+      end
+
+    else
+
+      def char_byte( n )
+        seen = byte = 0
+        if esc = self =~ COLOR_ESCAPE and esc < n
+          return( $~.end(0) + $'.char_byte( n - esc ) )
+        else n
+        end
+      end
+
+      def width
+        @@width[ hash ] ||= bleach.length
+      end
+
+    end
+
+    def align( alignment, width, fill = ' ' )
+      dup.align!( alignment, width, fill )
+    end
+
+    def align!( alignment, width, fill = ' ' )
+      strip!
+      case alignment.to_sym
+      when :left then left!( width, fill )
+      when :center then center!( width, fill )
+      when :right then right!( width, fill )
+      end
+    end
+
+    def blank?
+      empty? or self =~ /^(\s|#{COLOR_ESCAPE})*$/
+    end
+
+    def bleach
+      gsub( COLOR_ESCAPE, '' )
+    end
+
+    def bleach!
+      gsub!( COLOR_ESCAPE, '' )
+    end
+
+    def center!( w, fill = ' ' )
+      w > width or return( self )
+      if fill.length == 1
+        replace( center( w + invisible_size, fill ) )
+      else fill = self.class.new( fill )
+        even, odd = ( width - w ).divmod( 2 )
+        insert( 0, fill.tile( even ) )
+        self << fill.tile( even + odd )
+      end
+      self
+    end
+
+    def divide_at( len )
+      pos = char_byte( len )
+      return( [ self[ 0, pos ], self[ pos, size ] ] )
+    end
+
+    def each_escape
+      block_given? or return( enum_for( :each_escape ) )
+      scan( COLOR_ESCAPE ) do |esc|
+        yield( esc )
+      end
+    end
+
+    def escapes
+      each_escape.inject( self.class.new ) do | escs, esc |
+        escs << esc
+      end
+    end
+
+    def indent( n )
+      dup.indent!( n )
+    end
+
+    def indent!( num_spaces )
+      if num_spaces < 0
+        remaining_indent = Utils.at_least( level_of_indent + num_spaces, 0 )
+        lstrip!
+        indent!( remaining_indent )
+      else
+        insert( 0, ' ' * num_spaces )
+      end
+      return( self )
+    end
+
+    def invisible_size
+      @@invisible_size[ hash ] ||= size - width
+    end
+
+    def left!( w, fill = ' ' )
+      w > width or return( self )
+      if fill.length == 1
+        replace( ljust( w + invisible_size, fill ) )
+      else fill = self.class.new( fill )
+        insert( 0, fill.tile( width - w ) )
+      end
+      self
+    end
+
+    def level_of_indent
+      self =~ /^(\s+)/ ? $1.length : 0
+    end
+
+    def pad!( left, right = left )
+      right!( width + left )
+      left!( width + right )
+    end
+
+    def partial(len)
+      self[ 0, char_byte( len ) ]
+    end
+
+    def right!( w, fill = ' ' )
+      w > width or return( self )
+      if fill.length == 1
+        replace( rjust( w + invisible_size, fill ) )
+      else fill = self.class.new( fill )
+        self.insert( 0, fill.tile( w - width ) )
+      end
+      self
+    end
+
+    def tile( size )
+      width == 0 and return( )
+      full, partial = size.divmod( width )
+      self * full << partial( partial )
+    end
+
+    def truncate( w, tail = nil )
+      dup.truncate!( w, tail )
+    end
+
+    def truncate!( w, tail = nil )
+      width > w or return( self )
+      if tail then tail = Line( tail )
+        return( partial( w - tail.width ) << tail )
+      else
+        return( partial( w ) )
+      end
+      return( self )
+    end
+
+    def words
+      strip.split(/\s+/)
+    end
+
+    def height
+      1
+    end
+
+    def wrap( w )
+      if width > w
+        words = split( /\s+/ ).inject( [] ) do | words, word |
+          while word.width > w
+            frag, word = word.divide_at( w )
+            words << frag
+          end
+          words << word
+        end
+
+        line = words.shift || self.class.new
+        text = Text.new
+        w -= 1
+        while word = words.shift
+          if line.width + word.width > w
+            text << line
+            line = word
+          else
+            line << ' ' << word
+          end
+        end
+        text << line
+        return( text )
+      else
+        return( Text( self.dup ) )
+      end
+    end
+  end
+
+  class Text < Array
+    def self.clear_cache
+      @@width.clear
+      @@uniform.clear
+      return( self )
+    end
+
+    include MonoclePrint
+    @@width = {}
+    @@uniform = {}
+
+    def initialize( lines = nil, default = nil )
+      case lines
+      when Fixnum
+        if block_given?
+          super( lines ) { | i | Line( yield( i ) ) }
+        else
+          default = Line( default )
+          super( lines, default )
+        end
+      when Text then super( lines )
+      when Array
+        super( lines.join( $/ ).map { | l | Line( l.chomp! || l ) } )
+      when SingleLine then super(1, lines)
+      when nil then super()
+      else
+        super( lines.to_s.lines.map { |l| Line( l.chomp! || l ) } )
+      end
+    end
+
+    def initialize_copy( orig )
+      for line in orig
+        self << line.dup
+      end
+    end
+
+    def align( alignment, width, fill = ' ' )
+      dup.align!( alignment, width, fill )
+    end
+
+    def align!( alignment, width, fill = ' ' )
+      # if the width argument is less than the full block width of the text,
+      # make it the full block width to ensure uniform width
+      width = Utils.at_least( width, self.width )
+
+      if empty?
+        self << SingleLine.new( ' ' * width )
+      else
+        map! do | line |
+          line.align( alignment, width, fill )
+        end
+      end
+
+      return( self )
+    end
+
+    def bleach
+      dup.bleach!
+    end
+
+    def bleach!
+      each { | l | l.bleach! }
+    end
+
+    def fix
+      dup.fix!
+    end
+
+    def fix!
+      align!( :left, width )
+    end
+
+    def fixed_indent!( level = 0 )
+      level = Utils.at_least( level, 0 )
+      offset = level - level_of_indent
+      indent!( offset )
+    end
+
+    def fixed_indent( level = 0 )
+      dup.fixed_indent!( level )
+    end
+
+    def level_of_indent
+      level = nil
+      levels = map { | line | line.blank? ? nil : line.level_of_indent }
+      levels.compact!
+      levels.min || 0
+    end
+
+    def indent!( spaces )
+      for line in self do line.indent!( spaces ) end
+      self
+    end
+
+    def indent( spaces )
+      dup.indent!( spaces )
+    end
+
+    def frame( graphic_style )
+      dup.frame!( graphic_style )
+    end
+
+    def frame!( graphic_style )
+      top = graphic_style.box_top( width )
+      bottom = graphic_style.box_bottom( width )
+      for line in self
+        line.insert( 0, graphic_style.v )
+        line.insert( -1, graphic_style.v )
+      end
+      unshift( top )
+      push( bottom )
+      return( self )
+    end
+
+    def inspect
+      digits = Math.log10( Utils.at_least( length, 1 ) ).floor + 1
+      $/ + each_with_index.map do | line, i |
+        line_no = i.to_s.rjust( digits )
+        "#{ line_no } | #{ line }"
+      end.join( $/ ) + $/
+    end
+
+    def juxtapose( text, joint = ' ' )
+      dup.juxtapose!( text, joint )
+    end
+
+    def juxtapose!( text, joint = ' ' )
+      text = self.class.new( text ).fix!.valign!( :top, height )
+      valign!( :top, text.height ); fix!
+
+      zip( text ) do | left, right |
+        left << joint.to_s << right
+      end
+      return( self )
+    end
+
+    def pad( padding )
+      dup.pad!( padding )
+    end
+
+    def pad!( padding )
+      padding.top.times { unshift( Line('') ) }
+      padding.bottom.times { push( Line('') ) }
+      w = width
+      for line in self
+        line.left!( w )
+        line.pad!( padding.left, padding.right )
+      end
+      self
+    end
+
+    def reflow( paragraph_style = true )
+      if paragraph_style
+        cursor, new = 0, self.class.new
+        text = self.to_s
+        while text =~ /\n\s*\n/
+          before, text = $`, $'
+          new << `#{ before.gsub!( /[ \t]*\n/, ' ' ) || before }`
+          new << ``
+        end
+        new << `#{ text.gsub!( /[ \t]*\n/, ' ' ) || text }`
+        return( new )
+      else
+        text = self.to_s
+        text.strip!
+        text.gsub!( /\s+/, ' ' )
+        self.class.new( text )
+      end
+    end
+
+    def reflow!( paragraph_style = true )
+      replace( reflow( paragraph_style ) )
+    end
+
+    def wrap( width )
+      reflow.inject( self.class.new ) do | wrapped, line |
+        wrapped.concat( line.wrap( width ) )
+      end
+    end
+
+    def to_s
+      join( $/ )
+    end
+
+    def uniform?
+      @@uniform.fetch( hash ) do | h |
+        @@uniform[ h ] = all? { | l | l.width == width }
+      end
+    end
+
+    def valign!( alignment, h, filler = ''  )
+      filler = Line( filler )
+      h > height or return( self )
+      case alignment
+      when :top
+        fill( filler, height, h - height )
+      when :bottom
+        ( h - height ).times { unshift( filler ) }
+      when :center
+        even, odd = ( h - height ).divmod( 2 )
+        even.times { push( filler ); unshift( filler ) }
+        odd == 1 and push( filler )
+      end
+      return( self )
+    end
+
+    def width
+      @@width[ hash ] ||= ( map { | line | line.width }.max || 0 )
+    end
+
+    alias height length
+    alias | juxtapose
+    def `(str) #` # comment here cos my editor's colorizing freaks out
+      SingleLine.new( str )
+    end
+  end
+
+end

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