fOOrth 0.5.0

data/lib/fOOrth/library/duration/make.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+#* library/duration/make.rb - Support for duration constructor.
+module XfOOrth
+
+  #* library/duration/make.rb - Support for duration constructor.
+  class Duration
+    #The length of time of the duration.
+    attr_accessor :period
+
+    #Create a duration instance.
+    #<br>Parameters
+    #* period - The period of time of the duration.
+    def initialize(period)
+      @period = period.rationalize
+    end
+  end
+
+  #Connect the Duration class to the fOOrth class system
+  Duration.create_foorth_proxy("Duration")
+
+  #Stub out .new
+  Duration.create_exclusive_method('.new', TosSpec, [:stub])
+
+  #Helper Methods .to_duration and .to_duration!
+
+  #[number] .to_duration [a_duration]
+  Object.create_shared_method('.to_duration', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Duration.new(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  #[number] .to_duration! [a_duration]
+  Object.create_shared_method('.to_duration!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Duration.new(self))
+    rescue
+      error "F40: Cannot convert #{self.foorth_name} to a Duration instance"
+    end
+  })
+
+  Array.create_shared_method('.to_duration', TosSpec, [], &lambda {|vm|
+    begin
+      result, interval = 0, Duration::INTERVALS.reverse_each
+      self.reverse_each {|value| result += value * interval.next.to_r }
+      vm.push(Duration.new(result))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  Array.create_shared_method('.to_duration!', TosSpec, [], &lambda {|vm|
+    begin
+      result, interval = 0, Duration::INTERVALS.reverse_each
+      self.reverse_each {|value| result += value * interval.next.to_r }
+      vm.push(Duration.new(result))
+    rescue
+      error "F40: Cannot convert #{self.foorth_name} to a Duration instance"
+    end
+  })
+
+  #[a_duration] .to_duration [a_duration]
+  Duration.create_shared_method('.to_duration', TosSpec, [], &lambda {|vm|
+      vm.push(self)
+  })
+
+  #[a_duration] .to_duration! [a_duration]
+  Duration.create_shared_method('.to_duration!', TosSpec, [], &lambda {|vm|
+      vm.push(self)
+  })
+
+end

data/lib/fOOrth/library/duration_library.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require_relative 'duration/make'
+require_relative 'duration/arithmetic'
+require_relative 'duration/intervals'
+require_relative 'duration/formatter'
+
+#* library/duration_library.rb - The duration support fOOrth library.
+module XfOOrth
+
+  #The duration class adds support for intervals of time that are not
+  #directly associated with a date or time. Like 10 minutes as opposed
+  #to July 4, 2015 5:43 PM.
+  class Duration
+
+    #Convert this duration to an array.
+    #<br>Endemic Code Smells
+    #* :reek:FeatureEnvy -- false positive.
+    def to_a
+      balance = @period
+
+      Duration::INTERVALS.map do |item|
+        interval = item.to_r
+
+        if interval > 1
+          value = (balance / interval).to_i
+          balance -= value * interval
+          value
+        else
+          balance.to_f
+        end
+      end
+
+    end
+
+    #Pass off all unknown methods to the period data.
+    def method_missing(symbol, *args, &block)
+      @period.send(symbol, *args, &block)
+    end
+
+  end
+
+  #[a_duration] .to_a [an_array]
+  Duration.create_shared_method('.to_a', TosSpec, [], &lambda{|vm|
+    vm.push(self.to_a)
+  })
+
+  #Default conversion to string. See duration/formatter for formatted output.
+  Duration.create_shared_method('.to_s', TosSpec, [], &lambda {|vm|
+    vm.push("Duration instance <#{self.period.to_f} seconds>" )
+  })
+end

data/lib/fOOrth/library/fiber_library.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+#* library/fiber_library.rb - The fOOrth Fiber class library.
+module XfOOrth
+
+  #Define the Fiber class.
+  Object.create_foorth_subclass('Fiber').new_class
+
+  #The fOOrth Fiber class.
+  class XfOOrth_Fiber
+
+    #Tag for newly created fibers.
+    NEW   = "new".freeze
+
+    #Tag for running fibers.
+    ALIVE = "alive".freeze
+
+    #Tag for defunct fibers.
+    DEAD  = "dead".freeze
+
+    #Build up the fiber instance. A fiber is a light-weight coroutine.
+    def initialize(stack=[], &block)
+      @stack = stack
+      @fiber = Fiber.new &lambda{|vm| block.call(vm); nil}
+      @status = NEW
+    end
+
+    #Return this fiber as a fiber.
+    def to_foorth_fiber
+      self
+    end
+
+    #What is the status of this fiber?
+    def status
+      @status || DEAD
+    end
+
+    #Let the fiber run for one step.
+    def step(vm)
+      vm.data_stack, vm.fiber, @save = @stack, self, vm.data_stack
+      @status = @fiber.resume(vm)
+    rescue FiberError
+      error "F72: The fiber is dead, no further steps can be taken."
+    ensure
+      vm.data_stack, vm.fiber, @stack = @save, nil, vm.data_stack
+    end
+
+    #Yield back to the thread.
+    def yield
+      Fiber.yield(ALIVE)
+    end
+
+    #Yield a value back to the thread.
+    def yield_value(value)
+      @save << value
+      Fiber.yield(ALIVE)
+    end
+  end
+
+  #The .new method is stubbed out for fibers.
+  XfOOrth_Fiber.create_exclusive_method('.new', TosSpec, [:stub])
+
+  # [Fiber] .new{{ ... }} [a_fiber]
+  XfOOrth_Fiber.create_exclusive_method('.new{{', NosSpec, [], &lambda {|vm|
+    vm.push(XfOOrth_Fiber.new(&vm.pop))
+  })
+
+  # [a_procedure] .to_fiber [a_fiber]
+  Proc.create_shared_method('.to_fiber', TosSpec, [], &lambda {|vm|
+    vm.push(XfOOrth_Fiber.new(&self))
+  })
+
+  # [Fiber] .current [a_fiber or nil]
+  XfOOrth_Fiber.create_exclusive_method('.current', NosSpec, [], &lambda {|vm|
+    vm.push(vm.fiber)
+  })
+
+  # [a_fiber] .to_fiber [a_fiber]
+  XfOOrth_Fiber.create_shared_method('.to_fiber', TosSpec, [], &lambda {|vm|
+    vm.push(self)
+  })
+
+  # [a_fiber] .step [undefined]; The fiber performs a processing step.
+  XfOOrth_Fiber.create_shared_method('.step', TosSpec, [], &lambda {|vm|
+    self.step(vm)
+  })
+
+  # [] yield []; Yields obj to the containing thread.
+  VirtualMachine.create_shared_method('yield', VmSpec, [], &lambda {|vm|
+    error 'F71: May only yield in a fiber.' unless (fiber = vm.fiber)
+    fiber.yield
+  })
+
+  # [obj] .yield []; Yields obj to the containing thread.
+  VirtualMachine.create_shared_method('.yield', VmSpec, [], &lambda {|vm|
+    error 'F71: May only yield in a fiber.' unless (fiber = vm.fiber)
+    fiber.yield_value(vm.pop)
+  })
+
+  # [a_fiber] .alive? [a_boolean]; Is the fiber still alive?
+  XfOOrth_Fiber.create_shared_method('.alive?', TosSpec, [], &lambda {|vm|
+    vm.push(!@status.nil?)
+  })
+
+  # [a_fiber] .alive? [a_string]; Is the fiber still alive?
+  XfOOrth_Fiber.create_shared_method('.status', TosSpec, [], &lambda {|vm|
+    vm.push(status)
+  })
+
+end
+
+#Monkey patch Procedure to support fibers.
+class Proc
+
+  #Convert this procedure to a fiber.
+  def to_foorth_fiber
+    XfOOrth::XfOOrth_Fiber.new(&self)
+  end
+
+end

data/lib/fOOrth/library/hash_library.rb

@@ -0,0 +1,203 @@
+# coding: utf-8
+
+#* library/hash_library.rb - Hash support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Array class to the fOOrth class system.
+  Hash.create_foorth_proxy
+
+  # [] Hash .new [{}]; create an empty hash.
+  # The default implementation from Object is used for this.
+
+  #[object Hash] .new_default [hash]
+  Hash.create_exclusive_method('.new_default', TosSpec, [], &lambda{|vm|
+    begin
+      vm.poke(Hash.new(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  #[Hash] .new_default{{ ... }} [{}]
+  Hash.create_exclusive_method('.new_default{{', NosSpec, [], &lambda{|vm|
+    begin
+      block = vm.peek
+
+      vm.poke(Hash.new do |hsh, idx|
+        cvm = Thread.current[:vm]
+        hsh.instance_exec(cvm, nil, idx, &block)
+        cvm.pop
+      end)
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  #[object hash] .default []
+  Hash.create_shared_method('.default', TosSpec, [], &lambda{|vm|
+    self.default = vm.pop
+  })
+
+  #[object] .default{{ ... }} []
+  Hash.create_shared_method('.default{{', NosSpec, [], &lambda{|vm|
+    block = vm.pop
+
+    self.default_proc = lambda do |hsh, idx|
+      cvm = Thread.current[:vm]
+      hsh.instance_exec(cvm, nil, idx, &block)
+      cvm.pop
+    end
+  })
+
+  # [] { k1 v1 -> ... kn vn -> } [{k1=>v1,...kn=>vn}]; a hash literal value
+  VirtualMachine.create_shared_method('{', VmSpec, [:immediate], &lambda { |vm|
+    vm.nest_mode('vm.push(Hash.new); ', :hash_literal)
+
+    vm.context.create_local_method('->', LocalSpec, [:immediate],
+      &lambda {|vm| vm.process_text('vm.add_to_hash; ') })
+
+    vm.context.create_local_method('}', LocalSpec, [:immediate],
+      &lambda {|vm| vm.unnest_mode('', [:hash_literal]) })
+  })
+
+  # [hash] .each{{ ... }} [unspecified]
+  Hash.create_shared_method('.each{{', NosSpec, [], &lambda { |vm|
+    block = vm.pop
+    self.each { |idx, val| block.call(vm, val, idx) }
+  })
+
+  # [i h] .[]@ [h[i]]
+  Hash.create_shared_method('.[]@', TosSpec, [],
+    &lambda {|vm| vm.poke(self[vm.peek]); })
+
+  # [v i h] .[]! []; h[i]=v
+  Hash.create_shared_method('.[]!', TosSpec, [],
+    &lambda {|vm| value, index = vm.popm(2); self[index] = value; })
+
+  # [{"a"=>1, "b"=>2}] .length [2]]
+  Hash.create_shared_method('.length', TosSpec, [],
+    &lambda {|vm| vm.push(self.length); })
+
+  # [a_hash] .empty? [a_boolean]]
+  Hash.create_shared_method('.empty?', TosSpec, [],
+    &lambda {|vm| vm.push(self.empty?); })
+
+  # [h] .keys [[keys]]
+  Hash.create_shared_method('.keys', TosSpec, [],
+    &lambda {|vm| vm.push(self.keys); })
+
+  # [h] .values [[values]]
+  Hash.create_shared_method('.values', TosSpec, [],
+    &lambda {|vm| vm.push(self.values); })
+
+  # [h] .strmax2 [widest_key widest_value]
+  Hash.create_shared_method('.strmax2', TosSpec, [], &lambda {|vm|
+    widest_key = 0
+    widest_value = 0
+
+    self.each {|key, value|
+      key.foorth_strlen(vm)
+      temp = vm.pop
+      widest_key = widest_key > temp ? widest_key : temp
+
+      value.foorth_strlen(vm)
+      temp = vm.pop
+      widest_value = widest_value > temp ? widest_value : temp
+    }
+
+    vm.push(widest_key)
+    vm.push(widest_value)
+  })
+
+  # [hash] .to_s [string]
+  Hash.create_shared_method('.to_s', TosSpec, [], &lambda {|vm|
+    result = "{ "
+
+    self.each do |key, value|
+      key.to_foorth_s(vm)
+      result << (vm.pop || key.inspect) + " "
+
+      value.to_foorth_s(vm)
+      result << (vm.pop || value.inspect) + " -> "
+    end
+
+    vm.push(result + "}")
+  })
+
+  #[a_hash] .to_h [a_hash]
+  Hash.create_shared_method('.to_h', TosSpec, [],
+    &lambda{|vm| vm.push(self)})
+
+  #[a_hash] .to_a [an_array]
+  Hash.create_shared_method('.to_a', TosSpec, [],
+    &lambda{|vm| vm.push(self.values)})
+
+  # [a_hash] .map{{ ... }} [mapped_hash]
+  Hash.create_shared_method('.map{{', NosSpec, [], &lambda { |vm|
+    block = vm.pop
+    result = {}
+
+    self.each do |idx, val|
+      block.call(vm, val, idx)
+      result[idx] = vm.pop
+    end
+
+    vm.push(result)
+  })
+
+  # [a_hash] .select{{ ... }} [selected_hash]
+  Hash.create_shared_method('.select{{', NosSpec, [], &lambda { |vm|
+    block = vm.pop
+    result = {}
+
+    self.each do |idx, val|
+      block.call(vm, val, idx)
+      result[idx] = val if vm.pop
+    end
+
+    vm.push(result)
+  })
+
+
+  # [h] .pp []; pretty print the hash!
+  Hash.create_shared_method('.pp', TosSpec, [], &lambda {|vm|
+    self.foorth_strmax2(vm)
+    value_width = vm.pop
+    key_width   = vm.pop
+
+    width = value_width + key_width + 3
+    cols  = (width < 79) ? (79 / width) : 1
+    col   = (1..cols).cycle
+
+    self.each do |key, value|
+      key.to_foorth_s(vm)
+      key_str = vm.pop
+
+      value.to_foorth_s(vm)
+      value_str = vm.pop
+
+      if cols > 1
+        print "#{key_str.rjust(key_width)}=>#{value_str.ljust(value_width)} "
+      else
+        print "#{key_str.rjust(key_width)}=>#{value_str}"
+      end
+
+      puts if col.next == cols
+    end
+  })
+
+
+end
+
+#* Runtime library support for fOOrth constructs.
+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)  }
+    mkeys.collect {|key| XfOOrth::SymbolMap.unmap(key) || '?error?' }
+  end
+end