gloo 0.3.0

data/lib/gloo/core/script.rb

@@ -0,0 +1,37 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# A script to be run.
+#
+
+module Gloo
+  module Core
+    class Script
+      
+      # Set up the script.
+      def initialize obj
+        @obj = obj
+      end
+      
+      
+      # Run the script.
+      def run
+        if @obj.value.is_a? String
+          run_line @obj.value
+        elsif @obj.value.is_a? Array
+          @obj.value.each do |line|
+            run_line line
+          end
+        end
+      end
+      
+      # Run a single line of the script.
+      def run_line line
+        i = $engine.parser.parse_immediate line
+        return unless i
+        i.run
+      end
+      
+    end
+  end
+end

data/lib/gloo/core/tokens.rb

@@ -0,0 +1,123 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An ordered list of tokens.
+# The list of tokens makes up a command.
+#
+
+module Gloo
+  module Core
+    class Tokens
+      
+      attr_reader :cmd, :tokens
+      
+      # Set up the tokens.
+      def initialize( cmd_string )
+        @cmd = cmd_string
+        @tokens = []
+        tokenize @cmd
+      end
+      
+      # Create a list of token from the given string.
+      def tokenize str
+        if str.index( '"' )
+          i = str.index( '"' )
+          j = str.index( '"', i+1 )
+          j = str.length unless j
+          
+          tokenize( str[ 0..i-1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j+1..-1 ] ) if j+1 < str.length
+        elsif str.index( "'" )
+          i = str.index( "'" )
+          j = str.index( "'", i+1 )
+          j = str.length unless j
+
+          tokenize( str[ 0..i-1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j+1..-1 ] ) if j+1 < str.length
+        else
+          str.strip.split( " " ).each { |t| @tokens << t }
+        end
+      end
+      
+      # Get the number of tokens
+      def token_count
+        return @tokens.size
+      end
+      
+      # Get the verb (the first word)
+      def verb
+        return first
+      end
+
+      # Get all tokens except the first.
+      def params
+        return @tokens[ 1..-1 ]
+      end
+
+      # Get the first token.
+      def first
+        return @tokens.first if @tokens
+      end
+
+      # Get the last token.
+      def last
+        return @tokens.last if @tokens
+      end
+      
+      # Get the second token.
+      def second
+        return @tokens[1] if @tokens && @tokens.size > 0
+      end
+
+      def at index
+        return @tokens[index] if @tokens && @tokens.size >= index
+      end
+      
+      # Get the index of the given token.
+      def index_of token
+        return nil unless @tokens
+        return @tokens.find_index { |o| o.casecmp( token ) == 0 }
+      end
+
+      # Get the list of tokens after the given token
+      def tokens_after token
+        i = index_of token
+        if i && @tokens && @tokens.size > ( i+1 ) 
+          return @tokens[ i+1..-1 ]
+        end
+        return nil
+      end
+
+      # Get the expression after the given token
+      def expr_after token
+        str = ""
+        tokens_after( token ).each do |t|
+          str << " " if ( str.length > 0 )
+          str << "#{t}"
+        end
+        return str
+      end
+      
+      # Get the item after a given token.
+      def after_token token
+        i = index_of token
+        if i && @tokens && @tokens.size > ( i+1 ) 
+          return @tokens[ i+1 ]
+        end
+        return nil
+      end
+
+      # Get the item after a given token.
+      def before_token token
+        i = index_of token
+        if i && @tokens && @tokens.size >= ( i ) 
+          return @tokens[ 0..i-1 ]
+        end
+        return nil
+      end
+            
+    end
+  end
+end

data/lib/gloo/core/verb.rb

@@ -0,0 +1,63 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An abstract base verb.
+# Derives from the Baseo object.
+# It is a special type of object in that it can be run
+# and can perform an action.
+#
+
+module Gloo
+  module Core
+    class Verb < Baseo
+      
+			attr_reader :tokens, :params
+			
+      # Set up the verb.
+      def initialize( tokens, params=[] )
+        @tokens = tokens
+				@params = params
+      end
+      
+      # Register verbs when they are loaded.
+      def self.inherited( subclass )
+        Dictionary.instance.register_verb( subclass )
+      end
+      
+      # 
+      # Run the verb.
+      # 
+      # We'll mark the application as not running and let the
+      # engine stop gracefully next time through the loop.
+      # 
+      def run
+        raise 'this method should be overriden'
+      end
+      
+      # 
+      # Get the Verb's keyword.
+      # 
+      # The keyword will be in lower case only.
+      # It is used by the parser.
+      # 
+      def self.keyword
+        raise 'this method should be overriden'
+      end
+
+      # 
+      # Get the Verb's keyword shortcut.
+      # 
+      def self.keyword_shortcut
+        raise 'this method should be overriden'
+      end
+      
+      # 
+      # The object type, suitable for display.
+      # 
+      def type_display
+        return self.class.keyword
+      end
+
+    end
+  end
+end

data/lib/gloo/expr/expression.rb

@@ -0,0 +1,103 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Expression that can be evaluated.
+#
+
+module Gloo
+  module Expr
+    class Expression
+      
+      # Create the expression from a list of tokens.
+      def initialize tokens
+        @tokens = tokens
+        @symbols = []
+        @left = nil
+        @right = nil
+        @op = nil
+      end
+      
+      # Evaluate the expression and return the value.
+      def evaluate
+        identify_tokens
+        
+        @symbols.each do |sym|
+          if sym.is_a? Gloo::Core::Op
+            @op = sym
+          elsif @left == nil
+            @left = sym
+          else
+            @right = sym
+          end
+          
+          perform_op if @left && @right
+        end
+        
+        if @left.is_a? Gloo::Core::Literal 
+          return @left.value
+        elsif @left.is_a? Gloo::Core::Pn
+          return resolve_ref @left
+        else
+          return @left
+        end
+      end
+      
+      # Perform the operation.
+      def perform_op
+        @op = Gloo::Core::Op.default_op unless @op
+        l = evaluate_sym @left
+        r = evaluate_sym @right
+        @left = @op.perform l, r
+        @right = nil
+        @op = nil
+      end
+      
+      # Evaluate the symbol and get a simple value.
+      def evaluate_sym sym
+        if sym.is_a? Gloo::Core::Literal
+          return sym.value
+        elsif sym.is_a? Gloo::Core::Pn
+          return resolve_ref sym
+        else
+          return sym
+        end
+      end
+      
+      # resolve an object reference and get the value.
+      def resolve_ref ref
+				return ref.src if ref.is_color?
+
+        ob = ref.resolve
+        return ob.value if ob
+      end
+      
+      # Identify each token in the list.
+      def identify_tokens
+        @tokens.each do |o|
+          @symbols << identify_token( o )
+        end
+        
+        # @symbols.each do |o|
+        #   puts o.class.name
+        # end
+      end
+      
+      # 
+      # Identify the tokens and create appropriate symbols.
+      # 
+      def identify_token token
+        if Gloo::Core::Op.is_op?( token )
+          return Gloo::Core::Op.create_op( token )
+        end
+        
+        return LBoolean.new( token ) if LBoolean.is_boolean?( token )
+        return LInteger.new( token ) if LInteger.is_integer?( token )
+        return LString.new( token ) if LString.is_string?( token )
+        
+        # last chance: an Object reference
+        return Gloo::Core::Pn.new( token )
+      end
+      
+    end
+  end
+end

data/lib/gloo/expr/l_boolean.rb

@@ -0,0 +1,29 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Expression that can be evaluated.
+#
+
+module Gloo
+  module Expr
+    class LBoolean < Gloo::Core::Literal
+            
+      # Is the given token a boolean?
+      def self.is_boolean? token
+        return Gloo::Objs::Boolean.is_boolean? token
+      end
+      
+      # Set the value, converting to an boolean.
+      def set_value value
+        @value = Gloo::Objs::Boolean.coerse_to_bool value
+      end
+
+      # Get string representation
+      def to_s
+        return "false" unless @value
+        return @value.to_s
+      end
+
+    end
+  end
+end

data/lib/gloo/expr/l_integer.rb

@@ -0,0 +1,29 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Expression that can be evaluated.
+#
+
+module Gloo
+  module Expr
+    class LInteger < Gloo::Core::Literal
+            
+      # Is the given token an integer?
+      def self.is_integer? token
+        return true if token.is_a? Integer
+        s = token.strip
+        return s.to_i.to_s == s
+      end
+      
+      # Set the value, converting to an integer.
+      def set_value value
+        @value = value.to_i
+      end
+
+      def to_s
+        return self.value.to_s
+      end
+
+    end
+  end
+end

data/lib/gloo/expr/l_string.rb

@@ -0,0 +1,53 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# An Expression that can be evaluated.
+#
+
+module Gloo
+  module Expr
+    class LString < Gloo::Core::Literal
+            
+      # Set the value, triming opening and closing
+      # quotations if necessary.
+      def set_value value
+        @value = value
+        return unless value
+        @value = LString.strip_quotes( @value )
+      end
+      
+      # Is the given token a string?
+      def self.is_string? token
+        return false unless token.is_a? String
+        return true if token.start_with?( '"' )
+        return true if token.start_with?( "'" )
+        return false
+      end
+
+      # 
+      # Given a string with leading and trailing quotes,
+      # strip them out.
+      # 
+      def self.strip_quotes str
+        if str.start_with?( '"' )
+          str = str[ 1..-1 ]
+          if str.end_with?( '"' )
+            str = str[ 0..-2 ]
+          end
+          return str
+        elsif str.start_with?( "'" )
+          str = str[ 1..-1 ]
+          if str.end_with?( "'" )
+            str = str[ 0..-2 ]
+          end
+          return str
+        end
+      end
+            
+      def to_s
+        return self.value
+      end
+      
+    end
+  end
+end

data/lib/gloo/expr/op_div.rb

@@ -0,0 +1,20 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2019 Eric Crane.  All rights reserved.
+#
+# Division operator.
+#
+
+module Gloo
+  module Expr
+    class OpDiv < Gloo::Core::Op
+
+      # Perform the operation and return the result.
+      def perform left, right
+        if left.is_a? Integer
+          return left / right.to_i
+        end
+      end
+      
+    end
+  end
+end