gloo 0.3.0 → 0.5.3

data/lib/gloo/core/obj_finder.rb

@@ -7,29 +7,24 @@
 module Gloo
   module Core
     class ObjFinder
-                  
-      # 
+
+      #
       # Find all objects in the given container that have
       # the given name.
       # If the container isn't provided, root will be used.
-      # 
-      def self.by_name name, container=nil
-        if container.nil?
-          container = $engine.heap.root
-        end
+      #
+      def self.by_name( name, container = nil )
+        container = $engine.heap.root if container.nil?
         arr = []
-        
+
         container.children.each do |o|
           arr << o if o.name == name
-          if o.child_count > 0
-            arr += by_name( name, o )
-          end
+          arr += by_name( name, o ) if o.child_count.positive?
         end
-        
+
         return arr
       end
-      
-      
+
     end
   end
 end

data/lib/gloo/core/op.rb

@@ -7,27 +7,27 @@
 module Gloo
   module Core
     class Op
-                  
+
       # Is the token an operator?
-      def self.is_op? token
-        return [ "+", "-", "*", "/" ].include?( token.strip )
+      def self.op?( token )
+        return [ '+', '-', '*', '/' ].include?( token.strip )
       end
-      
+
       # Create the operator for the given token.
-      def self.create_op token
+      def self.create_op( token )
         return Gloo::Expr::OpMinus.new if token == '-'
         return Gloo::Expr::OpMult.new if token == '*'
         return Gloo::Expr::OpDiv.new if token == '/'
         return Gloo::Expr::OpPlus.new if token == '+'
-        
+
         return default_op
       end
-      
+
       # Get the default operator (+).
       def self.default_op
         return Gloo::Expr::OpPlus.new
       end
-      
+
     end
   end
 end

data/lib/gloo/core/parser.rb

@@ -8,45 +8,46 @@
 module Gloo
   module Core
     class Parser
-      
+
       # Set up the parser.
-      def initialize()
-        $log.debug "parser intialized..."
+      def initialize
+        $log.debug 'parser intialized...'
       end
-      
-      
+
       # Parse a command from the immediate execution context.
-      def parse_immediate cmd
-				cmd, params = split_params cmd
-				params = Gloo::Core::Tokens.new( params ) if params
+      def parse_immediate( cmd )
+        cmd, params = split_params cmd
+        params = Gloo::Core::Tokens.new( params ) if params
         tokens = Gloo::Core::Tokens.new( cmd )
         dic = Gloo::Core::Dictionary.instance
         verb = dic.find_verb( tokens.verb )
         return verb.new( tokens, params ) if verb
-          
+
         $log.error "Verb '#{tokens.verb}' was not found."
         return nil
       end
-			
-			# If additional params were provided, split them out 
-			# from the token list.
-			def split_params cmd
-				params = nil
-				i = cmd.rindex( '(' )
-				if i && cmd.strip.end_with?( ')' )
-					pstr = cmd[i+1..-1]
-					params = pstr.strip[0..-2] if pstr
-					cmd = cmd[ 0, i-1]
-				end
-				return cmd, params
-			end
-      
+
+      # If additional params were provided, split them out
+      # from the token list.
+      def split_params( cmd )
+        params = nil
+        i = cmd.rindex( '(' )
+        if i && cmd.strip.end_with?( ')' )
+          pstr = cmd[ i + 1..-1 ]
+          params = pstr.strip[ 0..-2 ] if pstr
+          cmd = cmd[ 0, i - 1 ]
+        end
+        return cmd, params
+      end
+
+      #
       # Parse a command and then run it if it parsed correctly.
-      def run cmd
+      #
+      def run( cmd )
         v = parse_immediate( cmd )
-        v.run if v
+        Gloo::Exec::Runner.go( v ) if v
       end
-      
+
     end
   end
 end

data/lib/gloo/core/pn.rb

@@ -9,40 +9,56 @@ module Gloo
   module Core
     class Pn < Baseo
 
+      ROOT = 'root'.freeze
+      IT = 'it'.freeze
+      ERROR = 'error'.freeze
+
       attr_reader :src, :elements
-      
+
       # Set up the object given a source string,
       # ie: the full path and name.
       def initialize( src )
         set_to src
       end
-      
+
       # Reference to the root object path.
       def self.root
-        return Pn.new( "root" )
+        return Pn.new( ROOT )
       end
 
       # Reference to it.
       def self.it
-        return Pn.new( "it" )
+        return Pn.new( IT )
       end
-      
-      # Does the pathname reference refer to the root?
-      def is_root?
-        return @src.downcase == "root"
+
+      # Reference to the error message.
+      def self.error
+        return Pn.new( ERROR )
       end
-      
+
       # Does the pathname reference refer to the root?
-      def is_it?
-        return @src.downcase == "it"
+      def root?
+        return @src.downcase == ROOT
+      end
+
+      # Does the pathname reference refer to it?
+      def it?
+        return @src.downcase == IT
       end
-      
+
+      # Does the pathname reference refer to error?
+      def error?
+        return @src.downcase == ERROR
+      end
+
       # Does the pathname reference refer to the gloo system object?
-      def is_gloo_sys?
-        return false unless @elements && @elements.count > 0
+      def gloo_sys?
+        return false unless @elements&.count&.positive?
+
         o = @elements.first.downcase
         return true if o == Gloo::Core::GlooSystem.typename
         return true if o == Gloo::Core::GlooSystem.short_typename
+
         return false
       end
 
@@ -52,42 +68,39 @@ module Gloo
       end
 
       # Set the object pathname to the given value.
-      def set_to value
-        @src = value.strip unless value.nil?
-        if @src.nil?
-          @elements = []
-        else
-          @elements = @src.split( '.' )
-        end
+      def set_to( value )
+        @src = value.nil? ? nil : value.strip
+        @elements = @src.nil? ? [] : @src.split( '.' )
       end
-      
+
       # Convert the raw string to a list of segments.
       def segments
         return @elements
       end
-      
+
       # Get the name element.
       def name
-        return "" unless self.has_name?
+        return '' unless self.named?
+
         return @elements.last
       end
 
       # Does the value include path elements?
-      def has_name?
-        return @elements.count > 0
+      def named?
+        return @elements.count.positive?
       end
 
       # Does the value include a name?
-      def has_path?
+      def includes_path?
         return @elements.count > 1
       end
-      
+
       # Get the parent that contains the object referenced.
       def get_parent
         o = $engine.heap.root
-        
-        if self.has_path?
-          @elements[0..-2].each do |e|
+
+        if self.includes_path?
+          @elements[ 0..-2 ].each do |e|
             o = o.find_child( e )
             if o.nil?
               $log.error "Object '#{e}' was not found."
@@ -95,38 +108,41 @@ module Gloo
             end
           end
         end
-        
+
         return o
       end
-      
+
       # Does the object at the path exist?
       def exists?
-        return true if self.is_root?
-        return true if self.is_it?
-        
+        return true if self.root?
+        return true if self.it?
+        return true if self.error?
+
         parent = self.get_parent
         return false unless parent
-        return parent.has_child? name
-      end
-			
-			# Is the reference to a color?
-			def is_color?
-				colors = [ "red", "blue", "green", "white", "black", "yellow" ]
-				return true if colors.include?( @src.downcase )
-			end
-      
+
+        return parent.contains_child? name
+      end
+
+      # Is the reference to a color?
+      def named_color?
+        colors = %w[red blue green white black yellow]
+        return true if colors.include?( @src.downcase )
+      end
+
       # Resolve the pathname reference.
       # Find the object referenced or return nil if it is not found.
       def resolve
-        return $engine.heap.root if self.is_root?
-        return $engine.heap.it if self.is_it?
-        if self.is_gloo_sys?
-          return Gloo::Core::GlooSystem.new( self ) 
-        end
-        
+        return $engine.heap.root if self.root?
+        return $engine.heap.it if self.it?
+        return $engine.heap.error if self.error?
+        return Gloo::Core::GlooSystem.new( self ) if self.gloo_sys?
+
         parent = self.get_parent
         return nil unless parent
-        return parent.find_child( self.name )
+
+        obj = parent.find_child( self.name )
+        return Gloo::Objs::Alias.resolve_alias( obj, self.src )
       end
 
     end

data/lib/gloo/core/script.rb

@@ -7,13 +7,12 @@
 module Gloo
   module Core
     class Script
-      
+
       # Set up the script.
-      def initialize obj
+      def initialize( obj )
         @obj = obj
       end
-      
-      
+
       # Run the script.
       def run
         if @obj.value.is_a? String
@@ -24,14 +23,15 @@ module Gloo
           end
         end
       end
-      
+
       # Run a single line of the script.
-      def run_line line
+      def run_line( line )
         i = $engine.parser.parse_immediate line
         return unless i
+
         i.run
       end
-      
+
     end
   end
 end

data/lib/gloo/core/tokens.rb

@@ -8,44 +8,44 @@
 module Gloo
   module Core
     class Tokens
-      
+
       attr_reader :cmd, :tokens
-      
+
       # Set up the tokens.
       def initialize( cmd_string )
         @cmd = cmd_string
         @tokens = []
         tokenize @cmd
       end
-      
+
       # Create a list of token from the given string.
-      def tokenize str
+      def tokenize( str )
         if str.index( '"' )
           i = str.index( '"' )
-          j = str.index( '"', i+1 )
-          j = str.length unless j
-          
-          tokenize( str[ 0..i-1 ] ) if i > 1
+          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
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
         elsif str.index( "'" )
           i = str.index( "'" )
-          j = str.index( "'", i+1 )
-          j = str.length unless j
+          j = str.index( "'", i + 1 )
+          j ||= str.length
 
-          tokenize( str[ 0..i-1 ] ) if i > 1
+          tokenize( str[ 0..i - 1 ] ) if i > 1
           @tokens << str[ i..j ]
-          tokenize( str[ j+1..-1 ] ) if j+1 < str.length
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
         else
-          str.strip.split( " " ).each { |t| @tokens << t }
+          str.strip.split( ' ' ).each { |t| @tokens << t }
         end
       end
-      
+
       # Get the number of tokens
       def token_count
         return @tokens.size
       end
-      
+
       # Get the verb (the first word)
       def verb
         return first
@@ -65,59 +65,57 @@ module Gloo
       def last
         return @tokens.last if @tokens
       end
-      
+
       # Get the second token.
       def second
-        return @tokens[1] if @tokens && @tokens.size > 0
+        return @tokens[ 1 ] if @tokens&.size&.positive?
       end
 
-      def at index
-        return @tokens[index] if @tokens && @tokens.size >= index
+      def at( index )
+        return @tokens[ index ] if @tokens && @tokens.size >= index
       end
-      
+
       # Get the index of the given token.
-      def index_of token
+      def index_of( token )
         return nil unless @tokens
-        return @tokens.find_index { |o| o.casecmp( token ) == 0 }
+
+        return @tokens.find_index { |o| o.casecmp( token ).zero? }
       end
 
       # Get the list of tokens after the given token
-      def tokens_after token
+      def tokens_after( token )
         i = index_of token
-        if i && @tokens && @tokens.size > ( i+1 ) 
-          return @tokens[ i+1..-1 ]
-        end
+        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 = ""
+      def expr_after( token )
+        str = ''
         tokens_after( token ).each do |t|
-          str << " " if ( str.length > 0 )
-          str << "#{t}"
+          str << ' ' unless str.empty?
+          str << t.to_s
         end
         return str
       end
-      
+
       # Get the item after a given token.
-      def after_token token
+      def after_token( token )
         i = index_of token
-        if i && @tokens && @tokens.size > ( i+1 ) 
-          return @tokens[ i+1 ]
-        end
+        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
+      def before_token( token )
         i = index_of token
-        if i && @tokens && @tokens.size >= ( i ) 
-          return @tokens[ 0..i-1 ]
-        end
+        return @tokens[ 0..i - 1 ] if i && @tokens && @tokens.size >= i
+
         return nil
       end
-            
+
     end
   end
 end