gloo 1.4.2 → 2.0.0

data/lib/gloo/core/obj.rb

@@ -0,0 +1,318 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An data/value object.
+# Derives from the Baseo object.  Is not a verb.
+#
+
+module Gloo
+  module Core
+    class Obj < Baseo
+
+      attr_accessor :value
+      attr_reader :children, :parent
+
+      #
+      # Set up the object.
+      #
+      def initialize( engine )
+        @engine = engine
+        @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 )
+        @parent = obj
+      end
+
+      #
+      # Is this the root object?
+      #
+      def root?
+        return false if @parent
+        return false unless name.downcase == 'root'
+
+        return true
+      end
+
+      # Can this object be created?
+      # This is true by default and only false for some special cases
+      # such as the System object.
+      def self.can_create?
+        true
+      end
+
+      #
+      # Get the path and name to this object.
+      #
+      def pn
+        str = self.name
+        p = self.parent
+        while p && !p.root?
+          str = "#{p.name}.#{str}"
+          p = p.parent
+        end
+        return str
+      end
+
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return self.pn
+      end
+
+      # ---------------------------------------------------------------------
+      #    Value
+      # ---------------------------------------------------------------------
+
+      #
+      # Set the value with any necessary type conversions.
+      #
+      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 multiline_value?
+        return false
+      end
+
+      #
+      # Is the value a 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
+      # ---------------------------------------------------------------------
+
+      #
+      # Find a child of the given name.
+      # If found, return it.  If not found create it.
+      #
+      def find_add_child( name, type )
+        child = self.find_child( name )
+        return child if child
+
+        params = { :name => name,
+                   :type => type,
+                   :value => nil,
+                   :parent => self }
+        return @engine.factory.create params
+      end
+
+      #
+      # Add a child object to the container.
+      #
+      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 contains_child?( name )
+        @children.each do |o|
+          return true if name.downcase == o.name.downcase
+        end
+        return false
+      end
+
+      #
+      # Find a child object with the given name.
+      #
+      def find_child( name )
+        if name.end_with?( Gloo::Objs::Alias::ALIAS_REFERENCE )
+          name = name[ 0..-2 ]
+        end
+
+        @children.each do |o|
+          return o if name.downcase == o.name.downcase
+        end
+
+        if self.type_display == Gloo::Objs::Alias.typename
+          ln = Gloo::Core::Pn.new( @engine, self.value )
+          redirect = ln.resolve
+          return redirect.find_child( name )
+        end
+        return nil
+      end
+
+      #
+      # Delete all children from the container.
+      #
+      def delete_children
+        @children.reverse.each do |o|
+          self.remove_child o
+        end
+      end
+
+      #
+      # Remove the object from the children collection.
+      #
+      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
+      # 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 %w[reload unload]
+      end
+
+      #
+      # Can this object receive a message?
+      #
+      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
+        return self.dispatch msg if self.can_receive_message? msg
+
+        @engine.log.error "Object #{self.name} cannot receive message #{msg}"
+        return false
+      end
+
+      #
+      # Dispatch the message to the object.
+      #
+      def dispatch( msg )
+        o = "msg_#{msg}"
+        if self.respond_to? o
+          self.public_send( o )
+          return true
+        else
+          @engine.log.error "Message #{msg} not implemented"
+          return false
+        end
+      end
+
+      #
+      # Send the object the unload message.
+      #
+      def msg_unload
+        if self.root?
+          @engine.log.error 'Cannot unload the root object.'
+          return
+        end
+
+        @engine.event_manager.on_unload self
+        @engine.heap.unload self
+        @engine.persist_man.unload self
+      end
+
+      #
+      # Send the object the reload message.
+      # Note that this will only work for objects with file assoications.
+      #
+      def msg_reload
+        if self.root?
+          @engine.log.error 'Cannot reload the root object.'
+          return
+        end
+
+        @engine.persist_man.reload 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

@@ -0,0 +1,30 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Utility used to find objects.
+#
+
+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( engine, name, container = nil )
+        container = engine.heap.root if container.nil?
+        arr = []
+
+        container.children.each do |o|
+          arr << o if o.name == name
+          arr += by_name( engine, name, o ) if o.child_count.positive?
+        end
+
+        return arr
+      end
+
+    end
+  end
+end

data/lib/gloo/core/op.rb

@@ -0,0 +1,40 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Operator; part of an expression.
+# A static helper class.
+#
+
+module Gloo
+  module Core
+    class Op
+
+      #
+      # Is the token an operator?
+      #
+      def self.op?( token )
+        return [ '+', '-', '*', '/' ].include?( token.strip )
+      end
+
+      #
+      # Create the operator for the given 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

@@ -0,0 +1,60 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# The Parser.
+# Can parse single line commands or files.
+#
+
+module Gloo
+  module Core
+    class Parser
+
+      #
+      # Set up the parser.
+      #
+      def initialize( engine )
+        @engine = engine
+        @engine.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
+        tokens = Gloo::Core::Tokens.new( cmd )
+        dic = Gloo::Core::Dictionary.instance
+        verb = dic.find_verb( tokens.verb )
+        return verb.new( @engine, tokens, params ) if verb
+
+        @engine.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
+
+      #
+      # Parse a command and then run it if it parsed correctly.
+      #
+      def run( cmd )
+        v = parse_immediate( cmd )
+        Gloo::Exec::Runner.go( @engine, v ) if v
+      end
+
+    end
+  end
+end

data/lib/gloo/core/pn.rb

@@ -0,0 +1,212 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An object path name.
+# Path and name elements are separated by periods.
+#
+
+module Gloo
+  module Core
+    class Pn < Baseo
+
+      ROOT = 'root'.freeze
+      IT = 'it'.freeze
+      ERROR = 'error'.freeze
+      CONTEXT = '@'.freeze
+
+      attr_reader :src, :elements
+
+      #
+      # Set up the object given a source string,
+      # ie: the full path and name.
+      #
+      def initialize( engine, src )
+        @engine = engine
+        set_to src
+      end
+
+      #
+      # Reference to the root object path.
+      #
+      def self.root( engine )
+        return Pn.new( engine, ROOT )
+      end
+
+      #
+      # Reference to it.
+      #
+      def self.it( engine )
+        return Pn.new( engine, IT )
+      end
+
+      #
+      # Reference to the error message.
+      #
+      def self.error( engine )
+        return Pn.new( engine, ERROR )
+      end
+
+      #
+      # Does the pathname reference refer to the root?
+      #
+      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 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
+
+      #
+      # Get the string representation of the pathname.
+      #
+      def to_s
+        return @src
+      end
+
+      #
+      # Set the object pathname to the given value.
+      #
+      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.named?
+
+        return @elements.last
+      end
+
+      #
+      # Does the value include path elements?
+      #
+      def named?
+        return @elements.count.positive?
+      end
+
+      #
+      # Does the value include a name?
+      #
+      def includes_path?
+        return @elements.count > 1
+      end
+
+      # 
+      # Does the path start with the context?
+      # 
+      def includes_context?
+        return @src.start_with?( "#{CONTEXT}." )
+      end
+
+      # 
+      # Expand the context so we have the full path.
+      # 
+      def expand_context
+        # return unless @engine.heap.context
+        self.set_to( "#{@engine.heap.context}#{@src[1..-1]}" )
+      end
+
+      #
+      # Get the parent that contains the object referenced.
+      #
+      def get_parent
+        o = @engine.heap.root
+
+        if self.includes_path?
+          @elements[ 0..-2 ].each do |e|
+            o = o.find_child( e )
+            if o.nil?
+              @engine.log.error "Object '#{e}' was not found."
+              return nil
+            end
+          end
+        end
+
+        return o
+      end
+
+      #
+      # Does the object at the path exist?
+      #
+      def exists?
+        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.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.root?
+        return @engine.heap.it if self.it?
+        return @engine.heap.error if self.error?
+        return Gloo::Core::GlooSystem.new(
+          @engine, self ) if self.gloo_sys?
+
+        if Here.includes_here_ref?( @elements )
+          Here.expand_here( @engine, self )
+        end
+
+        if self.includes_context?
+          expand_context
+        end
+
+        parent = self.get_parent
+        return nil unless parent
+
+        obj = parent.find_child( self.name )
+        return Gloo::Objs::Alias.resolve_alias( @engine, obj, self.src )
+      end
+
+    end
+  end
+end