rVM 0.0.10 → 0.0.11

data/lib/rake/helpers/code_statistics.rb

@@ -0,0 +1,167 @@
+# From rails (http://rubyonrails.com)
+#
+# Improved by murphy
+class CodeStatistics
+
+  TEST_TYPES = /\btest/i
+
+  # Create a new Code Statistic.
+  #
+  # Rakefile Example:
+  #
+  #  desc 'Report code statistics (LOC) from the application'
+  #  task :stats => :copy_files do
+  #    require 'rake_helpers/code_statistics'
+  #    CodeStatistics.new(
+  #      ["Main", "lib"],
+  #      ["Tests", "test"],
+  #      ["Demos", "demo"]
+  #    ).to_s
+  #   end
+  def initialize(*pairs)
+    @pairs = pairs
+    @statistics = calculate_statistics
+    @total = if pairs.empty? then nil else calculate_total end
+  end
+
+  # Print a textual table viewing the stats
+  #
+  # Intended for console output.
+  def print
+    print_header
+    @pairs.each { |name, path| print_line name, @statistics[name] }
+    print_splitter
+
+    if @total
+      print_line 'Total', @total
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+private
+
+  DEFAULT_FILE_PATTERN = /\.rb$/
+
+  def calculate_statistics
+    @pairs.inject({}) do |stats, (name, path, pattern, is_ruby_code)|
+      pattern ||= DEFAULT_FILE_PATTERN
+      path = File.join path, '*.rb'
+      stats[name] = calculate_directory_statistics path, pattern, is_ruby_code
+      stats
+    end
+  end
+
+  def calculate_directory_statistics directory, pattern = DEFAULT_FILE_PATTERN, is_ruby_code = true
+    is_ruby_code = true if is_ruby_code.nil?
+    stats = Hash.new 0
+
+    Dir[directory].each do |file_name|
+      puts "Scanning #{file_name}..." if $DEBUG
+      next unless file_name =~ pattern
+
+      lines = codelines = classes = modules = methods = 0
+      empty_lines = comment_lines = 0
+      in_comment_block = false
+
+      File.readlines(file_name).each do |line|
+        lines += 1
+        if line[/^\s*$/]
+          empty_lines += 1
+        elsif is_ruby_code
+          case line
+          when /^=end\b/
+            comment_lines += 1
+            in_comment_block = false
+          when in_comment_block
+            comment_lines += 1
+          when /^\s*class\b/: classes += 1
+          when /^\s*module\b/: modules += 1
+          when /^\s*def\b/: methods += 1
+          when /^\s*#/: comment_lines += 1
+          when /^=begin\b/
+            in_comment_block = false
+            comment_lines += 1
+          when /^__END__$/
+            in_comment_block = true
+          end
+        end
+      end
+
+      codelines = lines - comment_lines - empty_lines
+
+      stats[:lines] += lines
+      stats[:comments] += comment_lines
+      stats[:codelines] += codelines
+      stats[:classes] += classes
+      stats[:modules] += modules
+      stats[:methods] += methods
+      stats[:files] += 1
+    end
+
+    stats
+  end
+
+  def calculate_total
+    total = Hash.new 0
+    @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+    total
+  end
+
+  def calculate_code
+    code_loc = 0
+    @statistics.each { |k, v| code_loc += v[:codelines] unless k[TEST_TYPES] }
+    code_loc
+  end
+
+  def calculate_tests
+    test_loc = 0
+    @statistics.each { |k, v| test_loc += v[:codelines] if k[TEST_TYPES] }
+    test_loc
+  end
+
+  def print_header
+    print_splitter
+    puts "| T=Test  Name              | Files | Lines |   LOC | Comments | Classes | Modules | Methods | M/C | LOC/M |"
+    print_splitter
+  end
+
+  def print_splitter
+    puts "+---------------------------+-------+-------+-------+----------+---------+---------+---------+-----+-------+"
+  end
+
+  def print_line name, statistics
+    m_over_c = (statistics[:methods] / (statistics[:classes] + statistics[:modules])) rescue m_over_c = 0
+    loc_over_m = (statistics[:codelines] / statistics[:methods]) - 2 rescue loc_over_m = 0
+
+    if name[TEST_TYPES]
+      name = "T #{name}"
+    else
+      name = "  #{name}"
+    end
+
+    line = "| %-25s | %5d | %5d | %5d | %8d | %7d | %7d | %7d | %3d | %5d |" % (
+      [name, *statistics.values_at(:files, :lines, :codelines, :comments, :classes, :modules, :methods)] +
+      [m_over_c, loc_over_m] )
+
+    puts line
+  end
+
+  def print_code_test_stats
+    code = calculate_code
+    tests = calculate_tests
+
+    puts "  Code LOC = #{code}     Test LOC = #{tests}     Code:Test Ratio = [1 : #{sprintf("%.2f", tests.to_f/code)}]"
+    puts ""
+  end
+
+end
+
+# Run a test script.
+if $0 == __FILE__
+  $VERBOSE = true
+  CodeStatistics.new(
+    ['This dir', File.dirname(__FILE__)]
+  ).print
+end

data/lib/rvm/classes.rb

@@ -59,6 +59,10 @@ module RVM
         @variables ||= {:self => self, }
       end
       
+      def is_true?
+        true
+      end
+      
       # This defines the type of the class, it defaults to :any
       # it is important for tying and type conversion, as long as it
       # behaves like a string, it can look like a sting ;)

data/lib/rvm/classes/string.rb

@@ -59,6 +59,7 @@ module RVM
       end
       
       def + v
+        v = v.to_s if not v.is_a?(String)
         self.class.new(super(v))
       end
       

data/lib/rvm/functions/array.rb

@@ -1,3 +1,6 @@
 Dir[File.dirname(__FILE__) + '/array/*.rb'].each do |c|
   require c
+end
+Dir[File.dirname(__FILE__) + '/collection/*.rb'].each do |c|
+  require c
 end

data/lib/rvm/functions/array/set_at.rb

@@ -3,13 +3,9 @@ module RVM
     class SetAt < Function
       def SetAt.execute params, env
         if params.length == 3
-          p params
           array = params.shift
           pos = params.shift
           value = params.shift
-          p array
-          p pos
-          p value
           array[pos.to_i] = value
         else
           RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 3 ARGUMENTS BUT GOT #{params.length}")

data/lib/rvm/functions/collection/size.rb

@@ -7,12 +7,12 @@ module RVM
           RVM::Classes::Association
         ]
         def execute params, env
-          if COLLECTION_CLASSES.include?(this = env.read_var_val(:self)) and params.empty?
+          if COLLECTION_CLASSES.include?((this = env.read_var_val(:self)).class) and params.empty?
             RVM::Classes[:number].new(this.size)
           elsif params.length == 1
             RVM::Classes[:number].new(params[0].size)
           else
-            RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")
+            RVM::Classes[:error].new(1,"FUNCTION (#{self}) EXPECTS 1 or 0 ARGUMENTS BUT GOT #{params.length}")
           end
         end
         def signature

data/lib/rvm/functions/logic/and.rb

@@ -6,7 +6,7 @@ module RVM
         def execute params, env
           result = true
           while result and not params.empty?
-            result = result && params.shift.execute(env).is_true?
+            result = result && (v =  params.shift) && v.execute(env).is_true?
           end
           result
         end

data/lib/rvm/functions/logic/or.rb

@@ -4,8 +4,8 @@ module RVM
       class << self
         def execute params, env
           params.each do |p|
-            v =  p.execute(env)
-            return v if v.is_true?
+            
+            return v if p && (v =  p.execute(env)).is_true?
           end
           return RVM::Classes::Boolean.new(false)
         end

data/lib/rvm/interpreter.rb

@@ -9,6 +9,13 @@ module RVM
   #
   module Interpreter
     
+    
+    class Element
+      attr_accessor :pos
+      def initialize pos
+        @pos = pos
+      end
+    end
     # This is a helper fuctio to quickly generate a empty enviorment.
     def Interpreter.env aenv = {}
       RVM::debug "Interpreter.env" if $DEBUG
@@ -22,22 +29,8 @@ module RVM
       RVM::Interpreter::Constant.new(RVM::Classes[type].new(value), pos)
     end
     
-    
-    class VariableStorageCallback
-      def initialize obj, var, writable = true
-        @obj = obj
-        @get = var.to_sym
-        @set = "#{var}=".to_sym
-        @writable = writable
-      end
-      def val= v
-        @obj.send(@set,v) if @writable
-      end
-      def val
-        @obj.send(@get)
-      end
-    end
-    
+    # This class is used to store the variable content to allow chross refferencing
+    # and passing variables upwards through different scopes.
     class VariableStorage
       attr_accessor :val
       def initialize val = nil, writable = true, &block
@@ -50,6 +43,23 @@ module RVM
         @val = v if @writable
         @val
       end
+    end  
+    
+    # The callback storang is used to help publishing variables from a ruby
+    # class to the rVM, it will get and set the variables during runtime.
+    class VariableStorageCallback < VariableStorage
+      def initialize obj, var, writable = true
+        super(nil, writable)
+        @obj = obj
+        @get = var.to_sym
+        @set = "#{var}=".to_sym
+      end
+      def val= v
+        @obj.send(@set,v) if @writable
+      end
+      def val
+        @obj.send(@get)
+      end
     end
     
     # This class represents the enviroment, the memory so to say for the VM.
@@ -135,7 +145,7 @@ module RVM
       end
       # Defines a varialbe in the current scope, priviose variables are not
       # changed
-      def define k, v
+      def declare k, v
         @data[:locals][k] = VariableStorage.new(v)
       end
       
@@ -182,18 +192,18 @@ module RVM
     # is set to the object in which context we are!
     #
     # The class is stred in :class
-    class ObjectContext
+    class ObjectContext < Element
       def initialize object, code, pos = nil
+        super(pos)
         @object = object
         @code = code
-        @pos = pos
       end
       
       def execute env
         #The new 
         obj = @object.execute(env)
         new_env = Interpreter::Enviroment.new({:functions => obj.functions, :locals => obj.variables}, env)
-        new_env.define(:self, obj)
+        new_env.declare(:self, obj)
         @code.execute(new_env)
       end
     end
@@ -202,12 +212,12 @@ module RVM
     #This sets a funciton on a Class (to be included in its objects)
     #
     #To define class functions use ObjectContext and define the function normaly, nifty isn't it?
-    class SetClassFunction
+    class SetClassFunction < Element
       def initialize obj, name, function, pos = nil
+        super(pos)
         @object = obj
         @name = name
         @function = function
-        @pos = pos
       end
       
       def execute env
@@ -221,11 +231,11 @@ module RVM
     #
     # Blocks are mostly used to handle tasks as not interfeeing
     # With outer code.
-    class Block
+    class Block < Element
       attr_reader :content
       def initialize content, pos = nil
+        super(pos)
         @content = content
-        @pos = pos
       end
       
       # When executed a temporary enviroment is created with the passed
@@ -239,7 +249,7 @@ module RVM
     
     # This is a function definition used to write in the function libary
     #
-    class FunctionDefinition
+    class FunctionDefinition < Element
       
       # Initializes a new function definition
       #
@@ -254,10 +264,10 @@ module RVM
       #            replaced when it is called a second time.
       #            When false a exception is thrown
       def initialize name, body, override = true, pos = nil
+        super(pos)
         @name = name
         @body = body
         @override = override
-        @pos = pos
       end
       
       def execute env
@@ -265,14 +275,14 @@ module RVM
           raise "Function #{@name} already defined at #{@pos}!"
         end
         env.def_function(@name.execute(env),@body)
-        nil
+        @body
       end
     end
     
     
     # This is a loop. It is executed over and over again as long as
     # the passed condition evaluates to a value that matches is_true?.
-    class Loop 
+    class Loop < Element
       # Initializes a new loop.
       #
       # condition:: is executed before each run of the loop. If it evaluates
@@ -280,15 +290,17 @@ module RVM
       #             exection ends.
       # body::      For each itteration of the loop this is executed once.
       def initialize(condition, body, pos = nil)
+        super(pos)
         @condition = condition
         @body = body
-        @pos = pos
       end
       
       def execute env
+        r = nil
         while @condition.execute(env).is_true?
-          @body.execute(env)
+          r = @body.execute(env)
         end
+        r
       end
     end
     
@@ -296,11 +308,11 @@ module RVM
     # A constant, it evaluates to thevalue given and end the evaluation.
     # Meaning that no further execution is done in this tree branch, so the
     # value isn't evaluated.
-    class Constant
+    class Constant < Element
       attr_reader :value
       def initialize value, pos = nil
+        super(pos)
         @value = value
-        @pos = pos
       end
       
       def data_type
@@ -342,7 +354,7 @@ module RVM
     #   * execute for the true case is called and it's result returned
     # * if the result is false or is_true? is false:
     #   * execute is called for the false case and it's result is returned    
-    class Condition
+    class Condition < Element
       # Creates a new condition with the given parameters. The false_case can
       # be ommitted.
       #
@@ -351,10 +363,10 @@ module RVM
       #  * true_case - is only executed if value evalutes to true (is_true?)
       #  * false_case - is only executed if value evalutes to false (!is_true?)
       def initialize value, true_case, false_case = nil, pos = nil
+        super(pos)
         @value = value
         @true_case = true_case
         @false_case = false_case
-        @pos = pos
       end
       
       def data_type
@@ -382,11 +394,11 @@ module RVM
     #
     # Both the *name* and the *value* are evaluated before the assignment
     # is done.
-    class Assignment
+    class Assignment < Element
       def initialize name, value, pos = nil
+        super(pos)
         @name = name
         @value = value
-        @pos = pos
       end
       
       def data_type
@@ -399,14 +411,36 @@ module RVM
       end
     end
     
+    # A variable declarion that sets a local variable, it will redelcare 
+    # the variable if declared in a privouse scope.
+    #
+    # Both the *name* and the *value* are evaluated before the assignment
+    # is done.
+    class Declaration < Element
+      def initialize name, value, pos = nil
+        super(pos)
+        @name = name
+        @value = value
+      end
+      
+      def data_type
+        @value.data_type
+      end
+      
+      def execute env
+        RVM::debug "Executing Assignment at #{@pos}..." if $DEBUG
+        env.declare(@name.execute(env).to_s,@value.execute(env)).val
+      end
+    end    
+    
     # Reads the value of a variable in the enviroment.
     #
     # The *name* is evaluated before the variable is retrieved.  
-    class Variable
+    class Variable < Element
       def initialize name, pos = nil
+        super(pos)
         @name = name
         @type = :any
-        @pos = pos
       end
       
       # The type can only be tretrieved when the name is aconstant
@@ -429,11 +463,11 @@ module RVM
     
     # This evauates to the parameter passed to the function call.
     # The number of it is evaluated and typecasted to an interger.
-    class Parameter
+    class Parameter < Element
       def initialize num, pos = nil
+        super(pos)
         @num = num
         @type = :any
-        @pos = pos
       end
       
       # The type can only be tretrieved when the num is aconstant
@@ -454,6 +488,11 @@ module RVM
     # another.
     # The type of the squence is equal to the last element of the sequence.
     class Sequence < Array
+      attr_accessor :pos
+      def initialize src=[], pos = nil
+        super(src)
+        @pos = pos
+      end
       def execute env
         RVM::debug "Executing Sequence... #{inspect}" if $DEBUG
         r = nil
@@ -478,6 +517,7 @@ module RVM
     # The catching is handled bythe +RVM::Classes::Block+ class.
     class ReturnException < Exception
       attr_reader :val
+      attr_reader :pos
       def initialize val, pos = nil
         super()
         @val = val
@@ -488,10 +528,10 @@ module RVM
     # Represents the return statement, it throws a 
     # +ReturnException+ which can be caught to have the function
     # or block return what they wish.
-    class Return
+    class Return  < Element
       def initialize val, pos = nil
+        super(pos)
         @val = val
-        @pos = pos
       end
       
       def data_type
@@ -509,7 +549,7 @@ module RVM
     #
     # Arguments are only executed when the function does return true for 
     # execargs.
-    class FunctionCall
+    class FunctionCall < Element
       attr_reader :arguments
       attr_reader :function
       # The constructor. *function* can either be a block object or a function
@@ -517,9 +557,9 @@ module RVM
       #
       # Arguments is a list of the arguments to the function.
       def initialize function,  arguments, pos = nil
+        super(pos)
         @function = function
         @arguments = arguments
-        @pos = pos
       end
       
       def data_type