gloo 0.6.1 → 0.7.4

data/lib/gloo/core/tokens.rb

@@ -11,78 +11,85 @@ module Gloo
 
       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
 
-      # 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
+      # ---------------------------------------------------------------------
+      #    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 )
@@ -90,7 +97,9 @@ module Gloo
         return nil
       end
 
+      #
       # Get the expression after the given token
+      #
       def expr_after( token )
         str = ''
         tokens_after( token ).each do |t|
@@ -100,7 +109,9 @@ module Gloo
         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 )
@@ -108,7 +119,9 @@ module Gloo
         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
@@ -116,6 +129,37 @@ module Gloo
         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

@@ -13,13 +13,17 @@ module Gloo
 
       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

data/lib/gloo/exec/exec_env.rb

@@ -17,7 +17,7 @@ module Gloo
       HERE_STACK = 'here'.freeze
 
       #
-      # Set up the stack.
+      # Set up the execution environment.
       #
       def initialize
         $log.debug 'exec env intialized...'
@@ -37,21 +37,33 @@ module Gloo
         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

data/lib/gloo/expr/expression.rb

@@ -8,7 +8,13 @@ module Gloo
   module Expr
     class Expression
 
+      # ---------------------------------------------------------------------
+      #    Constructor
+      # ---------------------------------------------------------------------
+
+      #
       # Create the expression from a list of tokens.
+      #
       def initialize( tokens )
         @tokens = tokens
         @symbols = []
@@ -17,7 +23,13 @@ module Gloo
         @op = nil
       end
 
+      # ---------------------------------------------------------------------
+      #    Evaluate Expression
+      # ---------------------------------------------------------------------
+
+      #
       # Evaluate the expression and return the value.
+      #
       def evaluate
         identify_tokens
 
@@ -39,7 +51,15 @@ module Gloo
         return @left
       end
 
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
       # Perform the operation.
+      #
       def perform_op
         @op ||= Gloo::Core::Op.default_op
         l = evaluate_sym @left
@@ -49,7 +69,9 @@ module Gloo
         @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
@@ -57,7 +79,9 @@ module Gloo
         return sym
       end
 
+      #
       # resolve an object reference and get the value.
+      #
       def resolve_ref( ref )
         return ref.src if ref.named_color?
 
@@ -65,15 +89,13 @@ module Gloo
         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
 
       #

data/lib/gloo/expr/l_boolean.rb

@@ -8,17 +8,23 @@ 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
 

data/lib/gloo/expr/l_decimal.rb

@@ -18,13 +18,18 @@ module Gloo
         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

data/lib/gloo/expr/l_integer.rb

@@ -8,7 +8,9 @@ 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
 
@@ -16,11 +18,16 @@ module Gloo
         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

data/lib/gloo/expr/l_string.rb

@@ -8,8 +8,10 @@ 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
@@ -17,7 +19,9 @@ module Gloo
         @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?( '"' )
@@ -42,6 +46,9 @@ module Gloo
         end
       end
 
+      #
+      # Get string representation
+      #
       def to_s
         return self.value
       end

data/lib/gloo/expr/op_div.rb

@@ -8,7 +8,9 @@ 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
 

data/lib/gloo/expr/op_minus.rb

@@ -8,7 +8,9 @@ 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
 

data/lib/gloo/expr/op_mult.rb

@@ -8,7 +8,9 @@ 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