monospace_text_formatter 0.0.1

data/Changelog

@@ -0,0 +1,2 @@
+0.0.1 (February 16, 2012)
+  Initial release.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jacek Mikrut
+
+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/README.md

@@ -0,0 +1,173 @@
+MonospaceTextFormatter
+======================
+
+MonospaceTextFormatter is a Ruby Gem that formats monospaced text into a **line or visual box** of defined **width** and **height** boundaries (expressed in number of characters), by wrapping and/or truncating the text, and filling remaining area with spaces (or custom characters) so that it forms a rectangular block. It **doesn't split words** unless they are longer than the width boundary. It also applies **horizontal** and **vertical alignment** to the text. All these attributes are customizable and optional.
+
+* **MonospaceTextFormatter::Line** class formats a single-line text;
+
+* **MonospaceTextFormatter::Box** class formats multiple-line text.
+
+Usage examples
+--------------
+
+Note: All the following attributes can also be provided in Hash as the second argument for the constructor.
+
+### MonospaceTextFormatter::Line
+
+The `line` object for the following examples:
+
+```ruby
+  line = MonospaceTextFormatter::Line.new("This is some text.")
+```
+
+```ruby
+  line.to_s
+   => "This is some text."
+```
+
+* `width` (a number of characters)
+
+```ruby
+  line.width = 20
+  line.to_s
+   => "This is some text.  "
+
+  line.width = 16
+  line.to_s
+   => "This is some ..."
+```
+
+* `omission`
+
+```ruby
+  line.omission = " [...]"
+  line.to_s
+   => "This is [...]   "
+```
+
+* `align` (available options: `:left` _(default)_, `:center` and `:right`)
+
+```ruby
+  line.align = :right
+  line.to_s
+   => "   This is [...]"
+```
+
+* `fill`
+
+```ruby
+  line.fill = "-"
+  line.to_s
+   => "---This is [...]"
+```
+
+### MonospaceTextFormatter::Box
+
+The `box` object for the following examples:
+
+```ruby
+  box = MonospaceTextFormatter::Box.new("First line.\nAnd second, a little bit longer line.")
+```
+
+```ruby
+  box.to_s
+   => "First line.                          \nAnd second, a little bit longer line."
+
+  box.lines
+   => ["First line.                          ",
+       "And second, a little bit longer line."]
+```
+
+* `width` (a number of characters)
+
+```ruby
+  box.width = 20
+  box.lines
+   => ["First line.         ",
+       "And second, a little",
+       "bit longer line.    "]
+```
+
+* `height` (a number of lines)
+
+```ruby
+  box.height = 5
+  box.lines
+   => ["First line.         ",
+       "And second, a little",
+       "bit longer line.    ",
+       "                    ",
+       "                    "]
+
+  box.height = 2
+  box.lines
+   => ["First line.         ",
+       "And second, a ...   "]
+```
+
+* `omission`
+
+```ruby
+  box.omission = " [...]"
+  box.lines
+   => ["First line.         ",
+       "And second, a [...] "]
+```
+
+* `align` (available options: `:left` _(default)_, `:center` and `:right`)
+
+```ruby
+  box.align = :center
+  box.lines
+   => ["    First line.     ",
+       "And second, a [...] "]
+```
+
+* `valign` (available options: `:top` _(default)_, `:middle` and `:bottom`)
+
+```ruby
+  box.height = 5
+  box.valign = :bottom
+  box.lines
+   => ["                    ",
+       "                    ",
+       "    First line.     ",
+       "And second, a little",
+       "  bit longer line.  "]
+```
+
+* `fill`
+
+``` ruby
+  box.fill = "#"
+  box.lines
+   => ["####################",
+       "####################",
+       "####First line.#####",
+       "And second, a little",
+       "##bit longer line.##"]
+```
+
+More can be found in **RSpec examples**.
+
+Installation
+------------
+
+As a Ruby Gem, MonospaceTextFormatter can be installed either by running
+
+```bash
+  gem install monospace_text_formatter
+```
+
+or adding
+
+```ruby
+  gem "monospace_text_formatter"
+```
+
+to the Gemfile and then invoking `bundle install`.
+
+License
+-------
+
+License is included in the LICENSE file.

data/lib/monospace_text_formatter/atomic_chunk.rb

@@ -0,0 +1,40 @@
+module MonospaceTextFormatter
+  class AtomicChunk
+
+    def initialize(string)
+      @string = string
+    end
+
+    def display_string
+      @display_string ||= @string
+    end
+
+    def display_length
+      @display_length ||= display_string.length
+    end
+
+    def newline?
+      @string == "\n"
+    end
+
+    def blank?
+      @string.strip.empty?
+    end
+
+    def empty?
+      @string.empty?
+    end
+
+    def to_s
+      @string
+    end
+
+    def inspect
+      %Q(#<#{self.class} #{to_s.inspect}>)
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+  end
+end

data/lib/monospace_text_formatter/atomic_chunk_factory.rb

@@ -0,0 +1,31 @@
+module MonospaceTextFormatter
+  class AtomicChunkFactory
+
+    REGEXP = /^(?:\n|[ \t]+|[^ \t\n]+)/
+
+    def new(string)
+      AtomicChunk.new(string)
+    end
+
+    def slice_from!(string)
+      (slice = string.slice!(regexp)) ? new(slice) : nil
+    end
+
+    def slice_from(string)
+      slice_from!(string.dup)
+    end
+
+    def split_string(string, length)
+      duplicated_string = string.dup
+      head_chunk = new(duplicated_string.slice!(0, length))
+      tail_chunk = new(duplicated_string)
+      [ head_chunk, tail_chunk ]
+    end
+
+    protected
+
+    def regexp
+      REGEXP
+    end
+  end
+end

data/lib/monospace_text_formatter/box.rb

@@ -0,0 +1,158 @@
+module MonospaceTextFormatter
+  class Box
+
+    def initialize(string_or_chunk, attrs={})
+         @omission = string_to_chunk(" ...")
+            @align = :left
+           @valign = :top
+             @fill = " "
+
+      raise ArgumentError, "No string given" unless string_or_chunk
+      @original_chunk = to_chunk_if_string(string_or_chunk)
+
+      attributes(attrs)
+    end
+
+    attr_reader :omission, :align, :valign, :fill
+
+    def width
+      @fixed_width || content_lines.first && content_lines.first.width
+    end
+
+    def height
+      @fixed_height || content_lines.size
+    end
+
+    def attributes(attrs={})
+      attrs.each { |name, value| send("#{name}=", value) }
+    end
+
+    def width=(fixed_width)
+      return if fixed_width == @fixed_width
+      raise ArgumentError, "The :width must be equal or greater than 0, but is #{fixed_width}" unless fixed_width.nil? or fixed_width >= 0
+
+      @to_s = @lines = @aligned_all_lines = @all_lines = @empty_top_lines = @content_lines = @empty_bottom_lines = nil
+      @fixed_width = fixed_width
+    end
+
+    def height=(fixed_height)
+      return if fixed_height == @fixed_height
+      raise ArgumentError, "The :height must be equal or greater than 0, but is #{fixed_height}" unless fixed_height.nil? or fixed_height >= 0
+
+      @to_s = @lines = @aligned_all_lines = @all_lines = @empty_top_lines = @content_lines = @empty_bottom_lines = nil
+      @fixed_height = fixed_height
+    end
+
+    def omission=(omission)
+      return if omission == @omission
+
+      @to_s = @lines = @aligned_all_lines = @all_lines = @content_lines = nil if @content_lines && truncated?
+      @omission = to_chunk_if_string(omission)
+    end
+
+    def align=(align)
+      return if align == @align
+      raise ArgumentError, "The :align must be a Symbol or String with value 'left', 'center' or 'right', but is #{align.inspect}" unless [:left, :center, :right].include?(align.to_sym)
+
+      @to_s = @lines = @aligned_all_lines = nil
+      @align = align.to_sym
+    end
+
+    def valign=(valign)
+      return if valign == @valign
+      raise ArgumentError, "The :valign must be a Symbol or String with value 'top', 'middle' or 'bottom', but is #{valign.inspect}" unless [:top, :middle, :bottom].include?(valign.to_sym)
+
+      @to_s = @lines = @aligned_all_lines = @all_lines = @empty_top_lines = @empty_bottom_lines = nil
+      @valign = valign.to_sym
+    end
+
+    def fill=(fill)
+      return if fill == @fill
+
+      @to_s = @lines = @aligned_all_lines = @all_lines = @empty_top_lines = @empty_bottom_lines = nil
+      @fill = fill
+    end
+
+    def truncated?
+      content_lines.last && content_lines.last.truncated?
+    end
+
+    def lines
+      @lines ||= aligned_all_lines.map { |aligned_line| aligned_line.to_s }
+    end
+
+    def to_s
+      @to_s ||= lines.join("\n")
+    end
+
+    private
+
+    def to_chunk_if_string(string)
+      string.is_a?(String) ? string_to_chunk(string) : string
+    end
+
+    def string_to_chunk(string)
+      Chunk.new(string)
+    end
+
+    def aligned_all_lines
+      @aligned_all_lines ||= all_lines.each do |line|
+        line.attributes(:align => align, :fill => fill, :width => width)
+      end
+    end
+
+    def all_lines
+      @all_lines ||= empty_top_lines + content_lines + empty_bottom_lines
+    end
+
+    def empty_top_lines
+      @empty_top_lines ||= if @fixed_height && fill && !fill.empty?
+                             case valign
+                             when :top
+                               []
+                             when :middle
+                               Array.new(((@fixed_height - content_lines.size) / 2.0).floor, Line.new(""))
+                             when :bottom
+                               Array.new(@fixed_height - content_lines.size, Line.new(""))
+                             end
+                           else
+                             []
+                           end
+    end
+
+    def empty_bottom_lines
+      @empty_bottom_lines ||= if @fixed_height && fill && !fill.empty?
+                                case valign
+                                when :top
+                                  Array.new(@fixed_height - content_lines.size, Line.new(""))
+                                when :middle
+                                  Array.new(((@fixed_height - content_lines.size) / 2.0).ceil, Line.new(""))
+                                when :bottom
+                                  []
+                                end
+                              else
+                                []
+                              end
+    end
+
+    def content_lines
+      return @content_lines unless @content_lines.nil?
+      return @content_lines = [] if @fixed_width == 0 && @fixed_height.nil?
+      return @content_lines = [Line.new("")] if @original_chunk.empty?
+
+      @remaining_chunk = @original_chunk.duplicate
+      @line_chunks = []
+
+      until (@fixed_height && @line_chunks.size == @fixed_height) || @remaining_chunk.empty?
+        @line_chunks << if @line_chunks.size + 1 == @fixed_height
+                          @remaining_chunk
+                        else
+                          @remaining_chunk.slice!(@fixed_width ? @fixed_width : nil)
+                        end
+      end
+
+      common_width = @fixed_width || @line_chunks.map { |chunk| chunk.display_length }.max
+      @content_lines = @line_chunks.map { |chunk| Line.new(chunk, :width => common_width, :omission => omission) }
+    end
+  end
+end

data/lib/monospace_text_formatter/chunk.rb

@@ -0,0 +1,174 @@
+module MonospaceTextFormatter
+  class Chunk
+
+    def initialize(string=nil)
+      @remaining_string = ""
+        @atomic_chunks = []
+        @display_length = 0
+
+      concat(string) unless string.nil?
+    end
+
+    def duplicate
+      duplicate = self.clone
+      duplicate.instance_variable_set("@remaining_string", @remaining_string.clone)
+      duplicate.instance_variable_set(   "@atomic_chunks",    @atomic_chunks.clone)
+      duplicate
+    end
+
+    def multiline?
+      atomic_chunks.any? { |atomic_chunk| atomic_chunk.newline? } or remaining_string.include?("\n")
+    end
+
+    def blank?
+      to_s.strip.empty?
+    end
+
+    def empty?
+      to_s.empty?
+    end
+
+    def display_length
+      slice_whole_remaining_string unless remaining_string.empty?
+      @display_length
+    end
+
+    def concat(string_or_chunk)
+
+      if string_or_chunk.kind_of?(Chunk)
+        slice_whole_remaining_string if string_or_chunk.atomic_chunks.any?
+
+        string_or_chunk.atomic_chunks.each { |atomic_chunk| push_atomic_chunk(atomic_chunk) }
+        remaining_string.concat(string_or_chunk.remaining_string)
+
+      else
+        remaining_string.concat(string_or_chunk)
+
+      end
+      self
+    end
+
+    def +(string_or_chunk)
+      duplicate.concat(string_or_chunk)
+    end
+
+    def slice!(max_display_length=nil, smartly_split_too_long_words=true)
+      sliced_chunk = self.class.new
+      return sliced_chunk if max_display_length == 0
+
+      while retrieve_first_atomic_chunk
+
+        if atomic_chunks.first.blank? and sliced_chunk.blank?
+          shift_atomic_chunk
+          next
+
+        elsif max_display_length && (atomic_chunks.first.display_length + sliced_chunk.display_length > max_display_length)
+          break
+
+        elsif atomic_chunks.first.newline?
+          shift_atomic_chunk
+          break
+
+        else
+          sliced_chunk.push_atomic_chunk(shift_atomic_chunk)
+        end
+      end
+
+      sliced_chunk.pop_atomic_chunk while sliced_chunk.atomic_chunks.last && sliced_chunk.atomic_chunks.last.blank?
+
+      if smartly_split_too_long_words &&
+        max_display_length &&
+        retrieve_first_atomic_chunk &&
+        atomic_chunks.first.display_length > max_display_length
+
+        smartly_split_too_long_word(max_display_length, sliced_chunk)
+      end
+
+      sliced_chunk
+    end
+
+    def slice(max_display_length)
+      duplicate.slice!(max_display_length)
+    end
+
+    def to_s
+      atomic_chunks.map { |atomic_chunk| atomic_chunk.to_s }.join + remaining_string
+    end
+
+    def inspect
+      %Q(#<#{self.class} #{to_s.inspect}>)
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    protected
+
+    def atomic_chunk_factory
+      @atomic_chunk_factory ||= AtomicChunkFactory.new
+    end
+
+    attr_accessor :atomic_chunks, :remaining_string
+
+    def push_atomic_chunk(atomic_chunk)
+      atomic_chunks.push(atomic_chunk)
+      @display_length += atomic_chunk.display_length
+    end
+
+    def pop_atomic_chunk
+      chunk = atomic_chunks.pop
+      @display_length -= chunk.display_length
+      chunk
+    end
+
+    def unshift_atomic_chunk(atomic_chunk)
+      atomic_chunks.unshift(atomic_chunk)
+      @display_length += atomic_chunk.display_length
+    end
+
+    def shift_atomic_chunk
+      chunk = atomic_chunks.shift
+      @display_length -= chunk.display_length
+      chunk
+    end
+
+    def delete_atomic_chunk_at(index)
+      chunk = atomic_chunks.delete_at(index)
+      @display_length -= chunk.display_length
+      chunk
+    end
+
+    def retrieve_first_atomic_chunk
+      !!(atomic_chunks.first or slice_atomic_chunk_from_remaining_string!)
+    end
+
+    def slice_whole_remaining_string
+      slice_atomic_chunk_from_remaining_string! until remaining_string.empty?
+    end
+
+    def slice_atomic_chunk_from_remaining_string!
+      if atomic_chunk = slice_from_remaining_string!
+        push_atomic_chunk(atomic_chunk)
+        atomic_chunk
+      end
+    end
+
+    def slice_from_remaining_string!
+      atomic_chunk_factory.slice_from!(remaining_string)
+    end
+
+    def smartly_split_too_long_word(max_display_length, sliced_chunk)
+      length_needed = max_display_length - sliced_chunk.display_length - (sliced_chunk.blank? ? 0 : 1)
+      return unless atomic_chunks.first.display_length % max_display_length <= length_needed
+
+      atomic_chunk = shift_atomic_chunk
+      atomic_chunk_1, atomic_chunk_2 = atomic_chunk_factory.split_string(atomic_chunk.to_s, length_needed)
+
+      sliced_chunk.concat(" ") unless sliced_chunk.blank?
+      sliced_chunk.concat(atomic_chunk_1.to_s)
+
+      unshift_atomic_chunk(atomic_chunk_2)
+    end
+  end
+end

data/lib/monospace_text_formatter/line.rb

@@ -0,0 +1,100 @@
+module MonospaceTextFormatter
+  class Line
+
+    def initialize(string_or_chunk, attrs={})
+         @omission = string_to_chunk(" ...")
+            @align = :left
+             @fill = " "
+        @truncated = nil
+
+      raise ArgumentError, "No string given" unless string_or_chunk
+      @original_chunk = to_chunk_if_string(string_or_chunk)
+
+      attributes(attrs)
+    end
+
+    attr_reader :omission, :align, :fill
+
+    def width
+      @fixed_width || visible_chunk.display_length
+    end
+
+    def attributes(attrs={})
+      attrs.each { |name, value| send("#{name}=", value) }
+    end
+
+    def width=(fixed_width)
+      return if fixed_width == @fixed_width
+      raise ArgumentError, "The :width must be equal or greater than 0, but is #{fixed_width}" unless fixed_width.nil? or fixed_width >= 0
+
+      @aligned_visible_text = @visible_chunk = nil
+      @fixed_width = fixed_width
+    end
+
+    def omission=(omission)
+      return if omission == @omission
+
+      @aligned_visible_text = @visible_chunk = nil if @truncated
+      @omission = to_chunk_if_string(omission)
+    end
+
+    def align=(align)
+      return if align == @align
+      raise ArgumentError, "The :align must be a Symbol or String with value 'left', 'center' or 'right', but is #{align.inspect}" unless [:left, :center, :right].include?(align.to_sym)
+
+      @aligned_visible_text = nil
+      @align = align.to_sym
+    end
+
+    def fill=(fill)
+      return if fill == @fill
+
+      @aligned_visible_text = nil
+      @fill = fill
+    end
+
+    def truncated?
+      visible_chunk
+      @truncated
+    end
+
+    def to_s
+      aligned_visible_text
+    end
+
+    private
+
+    def to_chunk_if_string(string)
+      string.is_a?(String) ? string_to_chunk(string) : string
+    end
+
+    def string_to_chunk(string)
+      Chunk.new(string)
+    end
+
+    def aligned_visible_text
+      @aligned_visible_text ||= if @fixed_width.nil? or fill.nil? or fill.empty?
+                                  visible_chunk.to_s
+                                else
+                                  case align
+                                  when :left
+                                    visible_chunk.to_s.ljust(@fixed_width, fill)
+                                  when :center
+                                    visible_chunk.to_s.center(@fixed_width, fill)
+                                  when :right
+                                    visible_chunk.to_s.rjust(@fixed_width, fill)
+                                  end
+                                end
+    end
+
+    def visible_chunk
+      @visible_chunk ||= if @original_chunk.multiline? || @fixed_width && @original_chunk.display_length > @fixed_width
+                           @truncated = true
+                           @original_chunk.slice(@fixed_width ? @fixed_width - omission.display_length : nil).concat(omission).slice!(@fixed_width)
+                         else
+                           @truncated = false
+                           @original_chunk.slice(@fixed_width)
+                         end
+    end
+  end
+end

data/lib/monospace_text_formatter/version.rb

@@ -0,0 +1,3 @@
+module MonospaceTextFormatter
+  VERSION = "0.0.1"
+end

data/lib/monospace_text_formatter.rb

@@ -0,0 +1,10 @@
+require "monospace_text_formatter/version"
+
+require "monospace_text_formatter/atomic_chunk"
+require "monospace_text_formatter/atomic_chunk_factory"
+require "monospace_text_formatter/chunk"
+require "monospace_text_formatter/line"
+require "monospace_text_formatter/box"
+
+module MonospaceTextFormatter
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: monospace_text_formatter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jacek Mikrut
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70478590 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70478590
+description: Formats monospaced text into a line or visual box of defined 'width'
+  and 'height' boundaries (expressed in number of characters).
+email: jacekmikrut.software@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/monospace_text_formatter/atomic_chunk_factory.rb
+- lib/monospace_text_formatter/box.rb
+- lib/monospace_text_formatter/version.rb
+- lib/monospace_text_formatter/atomic_chunk.rb
+- lib/monospace_text_formatter/line.rb
+- lib/monospace_text_formatter/chunk.rb
+- lib/monospace_text_formatter.rb
+- README.md
+- LICENSE
+- Changelog
+homepage: http://github.com/jacekmikrut/monospace_text_formatter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Formats monospaced text into a line or visual box.
+test_files: []