fOOrth 0.6.4 → 0.6.5

data/lib/fOOrth/library/compile_library.rb

@@ -3,12 +3,27 @@
 #* library/compile_library.rb - The compile support fOOrth library.
 module XfOOrth
 
+  # METHOD CASTING ==============================
+
+  #TosSpec method cast.
+  VirtualMachine.create_shared_method("'.", VmSpec, [],
+    &lambda {|vm| vm.set_cast(TosSpec) })
+
+  #NosSpec method cast.
+  VirtualMachine.create_shared_method("'*", VmSpec, [],
+    &lambda {|vm| vm.set_cast(NosSpec) })
+
+  #SelfSpec method cast.
+  VirtualMachine.create_shared_method("'~", VmSpec, [],
+    &lambda {|vm| vm.set_cast(SelfSpec) })
+
   # COLON =======================================
 
   #The classic colon definition that creates a word in the Virtual Machine class.
   # [] : <name> <stuff omitted> ; []; creates <name> on the VirtualMachine
   VirtualMachine.create_shared_method(':', VmSpec, [:immediate],  &lambda {|vm|
     if execute_mode?
+      verify_cast([VmSpec])
       target = VirtualMachine
       name   = vm.parser.get_word()
       type   = VmSpec
@@ -32,6 +47,7 @@ module XfOOrth
   # [] !: <name> <stuff omitted> ; []; creates <name> on the VirtualMachine
   VirtualMachine.create_shared_method('!:', VmSpec, [:immediate],  &lambda {|vm|
     if execute_mode?
+      verify_cast([VmSpec])
       target = VirtualMachine
       name   = vm.parser.get_word()
       type   = VmSpec
@@ -58,7 +74,7 @@ module XfOOrth
       error "F13: The target of .: must be a class" unless target.is_a?(Class)
 
       name   = vm.parser.get_word()
-      type   = XfOOrth.name_to_type(name)
+      type   = XfOOrth.name_to_type(name, get_cast)
       XfOOrth.validate_type(vm, type, name)
       XfOOrth.validate_string_method(type, target, name)
 
@@ -116,7 +132,7 @@ module XfOOrth
     if execute_mode?
       target = vm.pop
       name   = vm.parser.get_word()
-      type   = XfOOrth.name_to_type(name)
+      type   = XfOOrth.name_to_type(name, get_cast)
       XfOOrth.validate_type(vm, type, name)
       XfOOrth.validate_string_method(type, target.class, name)
 
@@ -184,8 +200,10 @@ module XfOOrth
       &lambda {|vm| vm << 'super(vm); ' })
 
     #The standard end-compile adapter word: ';' semi-colon.
-    context.create_local_method(';', LocalSpec, [:immediate],
-      &lambda {|vm| vm.end_compile_mode([ctrl]) })
+    context.create_local_method(';', LocalSpec, [:immediate], &lambda {|vm|
+      vm.clear_cast
+      vm.end_compile_mode([ctrl])
+    })
   end
 
   #Determine the type of method being created. This only applies to non-vm
@@ -194,8 +212,8 @@ module XfOOrth
   #*name - The name of the method to be created.
   #<Returns>
   #* The class of the spec to be used for this method.
-  def self.name_to_type(name)
-    case name[0]
+  def self.name_to_type(name, cast_spec=nil)
+    normal_spec = case name[0]
     when '.'
       TosSpec
 
@@ -208,6 +226,8 @@ module XfOOrth
     else
       NosSpec
     end
+
+    cast_spec || normal_spec
   end
 
   #Compare the new method's spec against the specs of other methods of the
@@ -218,7 +238,7 @@ module XfOOrth
   #*type - The class of the method to be created.
   #*name - The name of the method to be created.
   def self.validate_type(vm, type, name)
-    if (spec = vm.context.map(name))
+    if (spec = vm.context.map(name, false))
       if spec.class != type
         error "F90: Spec type mismatch #{spec.foorth_name} vs #{type.foorth_name}"
       end

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

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+#* library/formatting/bullets.rb - Print out bullet points.
+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, []
+    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]
+      end
+    end
+
+    #Render the page as an array of strings.
+    def render
+      @key_length, results = get_key_length, []
+
+      @bullet_data.each do |key, item|
+        results.concat(render_bullet(key, item))
+      end
+
+      @bullet_data = []
+      results
+    end
+
+    private
+
+    #How large is the largest bullet?
+    def get_key_length
+      (@bullet_data.max_by {|line| line[0].length})[0].length
+    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
+      end
+
+      result << temp
+    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

@@ -0,0 +1,144 @@
+# coding: utf-8
+
+#* library/formatting/columns.rb - Print out data in columns.
+module XfOOrth
+
+  #A class to display data in columns.
+  class ColumnizedPage
+    #Prepare a blank page.
+    def initialize(page_length, page_width)
+      @page_length, @page_width = page_length, page_width
+      @page_data = []
+    end
+
+    #Add an item to this page.
+    #<br>Returns
+    #* The number if items that did not fit in the page.
+    def add(raw_item)
+      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
+      else
+        @page_data << [item]
+      end
+
+      adjust_configuration
+    end
+
+    #Render the page as an array of strings.
+    def render
+      results = []
+      widths  = @page_data.map {|column| column.foorth_column_width}
+
+      (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
+
+      @page_data = []
+      results
+    end
+
+    private
+
+    #Make sure the page fits within its boundaries.
+    #<br>Returns
+    #* The number if items that did not fit in the page.
+    def adjust_configuration
+      while total_width >= @page_width
+        return @page_data.pop.length if rows == @page_length
+        add_a_row
+      end
+
+      0
+    end
+
+    #Add a row to the page, moving items as needed.
+    def add_a_row
+      target = rows + 1
+      pool, @page_data = @page_data.flatten, []
+
+      until pool.empty?
+        @page_data << pool.shift(target)
+      end
+    end
+
+    #Compute the total width of all of the columns.
+    #<br>Returns
+    #* The sum of the widths of the widest items of each column plus a space
+    #  between each of those columns.
+    def total_width
+      if empty?
+        0
+      else
+        @page_data.inject(@page_data.length-1) do |sum, column|
+          sum + column.foorth_column_width
+        end
+      end
+    end
+
+    #Does the data fit on the page?
+    def fits?
+      total_width < @page_width
+    end
+
+    #How many rows are currently in this page?
+    def rows
+      empty? ? 0 : @page_data[0].length
+    end
+
+    #Is this page empty?
+    def empty?
+      @page_data.empty?
+    end
+
+    #Which column will receive the next item?
+    #<br>Returns
+    #* The index of the first non-filled column or nil if none found.
+    def find_next_column
+      (1...(@page_data.length)).each do |index|
+        if @page_data[index].length < @page_data[index-1].length
+          return index
+        end
+      end
+
+      nil
+    end
+  end
+
+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
+

data/lib/fOOrth/library/hash_library.rb

@@ -197,7 +197,8 @@ class Hash
   #A helper method to extract non-stub method names from a method hash.
   def extract_method_names(search_type = :no_stubs)
     search_value = (search_type == :stubs)
-    mkeys = self.keys.select {|key| search_value == self[key].has_tag?(:stub)  }
+    get_all = (search_type == :all)
+    mkeys = self.keys.select {|key| get_all || search_value == self[key].has_tag?(:stub)  }
     mkeys.collect {|key| XfOOrth::SymbolMap.unmap(key) || '?error?' }
   end
 end

data/lib/fOOrth/library/introspection/class.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+
+#* library/introspection/class.rb - Class support for introspection.
+class Class
+
+  #Get information about the mapping of the symbol.
+  def map_foorth_shared_info(symbol, shallow=nil)
+    if (spec = foorth_shared[symbol])
+      [spec, [["Class", foorth_class_name], ["Scope", "Shared"]]]
+    elsif (sc = superclass) && !shallow
+      sc.map_foorth_shared_info(symbol)
+    else
+      [nil, nil]
+    end
+  end
+
+  #Get the lineage of this class.
+  def lineage
+    #Ugly hack, sorry!
+    if [Object, Module].include?(self)
+      "Object"
+    else
+      foorth_class_name + " < " + superclass.lineage
+    end
+  end
+
+  #Investigate a method of this class.
+  def foorth_method_info(name)
+    symbol, results = XfOOrth::SymbolMap.map_info(name)
+    found = false
+
+    if symbol
+      spec, info = map_foorth_shared_info(symbol)
+
+      if spec && !spec.has_tag?(:stub)
+        (results << ["", ""]).concat(info).concat(spec.get_info)
+        found = true
+      end
+
+      spec, info = map_foorth_exclusive_info(symbol)
+
+      if spec && !spec.has_tag?(:stub)
+        (results << ["", ""]).concat(info).concat(spec.get_info)
+        found = true
+      end
+
+      results << ["Scope", "not found."] unless found
+    end
+
+    results
+  end
+
+  #Get introspection info.
+  def get_info
+    results = [["Lineage", lineage]]
+
+    if foorth_has_exclusive?
+      results.concat([["", ""], ["Methods", "Class"]])
+
+      foorth_exclusive.extract_method_names(:all).sort.each do |name|
+        symbol, info = XfOOrth::SymbolMap.map_info(name)
+        (results << ["", ""]).concat(info)
+
+        spec, info = map_foorth_exclusive_info(symbol, :shallow)
+        results.concat(info).concat(spec.get_info)
+      end
+    end
+
+    unless foorth_shared.empty?
+      results.concat([["", ""], ["Methods", "Shared"]])
+
+      foorth_shared.extract_method_names(:all).sort.each do |name|
+        symbol, info = XfOOrth::SymbolMap.map_info(name)
+        (results << ["", ""]).concat(info)
+
+        spec, info = map_foorth_shared_info(symbol, :shallow)
+        results.concat(info).concat(spec.get_info)
+      end
+    end
+
+    results
+  end
+
+end