gloo 1.4.2 → 2.0.0

data/lib/gloo/persist/persist_man.rb

@@ -0,0 +1,153 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# The persistance manager.
+# Keeps a collection of object-file mappings, and then
+# uses mappings to know how/where to save updated objects.
+#
+
+module Gloo
+  module Persist
+    class PersistMan
+
+      attr_reader :maps, :mech
+
+      #
+      # Contructor for the persistence manager.
+      #
+      def initialize( engine )
+        @engine = engine
+        @maps = []
+        @mech = @engine.platform.getFileMech( @engine )
+      end
+
+      #
+      # Save one object to the file.
+      #
+      def save( name = '' )
+        name.blank? ? save_all : save_one( name )
+      end
+
+      #
+      # Save one object to the file.
+      #
+      def save_all
+        @maps.each( &:save )
+      end
+
+      #
+      # Save one object to the file.
+      #
+      def save_one( name )
+        ref = Gloo::Core::Pn.new( @engine, name )
+        obj = ref.resolve
+
+        fs = find_file_storage( obj )
+        fs.save
+      end
+
+      #
+      # Load the object from the file.
+      #
+      def load( name )
+        pns = get_full_path_names name
+        return unless pns
+
+        pns.each do |pn|
+          @engine.log.debug "Load file(s) at: #{pn}"
+          fs = Gloo::Persist::FileStorage.new( @engine, pn )
+          fs.load
+          @maps << fs
+          @engine.event_manager.on_load fs.obj
+        end
+      end
+
+      # 
+      # The given object is unloading.
+      # Do any necessary clean up here.
+      # 
+      def unload( obj )
+        @maps.each_with_index do |o, i|
+          if o.obj.pn === obj.pn
+            @maps.delete_at( i )
+            return
+          end
+        end
+      end
+
+      # 
+      # Reload all objects.
+      # 
+      def reload_all
+        return unless @maps
+        
+        @maps.each do |fs|
+          @engine.heap.unload fs.obj
+          fs.load
+        end
+      end
+
+      # 
+      # Re-load the given object from file.
+      # 
+      def reload( obj )
+        fs = find_file_storage( obj )
+        return unless fs
+
+        @engine.heap.unload obj
+        fs.load
+      end
+
+      # 
+      # Find the objects FileStorage in the list.
+      # 
+      def find_file_storage( obj )
+        @maps.each do |o|
+          return o if ( o.obj.pn === obj.pn )
+        end
+
+        # It was not found, so return nil.
+        return nil
+      end
+
+
+      #
+      # Get the full path and name of the file.
+      #
+      def get_full_path_names( name )
+        return nil if name.strip.empty?
+
+        if name.strip[ -1 ] == '*'
+          return @mech.get_all_files_in( name[ 0..-2 ] )
+        else
+          return @mech.expand( name )
+        end
+      end
+
+      #
+      # Check to see if a given path name refers to a gloo object file.
+      #
+      def gloo_file?( name )
+        return @mech.valid?( name )
+      end
+
+      #
+      # Get the default file extention.
+      #
+      def file_ext
+        return @mech.file_ext
+      end
+
+      #
+      # Print out all object - persistance mappings.
+      # This is a debugging tool.
+      #
+      def show_maps
+        @maps.each do |o|
+          puts " \t #{o.pn} \t #{o.obj.name}"
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo/utils/format.rb

@@ -0,0 +1,21 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Formatting utilities
+#
+
+module Gloo
+  module Utils
+    class Format
+
+      #
+      # Format number, adding comma separators.
+      # Ex: 1000 -> 1,000
+      #
+      def self.number( num )
+        return num.to_s.reverse.scan( /.{1,3}/ ).join( ',' ).reverse
+      end
+
+    end
+  end
+end

data/lib/gloo/utils/stats.rb

@@ -0,0 +1,206 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Utilities related to words (strings).
+#
+
+module Gloo
+  module Utils
+    class Stats
+
+      DIR_NOT_FOUND_ERR = 'The folder was not found!'.freeze
+
+      # ---------------------------------------------------------------------
+      #    Setup
+      # ---------------------------------------------------------------------
+
+      #
+      # Create a stats utility class for the given directory.
+      #
+      def initialize( engine, dir, types, skip = [] )
+        @engine = engine
+        @dir = dir
+        setup_loc types
+        @skip = skip
+      end
+
+      # ---------------------------------------------------------------------
+      #    Public Functions
+      # ---------------------------------------------------------------------
+
+      #
+      # Is the stats utility valid?
+      # Does it have a valid root directory.
+      #
+      def valid?
+        return true if @dir && File.directory?( @dir )
+
+        @engine.err DIR_NOT_FOUND_ERR
+        @engine.heap.it.set_to false
+
+        return false
+      end
+
+      #
+      # Show all stat data for the project.
+      #
+      def show_all
+        return unless valid?
+
+        generate
+        puts "Showing All stats for #{@dir}".white
+        puts "\n ** #{@dir_cnt} Total Folders ** "
+        puts " ** #{@file_cnt} Total Files ** "
+
+        busy_folders( 7 )
+        file_types
+        loc
+      end
+
+      #
+      # Get a list of the busiest folders.
+      # Count is how many results we want.
+      #
+      def busy_folders( count = 17 )
+        return unless valid?
+
+        generate
+        puts "\nBusy Folders:".yellow
+
+        @folders.sort! { |a, b| a[ :cnt ] <=> b[ :cnt ] }
+        @folders.reverse!
+        @folders[ 0..count ].each do |f|
+          puts "  #{f[ :cnt ]} - #{f[ :name ]}"
+        end
+      end
+
+      #
+      # Show file types and how many of each there are.
+      #
+      def file_types
+        return unless valid?
+
+        generate
+        puts "\nFiles by Type:".yellow
+
+        @types = @types.sort_by( &:last )
+        @types.reverse!
+        @types.each do |o|
+          puts "  #{o[ 1 ]} - #{o[ 0 ]}" unless o[ 0 ].empty?
+        end
+      end
+
+      #
+      # Show Lines of Code
+      #
+      def loc
+        return unless valid?
+
+        generate
+        total = 0
+
+        @loc.each do |k, v|
+          puts "\n #{k} Lines of Code".yellow
+          total += v[ :lines ]
+          formatted = Gloo::Utils::Format.number( v[ :lines ] )
+          puts " ** #{formatted} in #{v[ :files ].count} #{k} files ** "
+
+          puts "\n Busy #{k} files:".yellow
+          files = v[ :files ].sort! { |a, b| a[ :lines ] <=> b[ :lines ] }
+          files.reverse!
+          files[ 0..12 ].each do |f|
+            puts "  #{f[ :lines ]} - #{f[ :file ]}"
+          end
+        end
+
+        formatted = Gloo::Utils::Format.number( total )
+        puts "\n #{formatted} Total Lines of Code".white
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private Functions
+      # ---------------------------------------------------------------------
+
+      #
+      # Setup counters for lines of code by file type.
+      def setup_loc( types )
+        @loc = {}
+
+        types.split( ' ' ).each do |t|
+          @loc[ t ] = { lines: 0, files: [] }
+        end
+      end
+
+      #
+      # Generate stat data unless we've already done so.
+      #
+      def generate
+        return if @folders
+
+        @engine.log.debug 'Generating...'
+        @folders = []
+        @types = {}
+        @file_cnt = 0
+        @dir_cnt = 0
+
+        generate_for Pathname.new( @dir )
+      end
+
+      #
+      # Generate data for the given path.
+      # NOTE: this is a recursive function.
+      # It traverses all sub-direcctories.
+      #
+      def generate_for( path )
+        return if @skip.include?( File.basename( path ) )
+
+        cnt = 0
+        path.children.each do |f|
+          if f.directory?
+            @dir_cnt += 1
+            generate_for( f )
+          else
+            @file_cnt += 1
+            cnt += 1
+            handle_file( f )
+            inc_type( File.extname( f ) )
+          end
+        end
+        @folders << { name: path, cnt: cnt }
+      end
+
+      #
+      # Increment the file count.
+      #
+      def inc_type( type )
+        if @types[ type ]
+          @types[ type ] += 1
+        else
+          @types[ type ] = 1
+        end
+      end
+
+      #
+      # Consider code file types.
+      #
+      def handle_file( file )
+        ext = File.extname( file )
+        return unless ext
+
+        ext = ext[ 1..-1 ]
+        return unless @loc.key?( ext )
+
+        lines = count_lines( file )
+        @loc[ ext ][ :lines ] += lines
+        @loc[ ext ][ :files ] << { lines: lines, file: file }
+      end
+
+      #
+      # Count lines of code in file.
+      def count_lines( file )
+        return `wc -l #{file}`.split.first.to_i
+      end
+
+    end
+  end
+end

data/lib/gloo/utils/words.rb

@@ -0,0 +1,19 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Utilities related to words (strings).
+#
+
+require 'active_support/inflector'
+
+module Gloo
+  module Utils
+    class Words
+
+      def self.pluralize( word )
+        return word.pluralize
+      end
+
+    end
+  end
+end

data/lib/gloo/verbs/alert.rb

@@ -6,7 +6,7 @@
 
 module Gloo
   module Verbs
-    class Alert < GlooLang::Core::Verb
+    class Alert < Gloo::Core::Verb
 
       KEYWORD = 'alert'.freeze
       KEYWORD_SHORT = '!'.freeze
@@ -23,7 +23,7 @@ module Gloo
           return
         end
 
-        expr = GlooLang::Expr::Expression.new( @engine, @tokens.params )
+        expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
         result = expr.evaluate
 
         if result

data/lib/gloo/verbs/beep.rb

@@ -6,7 +6,7 @@
 
 module Gloo
   module Verbs
-    class Beep < GlooLang::Core::Verb
+    class Beep < Gloo::Core::Verb
 
       KEYWORD = 'beep'.freeze
       KEYWORD_SHORT = 'b'.freeze

data/lib/gloo/verbs/cls.rb

@@ -6,7 +6,7 @@
 
 module Gloo
   module Verbs
-    class Cls < GlooLang::Core::Verb
+    class Cls < Gloo::Core::Verb
 
       KEYWORD = 'cls'.freeze
       KEYWORD_SHORT = 'cls'.freeze

data/lib/gloo/verbs/context.rb

@@ -0,0 +1,62 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Set the current context pointer.
+# Alternatively if no value is provided, just show the context.
+#
+
+module Gloo
+  module Verbs
+    class Context < Gloo::Core::Verb
+
+      KEYWORD = 'context'.freeze
+      KEYWORD_SHORT = '@'.freeze
+
+      #
+      # Run the verb.
+      #
+      def run
+        set_context if @tokens.token_count > 1
+        show_context
+      end
+
+      #
+      # Show the current context.
+      #
+      def show_context
+        @engine.log.show "Context:  #{@engine.heap.context}"
+      end
+
+      #
+      # Get the Verb's keyword.
+      #
+      def self.keyword
+        return KEYWORD
+      end
+
+      #
+      # Get the Verb's keyword shortcut.
+      #
+      def self.keyword_shortcut
+        return KEYWORD_SHORT
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Set the context to the given path.
+      #
+      def set_context
+        path = @tokens.second
+        @engine.heap.context.set_to path
+        @engine.heap.it.set_to path
+        @engine.log.debug "Context set to #{@engine.heap.context}"
+      end
+
+    end
+  end
+end

data/lib/gloo/verbs/create.rb

@@ -0,0 +1,68 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Create an object, optionally of a type.
+#
+
+module Gloo
+  module Verbs
+    class Create < Gloo::Core::Verb
+
+      KEYWORD = 'create'.freeze
+      KEYWORD_SHORT = '`'.freeze
+      AS = 'as'.freeze
+      VAL = ':'.freeze
+      NO_NAME_ERR = 'Object name is missing!'.freeze
+
+      #
+      # Run the verb.
+      #
+      def run
+        name = @tokens.second
+        type = @tokens.after_token( AS )
+        value = @tokens.after_token( VAL )
+
+        unless name
+          @engine.err NO_NAME_ERR
+          return
+        end
+        create name, type, value
+      end
+
+      #
+      # Get the Verb's keyword.
+      #
+      def self.keyword
+        return KEYWORD
+      end
+
+      #
+      # Get the Verb's keyword shortcut.
+      #
+      def self.keyword_shortcut
+        return KEYWORD_SHORT
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Create an object with given name of given type with
+      # the given initial value.
+      #
+      def create( name, type, value )
+        if Gloo::Expr::LString.string?( value )
+          value = Gloo::Expr::LString.strip_quotes( value )
+        end
+        obj = @engine.factory.create( { name: name, type: type, value: value } )
+
+        obj.add_default_children if obj&.add_children_on_create?
+        @engine.heap.it.set_to value
+      end
+
+    end
+  end
+end

data/lib/gloo/verbs/execute.rb

@@ -0,0 +1,56 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Execute a shell command.
+#
+
+module Gloo
+  module Verbs
+    class Execute < Gloo::Core::Verb
+
+      KEYWORD = 'execute'.freeze
+      KEYWORD_SHORT = 'exec'.freeze
+      MISSING_EXPR_ERR = 'Missing Expression!'.freeze
+
+      #
+      # Run the verb.
+      #
+      def run
+        if @tokens.token_count < 2
+          @engine.err MISSING_EXPR_ERR
+          return
+        end
+
+        expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
+        cmd = expr.evaluate
+        @engine.log.debug "starting cmd: #{cmd}"
+
+        pid = fork { exec( cmd ) }
+        Process.wait pid
+
+        # pid = spawn cmd
+        # Process.wait pid
+        @engine.log.debug "done executing cmd: #{cmd}"
+
+        # system expr.evaluate  #, chdir: Dir.pwd
+        # `#{expr.evaluate}`
+        # exec expr.evaluate
+      end
+
+      #
+      # Get the Verb's keyword.
+      #
+      def self.keyword
+        return KEYWORD
+      end
+
+      #
+      # Get the Verb's keyword shortcut.
+      #
+      def self.keyword_shortcut
+        return KEYWORD_SHORT
+      end
+
+    end
+  end
+end

data/lib/gloo/verbs/files.rb

@@ -0,0 +1,49 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2022 Eric Crane.  All rights reserved.
+#
+# Show all the currently loaded files.
+#
+
+module Gloo
+  module Verbs
+    class Files < Gloo::Core::Verb
+
+      KEYWORD = 'files'.freeze
+      KEYWORD_SHORT = 'fs'.freeze
+
+      #
+      # Run the verb.
+      #
+      def run
+        return unless @engine.persist_man.maps
+        
+        @engine.persist_man.maps.each do |map|
+          # puts "#{map.obj.name} - #{map.pn}"
+          @engine.log.show "#{map.obj.name} - #{map.pn}"
+        end
+        @engine.heap.it.set_to @engine.persist_man.maps.count
+      end
+
+      #
+      # Get the Verb's keyword.
+      #
+      def self.keyword
+        return KEYWORD
+      end
+
+      #
+      # Get the Verb's keyword shortcut.
+      #
+      def self.keyword_shortcut
+        return KEYWORD_SHORT
+      end
+
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+    end
+  end
+end

data/lib/gloo/verbs/help.rb

@@ -6,7 +6,7 @@
 
 module Gloo
   module Verbs
-    class Help < GlooLang::Core::Verb
+    class Help < Gloo::Core::Verb
 
       KEYWORD = 'help'.freeze
       KEYWORD_SHORT = '?'.freeze