gloo 0.8.0 → 1.0.0

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

data/lib/gloo/expr/l_boolean.rb

@@ -1,36 +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 LBoolean < Gloo::Core::Literal
-
-      #
-      # Is the given token a boolean?
-      #
-      def self.boolean?( token )
-        return Gloo::Objs::Boolean.boolean? token
-      end
-
-      #
-      # Set the value, converting to an boolean.
-      #
-      def set_value( value )
-        @value = Gloo::Objs::Boolean.coerse_to_bool value
-      end
-
-      #
-      # Get string representation
-      #
-      def to_s
-        return 'false' unless @value
-
-        return @value.to_s
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/l_decimal.rb

@@ -1,39 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
-#
-# A literal decimal value.
-#
-
-module Gloo
-  module Expr
-    class LDecimal < Gloo::Core::Literal
-
-      #
-      # Is the given token a decimal?
-      #
-      def self.decimal?( token )
-        return true if token.is_a? Numeric
-
-        s = token.strip
-        return s.to_f.to_s == s
-      end
-
-      #
-      # Set the value, converting to an integer.
-      #
-      def set_value( value )
-        value = value.to_s if value.is_a? Numeric
-
-        @value = value.to_f
-      end
-
-      #
-      # Get string representation
-      #
-      def to_s
-        return self.value.to_s
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/l_integer.rb

@@ -1,37 +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 LInteger < Gloo::Core::Literal
-
-      #
-      # Is the given token an integer?
-      #
-      def self.integer?( token )
-        return true if token.is_a? Integer
-
-        s = token.strip
-        return s.to_i.to_s == s
-      end
-
-      #
-      # Set the value, converting to an integer.
-      #
-      def set_value( value )
-        @value = value.to_i
-      end
-
-      #
-      # Get string representation
-      #
-      def to_s
-        return self.value.to_s
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/l_string.rb

@@ -1,58 +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 LString < Gloo::Core::Literal
-
-      #
-      # Set the value, triming opening and closing
-      # quotations if necessary.
-      #
-      def set_value( value )
-        @value = value
-        return unless value
-
-        @value = LString.strip_quotes( @value )
-      end
-
-      #
-      # Is the given token a string?
-      #
-      def self.string?( token )
-        return false unless token.is_a? String
-        return true if token.start_with?( '"' )
-        return true if token.start_with?( "'" )
-
-        return false
-      end
-
-      #
-      # Given a string with leading and trailing quotes,
-      # strip them out.
-      #
-      def self.strip_quotes( str )
-        if str.start_with?( '"' )
-          str = str[ 1..-1 ]
-          str = str[ 0..-2 ] if str.end_with?( '"' )
-          return str
-        elsif str.start_with?( "'" )
-          str = str[ 1..-1 ]
-          str = str[ 0..-2 ] if str.end_with?( "'" )
-          return str
-        end
-      end
-
-      #
-      # Get string representation
-      #
-      def to_s
-        return self.value
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/op_div.rb

@@ -1,22 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
-#
-# Division operator.
-#
-
-module Gloo
-  module Expr
-    class OpDiv < Gloo::Core::Op
-
-      #
-      # Perform the operation and return the result.
-      #
-      def perform( left, right )
-        return left / right.to_i if left.is_a? Integer
-
-        return left / right.to_f if left.is_a? Numeric
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/op_minus.rb

@@ -1,22 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
-#
-# Subtraction operator.
-#
-
-module Gloo
-  module Expr
-    class OpMinus < Gloo::Core::Op
-
-      #
-      # Perform the operation and return the result.
-      #
-      def perform( left, right )
-        return left - right.to_i if left.is_a? Integer
-
-        return left - right.to_f if left.is_a? Numeric
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/op_mult.rb

@@ -1,22 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
-#
-# Multiplication operator.
-#
-
-module Gloo
-  module Expr
-    class OpMult < Gloo::Core::Op
-
-      #
-      # Perform the operation and return the result.
-      #
-      def perform( left, right )
-        return left * right.to_i if left.is_a? Integer
-
-        return left * right.to_f if left.is_a? Numeric
-      end
-
-    end
-  end
-end

data/lib/gloo/expr/op_plus.rb

@@ -1,24 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
-#
-# Addition operator.
-#
-
-module Gloo
-  module Expr
-    class OpPlus < Gloo::Core::Op
-
-      #
-      # Perform the operation and return the result.
-      #
-      def perform( left, right )
-        return left + right.to_s if left.is_a? String
-
-        return left + right.to_i if left.is_a? Integer
-
-        return left + right.to_f if left.is_a? Numeric
-      end
-
-    end
-  end
-end

data/lib/gloo/objs/basic/alias.rb

@@ -1,78 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
-#
-# A String.
-#
-
-module Gloo
-  module Objs
-    class Alias < Gloo::Core::Obj
-
-      KEYWORD = 'alias'.freeze
-      KEYWORD_SHORT = 'ln'.freeze
-      ALIAS_REFERENCE = '*'.freeze
-
-      #
-      # The name of the object type.
-      #
-      def self.typename
-        return KEYWORD
-      end
-
-      #
-      # The short name of the object type.
-      #
-      def self.short_typename
-        return KEYWORD_SHORT
-      end
-
-      #
-      # Set the value with any necessary type conversions.
-      #
-      def set_value( new_value )
-        self.value = new_value.to_s
-      end
-
-      # ---------------------------------------------------------------------
-      #    Messages
-      # ---------------------------------------------------------------------
-
-      #
-      # Get a list of message names that this object receives.
-      #
-      def self.messages
-        return super + %w[resolve]
-      end
-
-      #
-      # Check to see if the referenced object exists.
-      #
-      def msg_resolve
-        pn = Gloo::Core::Pn.new( self.value )
-        s = pn.exists?
-        $engine.heap.it.set_to s
-        return s
-      end
-
-      # ---------------------------------------------------------------------
-      #    Resolve
-      # ---------------------------------------------------------------------
-
-      #
-      # Is the object an alias  If so, then resolve it.
-      # The ref_name is the name used to refer to the object.
-      # If it ends with the * then we won't resolve the alias since
-      # we are trying to refer to the alias itself.
-      #
-      def self.resolve_alias( obj, ref_name = nil )
-        return nil unless obj
-        return obj unless obj.type_display == Gloo::Objs::Alias.typename
-        return obj if ref_name&.end_with?( ALIAS_REFERENCE )
-
-        ln = Gloo::Core::Pn.new( obj.value )
-        return ln.resolve
-      end
-
-    end
-  end
-end