gloo 0.3.0 → 0.5.3

data/lib/gloo/app/engine.rb

@@ -15,24 +15,24 @@ module Gloo
       attr_reader :args, :mode, :running
       attr_reader :dictionary, :parser, :heap, :factory
       attr_accessor :last_cmd, :persist_man, :event_manager
-      
+
       # Set up the engine with basic elements.
       def initialize( params = [] )
         $engine = self
         @args = Args.new( params )
         $settings = Settings.new( ENV[ 'GLOO_ENV' ] )
         $log = Log.new( @args.quiet? )
-				$prompt = TTY::Prompt.new
-        $log.debug "engine intialized..."
+        $prompt = TTY::Prompt.new
+        $log.debug 'engine intialized...'
       end
-      
+
       # Start the engine.
       def start
-        $log.debug "starting the engine..."
+        $log.debug 'starting the engine...'
         $log.debug Info.display_title
         @mode = @args.detect_mode
         @running = true
-        
+
         @dictionary = Gloo::Core::Dictionary.instance
         @dictionary.init
         @parser = Gloo::Core::Parser.new
@@ -40,10 +40,14 @@ module Gloo
         @factory = Gloo::Core::Factory.new
         @persist_man = Gloo::Persist::PersistMan.new
         @event_manager = Gloo::Core::EventManager.new
-        
+
         run_mode
       end
-      
+
+      # ---------------------------------------------------------------------
+      #    Run
+      # ---------------------------------------------------------------------
+
       # Run the selected mode.
       def run_mode
         if @mode == Mode::VERSION
@@ -56,14 +60,14 @@ module Gloo
           run
         end
       end
-      
+
       # Run files specified on the CLI.
       # Then quit.
       def run_files
         @args.files.each do |f|
           @persist_man.load( f )
         end
-        
+
         quit
       end
 
@@ -71,17 +75,17 @@ module Gloo
       def run
         # Open default files
         self.open_start_file
-        
+
         # TODO: open any files specifed in args
-        
+
         unless @mode == Mode::SCRIPT || @args.quiet?
           @cursor = TTY::Cursor
-          self.loop 
+          self.loop
         end
 
         quit
       end
-      
+
       # Get the setting for the start_with file and open it.
       def open_start_file
         name = $settings.start_with
@@ -94,9 +98,9 @@ module Gloo
         d = dt.strftime( '%Y.%m.%d' )
         t = dt.strftime( '%I:%M:%S' )
 
-        @last_cmd = $prompt.ask( "#{d.yellow} #{t.white} >" )
+        @last_cmd = $prompt.ask( "#{'gloo'.blue} #{d.yellow} #{t.white} >" )
       end
-      
+
       # Is the last command entered blank?
       def last_cmd_blank?
         return true if @last_cmd.nil?
@@ -110,28 +114,31 @@ module Gloo
           process_cmd
         end
       end
-      
+
       # Process the command.
       def process_cmd
         if last_cmd_blank?
           clear_screen
           return
         end
-        
-        @immediate = @parser.parse_immediate @last_cmd
-        @immediate.run if @immediate
+
+        @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..."
+        $log.debug 'quitting...'
       end
-      
+
+      # ---------------------------------------------------------------------
+      #    Helpers
+      # ---------------------------------------------------------------------
+
       # Show the version information and then quit.
       def run_version
         puts Info.display_title unless @args.quiet?
@@ -139,20 +146,63 @@ module Gloo
       end
 
       # Show the help information and then quit.
-      def run_help keep_running=false
-        unless @args.quiet?
-          puts Info.display_title
-          puts Help.get_help_text
-        end
+      def run_help( keep_running = false )
+        out = "#{Info.display_title}\n"
+        out << Help.get_help_text
+        $engine.heap.it.set_to out
+        puts out unless @args.quiet?
         quit unless keep_running
       end
-      
+
       # Clear the screen.
       def clear_screen
+        @cursor ||= TTY::Cursor
         print @cursor.clear_screen
         print @cursor.move_to( 0, 0 )
       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
+        self.heap.error.set_to msg
+      end
+
+      # ---------------------------------------------------------------------
+      #    Convert
+      # ---------------------------------------------------------------------
+
+      #
+      # Convert the given value to the specified type,
+      # or if no conversion is available, revert to default.
+      #
+      def convert( value, to_type, default = nil )
+        begin
+          name = "Gloo::Convert::#{value.class}To#{to_type}"
+          clazz = name.split( '::' ).inject( Object ) { |o, c| o.const_get c }
+          o = clazz.new
+          return o.convert( value )
+        rescue => e
+          $log.error e.message
+          $engine.heap.error.set_to e.message
+        end
+
+        return default
+      end
+
     end
   end
 end

data/lib/gloo/app/help.rb

@@ -11,19 +11,25 @@ module Gloo
       # Get text to display when the application is run
       # in HELP mode.
       def self.get_help_text
-        str = "\nNAME\n\tgloo\n\n"
-        str << "\nDESCRIPTION\n\tGloo scripting language.  A scripting language built on ruby.\n"
-        str << "\tMore information coming soon.\n\n"
-        str << "\nSYNOPSIS\n\tgloo [global option] [file]\n\n"
-        str << "\nGLOBAL OPTIONS\n"
-        str << "\t--cli \t\t - Run in CLI mode\n"
-        str << "\t--version \t - Show application version\n"
-        str << "\t--help \t\t - Show this help page\n"
-        str << "\n"
-        return str
+        return <<~TEXT
+          NAME
+          \tgloo
+
+          DESCRIPTION
+          \tGloo scripting language.  A scripting language built on ruby.
+          \tMore information coming soon.
+
+          SYNOPSIS
+          \tgloo [global option] [file]
+
+          GLOBAL OPTIONS
+          \t--cli \t\t - Run in CLI mode
+          \t--version \t - Show application version
+          \t--help \t\t - Show this help page
+
+        TEXT
       end
 
     end
   end
 end
-

data/lib/gloo/app/info.rb

@@ -8,9 +8,10 @@ module Gloo
   module App
     class Info
 
-      VERSION = "0.3.0"
-      APP_NAME = "Gloo"
+      VERSION = '0.5.3'.freeze
+      APP_NAME = 'Gloo'.freeze
 
+      # Get the application display title.
       def self.display_title
         return "#{APP_NAME}, version #{VERSION}"
       end
@@ -18,4 +19,3 @@ module Gloo
     end
   end
 end
-

data/lib/gloo/app/log.rb

@@ -12,46 +12,46 @@ module Gloo
     class Log
 
       attr_reader :logger, :quiet
-      
+
       def initialize( quiet )
-        f = File.join( $settings.log_path, "gloo.log" )
+        f = File.join( $settings.log_path, 'gloo.log' )
         @logger = Logger.new( f )
         @logger.level = Logger::DEBUG
         @quiet = quiet
       end
-      
+
       # Show a message unless we're in quite mode.
-      def show msg
+      def show( msg )
         puts msg unless @quiet
       end
-      
-      def debug msg
+
+      def debug( msg )
         @logger.debug msg
       end
 
-      def info msg
+      def info( msg )
         @logger.info msg
         puts msg.blue unless @quiet
       end
 
-      def warn msg
+      def warn( msg )
         @logger.warn msg
         puts msg.yellow unless @quiet
       end
 
-      def error msg, e = nil
-        if e
-          @logger.error msg
-          @logger.error e.message
-          @logger.error e.backtrace
+      def error( msg, ex = nil, engine = nil )
+        engine&.heap&.error&.set_to msg
+        @logger.error msg
+        if ex
+          @logger.error ex.message
+          @logger.error ex.backtrace
           puts msg.red unless @quiet
-          puts e.message.red unless @quiet
-          puts e.backtrace unless @quiet
+          puts ex.message.red unless @quiet
+          puts ex.backtrace unless @quiet
         else
-          @logger.error msg
           puts msg.red unless @quiet
         end
-      end  
+      end
 
     end
   end

data/lib/gloo/app/mode.rb

@@ -7,19 +7,19 @@
 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
+end

data/lib/gloo/app/settings.rb

@@ -13,92 +13,102 @@ module Gloo
     class Settings
 
       attr_reader :user_root, :log_path, :config_path, :project_path
-      attr_reader :start_with, :list_indent
-
+      attr_reader :start_with, :list_indent, :tmp_path
 
       # Load setting from the yml file.
-      def initialize mode
+      def initialize( mode )
         @mode = mode
         init_root
         init_path_settings
         init_user_settings
       end
-      
+
       def init_root
         if in_test_mode?
           path = File.dirname( File.dirname( File.absolute_path( __FILE__ ) ) )
           path = File.dirname( File.dirname( path ) )
-          path = File.join( path, "test", "gloo" )
+          path = File.join( path, 'test', 'gloo' )
           @user_root = path
         else
-          @user_root = File.join( Dir.home, "gloo" )
+          @user_root = File.join( Dir.home, 'gloo' )
         end
       end
-      
+
       # Are we in test mode?
       def in_test_mode?
         return @mode == 'TEST'
       end
 
+      # Get the project path for the current mode.
+      def project_path_for_mode( settings )
+        return File.join( @user_root, 'projects' ) if in_test_mode?
+
+        return settings[ 'gloo' ][ 'project_path' ]
+      end
+
       # Get the app's required directories.
       def init_path_settings
-        Dir.mkdir( @user_root ) unless File.exists?( @user_root )
+        Dir.mkdir( @user_root ) unless File.exist?( @user_root )
 
-        @log_path = File.join( @user_root, "logs" )
-        Dir.mkdir( @log_path ) unless File.exists?( @log_path )
+        @log_path = File.join( @user_root, 'logs' )
+        Dir.mkdir( @log_path ) unless File.exist?( @log_path )
 
-        @config_path = File.join( @user_root, "config" )
-        Dir.mkdir( @config_path ) unless File.exists?( @config_path )
+        @config_path = File.join( @user_root, 'config' )
+        Dir.mkdir( @config_path ) unless File.exist?( @config_path )
+
+        @tmp_path = File.join( @user_root, 'tmp' )
+        Dir.mkdir( @tmp_path ) unless File.exist?( @tmp_path )
       end
 
+      # Initialize the user settings for the currently
+      # running environment.
       def init_user_settings
         settings = get_settings
-        
-        if in_test_mode?
-          @project_path = File.join( @user_root, "projects" )
-        else
-          @project_path = settings[ 'gloo' ][ 'project_path' ]
-        end
+
+        @project_path = project_path_for_mode settings
         @start_with = settings[ 'gloo' ][ 'start_with' ]
         @list_indent = settings[ 'gloo' ][ 'list_indent' ]
       end
-      
+
       # Get the app's required directories.
       def get_settings
-        f = File.join( @config_path, "gloo.yml" )
-        create_settings( f ) unless File.exists?( f )
-        return YAML::load_file f
+        f = File.join( @config_path, 'gloo.yml' )
+        create_settings( f ) unless File.exist?( f )
+        return YAML.load_file f
       end
 
       # Create settings file.
-      def create_settings f
-        IO.write( f, get_default_settings )
+      def create_settings( file )
+        IO.write( file, get_default_settings )
       end
 
       # Get the value for default settings.
       def get_default_settings
-        home_dir = Dir.home
-        projects = File.join( @user_root, "projects" )
-        str = <<TEXT
-gloo:
-  project_path: #{projects}
-  start_with: 
-  list_indent: 1
-TEXT
+        projects = File.join( @user_root, 'projects' )
+        str = <<~TEXT
+          gloo:
+            project_path: #{projects}
+            start_with:
+            list_indent: 1
+        TEXT
         return str
       end
 
+      #
       # Show the current application settings.
+      # Can be seen in app with 'help settings'
+      #
       def show
         puts "\nApplication Settings:".blue
-        puts "  User Root Path is here:  ".yellow + @user_root.white
-        puts "  Projects directory:  ".yellow + @projects.white
-        puts "  Startup with:  ".yellow + @start_with.white
-        puts "  Indent in Listing:  ".yellow + @list_indent.white
-        puts ""
-        puts "  Screen Lines:  ".yellow + "#{Settings.lines}".white
-        puts "  Page Size:  ".yellow + "#{Settings.page_size}".white
-        puts ""
+        puts '  User Root Path is here:  '.yellow + @user_root.white
+        puts '  Projects directory:  '.yellow + @project_path.white
+        puts '  Tmp directory:  '.yellow + @tmp_path.white
+        puts '  Startup with:  '.yellow + @start_with.white
+        puts '  Indent in Listing:  '.yellow + @list_indent.to_s.white
+        puts ''
+        puts '  Screen Lines:  '.yellow + Gloo::App::Settings.lines.to_s.white
+        puts '  Page Size:  '.yellow + Gloo::App::Settings.page_size.to_s.white
+        puts ''
       end
 
       # Get the number of lines on screen.
@@ -122,4 +132,4 @@ TEXT
 
     end
   end
-end
+end