gloo 0.3.0 → 0.4.0

data/lib/gloo/core/it.rb

@@ -7,16 +7,16 @@
 module Gloo
   module Core
     class It
-      
+
       attr_accessor :value
-      
+
       # Set up the object.
-      def initialize()
+      def initialize
         @value = nil
       end
-            
+
       # Set the value of it.
-      def set_to new_value
+      def set_to( new_value )
         @value = new_value
       end
 

data/lib/gloo/core/literal.rb

@@ -7,19 +7,19 @@
 module Gloo
   module Core
     class Literal
-      
+
       attr_reader :value
-      
+
       # Create the expression from a list of tokens.
-      def initialize value
+      def initialize( value )
         set_value( value )
       end
-      
+
       # Set the literal value.
-      def set_value value
+      def set_value( value )
         @value = value
-      end      
-      
+      end
+
     end
   end
 end

data/lib/gloo/core/obj.rb

@@ -8,47 +8,48 @@
 module Gloo
   module Core
     class Obj < Baseo
-      
+
       attr_accessor :value
       attr_reader :children, :parent
 
       # Set up the object.
-      def initialize()
-        @value = ""
+      def initialize
+        @value = ''
         @children = []
         @parent = nil
       end
-        
+
       # Register object types when they are loaded.
       def self.inherited( subclass )
         Dictionary.instance.register_obj( subclass )
       end
 
-      # 
+      #
       # The name of the object type.
-      # 
+      #
       def self.typename
         raise 'this method should be overriden'
       end
 
-      # 
+      #
       # The object type, suitable for display.
-      # 
+      #
       def type_display
         return self.class.typename
       end
 
-      # 
+      #
       # Set the parent for the object.
-      # 
-      def set_parent obj
+      #
+      def set_parent( obj )
         @parent = obj
       end
-      
+
       # Is this the root object?
-      def is_root?
+      def root?
         return false if @parent
-        return false unless name.downcase == "root"
+        return false unless name.downcase == 'root'
+
         return true
       end
 
@@ -58,165 +59,174 @@ module Gloo
       def self.can_create?
         true
       end
-      
-      
+
       # ---------------------------------------------------------------------
       #    Value
       # ---------------------------------------------------------------------
 
-      # 
+      #
       # Set the value with any necessary type conversions.
-      # 
-      def set_value new_value
+      #
+      def set_value( new_value )
         self.value = new_value
       end
-      
-      # 
+
+      #
       # Get the value for display purposes.
-      # 
+      #
       def value_display
         return self.value.to_s
       end
-      
-      # 
+
+      #
       # Does this object support multi-line values?
       # Initially only true for scripts.
-      # 
-      def has_multiline_value?
+      #
+      def multiline_value?
         return false
       end
-      
-      # 
+
+      #
       # Is the value a String?
-      # 
-      def value_is_string?
+      #
+      def value_string?
         return self.value.is_a? String
       end
 
-      # 
+      #
       # Is the value an Array?
-      # 
+      #
       def value_is_array?
         return self.value.is_a? Array
       end
-      
-      # 
+
+      #
       # Is the value a blank string?
-      # 
+      #
       def value_is_blank?
         return true if value.nil?
+
         return self.value.to_s.strip.empty?
       end
-      
 
       # ---------------------------------------------------------------------
       #    Children
       # ---------------------------------------------------------------------
-      
+
       # Add a child object to the container.
-      def add_child obj
+      def add_child( obj )
         @children << obj
         obj.set_parent self
       end
-      
+
       # Get the number of children.
       def child_count
         return @children.count
       end
-      
+
       # Does this object contain an object with the given name?
-      def has_child? name
+      def contains_child?( name )
         @children.each do |o|
-          return true if ( name.downcase == o.name.downcase )
+          return true if name.downcase == o.name.downcase
         end
         return false
       end
 
       # Find a child object with the given name.
-      def find_child name
+      def find_child( name )
         @children.each do |o|
-          return o if ( name.downcase == o.name.downcase )
+          return o if name.downcase == o.name.downcase
         end
         return nil
       end
-      
+
       # Remove the object from the children collection.
-      def remove_child obj
+      def remove_child( obj )
         @children.delete obj
       end
-      
+
       # Does this object have children to add when an object
       # is created in interactive mode?
       # This does not apply during obj load, etc.
       def add_children_on_create?
         return false
       end
-      
+
       # Add children to this object.
-      # This is used by containers to add children needed 
+      # This is used by containers to add children needed
       # for default configurations.
       def add_default_children
+        # Override this.
       end
 
-      
       # ---------------------------------------------------------------------
       #    Messages
       # ---------------------------------------------------------------------
 
-      # 
+      #
       # Get a list of message names that this object receives.
-      # 
+      #
       def self.messages
-        return [ "unload" ]
+        return [ 'unload' ]
       end
-      
-      # 
+
+      #
       # Can this object receive a message?
-      # 
-      def can_receive_message? msg
+      #
+      def can_receive_message?( msg )
         msgs = self.class.messages
         return msgs.include?( msg.strip.downcase )
       end
 
-      # 
+      #
       # Sent this object the given message.
-      # 
-      def send_message msg, params=nil
-				@params = params
-        if self.can_receive_message? msg
-          return self.dispatch msg
-        else
-          $log.error "Object #{self.name} cannot receive message #{msg}"
-          return false
-        end
+      #
+      def send_message( msg, params = nil )
+        @params = params
+        return self.dispatch msg if self.can_receive_message? msg
+
+        $log.error "Object #{self.name} cannot receive message #{msg}"
+        return false
       end
-      
-      # 
+
+      #
       # Dispatch the message to the object.
-      # 
-      def dispatch msg
+      #
+      def dispatch( msg )
         o = "msg_#{msg}"
-        if self.respond_to? o 
-          self.public_send( o ) 
+        if self.respond_to? o
+          self.public_send( o )
           return true
         else
           $log.error "Message #{msg} not implemented"
           return false
         end
       end
-      
-      # 
+
+      #
       # Send the object the unload message.
-      # 
+      #
       def msg_unload
-        if self.is_root?
-          $log.error "Cannot unload the root object."
+        if self.root?
+          $log.error 'Cannot unload the root object.'
           return
         end
+
         $engine.event_manager.on_unload self
         $engine.heap.unload self
       end
-      
+
+      # ---------------------------------------------------------------------
+      #    Help
+      # ---------------------------------------------------------------------
+
+      #
+      # Get help for this object.
+      #
+      def self.help
+        return 'No help found.'
+      end
+
     end
   end
 end

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,44 @@
 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
+        Runner.go( v ) if v
       end
-      
+
     end
   end
 end