gloo-lang 0.9.2 → 0.9.5

data/lib/gloo_lang/persist/line_splitter.rb

@@ -0,0 +1,81 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Helper class used as part of file loading.
+# It is responsible for splitting a line into components.
+#
+
+module GlooLang
+  module Persist
+    class LineSplitter
+
+      BEGIN_BLOCK = 'BEGIN'.freeze
+      END_BLOCK = 'END'.freeze
+
+      attr_reader :obj
+
+      #
+      # Set up a line splitter
+      #
+      def initialize( line, tabs )
+        @line = line
+        @tabs = tabs
+      end
+
+      #
+      # Split the line into 3 parts.
+      #
+      def split
+        detect_name
+        detect_type
+        detect_value
+
+        return @name, @type, @value
+      end
+
+      #
+      # Detect the object name.
+      #
+      def detect_name
+        @line = @line.strip
+        @idx = @line.index( ' ' )
+        @name = @line[ 0..@idx - 1 ]
+      end
+
+      #
+      # Detect the object type.
+      #
+      def detect_type
+        @line = @line[ @idx + 1..-1 ]
+        @idx = @line.index( ' ' )
+
+        if @line[ 0 ] == ':'
+          @type = 'untyped'
+          return
+        end
+
+        @type = @line[ 0..( @idx ? @idx - 1 : -1 ) ]
+        @type = @type[ 1..-1 ] if @type[ 0 ] == '['
+        @type = @type[ 0..-2 ] if @type[ -1 ] == ']'
+      end
+
+      #
+      # Detect the object value.
+      # Use nil if there is no value specified.
+      #
+      def detect_value
+        if @idx
+          @value = @line[ @idx + 1..-1 ]
+          if @value[ 0..1 ] == ': '
+            @value = @value[ 2..-1 ]
+          elsif @value[ 0 ] == ':'
+            @value = @value[ 1..-1 ]
+          end
+        else
+          @value = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/gloo_lang/persist/persist_man.rb

@@ -0,0 +1,120 @@
+# 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 GlooLang
+  module Persist
+    class PersistMan
+
+      attr_reader :maps
+
+      #
+      # Contructor for the persistence manager.
+      #
+      def initialize
+        @maps = []
+      end
+
+      #
+      # Save one object to the file.
+      #
+      def save( name = '' )
+        if name.nil? || name.strip.empty?
+          save_all
+        else
+          save_one name
+        end
+      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 = GlooLang::Core::Pn.new name
+        obj = ref.resolve
+        pn = get_full_path_name name
+        fs = GlooLang::Persist::FileStorage.new( pn, 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|
+          $log.debug "Load file(s) at: #{pn}"
+          fs = GlooLang::Persist::FileStorage.new( pn )
+          fs.load
+          @maps << fs
+          $engine.event_manager.on_load fs.obj
+        end
+      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 ] == '*'
+          pns = []
+          dir = File.join( $settings.project_path, name[ 0..-2 ] )
+          Dir.glob( "#{dir}*.gloo" ).each do |f|
+            pns << f
+          end
+          return pns
+        else
+          ext_path = File.expand_path( name )
+          return [ ext_path ] if self.gloo_file?( ext_path )
+
+          full_name = "#{name}#{file_ext}"
+          return [ File.join( $settings.project_path, full_name ) ]
+        end
+      end
+
+      #
+      # Check to see if a given path name refers to a gloo object file.
+      #
+      def gloo_file?( name )
+        return false unless name
+        return false unless File.exist?( name )
+        return false unless File.file?( name )
+        return false unless name.end_with?( self.file_ext )
+
+        return true
+      end
+
+      #
+      # Get the default file extention.
+      #
+      def file_ext
+        return '.gloo'
+      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_lang/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 GlooLang
+  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_lang/utils/stats.rb

@@ -0,0 +1,205 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# Utilities related to words (strings).
+#
+
+module GlooLang
+  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( dir, types, skip = [] )
+        @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 = GlooLang::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 = GlooLang::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
+
+        $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_lang/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 GlooLang
+  module Utils
+    class Words
+
+      def self.pluralize( word )
+        return word.pluralize
+      end
+
+    end
+  end
+end

data/lib/gloo_lang/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 GlooLang
+  module Verbs
+    class Context < GlooLang::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
+        $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
+        $log.debug "Context set to #{$engine.heap.context}"
+      end
+
+    end
+  end
+end

data/lib/gloo_lang/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 GlooLang
+  module Verbs
+    class Create < GlooLang::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 GlooLang::Expr::LString.string?( value )
+          value = GlooLang::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_lang/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 GlooLang
+  module Verbs
+    class Execute < GlooLang::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 = GlooLang::Expr::Expression.new( @tokens.params )
+        cmd = expr.evaluate
+        $log.debug "starting cmd: #{cmd}"
+
+        pid = fork { exec( cmd ) }
+        Process.wait pid
+
+        # pid = spawn cmd
+        # Process.wait pid
+        $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