gloo 0.3.0 → 0.4.0

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
+      def set_to( value )
         @src = value.strip unless value.nil?
-        if @src.nil?
-          @elements = []
-        else
-          @elements = @src.split( '.' )
-        end
+        @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,37 +108,39 @@ 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 )
       end
 

data/lib/gloo/core/runner.rb

@@ -0,0 +1,26 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 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 Core
+    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 )
+        $engine.heap.error.start_tracking
+        verb&.run
+        $engine.heap.error.clear_if_no_errors
+      end
+
+    end
+  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

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