fOOrth 0.6.6 → 0.6.11

data/lib/fOOrth/library/complex_library.rb

@@ -1,81 +1,83 @@
-# coding: utf-8
-
-#* library/complex_library.rb - Numeric support for the fOOrth library.
-module XfOOrth
-
-  #Connect the Complex class to the fOOrth class system.
-  Complex.create_foorth_proxy
-
-  #Some complex stubs.
-  Complex.create_shared_method('mod',    NosSpec, [:stub])
-  Complex.create_shared_method('.ceil',  TosSpec, [:stub])
-  Complex.create_shared_method('.floor', TosSpec, [:stub])
-  Complex.create_shared_method('.round', TosSpec, [:stub])
-  Complex.create_shared_method('<',      NosSpec, [:stub])
-  Complex.create_shared_method('>',      NosSpec, [:stub])
-  Complex.create_shared_method('<=',     NosSpec, [:stub])
-  Complex.create_shared_method('>=',     NosSpec, [:stub])
-  Complex.create_shared_method('<=>',    NosSpec, [:stub])
-
-
-  #Some conversion words.
-  # [a b] complex [a+bi]
-  VirtualMachine.create_shared_method('complex', VmSpec, [], &lambda {|vm|
-    real,imag = popm(2)
-
-    begin
-      push(Complex(real,imag));
-    rescue
-      error "F40: Cannot coerce a #{real.foorth_name}, #{imag.foorth_name} to a Complex"
-    end
-  })
-
-  # [a+bi] .split [a b]
-  Complex.create_shared_method('.split', TosSpec, [],
-    &lambda {|vm| vm.push(self.real); vm.push(self.imaginary); })
-
-  # [a] .to_x [compleX or nil]
-  Object.create_shared_method('.to_x', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(Complex(self))
-    rescue
-      vm.push(nil)
-    end
-  })
-
-  # [a] .to_x! [compleX]
-  Object.create_shared_method('.to_x!', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(Complex(self))
-    rescue
-      error "F40: Cannot coerce a #{self.foorth_name} to a Complex"
-    end
-  })
-
-  # [a+bi] .imaginary [b]
-  Numeric.create_shared_method('.imaginary', TosSpec, [],
-    &lambda {|vm| vm.push(self.imaginary); })
-
-  # [a+bi] .real [a]
-  Numeric.create_shared_method('.real', TosSpec, [],
-    &lambda {|vm| vm.push(self.real); })
-
-  # [a+bi] .angle [atan2(b,a) or 0]
-  Numeric.create_shared_method('.angle', TosSpec, [],
-    &lambda {|vm| vm.push(self.angle); })
-
-  # [a+bi] .magnitude [sqrt(a**2 + b**2)]
-  Numeric.create_shared_method('.magnitude', TosSpec, [],
-    &lambda {|vm| vm.push(self.magnitude); })
-
-  # [a+bi] .conjugate [a-bi]
-  # Complex convicts that behave well are allowed .conjugate visits.
-  Numeric.create_shared_method('.conjugate', TosSpec, [],
-    &lambda {|vm| vm.push(self.conjugate); })
-
-  # [a+bi] .polar [magnitude angle]
-  # Convert a complex number to polar format
-  Numeric.create_shared_method('.polar', TosSpec, [],
-    &lambda {|vm| vm.pushm(self.polar); })
-
+# coding: utf-8
+
+#* library/complex_library.rb - Numeric support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Complex class to the fOOrth class system.
+  Complex.create_foorth_proxy
+
+  #Some complex stubs.
+  Complex.create_shared_method('mod',          NosSpec, [:stub])
+  Complex.create_shared_method('.ceil',        TosSpec, [:stub])
+  Complex.create_shared_method('.floor',       TosSpec, [:stub])
+  Complex.create_shared_method('.round',       TosSpec, [:stub])
+  Complex.create_shared_method('<',            NosSpec, [:stub])
+  Complex.create_shared_method('>',            NosSpec, [:stub])
+  Complex.create_shared_method('<=',           NosSpec, [:stub])
+  Complex.create_shared_method('>=',           NosSpec, [:stub])
+  Complex.create_shared_method('<=>',          NosSpec, [:stub])
+  Complex.create_shared_method('.numerator',   TosSpec, [:stub])
+  Complex.create_shared_method('.denominator', TosSpec, [:stub])
+
+
+  #Some conversion words.
+  # [a b] complex [a+bi]
+  VirtualMachine.create_shared_method('complex', VmSpec, [], &lambda {|vm|
+    real,imag = popm(2)
+
+    begin
+      push(Complex(real,imag));
+    rescue
+      error "F40: Cannot coerce a #{real.foorth_name}, #{imag.foorth_name} to a Complex"
+    end
+  })
+
+  # [a+bi] .split [a b]
+  Complex.create_shared_method('.split', TosSpec, [],
+    &lambda {|vm| vm.push(self.real); vm.push(self.imaginary); })
+
+  # [a] .to_x [compleX or nil]
+  Object.create_shared_method('.to_x', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Complex(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a] .to_x! [compleX]
+  Object.create_shared_method('.to_x!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Complex(self))
+    rescue
+      error "F40: Cannot coerce a #{self.foorth_name} to a Complex"
+    end
+  })
+
+  # [a+bi] .imaginary [b]
+  Numeric.create_shared_method('.imaginary', TosSpec, [],
+    &lambda {|vm| vm.push(self.imaginary); })
+
+  # [a+bi] .real [a]
+  Numeric.create_shared_method('.real', TosSpec, [],
+    &lambda {|vm| vm.push(self.real); })
+
+  # [a+bi] .angle [atan2(b,a) or 0]
+  Numeric.create_shared_method('.angle', TosSpec, [],
+    &lambda {|vm| vm.push(self.angle); })
+
+  # [a+bi] .magnitude [sqrt(a**2 + b**2)]
+  Numeric.create_shared_method('.magnitude', TosSpec, [],
+    &lambda {|vm| vm.push(self.magnitude); })
+
+  # [a+bi] .conjugate [a-bi]
+  # Complex convicts that behave well are allowed .conjugate visits.
+  Numeric.create_shared_method('.conjugate', TosSpec, [],
+    &lambda {|vm| vm.push(self.conjugate); })
+
+  # [a+bi] .polar [magnitude angle]
+  # Convert a complex number to polar format
+  Numeric.create_shared_method('.polar', TosSpec, [],
+    &lambda {|vm| vm.pushm(self.polar); })
+
 end

data/lib/fOOrth/library/float_library.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+#* library/float_library.rb - Float specific support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Float class to the fOOrth class system.
+  Float.create_foorth_proxy
+
+  # [a] .to_f [Float or nil]
+  Object.create_shared_method('.to_f', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Float(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a] .to_f! [Float]
+  Object.create_shared_method('.to_f!', TosSpec, [],
+    &lambda {|vm| vm.push(Float.foorth_coerce(self)) })
+
+  # [num_digits a_number] .round_to [a_float]
+  Numeric.create_shared_method('.round_to', TosSpec, [], &lambda {|vm|
+    value = Float.foorth_coerce(self)
+    digits = Integer.foorth_coerce(vm.pop)
+    vm.push(value.round(digits))
+  })
+
+  # [n/d] .numerator [n]
+  Float.create_shared_method('.numerator', TosSpec, [],
+    &lambda {|vm| vm.push(self.rationalize.numerator); })
+
+  # [n/d] .denominator [d]
+  Float.create_shared_method('.denominator', TosSpec, [],
+    &lambda {|vm| vm.push(self.rationalize.denominator); })
+
+end

data/lib/fOOrth/library/formatting/array.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+#* library/formatting/array.rb - Array support for displaying data formatted neatly.
+class Array
+
+  # Columns ========================================================
+
+  #Print out the array with efficient columns.
+  def puts_foorth_columns(page_length, page_width)
+    format_foorth_pages(page_length, page_width).each do |page|
+      puts page, ""
+    end
+  end
+
+  #Convert the array to strings with efficient columns.
+  #<br>Returns
+  #* A string.
+  def format_foorth_columns(page_length, page_width)
+    format_foorth_pages(page_length, page_width)
+      .map {|page| page << ""}
+      .flatten[0...-1]
+      .join("\n")
+      .freeze
+  end
+
+  #Get the widest element of an array.
+  #<br>Returns
+  #* The width of the widest string in the array.
+  def foorth_column_width
+    (self.max_by {|item| item.length}).length
+  end
+
+  private
+
+  #Convert the array to strings with efficient columns.
+  #<br>Returns
+  #* An array of pages (arrays of strings)
+  def format_foorth_pages(page_length, page_width)
+    index, pages, limit = 0, [], self.length
+    builder = XfOOrth::ColumnizedPage.new(page_length, page_width)
+
+    while index < limit
+      index += 1 - (left_over = builder.add(self[index]))
+      pages << builder.render if (left_over > 0) || (index == limit)
+    end
+
+    pages
+  end
+
+  # Bullets ========================================================
+
+  public
+
+  #Print out the array as bullet points.
+  def puts_foorth_bullets(page_width)
+    puts foorth_format_bullets(page_width)
+  end
+
+  #Convert the array to strings with bullet points.
+  #<br>Returns
+  #* A string
+  def foorth_format_bullets(page_width)
+    return "" if empty?
+
+    builder = XfOOrth::BulletPoints.new(page_width)
+
+    self.each do |pair|
+      builder.add(*pair.prepare_bullet_data)
+    end
+
+    builder.render.join("\n").freeze
+  end
+
+  #Convert the array to a bullet point description.
+  #<br>Returns
+  #* An array of strings.
+  def format_description(page_width)
+    format_foorth_pages(false, page_width)[0] || []
+  end
+
+  #Get data ready for being in a bullet point.
+  def prepare_bullet_data
+    if length < 2
+      ["*", self[0]]
+    else
+      self
+    end
+  end
+
+end

data/lib/fOOrth/library/formatting/bullets.rb

@@ -5,30 +5,22 @@ module XfOOrth
 
   #A class to display data in bullet points.
   class BulletPoints
+
     #Prepare a blank slate.
     def initialize(page_width)
-      @page_width, @bullet_data = page_width, []
+      @page_width  = page_width
+      @bullet_data = []
     end
 
-    #Add an item to this page.
-    #<br>Returns
-    #* The number if items that did not fit in the page.
-    def add(raw_bullet = "*", *raw_item)
-
-      if raw_item.empty?
-        bullet = ["*"]
-        items = raw_bullet.in_array
-      else
-        bullet = raw_bullet.in_array
-        items = raw_item.in_array
-      end
-
-      items.each_index do |index|
-        @bullet_data << [(bullet[index] || "").to_s, items[index].to_s]
+    #Add items to these bullet points.
+    def add(bullet, *items)
+      items.each do |item|
+        @bullet_data << [bullet.to_s, item]
+        bullet = ""
       end
     end
 
-    #Render the page as an array of strings.
+    #Render the bullet points as an array of strings.
     def render
       @key_length, results = get_key_length, []
 
@@ -42,80 +34,24 @@ module XfOOrth
 
     private
 
-    #How large is the largest bullet?
+    #Allowing for a trailing space, how large is the largest bullet?
     def get_key_length
-      (@bullet_data.max_by {|line| line[0].length})[0].length
+      (@bullet_data.max_by {|line| line[0].length})[0].length + 1
     end
 
     #Render one bullet point.
     def render_bullet(key, item)
       result = []
-      input  = item.split(' ').each
-      temp   = key.ljust(len = @key_length)
-      pass_one = true
-
-      loop do
-        word = ' ' + input.next
 
-        while len >= @page_width
-          result << temp.slice!(0, @page_width - 1)
-          temp = (' ' * @key_length) + ' ' + temp
-          len  = temp.length
-        end
-
-        if ((len += word.length) >= @page_width) && !pass_one
-          result << temp
-          temp = (' ' * @key_length) + word
-          len  = temp.length
-        else
-          temp << word
-          pass_one = false
-        end
+      item.format_description(@page_width - @key_length - 1).each do |desc_line|
+        result << key.ljust(@key_length) + desc_line
+        key = ""
       end
 
-      result << temp
+      result
     end
 
   end
 
 end
 
-class Array
-  #Print out the array as bullet points.
-  def puts_foorth_bullets(page_width)
-    puts foorth_bulletize(page_width)
-  end
-
-  #Convert the array to strings with bullet points.
-  #<br>
-  #* An array of arrays of strings
-  def foorth_bulletize(page_width)
-    builder = XfOOrth::BulletPoints.new(page_width)
-
-    self.each do |pair|
-      builder.add(*pair)
-    end
-
-    builder.render
-  end
-end
-
-class Hash
-  #Print out the hash as bullet points.
-  def puts_foorth_bullets(page_width)
-    puts foorth_bulletize(page_width)
-  end
-
-  #Convert the hash to strings with bullet points.
-  #<br>
-  #* An array of arrays of strings
-  def foorth_bulletize(page_width)
-    builder = XfOOrth::BulletPoints.new(page_width)
-
-    self.each do |key, value|
-      builder.add(key, *value.in_array)
-    end
-
-    builder.render
-  end
-end

data/lib/fOOrth/library/formatting/columns.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-#* library/formatting/columns.rb - Print out data in columns.
+#* library/formatting/bullets.rb - Print out data in neat columns.
 module XfOOrth
 
   #A class to display data in columns.
@@ -18,8 +18,8 @@ module XfOOrth
       item = raw_item.to_s
       fail "Item too large to fit." unless item.length < @page_width
 
-      if (slot = find_next_column)
-        @page_data[slot] << item
+      if (column = find_next_column)
+        @page_data[column] << item
       else
         @page_data << [item]
       end
@@ -29,21 +29,28 @@ module XfOOrth
 
     #Render the page as an array of strings.
     def render
-      results = []
-      widths  = @page_data.map {|column| column.foorth_column_width}
+      results, column_widths = [], get_column_widths
 
-      (0...rows).each do |column_index|
-        results << @page_data.each_with_index.map do |column, index|
-          column[column_index].to_s.ljust(widths[index])
-        end.join(" ").freeze
-      end
+      rows.times { |row_index| results << render_row(row_index, column_widths)}
 
-      @page_data = []
+      @page_data.clear
       results
     end
 
     private
 
+    #Get the widths of all columns
+    def get_column_widths
+      @page_data.map {|column| column.foorth_column_width}
+    end
+
+    #Render a single row of data.
+    def render_row(row_index, widths)
+      @page_data.each_with_index.map do |column, index|
+        column[row_index].to_s.ljust(widths[index])
+      end.join(" ")
+    end
+
     #Make sure the page fits within its boundaries.
     #<br>Returns
     #* The number if items that did not fit in the page.
@@ -74,6 +81,8 @@ module XfOOrth
       if empty?
         0
       else
+        #The starting point, @page_data.length-1, represents the spaces needed
+        #between the columns. So N columns means N-1 spaces.
         @page_data.inject(@page_data.length-1) do |sum, column|
           sum + column.foorth_column_width
         end
@@ -111,34 +120,3 @@ module XfOOrth
 
 end
 
-#Support for displaying an array in neat columns.
-class Array
-  #Print out the array with efficient columns.
-  def puts_foorth_columnized(page_length, page_width)
-    foorth_columnize(page_length, page_width).each do |page|
-      puts page
-      puts
-    end
-  end
-
-  #Convert the array to strings with efficient columns.
-  #<br>
-  #* An array of arrays of strings
-  def foorth_columnize(page_length, page_width)
-    index, pages, limit = 0, [], self.length
-    builder = XfOOrth::ColumnizedPage.new(page_length, page_width)
-
-    while index < limit
-      index += 1 - (left_over = builder.add(self[index]))
-      pages << builder.render if (left_over > 0) || (index == limit)
-    end
-
-    pages
-  end
-
-  #Get the widest element of an array.
-  def foorth_column_width
-    (self.max_by {|item| item.length}).length
-  end
-end
-