gloo 0.7.6 → 1.0.0

data/lib/gloo/core/tokens.rb

@@ -1,165 +0,0 @@
-# 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

@@ -1,86 +0,0 @@
-# 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( tokens, params = [] )
-        @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

@@ -1,48 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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( msg, to_obj, params = nil )
-        $log.debug "Dispatch message #{msg} to #{to_obj.name}"
-        a = Gloo::Exec::Action.new msg, to_obj, params
-        Gloo::Exec::Dispatch.action a
-      end
-
-      #
-      # Dispatch an action.
-      #
-      def self.action( action )
-        unless action.valid?
-          $log.warn "Object #{action.to.name} does not respond to #{action.msg}"
-        end
-
-        $engine.exec_env.push_action action
-        $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

@@ -1,74 +0,0 @@
-# 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
-        $log.debug 'exec env intialized...'
-
-        @verbs = Gloo::Exec::Stack.new VERB_STACK
-        @actions = Gloo::Exec::Stack.new ACTION_STACK
-        @scripts = Gloo::Exec::Stack.new SCRIPT_STACK
-        @here = Gloo::Exec::Stack.new 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

@@ -1,45 +0,0 @@
-# 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( verb )
-        $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( path_name )
-        $log.debug "running script at #{path_name}"
-        pn = Gloo::Core::Pn.new path_name
-        o = pn.resolve
-
-        if o
-          o.send_message 'run'
-        else
-          $log.error "Could not send message to object.  Bad path: #{path_name}"
-        end
-      end
-
-    end
-  end
-end

data/lib/gloo/exec/script.rb

@@ -1,49 +0,0 @@
-# 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( obj )
-        @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

@@ -1,78 +0,0 @@
-# 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( name )
-        @name = name
-        clear_stack
-        $log.debug "#{name} stack intialized..."
-      end
-
-      #
-      # Push an item onto the stack.
-      #
-      def push( obj )
-        $log.debug "#{@name}:push #{obj.display_value}"
-        @stack.push obj
-        self.update_out_file if $settings.debug
-      end
-
-      #
-      # Pop an item from the stack.
-      #
-      def pop
-        o = @stack.pop
-        $log.debug "#{@name}:pop #{o.display_value}"
-        self.update_out_file if $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( $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

@@ -1,118 +0,0 @@
-# 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( tokens )
-        @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( token )
-      end
-
-    end
-  end
-end