fOOrth 0.5.0

data/lib/fOOrth/monkey_patch/rational.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+#Extensions to the \Rational class required by the fOOrth language system.
+class Rational
+  #Convert this rational number to a form suitable for embedding in a source string.
+  #<br>Returns
+  #* An embeddable form of this rational number as a string.
+  def foorth_embed
+    "'#{self.to_s}'.to_r"
+  end
+
+  #Convert this object to a rational. Returns self.
+  def to_foorth_r
+    self
+  end
+
+  #Argument coercion methods.
+
+  #Coerce the argument to match my type.
+  def self.foorth_coerce(arg)
+    arg.to_foorth_r || (error "F40: Cannot coerce a #{arg.foorth_name} to a Rational")
+  end
+
+  #Coerce the argument to match my type.
+  #<br>Endemic Code Smells
+  #* :reek:FeatureEnvy  -- false positive
+  def foorth_coerce(arg)
+    arg.to_foorth_r || (error "F40: Cannot coerce a #{arg.foorth_name} to a Rational")
+  end
+
+end

data/lib/fOOrth/monkey_patch/string.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+#Extensions to the \String class required by the fOOrth language system.
+class String
+  #Convert this String to a form suitable for embedding in a source string.
+  #<br>Returns
+  #* An embeddable form of this string as a string.
+  def foorth_embed
+    self.inspect
+  end
+
+  #Coerce the argument to match my type.
+  #<br>Endemic Code Smells
+  #* :reek:FeatureEnvy -- false positive
+  def foorth_coerce(arg)
+    arg.to_s
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to an String instance"
+  end
+
+  #Convert this string to a single character string.
+  def to_foorth_c
+    self[0]
+  end
+
+  #Convert this string to a numeric. Return a number or nil on fail.
+  def to_foorth_n
+    if /\di$/ =~ self      #Check for a trailing '<digit>i'.
+      #Check for the internal '+' or '-'sign.
+      if /(?<=\d)[+-]/ =~ self
+        Complex(($PREMATCH).to_foorth_n, ($MATCH + $POSTMATCH).chop.to_foorth_n)
+      else
+        Complex(0, self.chop.to_foorth_n)
+      end
+    elsif /\d\/\d/ =~ self #Check for an embedded '<digit>/<digit>'.
+      Rational(self)
+    elsif /\d\.\d/ =~ self #Check for an embedded '<digit>.<digit>'.
+      Float(self)
+    else                   #For the rest, assume an integer.
+      Integer(self)
+    end
+  rescue
+    nil
+  end
+
+  #Convert this string to a rational. Return a number or nil on fail.
+  def to_foorth_r
+    self.to_foorth_n.to_foorth_r
+  end
+
+end

data/lib/fOOrth/symbol_map.rb

@@ -0,0 +1,82 @@
+# coding: utf-8
+
+#* symbol_map.rb - The name mangler for the foorth Language System.
+module XfOOrth
+
+  #A module used to map strings to unique symbols
+  module SymbolMap
+
+    class << self
+      #Access to the mapping of names to symbols.
+      attr_reader :forward_map
+
+      #Access to the mapping of symbols to names.
+      attr_reader :reverse_map
+    end
+
+    @sync = Mutex.new
+    @incrementer = '_000'
+    @forward_map = Hash.new
+    @reverse_map = Hash.new
+
+    #Add a global mapping for a string to a symbol that will not collide with
+    #existing symbols.
+    #<br>Parameters:
+    #* name - The string to be mapped.
+    #* presym - A pre-assigned symbol value or nil to generate a symbol.
+    #<br>Returns:
+    #* The symbol that corresponds to the name.
+    #<br>Endemic Code Smells
+    #* :reek:ControlParameter -- false positive
+    def self.add_entry(name, presym=nil)
+      @sync.synchronize do
+        unless (symbol = @forward_map[name])
+          symbol = presym || (@incrementer.succ!).to_sym
+          connect(name, symbol)
+        else
+          error "F90: Attempt to redefine #{name}." if presym && presym != symbol
+        end
+
+        symbol
+      end
+    end
+
+    #Get the entry for the mapping string. Return nil if there is no entry.
+    #<br>Parameters:
+    #* name - The string to be looked up.
+    #<br>Returns:
+    #* A symbol or nil if the symbol is not in the map.
+    def self.map(name)
+      @forward_map[name]
+    end
+
+    #Get the entry for the mapping symbol. Return nil if there is no entry.
+    #<br>Parameters:
+    #* mapped - The mapping of the desired symbol.
+    #<br>Returns:
+    #* The name or nil if the symbol is not in the map.
+    def self.unmap(mapped)
+      @reverse_map[mapped]
+    end
+
+    #Reset the incrementer to the given string. This used for testing only.
+    #<br>Parameters:
+    #* start - The new starting point of the generated symbols.
+    #<br>Note:
+    #* FOR TESTING ONLY.
+    def self.restart(start)
+      @incrementer = start
+    end
+
+    #Set up the internal workings of the mapping hashes.
+    private
+    def self.connect(name, symbol)
+      if (old = @reverse_map[symbol]) && (old != name)
+        error "F90: Attempt to redefine #{name}."
+      end
+
+      @reverse_map[symbol] = name
+      @forward_map[name] = symbol
+    end
+  end
+end

data/lib/fOOrth/version.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+#* version.rb - The version string for fOOrth.
+module XfOOrth
+  #The version string for fOOrth.
+  VERSION = "0.5.0"
+end

data/license.txt

@@ -0,0 +1,21 @@
+=== The MIT License (MIT).
+
+Copyright (c) 2014 Peter Camilleri
+
+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.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rake
+# coding: utf-8
+
+require 'rake/testtask'
+require 'rdoc/task'
+require "bundler/gem_tasks"
+
+#Generate internal documentation with rdoc.
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+
+  #List out all the files to be documented.
+  rdoc.rdoc_files.include("lib/**/*.rb", "license.txt", "README.md")
+
+  #Make all access levels visible.
+  rdoc.options << '--visibility' << 'private'
+  #rdoc.options << '--verbose'
+  #rdoc.options << '--coverage-report'
+
+  #Set a title.
+  rdoc.options << '--title' << 'fOOrth Language Internals'
+
+end
+
+#Run the fOOrth unit test suite.
+Rake::TestTask.new do |t|
+  #List out all the test files.
+  t.test_files = FileList['tests/**/*.rb']
+  t.verbose = false
+end
+
+#Run the fOOrth integration test suite.
+Rake::TestTask.new(:integration) do |t|
+  #List out all the test files.
+  t.test_files = FileList['integration/*.rb']
+end
+
+desc "Run a scan for smelly code!"
+task :reek do |t|
+  `reek --no-color lib > reek.txt`
+end
+
+desc "Fire up an IRB session with fOOrth preloaded."
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require './lib/fOOrth'
+  puts "Starting an IRB console for fOOrth."
+  ARGV.clear
+  IRB.start
+end
+
+desc "Run an Interactive fOOrth Session."
+task :run do
+  require './lib/fOOrth'
+  ARGV.clear
+  XfOOrth::main
+end
+
+desc "What version of fOOrth is this?"
+task :vers do |t|
+  puts
+  puts "fOOrth version = #{XfOOrth::VERSION}"
+end
+

data/reek.txt

@@ -0,0 +1 @@
+0 total warnings

data/sire.rb

@@ -0,0 +1,132 @@
+# coding: utf-8
+# A Simple Interactive Ruby Environment
+
+$no_alias_read_line_module = true
+require 'mini_readline'
+require 'pp'
+
+if ARGV[0] == 'local'
+  require_relative 'lib/fOOrth'
+  puts "\nOption(local) Loaded fOOrth from the local code folder."
+elsif defined?(XfOOrth)
+  puts "The fOOrth system is already loaded."
+else
+  begin
+    require 'fOOrth'
+    puts "\nLoaded fOOrth from the system gem."
+  rescue LoadError
+    require_relative 'lib/fOOrth'
+    puts "\nLoaded fOOrth from the local code folder."
+  end
+end
+
+puts "fOOrth version = #{XfOOrth::VERSION}"
+puts
+
+class Object
+  #Generate the class lineage of the object.
+  def classes
+    begin
+      result = ""
+      klass  = self.instance_of?(Class) ? self : self.class
+
+      begin
+        result << klass.to_s
+        klass = klass.superclass
+        result << " < " if klass
+      end while klass
+
+      result
+    end
+  end
+end
+
+class SIRE
+  #Set up the interactive session.
+  def initialize
+    @_done = false
+    @_edit = MiniReadline::Readline.new(history: true,
+                                        auto_complete: true,
+                                        auto_source: MiniReadline::QuotedFileFolderSource,
+                                        eoi_detect: true)
+
+    puts "Welcome to a Simple Interactive Ruby Environment\n"
+    puts
+    puts "Local commands:"
+    puts "    q       - quit SIRE."
+    puts "    r       - run fOOrth."
+    puts "    v       - version manifest"
+    puts "obj classes - show the obj's class heritage."
+    puts
+  end
+
+  #Quit the interactive session.
+  def q
+    @_done = true
+    puts
+    "Bye bye for now!"
+  end
+
+  def r
+    ARGV.clear
+    XfOOrth::main.data_stack
+  end
+
+  def v
+    puts "Version Manifest"
+    mods = ObjectSpace.each_object(Module).select{|c| c.const_defined?("VERSION")}
+    width = (mods.max_by{|m| m.to_s.length}).to_s.length
+    list = mods.map {|m| "#{m.to_s.ljust(width)} #{m.const_get(:VERSION)}" }
+    list.sort
+  end
+
+  #Load and run a file
+  def l(file_name)
+    @_break = false
+    lines = IO.readlines(file_name)
+
+    lines.each do |line|
+      exec_line(line)
+      return if @_break
+    end
+
+    "End of file '#{file_name}'."
+  end
+
+  #Execute a single line.
+  def exec_line(line)
+    result = eval line
+    pp result unless line.length == 0
+
+  rescue Interrupt => e
+    @_break = true
+    puts "\nExecution Interrupted!"
+    puts "\n#{e.class} detected: #{e}\n"
+    puts e.backtrace
+    puts "\n"
+
+  rescue Exception => e
+    @_break = true
+    puts "\n#{e.class} detected: #{e}\n"
+    puts e.backtrace
+    puts
+  end
+
+  #Run the interactive session.
+  def run_sire
+    until @_done
+      @_break = false
+      exec_line(@_edit.readline(prompt: 'SIRE>'))
+    end
+
+    puts "\n\n"
+
+  rescue MiniReadlineEOI, Interrupt => e
+    puts "\nInterrupted! Program Terminating."
+  end
+
+end
+
+if __FILE__ == $0
+  SIRE.new.run_sire
+end

data/t.txt

@@ -0,0 +1,3 @@
+XfOOrth.create_proxy(Numeric, XfOOrth.object_class)
+Numeric.name
+(4).name

data/test.foorth

@@ -0,0 +1,5 @@
+// A general test file for fOOrth.
+// Used in non-specific interactive tests.
+
+)vm cr cr )vm! cr
+

data/tests/compiler/context_tests.rb

@@ -0,0 +1,180 @@
+# coding: utf-8
+
+$exclude_fOOrth_library = true
+require_relative '../../lib/fOOrth'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class MockClass
+  def initialize; @data = {}; end
+  def []=(index, value); @data[index] = value; end
+  def map_foorth_shared(index); @data[index]; end
+end
+
+class MockObject
+  def initialize; @data = {}; end
+  def []=(index, value); @data[index] = value; end
+  def map_foorth_exclusive(index); @data[index]; end
+end
+
+#Test the monkey patches applied to the Object class.
+class ContextTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_data_store
+    context = XfOOrth::Context.new(45, stuff: 'buy', price: :plenty)
+
+    assert_equal(context.previous, 45)
+    assert_equal(context[:stuff], 'buy')
+    assert_equal(context[:price], :plenty)
+
+    context[:stuff] = 'sell'
+    assert_equal(context[:stuff], 'sell')
+    assert_equal(context[:price], :plenty)
+
+    context[:price] = 9.95
+    assert_equal(context[:stuff], 'sell')
+    assert_equal(context[:price], 9.95)
+  end
+
+  #Test level counting
+  def test_level_tracking
+    context = XfOOrth::Context.new(nil, stuff: 'buy')
+    assert_equal(context.depth, 1)
+
+    context = XfOOrth::Context.new(context, stuff: 'other')
+    assert_equal(context.depth, 2)
+
+    context = XfOOrth::Context.new(context, stuff: 'more')
+    assert_equal(context.depth, 3)
+
+    context = context.previous
+    assert_equal(context.depth, 2)
+
+    context = context.previous
+    assert_equal(context.depth, 1)
+
+    context = context.previous
+    assert_equal(context, nil)
+  end
+
+  def test_the_nesting_of_scopes
+    context = XfOOrth::Context.new(nil, stuff: 'buy')
+    assert_equal(context[:foo], nil)
+    assert_equal(context[:jelly], nil)
+    assert_equal(context[:stuff], 'buy')
+    context[:foo] = 1
+    context[:jelly] = 'donut'
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'buy')
+    assert_equal(context[:foo], 1)
+
+    context = XfOOrth::Context.new(context, stuff: 'other')
+    assert_equal(context[:foo], 1)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+    context[:foo] = 2
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+    assert_equal(context[:foo], 2)
+
+    context = XfOOrth::Context.new(context, stuff: 'more')
+    assert_equal(context[:foo], 2)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'more')
+    context[:foo] = 3
+    context[:jelly] = 'Berliner'
+    assert_equal(context[:jelly], 'Berliner')
+    assert_equal(context[:stuff], 'more')
+    assert_equal(context[:foo], 3)
+
+    context = context.previous
+    assert_equal(context[:foo], 2)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+
+    context = context.previous
+    assert_equal(context[:foo], 1)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'buy')
+  end
+
+  def test_the_local_mapping_of_symbols
+    context = XfOOrth::Context.new(nil)
+
+    name = 'b'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    context[sym] = XfOOrth::VmSpec.new(name, sym)
+    spec = context.map(name)
+    assert(spec.is_a?(XfOOrth::VmSpec))
+  end
+
+  def test_the_class_mapping_of_symbols
+    mk = MockClass.new
+    context = XfOOrth::Context.new(nil, cls: mk)
+
+    name = '.c'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    mk[sym] = XfOOrth::TosSpec.new(name, sym)
+    spec = context.map(name)
+    assert(spec.is_a?(XfOOrth::TosSpec))
+  end
+
+  def test_the_exclusive_mapping_of_symbols
+    mk = MockObject.new
+    context = XfOOrth::Context.new(nil, obj: mk)
+
+    name = '.d'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    mk[sym] = XfOOrth::TosSpec.new(name, sym)
+    spec = context.map(name)
+    assert(spec.is_a?(XfOOrth::TosSpec))
+  end
+
+  def test_that_it_verifies_sets
+    context = XfOOrth::Context.new(nil, mode: :Execute, ctrl: :colon)
+
+    assert(context.check_set(:mode, [:Execute, :Compile]))
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      context.check_set(:mode, [:Compile, :Deferred])
+    end
+
+    assert(context.check_set(:stuff, [nil]))
+  end
+
+  def test_the_locating_of_the_receiver
+    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
+    assert_equal('vm_sample', context.recvr)
+
+    context = XfOOrth::Context.new(context, cls: 'cls_sample')
+    assert_equal('cls_sample', context.recvr)
+
+    context = XfOOrth::Context.new(context, obj: 'obj_sample')
+    assert_equal('obj_sample', context.recvr)
+
+    context = XfOOrth::Context.new(nil)
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      context.recvr
+    end
+  end
+
+  def test_adding_and_removing_local_methods
+    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
+    name = 'lm'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    spec = context.create_local_method(name, XfOOrth::LocalSpec, [])
+
+    assert_equal(spec, context[sym])
+
+    context.remove_local_method(name)
+
+    assert_equal(nil, context[sym])
+
+  end
+
+end