gloo 1.4.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6591892e28f187a9d4a9423b73cad883ce4e82727b1766c7e2479cfda45c6eb5
-  data.tar.gz: '0849baf49b9e3f5badea735a10e7681bed0e5aa6844077acb08b60cdd8686ed6'
+  metadata.gz: 9b19e54f7dd61af964351d823b146fdd04506784a31c6a146461cd608f34c879
+  data.tar.gz: 6d5cbb60e6de73b127a1156bcbd37a1711c3d39ae5da76c280d4893f327e65da
 SHA512:
-  metadata.gz: 27430e48100e1b2d983c75978104e164f5a5aaca69223df0e765515e1f596c77fcca75828afe7e3e17c2ceef3bef54c1b3333a80282acadc226aea972a45ba82
-  data.tar.gz: '068f43c3a736319df51dad920cad68322543326ea41b8713b06d5f88daaa757c6c5da8d5b20189b0de4f08c5d706a104601df0a3baf05a2ad92b1159d0f44b9c'
+  metadata.gz: cc2f6254760735dd87fa7d42aa8c9698d6a162afc322478e76b49cab1b52305a3d833fc85c202169f5b7e1df69ba567eaeb85fda4174e7daff451296ec1a4661
+  data.tar.gz: 63a96da42cd2d21cc5e27489c7161c20e3a58e1b3b72534766bf4d48c6ac469e7168b7de975e7731bd566b3698566890b568e99441899b0061b61c45fde2c2a5

data/.gitignore

@@ -11,3 +11,4 @@
 test/gloo/debug/*
 Gemfile.lock
 *.DS_Store
+.DS_Store

data/gloo.gemspec

@@ -37,8 +37,6 @@ Gem::Specification.new do |spec|
   # spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency "rake", '~> 13.0', '>= 13.0.1'
 
-  spec.add_dependency "gloo-lang", '~> 1.2', ">= 1.4.3"
-
   spec.add_dependency "activesupport", '~> 6.1', ">= 6.1.5"
   # spec.add_dependency "activesupport", '~> 6.1', ">= 6.1.4.6"
   # spec.add_dependency "activesupport", '~> 5.2', ">= 5.2.4.3"

data/lib/VERSION

@@ -1 +1 @@
-1.4.2
+2.0.0

data/lib/dependencies.rb

@@ -2,8 +2,8 @@
 # Script to build a list of dependencies
 #
 
-require 'gloo_lang/core/baseo'
-require 'gloo_lang/core/obj'
+# require 'gloo_lang/core/baseo'
+# require 'gloo_lang/core/obj'
 
 path = File.dirname( File.absolute_path( __FILE__ ) )
 
@@ -11,8 +11,8 @@ files = []
 #
 # We want to start with these to avoid dependency errors later on.
 #
-# files << File.join( path, 'gloo_lang', 'core', 'baseo.rb' )
-# files << File.join( path, 'gloo_lang', 'core', 'obj.rb' )
+files << File.join( path, 'gloo', 'core', 'baseo.rb' )
+files << File.join( path, 'gloo', 'core', 'obj.rb' )
 
 root = File.join( path, 'gloo', '**/*.rb' )
 Dir.glob( root ).each do |ruby_file|

data/lib/gloo/app/args.rb

@@ -0,0 +1,112 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Arguments (parameters) used to specify functionality.
+# These might have come from the CLI or as parameters
+# in the constructor.
+#
+require 'active_support'
+
+module Gloo
+  module App
+    class Args
+
+      QUIET = 'quiet'.freeze
+      GLOO_ENV = 'GLOO_ENV'.freeze
+
+      attr_reader :switches, :files
+
+      #
+      # Create arguments and setup.
+      #
+      def initialize( engine, params = [] )
+        @engine = engine
+        @switches = []
+        @files = []
+
+        params.each { |o| process_one_arg( o ) }
+        ARGV.each { |o| process_one_arg( o ) }
+      end
+
+      #
+      # Was the --quiet arg passed?
+      #
+      def quiet?
+        return @switches.include?( QUIET )
+      end
+
+      #
+      # Is the version switch set?
+      #
+      def version?
+        @switches.include?( Gloo::App::Mode::VERSION.to_s )
+      end
+
+      #
+      # Is the help switch set?
+      #
+      def help?
+        @switches.include?( Gloo::App::Mode::HELP.to_s )
+      end
+
+      #
+      # Is the cli switch set?
+      #
+      def cli?
+        @switches.include?( Gloo::App::Mode::CLI.to_s )
+      end
+
+      #
+      # Is the embed switch set?
+      #
+      def embed?
+        @switches.include?( Gloo::App::Mode::EMBED.to_s )
+      end
+
+      #
+      # Detect the mode to be run in.
+      # Start by seeing if a mode is specified.
+      # Then look for the presence of files.
+      # Then finally use the default: embedded mode.
+      #
+      def detect_mode
+        mode = if ENV[ GLOO_ENV ] == Gloo::App::Mode::TEST.to_s
+                 Mode::TEST
+               elsif version?
+                 Mode::VERSION
+               elsif help?
+                 Mode::HELP
+               elsif cli?
+                 Mode::CLI
+               elsif embed?
+                 Mode::EMBED
+               elsif @files.count.positive?
+                 Mode::SCRIPT
+               else
+                 Mode.default_mode
+               end
+        @engine.log.debug "running in #{mode} mode"
+
+        return mode
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Process one argument or parameter.
+      #
+      def process_one_arg( arg )
+        if arg.start_with? '--'
+          switches << arg[ 2..-1 ]
+        else
+          files << arg
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo/app/engine.rb

@@ -0,0 +1,247 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# The Gloo Script Engine.
+# The Engine aggregates all the elements needed to run gloo.
+# The Engine runs the main event loop and delegates processing
+# to the relevant element.
+#
+
+module Gloo
+  module App
+    class Engine
+
+      attr_reader :settings, :log
+      attr_reader :args, :mode, :running, :platform,
+                  :dictionary, :parser, :heap, :factory
+      attr_accessor :last_cmd, :persist_man, :event_manager,
+                    :exec_env, :converter
+
+      #
+      # Set up the engine with basic elements.
+      #
+      def initialize( context )
+        @args = Args.new( self, context.params )
+        @settings = Settings.new( self, context.user_root )
+
+        @log = context.log.new( self, @args.quiet? )
+        @log.debug "log (class: #{@log.class.name}) in use ..."
+
+        @platform = context.platform
+        @log.debug "platform (class: #{@platform.class.name}) in use ..."
+
+        @log.debug 'engine intialized...'
+      end
+
+      #
+      # Start the engine.
+      # Load object and verb definitions and setup engine elements.
+      #
+      def start
+        @log.debug 'starting the engine...'
+        @log.debug Gloo::App::Info.display_title
+        @mode = @args.detect_mode
+        @running = true
+
+        @dictionary = Gloo::Core::Dictionary.get
+
+        @parser = Gloo::Core::Parser.new( self )
+        @heap = Gloo::Core::Heap.new( self )
+        @factory = Gloo::Core::Factory.new( self )
+        @persist_man = Gloo::Persist::PersistMan.new( self )
+        @event_manager = Gloo::Core::EventManager.new( self )
+
+        @exec_env = Gloo::Exec::ExecEnv.new( self )
+        @converter = Gloo::Convert::Converter.new( self )
+
+        @log.debug 'the engine has started'
+        run_mode
+      end
+
+      # ---------------------------------------------------------------------
+      #    Serialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Prepare for serialization by removing any file references.
+      # Without this, the engine cannot be serialized.
+      #
+      def prep_serialize
+        @log.prep_serialize
+      end
+
+      #
+      # Get the serialized version of this Engine.
+      #
+      def serialize
+        prep_serialize
+        Marshal::dump( self )
+      end
+
+      #
+      # Deserialize the Engine data.
+      #
+      def self.deserialize data
+        e = Marshal::load( data )
+        e.restore_after_deserialization
+        return e
+      end
+
+      #
+      # Restore the engine after deserialization.
+      #
+      def restore_after_deserialization
+        @log.restore_after_deserialization
+      end
+
+      # ---------------------------------------------------------------------
+      #    Run
+      # ---------------------------------------------------------------------
+
+      #
+      # Run gloo in the selected mode.
+      #
+      def run_mode
+        @log.debug "running gloo in #{@mode} mode"
+
+        if @mode == Mode::VERSION
+          run_version
+        elsif @mode == Mode::SCRIPT
+          run_files
+        elsif @mode == Mode::EMBED
+          run_keep_alive
+        else
+          run
+        end
+      end
+
+      #
+      # Run files specified on the CLI.
+      # Then quit.
+      #
+      def run_files
+        load_files
+        quit
+      end
+
+      # 
+      # Load all file specified in the CLI.
+      # 
+      def load_files
+        @args.files.each { |f| @persist_man.load( f ) }
+      end
+
+      #
+      # Run in interactive mode.
+      #
+      def run
+        # Open default file(s)
+        self.open_start_file
+
+        # Open any files specifed in args
+        load_files
+
+        unless @mode == Mode::SCRIPT || @args.quiet?
+          self.loop
+        end
+
+        quit
+      end
+
+      #
+      # Run in Embedded mode, which means we'll
+      # start the engine, but wait for external inputs.
+      #
+      def run_keep_alive
+        @log.debug 'Running in Embedded mode...'
+      end
+
+      #
+      # Get the setting for the start_with file and open it.
+      #
+      def open_start_file
+        name = @settings.start_with
+        @persist_man.load( name ) if name
+      end
+
+      #
+      # Is the last command entered blank?
+      #
+      def last_cmd_blank?
+        return true if @last_cmd.nil?
+        return true if @last_cmd.strip.empty?
+
+        return false
+      end
+
+      #
+      # Prompt, Get input, process.
+      #
+      def loop
+        while @running
+          @last_cmd = @platform.prompt_cmd
+          process_cmd
+        end
+      end
+
+      #
+      # Process the command.
+      #
+      def process_cmd
+        if last_cmd_blank?
+          @platform.clear_screen
+          return
+        end
+
+        @parser.run @last_cmd
+      end
+
+      #
+      # Request the engine to stop running.
+      #
+      def stop_running
+        @running = false
+      end
+
+      #
+      # Do any clean up and quit.
+      #
+      def quit
+        @log.debug 'quitting...'
+      end
+
+      # ---------------------------------------------------------------------
+      #    Helpers
+      # ---------------------------------------------------------------------
+
+      #
+      # Show the version information and then quit.
+      #
+      def run_version
+        @platform.show Info.full_version unless @args.quiet?
+        quit
+      end
+
+      # ---------------------------------------------------------------------
+      #    Error Handling
+      # ---------------------------------------------------------------------
+
+      #
+      # Did the last command result in an error?
+      #
+      def error?
+        return !@heap.error.value.nil?
+      end
+
+      #
+      # Report an error.
+      # Write it to the log and set the heap error value.
+      #
+      def err( msg )
+        @log.error msg
+        @heap.error.set_to msg
+      end
+
+    end
+  end
+end

data/lib/gloo/app/engine_context.rb

@@ -0,0 +1,25 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2022 Eric Crane.  All rights reserved.
+#
+# The context (parameters) for the Gloo Script Engine.
+#
+
+module Gloo
+  module App
+    class EngineContext
+
+      attr_accessor :params, :platform, :log, :user_root
+
+      #
+      # Create the context, supplying defaults where relevant.
+      #
+      def initialize( params = [], platform=nil, log=nil, user_root=nil )
+        @params = params
+        @platform = platform ? platform : Gloo::App::Platform.new
+        @log = log ? log : Gloo::App::Log
+        @user_root = user_root
+      end
+
+    end
+  end
+end

data/lib/gloo/app/info.rb

@@ -4,11 +4,11 @@
 # Application information such as Version and public name.
 #
 
-require 'gloo-lang'
+# require 'gloo-lang'
 
 module Gloo
   module App
-    class Info < GlooLang::App::Info
+    class Info
 
       #
       # Load the version from the VERSION file.
@@ -30,6 +30,23 @@ module Gloo
         return "#{APP_NAME}, version #{VERSION}"
       end
 
+
+      #
+      # Get the full application version information,
+      # including engine version.
+      #
+      def self.full_version
+        return "#{display_title}\n#{ruby_info}"
+        return str
+      end
+
+      # 
+      # Get the version of Ruby.
+      # 
+      def self.ruby_info
+        return "Ruby version: #{RUBY_VERSION}"
+      end
+
     end
   end
-end
+end

data/lib/gloo/app/log.rb

@@ -9,7 +9,60 @@ require 'colorized_string'
 
 module Gloo
   module App
-    class Log < GlooLang::App::Log
+    class Log
+
+      attr_accessor :quiet
+      attr_reader :logger
+
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up a logger.
+      # If quiet is true, then message are written to the log
+      # but not to the console.
+      #
+      def initialize( engine, quiet=true )
+        @engine = engine
+        @quite = quiet
+
+        create_logger
+
+        debug 'log intialized...'
+      end
+
+      #
+      # Create the default [file] logger.
+      #
+      def create_logger
+        f = File.join( @engine.settings.log_path, 'gloo.log' )
+        @logger = Logger.new( f )
+        @logger.level = Logger::DEBUG
+      end
+
+      # ---------------------------------------------------------------------
+      #    Standard Output
+      # ---------------------------------------------------------------------
+
+      #
+      # Show a message unless we're in quite mode.
+      #
+      def show( msg )
+        puts msg unless @quiet
+      end
+
+      # ---------------------------------------------------------------------
+      #    Logging functions
+      # ---------------------------------------------------------------------
+
+      #
+      # Write a debug message to the log.
+      #
+      def debug( msg )
+        @logger.debug msg
+      end
+
 
       #
       # Write an information message to the log.
@@ -48,6 +101,25 @@ module Gloo
         end
       end
 
+      # ---------------------------------------------------------------------
+      #    Serialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Prepare for serialization by removing the file reference.
+      # Without this, the engine cannot be serialized.
+      #
+      def prep_serialize
+        @logger = nil
+      end
+
+      #
+      # Restore the logger after deserialization.
+      #
+      def restore_after_deserialization
+        create_logger
+      end
+
     end
   end
 end

data/lib/gloo/app/mode.rb

@@ -0,0 +1,27 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Mode the Application is running in.
+#
+
+module Gloo
+  module App
+    class Mode
+
+      EMBED = :embed      # Run as embedded script processor
+      CLI = :cli          # Run in interactive (CLI) mode
+      SCRIPT = :script    # Run a script
+      VERSION = :version  # Show version information
+      HELP = :help        # Show the help screen
+      TEST = :test        # Running in Unit Test mode.
+
+      #
+      # Get the default mode.
+      #
+      def self.default_mode
+        return EMBED
+      end
+
+    end
+  end
+end

data/lib/gloo/app/platform.rb

@@ -17,7 +17,7 @@ require 'pastel'
 
 module Gloo
   module App
-    class Platform < GlooLang::App::Platform
+    class Platform
 
       DEFAULT_TMP_FILE = 'tmp.txt'.freeze
 
@@ -73,6 +73,13 @@ module Gloo
         return File.read( tmp )
       end
 
+      # 
+      # Get the file mechanism for this platform.
+      # 
+      def getFileMech( engine )
+        return Gloo::Persist::DiscMech.new( engine )
+      end
+
       # ---------------------------------------------------------------------
       #    Color helper
       # ---------------------------------------------------------------------