gloo 1.4.2 → 2.0.0

data/lib/gloo/core/tokens.rb

@@ -0,0 +1,165 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An ordered list of tokens.
+# The list of tokens makes up a command.
+#
+
+module Gloo
+  module Core
+    class Tokens
+
+      attr_reader :cmd, :tokens
+
+      # ---------------------------------------------------------------------
+      #    Constructor
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the tokens.
+      # The command string is parsed into tokens during creation.
+      #
+      def initialize( cmd_string )
+        @cmd = cmd_string
+        @tokens = []
+        tokenize @cmd
+      end
+
+      # ---------------------------------------------------------------------
+      #    Public functions
+      # ---------------------------------------------------------------------
+
+      #
+      # Get the number of tokens
+      #
+      def token_count
+        return @tokens.size
+      end
+
+      #
+      # Get the verb (the first word)
+      #
+      def verb
+        return first
+      end
+
+      #
+      # Get all tokens except the first.
+      #
+      def params
+        return @tokens[ 1..-1 ]
+      end
+
+      #
+      # Get the first token.
+      #
+      def first
+        return @tokens.first if @tokens
+      end
+
+      #
+      # Get the last token.
+      #
+      def last
+        return @tokens.last if @tokens
+      end
+
+      #
+      # Get the second token.
+      #
+      def second
+        return @tokens[ 1 ] if @tokens&.size&.positive?
+      end
+
+      #
+      # Get the token at the the requested index.
+      #
+      def at( index )
+        return @tokens[ index ] if @tokens && @tokens.size >= index
+      end
+
+      #
+      # Get the index of the given token.
+      #
+      def index_of( token )
+        return nil unless @tokens
+
+        return @tokens.find_index { |o| o.casecmp( token ).zero? }
+      end
+
+      #
+      # Get the list of tokens after the given token
+      #
+      def tokens_after( token )
+        i = index_of token
+        return @tokens[ i + 1..-1 ] if i && @tokens && @tokens.size > ( i + 1 )
+
+        return nil
+      end
+
+      #
+      # Get the expression after the given token
+      #
+      def expr_after( token )
+        str = ''
+        tokens_after( token ).each do |t|
+          str << ' ' unless str.empty?
+          str << t.to_s
+        end
+        return str
+      end
+
+      #
+      # Get the item after a given token.
+      #
+      def after_token( token )
+        i = index_of token
+        return @tokens[ i + 1 ] if i && @tokens && @tokens.size > ( i + 1 )
+
+        return nil
+      end
+
+      #
+      # Get the item after a given token.
+      #
+      def before_token( token )
+        i = index_of token
+        return @tokens[ 0..i - 1 ] if i && @tokens && @tokens.size >= i
+
+        return nil
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Create a list of token from the given string.
+      #
+      def tokenize( str )
+        if str.index( '"' )
+          i = str.index( '"' )
+          j = str.index( '"', i + 1 )
+          j ||= str.length
+
+          tokenize( str[ 0..i - 1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
+        elsif str.index( "'" )
+          i = str.index( "'" )
+          j = str.index( "'", i + 1 )
+          j ||= str.length
+
+          tokenize( str[ 0..i - 1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
+        else
+          str.strip.split( ' ' ).each { |t| @tokens << t }
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo/core/verb.rb

@@ -0,0 +1,87 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An abstract base verb.
+# Derives from the Baseo object.
+# It is a special type of object in that it can be run
+# and can perform an action.
+#
+
+module Gloo
+  module Core
+    class Verb < Baseo
+
+      attr_reader :tokens, :params
+
+      #
+      # Set up the verb.
+      #
+      def initialize( engine, tokens, params = [] )
+        @engine = engine
+        @tokens = tokens
+        @params = params
+      end
+
+      #
+      # Register verbs when they are loaded.
+      #
+      def self.inherited( subclass )
+        Dictionary.instance.register_verb( subclass )
+      end
+
+      #
+      # Run the verb.
+      #
+      # We'll mark the application as not running and let the
+      # engine stop gracefully next time through the loop.
+      #
+      def run
+        raise 'this method should be overriden'
+      end
+
+      #
+      # Get the Verb's keyword.
+      #
+      # The keyword will be in lower case only.
+      # It is used by the parser.
+      #
+      def self.keyword
+        raise 'this method should be overriden'
+      end
+
+      #
+      # Get the Verb's keyword shortcut.
+      #
+      def self.keyword_shortcut
+        raise 'this method should be overriden'
+      end
+
+      #
+      # The object type, suitable for display.
+      #
+      def type_display
+        return self.class.keyword
+      end
+
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return self.class.keyword
+      end
+
+      # ---------------------------------------------------------------------
+      #    Help
+      # ---------------------------------------------------------------------
+
+      #
+      # Get help for this verb.
+      #
+      def self.help
+        return 'No help found.'
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/action.rb

@@ -0,0 +1,48 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# An action is a message sent to an object with optional parameters.
+#
+
+module Gloo
+  module Exec
+    class Action
+
+      attr_accessor :msg, :to, :params
+
+      #
+      # Set up the action.
+      #
+      def initialize( msg, to, params = nil )
+        @msg = msg
+        @to = to
+        @params = params
+      end
+
+      #
+      # The action is valid if the object can receive
+      # the message specified.
+      #
+      def valid?
+        return @to.can_receive_message?( @msg )
+      end
+
+      #
+      # Execute the action.
+      # Dispatch the message to the object.
+      #
+      def dispatch
+        @to.send_message @msg, @params
+      end
+
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return "#{@msg} -> #{@to.pn}"
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/dispatch.rb

@@ -0,0 +1,40 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Central Message Dispatch.
+# Responsible for sending message to objects.
+# All object messaging goes through here so we can uniformly
+# manage things like checking to make sure object can
+# receive the messages sent, handling errors, etc.
+#
+
+module Gloo
+  module Exec
+    class Dispatch
+
+      #
+      # Dispatch the given message to the given object.
+      #
+      def self.message( engine, msg, to_obj, params = nil )
+        engine.log.debug "Dispatch message #{msg} to #{to_obj.name}"
+        a = Gloo::Exec::Action.new msg, to_obj, params
+        Gloo::Exec::Dispatch.action( engine, a )
+      end
+
+      #
+      # Dispatch an action.
+      #
+      def self.action( engine, action )
+        unless action.valid?
+          engine.log.warn "Object #{action.to.name} does not respond to #{action.msg}"
+        end
+
+        engine.exec_env.push_action action
+        engine.log.debug "Sending message #{action.msg} to #{action.to.name}"
+        action.dispatch
+        engine.exec_env.pop_action
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/exec_env.rb

@@ -0,0 +1,75 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# The execution environment.
+# The current state of running scripts and messaging.
+#
+
+module Gloo
+  module Exec
+    class ExecEnv
+
+      attr_accessor :verbs, :actions, :scripts, :here
+
+      VERB_STACK = 'verbs'.freeze
+      ACTION_STACK = 'actions'.freeze
+      SCRIPT_STACK = 'scripts'.freeze
+      HERE_STACK = 'here'.freeze
+
+      #
+      # Set up the execution environment.
+      #
+      def initialize( engine )
+        @engine = engine
+        @engine.log.debug 'exec env intialized...'
+
+        @verbs = Gloo::Exec::Stack.new( @engine, VERB_STACK )
+        @actions = Gloo::Exec::Stack.new( @engine, ACTION_STACK )
+        @scripts = Gloo::Exec::Stack.new( @engine, SCRIPT_STACK )
+        @here = Gloo::Exec::Stack.new( @engine, HERE_STACK )
+      end
+
+      #
+      # Get the here object.
+      #
+      def here_obj
+        return nil if @here.stack.empty?
+
+        return @here.stack.last
+      end
+
+      #
+      # Push a script onto the stack.
+      #
+      def push_script( script )
+        @scripts.push script
+        @here.push script.obj
+      end
+
+      #
+      # Pop a script off the stack.
+      #
+      def pop_script
+        @scripts.pop
+        @here.pop
+      end
+
+      #
+      # Push an action onto the stack.
+      #
+      def push_action( action )
+        @actions.push action
+        # @here.push action.to
+      end
+
+      #
+      # Pop an action off the stack.
+      #
+      def pop_action
+        @actions.pop
+        # @here.pop
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/runner.rb

@@ -0,0 +1,45 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# The Runner is a static helper function.
+# It is used to send the run command to verbs.
+#
+
+module Gloo
+  module Exec
+    class Runner
+
+      #
+      # Dispatch run command to a verb.
+      # We abstract this out in case there are things
+      # that need to be done before or after a verb
+      # is done running.
+      #
+      def self.go( engine, verb )
+        engine.log.debug "running verb #{verb.type_display}"
+        engine.heap.error.start_tracking
+        engine.exec_env.verbs.push verb
+        verb&.run
+        engine.exec_env.verbs.pop
+        engine.heap.error.clear_if_no_errors
+      end
+
+      #
+      # Send 'run' message to the object.
+      # Resolve the path_name and then send the run message.
+      #
+      def self.run( engine, path_name )
+        engine.log.debug "running script at #{path_name}"
+        pn = Gloo::Core::Pn.new( engine, path_name )
+        o = pn.resolve
+
+        if o
+          o.send_message 'run'
+        else
+          engine.log.error "Could not send message to object.  Bad path: #{path_name}"
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/script.rb

@@ -0,0 +1,50 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# A script to be run.
+#
+
+module Gloo
+  module Exec
+    class Script
+
+      attr_accessor :obj
+
+      #
+      # Set up the script.
+      #
+      def initialize( engine, obj )
+        @engine = engine
+        @obj = obj
+      end
+
+      #
+      # Run the script.
+      # The script might be a single string or an array
+      # of lines.
+      #
+      def run
+        @engine.exec_env.push_script self
+
+        if @obj.value.is_a? String
+          @engine.parser.run @obj.value
+        elsif @obj.value.is_a? Array
+          @obj.value.each do |line|
+            @engine.parser.run line
+          end
+        end
+
+        @engine.exec_env.pop_script
+      end
+
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return @obj.pn
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/stack.rb

@@ -0,0 +1,79 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# A stack of items, a call stack.
+#
+
+module Gloo
+  module Exec
+    class Stack
+
+      attr_accessor :stack
+
+      #
+      # Set up the stack.
+      #
+      def initialize( engine, name )
+        @engine = engine
+        @name = name
+        clear_stack
+        @engine.log.debug "#{name} stack intialized..."
+      end
+
+      #
+      # Push an item onto the stack.
+      #
+      def push( obj )
+        @engine.log.debug "#{@name}:push #{obj.display_value}"
+        @stack.push obj
+        self.update_out_file if @engine.settings.debug
+      end
+
+      #
+      # Pop an item from the stack.
+      #
+      def pop
+        o = @stack.pop
+        @engine.log.debug "#{@name}:pop #{o.display_value}"
+        self.update_out_file if @engine.settings.debug
+      end
+
+      #
+      # Get the current size of the call stack.
+      #
+      def size
+        return @stack.size
+      end
+
+      #
+      # Get stack data for output.
+      #
+      def out_data
+        return @stack.map( &:display_value ).join( "\n" )
+      end
+
+      #
+      # Get the file we'll write debug information for the stack.
+      #
+      def out_file
+        return File.join( @engine.settings.debug_path, @name )
+      end
+
+      #
+      # Update the stack trace file.
+      #
+      def update_out_file
+        File.write( self.out_file, self.out_data )
+      end
+
+      #
+      # Clear the stack and the output file.
+      #
+      def clear_stack
+        @stack = []
+        self.update_out_file
+      end
+
+    end
+  end
+end

data/lib/gloo/expr/expression.rb

@@ -0,0 +1,119 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Expression that can be evaluated.
+#
+
+module Gloo
+  module Expr
+    class Expression
+
+      # ---------------------------------------------------------------------
+      #    Constructor
+      # ---------------------------------------------------------------------
+
+      #
+      # Create the expression from a list of tokens.
+      #
+      def initialize( engine, tokens )
+        @engine = engine
+        @tokens = tokens
+        @symbols = []
+        @left = nil
+        @right = nil
+        @op = nil
+      end
+
+      # ---------------------------------------------------------------------
+      #    Evaluate Expression
+      # ---------------------------------------------------------------------
+
+      #
+      # Evaluate the expression and return the value.
+      #
+      def evaluate
+        identify_tokens
+
+        @symbols.each do |sym|
+          if sym.is_a? Gloo::Core::Op
+            @op = sym
+          elsif @left.nil?
+            @left = sym
+          else
+            @right = sym
+          end
+
+          perform_op if @left && @right
+        end
+
+        return @left.value if @left.is_a? Gloo::Core::Literal
+        return resolve_ref @left if @left.is_a? Gloo::Core::Pn
+
+        return @left
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Perform the operation.
+      #
+      def perform_op
+        @op ||= Gloo::Core::Op.default_op
+        l = evaluate_sym @left
+        r = evaluate_sym @right
+        @left = @op.perform l, r
+        @right = nil
+        @op = nil
+      end
+
+      #
+      # Evaluate the symbol and get a simple value.
+      #
+      def evaluate_sym( sym )
+        return sym.value if sym.is_a? Gloo::Core::Literal
+        return resolve_ref sym if sym.is_a? Gloo::Core::Pn
+
+        return sym
+      end
+
+      #
+      # resolve an object reference and get the value.
+      #
+      def resolve_ref( ref )
+        return ref.src if ref.named_color?
+
+        ob = ref.resolve
+        return ob.value if ob
+      end
+
+      #
+      # Identify each token in the list.
+      #
+      def identify_tokens
+        @tokens.each do |o|
+          @symbols << identify_token( o )
+        end
+      end
+
+      #
+      # Identify the tokens and create appropriate symbols.
+      #
+      def identify_token( token )
+        return Gloo::Core::Op.create_op( token ) if Gloo::Core::Op.op?( token )
+
+        return LBoolean.new( token ) if LBoolean.boolean?( token )
+        return LInteger.new( token ) if LInteger.integer?( token )
+        return LString.new( token ) if LString.string?( token )
+        return LDecimal.new( token ) if LDecimal.decimal?( token )
+
+        # last chance: an Object reference
+        return Gloo::Core::Pn.new( @engine, token )
+      end
+
+    end
+  end
+end