gloo 0.3.0 → 0.5.3

data/lib/gloo/core/verb.rb

@@ -10,54 +10,65 @@
 module Gloo
   module Core
     class Verb < Baseo
-      
-			attr_reader :tokens, :params
-			
+
+      attr_reader :tokens, :params
+
       # Set up the verb.
-      def initialize( tokens, params=[] )
+      def initialize( tokens, params = [] )
         @tokens = tokens
-				@params = params
+        @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
 
+      # ---------------------------------------------------------------------
+      #    Help
+      # ---------------------------------------------------------------------
+
+      #
+      # Get help for this verb.
+      #
+      def self.help
+        return 'No help found.'
+      end
+
     end
   end
 end

data/lib/gloo/exec/dispatch.rb

@@ -0,0 +1,30 @@
+# 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 "----- Sending message #{msg} to #{to_obj.name}"
+
+        if to_obj.can_receive_message? msg
+          to_obj.send_message msg, params
+        else
+          $log.warn "Object #{to_obj.name} does not respond to #{msg}"
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/runner.rb

@@ -0,0 +1,43 @@
+# 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
+        verb&.run
+        $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/expr/expression.rb

@@ -7,97 +7,90 @@
 module Gloo
   module Expr
     class Expression
-      
+
       # Create the expression from a list of tokens.
-      def initialize tokens
+      def initialize( tokens )
         @tokens = tokens
         @symbols = []
         @left = nil
         @right = nil
         @op = nil
       end
-      
+
       # 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
+          elsif @left.nil?
             @left = sym
           else
             @right = sym
           end
-          
+
           perform_op if @left && @right
         end
-        
-        if @left.is_a? Gloo::Core::Literal 
-          return @left.value
-        elsif @left.is_a? Gloo::Core::Pn
-          return resolve_ref @left
-        else
-          return @left
-        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
-      
+
       # Perform the operation.
       def perform_op
-        @op = Gloo::Core::Op.default_op unless @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
-        if sym.is_a? Gloo::Core::Literal
-          return sym.value
-        elsif sym.is_a? Gloo::Core::Pn
-          return resolve_ref sym
-        else
-          return sym
-        end
+      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.is_color?
+      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
-        
+
         # @symbols.each do |o|
         #   puts o.class.name
         # end
       end
-      
-      # 
+
+      #
       # Identify the tokens and create appropriate symbols.
-      # 
-      def identify_token token
-        if Gloo::Core::Op.is_op?( token )
-          return Gloo::Core::Op.create_op( token )
-        end
-        
-        return LBoolean.new( token ) if LBoolean.is_boolean?( token )
-        return LInteger.new( token ) if LInteger.is_integer?( token )
-        return LString.new( token ) if LString.is_string?( token )
-        
+      #
+      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

@@ -7,20 +7,21 @@
 module Gloo
   module Expr
     class LBoolean < Gloo::Core::Literal
-            
+
       # Is the given token a boolean?
-      def self.is_boolean? token
-        return Gloo::Objs::Boolean.is_boolean? token
+      def self.boolean?( token )
+        return Gloo::Objs::Boolean.boolean? token
       end
-      
+
       # Set the value, converting to an boolean.
-      def set_value value
+      def set_value( value )
         @value = Gloo::Objs::Boolean.coerse_to_bool value
       end
 
       # Get string representation
       def to_s
-        return "false" unless @value
+        return 'false' unless @value
+
         return @value.to_s
       end
 

data/lib/gloo/expr/l_decimal.rb

@@ -0,0 +1,34 @@
+# 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
+
+      def to_s
+        return self.value.to_s
+      end
+
+    end
+  end
+end

data/lib/gloo/expr/l_integer.rb

@@ -7,16 +7,17 @@
 module Gloo
   module Expr
     class LInteger < Gloo::Core::Literal
-            
+
       # Is the given token an integer?
-      def self.is_integer? token
+      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
+      def set_value( value )
         @value = value.to_i
       end
 

data/lib/gloo/expr/l_string.rb

@@ -7,47 +7,45 @@
 module Gloo
   module Expr
     class LString < Gloo::Core::Literal
-            
+
       # Set the value, triming opening and closing
       # quotations if necessary.
-      def set_value value
+      def set_value( value )
         @value = value
         return unless value
+
         @value = LString.strip_quotes( @value )
       end
-      
+
       # Is the given token a string?
-      def self.is_string? token
+      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
+      #
+      def self.strip_quotes( str )
         if str.start_with?( '"' )
           str = str[ 1..-1 ]
-          if str.end_with?( '"' )
-            str = str[ 0..-2 ]
-          end
+          str = str[ 0..-2 ] if str.end_with?( '"' )
           return str
         elsif str.start_with?( "'" )
           str = str[ 1..-1 ]
-          if str.end_with?( "'" )
-            str = str[ 0..-2 ]
-          end
+          str = str[ 0..-2 ] if str.end_with?( "'" )
           return str
         end
       end
-            
+
       def to_s
         return self.value
       end
-      
+
     end
   end
 end

data/lib/gloo/expr/op_div.rb

@@ -9,12 +9,12 @@ module Gloo
     class OpDiv < Gloo::Core::Op
 
       # Perform the operation and return the result.
-      def perform left, right
-        if left.is_a? Integer
-          return left / right.to_i
-        end
+      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