rubyless 0.3.5 → 0.4.0

data/.gitignore

@@ -0,0 +1,4 @@
+pkg
+rdoc
+*.gem
+coverage

data/History.txt

@@ -1,60 +1,75 @@
+== 0.4.0 2010-03-21
+
+* 4 major enhancement
+  * Parsing inheritance tree to get safe_method_type.
+  * Instance variable (ivar) support (declared as safe_methods).
+  * Added support for prepend variables to tranform methods like link("foo") to link(@node, "foo").
+  * Better handling of sub-types in signature matching.
+
+* 5 minor enhancements
+  * Moved files into a ruby_less directory to enable file auto-loading.
+  * Raises RubyLess::NoMethodError / RubyLess::SyntaxError instead of generic Error.
+  * Improved error reporting use method signature.
+  * Added 'safe_literal_class' to enable/disable ruby literals.
+  * Added 'RubyLess.translate_string' method.
+
 == 0.3.5 2009-11-08
 
 * 1 major enhancement
-  * added support for hash in signature: ['img', {'mode' => String, 'class' => String}]
+  * Added support for hash in signature: ['img', {'mode' => String, 'class' => String}].
 
 * 1 minor enhancement
-  * added 'disable_safe_read' method
+  * Added 'disable_safe_read' method.
 
 == 0.3.4 2009-11-05
 
 * 1 minor enhancement
-  * added 'safe_context' method
+  * Added 'safe_context' method.
 
 == 0.3.3 2009-10-26
 
 * 1 minor enhancement
-  * added support for symbols (only used with helper)
+  * Added support for symbols (only used with helper).
 
 == 0.3.2 2009-10-15
 
 * 1 minor enhancement
-  * removed 'ruby-debug' require
+  * Removed 'ruby-debug' require.
 
 == 0.3.1 2009-10-07
 
 * 3 major enhancements
-  * method name in signatures should always be a string
-  * type[:method] is always set and is always a string
-  * fixed how class type is guessed from ActiveRecord column
+  * Method name in signatures should always be a string.
+  * Type[:method] is always set and is always a string.
+  * Fixed how class type is guessed from ActiveRecord column.
 
 * 1 minor enhancement
-  * added 'safe_read' method to objects
+  * Added 'safe_read' method to objects.
 
 == 0.3.1 2009-10-03
 
 * 1 major enhancement
-  * Moved from ParseTree to RubyParser
+  * Moved from ParseTree to RubyParser.
 
 * 1 minor enhancement:
-  * Using Mr Bones to generate gems
+  * Using Mr Bones to generate gems.
 
 == 0.2.1 2009-07-01
 
 * 2 minor enhancements:
-  * :[] method is now treated as in conventional ruby (foo[:bar], not foo.[](:bar))
-  * Better error reporting in case of signature mismatch
+  * :[] method is now treated as in conventional ruby (foo[:bar], not foo.[](:bar)).
+  * Better error reporting in case of signature mismatch.
 
 == 0.2.0 2009-06-02
 
 * 1 major enhancement:
-  * Added support for ActiveRecord attributes
+  * Added support for ActiveRecord attributes.
 
 * 2 minor enhancements:
   * Better documentation
-  * Removed eval (this means safe methods are globally declared)
+  * Removed eval (this means safe methods are globally declared).
 
 == 0.1.0 2009-06-02
 
 * 1 major enhancement:
-  * Initial alpha release
+  * Initial alpha release.

data/{README.txt → README.rdoc}

@@ -50,16 +50,16 @@ Or you can group all declarations in a single place with 'safe_method_for':
 You can now parse some ruby code:
 
  RubyLess.translate("!prev.ancestor?(main) && !node.ancestor?(main)", self)
- => "(not previous.ancestor?(@node) and not var1.ancestor?(@node))"
+ => "(not previous.ancestor?(@node) and not node.ancestor?(@node))"
 
  RubyLess.translate("id > 45 and (3 > -id or 3+3)", self)
- => "(var1.zip>45 and ((3>-var1.zip) or (3+3)))"
+ => "(node.zip>45 and ((3>-node.zip) or (3+3)))"
 
  RubyLess.translate("strftime(now, '%Y')", self)
  => "strftime(Time.now, \"%Y\")"
 
  RubyLess.translate("log_info(spouse, spouse.name)", self)
- => "(var1.spouse ? log_info(var1.spouse, var1.spouse.name) : nil)"
+ => "(node.spouse ? log_info(node.spouse, node.spouse.name) : nil)"
 
 You can look at the tests for an idea of how to declare things. If you have more questions, ask on zena's mailing list:
 

data/Rakefile

@@ -1,48 +1,59 @@
-require "rubygems"
-require "rake/rdoctask"
+require 'rubygems'
+require 'rake'
 
-task :default => :test
+require(File.join(File.dirname(__FILE__), 'lib/ruby_less/info'))
 
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = RubyLess::VERSION
+    gem.name = "rubyless"
+    gem.summary = %Q{RubyLess is an interpreter for "safe ruby"}
+    gem.description = %Q{RubyLess is an interpreter for "safe ruby". The idea is to transform some "unsafe" ruby code into safe, type checked ruby, eventually rewriting some variables or methods.}
+    gem.email = "gaspard@teti.ch"
+    gem.homepage = "http://zenadmin.org/546"
+    gem.authors = ["Gaspard Bucher"]
+    gem.add_dependency 'ruby_parser', '>= 2.0.4'
+    gem.add_dependency 'sexp_processor', '>= 3.0.1'
+    gem.add_development_dependency "shoulda", ">= 0"
+    gem.add_development_dependency "yamltest", ">= 0.5.3"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
-
-# BONES gem management
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
 
 begin
-  require 'bones'
-  Bones.setup
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
 rescue LoadError
-  begin
-    load 'tasks/setup.rb'
-  rescue LoadError
-    raise RuntimeError, '### please install the "bones" gem ###'
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
   end
 end
 
-ensure_in_path 'lib'
-require 'rubyless'
-
-PROJ.name = 'rubyless'
-PROJ.authors = 'Gaspard Bucher'
-PROJ.email = 'gaspard@teti.ch'
-PROJ.url = 'http://zenadmin.org/546'
-PROJ.version = RubyLess::VERSION
-PROJ.rubyforge.name = 'rubyless'
-
-PROJ.spec.opts << '--color'
-PROJ.gem.files = (
-  ['History.txt', 'README.txt', 'Rakefile', 'rubyless.gemspec'] +
-  ['lib', 'test'].map do |d|
-    Dir.glob("#{d}/**/*").reject {|path| File.basename(path) =~ /^\./ }
-  end
-).flatten
+task :test => :check_dependencies
 
-PROJ.gem.dependencies << ['ruby_parser', '>= 2.0.4']
-PROJ.gem.dependencies << ['sexp_processor', '>= 3.0.1']
-PROJ.gem.development_dependencies << ['yamltest', '>= 0.5.3']
+task :default => :test
 
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubyless #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/ruby_less/basic_types.rb

@@ -0,0 +1,15 @@
+require 'ruby_less/safe_class'
+
+
+class Boolean
+end
+
+class Number
+end
+
+RubyLess::SafeClass.safe_literal_class Fixnum => Number, Float => Number, Symbol => Symbol, Regexp => Regexp
+RubyLess::SafeClass.safe_method_for( Number,
+  [:==, Number] => Boolean, [:< , Number] => Boolean, [:> , Number] => Boolean,
+  [:<=, Number] => Boolean, [:>=, Number] => Boolean, [:- , Number] => Number,
+  [:+ , Number] => Number,  [:* , Number] => Number,  [:/ , Number] => Number,
+  [:% , Number] => Number,  [:"-@"]       => Number )

data/lib/ruby_less/error.rb

@@ -0,0 +1,4 @@
+module RubyLess
+  class Error < Exception
+  end
+end

data/lib/ruby_less/info.rb

@@ -0,0 +1,3 @@
+module RubyLess
+  VERSION = '0.4.0'
+end

data/lib/ruby_less/no_method_error.rb

@@ -0,0 +1,47 @@
+module RubyLess
+  class NoMethodError < RubyLess::Error
+    attr_reader :receiver, :klass, :signature
+
+    def initialize(receiver, klass, signature)
+      @receiver = receiver
+      @klass = klass
+      @signature = signature
+    end
+
+    def message
+      "#{receiver_with_class}: #{error_message} '#{method_with_arguments}'."
+    end
+
+    def error_message
+      if ivar?
+        "unknown instance variable"
+      else
+        "unknown method"
+      end
+    end
+
+    def receiver_with_class
+      @receiver ? "#{@receiver} (#{@klass})" : "(#{@klass.class})"
+    end
+
+    def method_with_arguments
+      method = @signature.first
+      signature = @signature[1..-1]
+      return method if ivar?
+      if signature.size == 0
+        arguments = ''
+      else
+        arguments = signature.map{|s| s.kind_of?(Class) ? s.to_s : s.inspect}.join(', ')
+        if signature.size == 1 && (signature.first.kind_of?(Array) || signature.first.kind_of?(Hash))
+          arguments = arguments[1..-2]
+        end
+      end
+      "#{method}(#{arguments})"
+    end
+
+    def ivar?
+      @signature.first =~ /\A@/
+    end
+
+  end
+end

data/lib/{processor.rb → ruby_less/processor.rb}

@@ -2,10 +2,6 @@ require 'rubygems'
 require 'ruby_parser'
 require 'sexp_processor'
 
-require 'basic_types'
-require 'typed_string'
-require 'safe_class'
-
 module RubyLess
   class RubyLessProcessor < SexpProcessor
     attr_reader :ruby
@@ -27,11 +23,18 @@ module RubyLess
       self.expected = TypedString
     end
 
-    #def process(exp)
-    #  return nil if exp.nil?
-    #  method = exp.shift
-    #  send("process_#{method}", exp)
-    #end
+    def process(exp)
+      super
+    rescue UnknownNodeError => err
+      if err.message =~ /Unknown node-type :(.*?) /
+        raise RubyLess::SyntaxError.new("'#{$1}' not available in RubyLess.")
+      else
+        raise RubyLess::SyntaxError.new(err.message)
+      end
+      # return nil if exp.nil?
+      # method = exp.shift
+      # send("process_#{method}", exp)
+    end
 
     def process_and(exp)
       t "(#{process(exp.shift)} and #{process(exp.shift)})", Boolean
@@ -51,9 +54,9 @@ module RubyLess
       false_res = process(exp.shift)
 
       if true_res && false_res && true_res.klass != false_res.klass
-        raise "Error in conditional expression: '#{true_res}' and '#{false_res}' do not return results of same type (#{true_res.klass} != #{false_res.klass})."
+        raise RubyLess::SyntaxError.new("Error in conditional expression: '#{true_res}' and '#{false_res}' do not return results of same type (#{true_res.klass} != #{false_res.klass}).")
       end
-      raise "Error in conditional expression." unless true_res || false_res
+      raise RubyLess::SyntaxError.new("Error in conditional expression.") unless true_res || false_res
       opts = {}
       opts[:nil] = true_res.nil? || true_res.could_be_nil? || false_res.nil? || false_res.could_be_nil?
       opts[:class] = true_res ? true_res.klass : false_res.klass
@@ -90,15 +93,18 @@ module RubyLess
     def process_vcall(exp)
       var_name = exp.shift
       unless opts = get_method([var_name], @helper, false)
-        raise "Unknown variable or method '#{var_name}'."
+        raise RubyLess::NoMethodError.new("Unknown variable or method '#{var_name}'.")
       end
       method = opts[:method]
+      if args = opts[:prepend_args]
+        method = "#{method}(#{args.raw})"
+      end
       t method, opts
     end
 
     def process_lit(exp)
       lit = exp.shift
-      t lit.inspect, lit.class == Symbol ? Symbol : Number
+      t lit.inspect, get_lit_class(lit.class)
     end
 
     def process_str(exp)
@@ -130,13 +136,17 @@ module RubyLess
           klass[key] = rhs.klass
         else
           # ERROR: invalid key
-          raise "Invalid key type for hash (should be a literal value, was #{key.first.inspect})"
+          raise RubyLess::SyntaxError.new("Invalid key type for hash (should be a literal value, was #{key.first.inspect})")
         end
       end
 
       t "{#{result.join(', ')}}", :class => klass
     end
 
+    def process_ivar(exp)
+      method_call(nil, exp)
+    end
+
     private
       def t(content, opts = nil)
         if opts.nil?
@@ -174,14 +184,15 @@ module RubyLess
         if arg_sexp
           args = process(arg_sexp)
           if args == ''
+            args = nil
             signature = [method]
           else
             signature = [method] + [args.klass].flatten
           end
           # execution conditional
-          cond = args.cond || []
+          cond = args ? (args.cond || []) : []
         else
-          args = []
+          args = nil
           signature = [method]
           cond = []
         end
@@ -190,7 +201,7 @@ module RubyLess
           if receiver.could_be_nil?
             cond += receiver.cond
           end
-          raise "'#{receiver}' does not respond to '#{method}(#{signature[1..-1].join(', ')})'." unless opts = get_method(signature, receiver.klass)
+          opts = get_method(receiver, signature)
           method = opts[:method]
           if method == '/'
             t_if cond, "(#{receiver.raw}#{method}#{args.raw} rescue nil)", opts.merge(:nil => true)
@@ -201,13 +212,15 @@ module RubyLess
           elsif method == '[]'
             t_if cond, "#{receiver.raw}[#{args.raw}]", opts
           else
-            args = "(#{args.raw})" if args != ''
+            args = args_with_prepend(args, opts)
+            args = "(#{args.raw})" if args
             t_if cond, "#{receiver.raw}.#{method}#{args}", opts
           end
         else
-          raise "Unknown method '#{method}(#{args.raw})'." unless opts = get_method(signature, @helper, false)
+          opts = get_method(nil, signature)
           method = opts[:method]
-          args = "(#{args.raw})" if args != ''
+          args = args_with_prepend(args, opts)
+          args = "(#{args.raw})" if args
           t_if cond, "#{method}#{args}", opts
         end
       end
@@ -232,11 +245,37 @@ module RubyLess
         res
       end
 
-      def get_method(signature, receiver, is_method = true)
-        type = receiver.respond_to?(:safe_method_type) ? receiver.safe_method_type(signature) : SafeClass.safe_method_type_for(receiver, signature)
-        return nil if !type || type[:class].kind_of?(Symbol) # we cannot send: no object.
+      def get_method(receiver, signature)
+        klass = receiver ? receiver.klass : @helper
+
+        type = klass.respond_to?(:safe_method_type) ? klass.safe_method_type(signature) : SafeClass.safe_method_type_for(klass, signature)
+
+        if type.nil?
+          # We try to match with the superclass of the arguments
+        end
+        raise RubyLess::NoMethodError.new(receiver, klass, signature) if !type || type[:class].kind_of?(Symbol) # we cannot send: no object.
 
         type[:class].kind_of?(Proc) ? type[:class].call(@helper, signature) : type
       end
+
+      def get_lit_class(klass)
+        unless lit_class = RubyLess::SafeClass.literal_class_for(klass)
+          raise RubyLess::SyntaxError.new("#{klass} literal not supported by RubyLess.")
+        end
+        lit_class
+      end
+
+      def args_with_prepend(args, opts)
+        if prepend_args = opts[:prepend_args]
+          if args
+            prepend_args.append_argument(args)
+            prepend_args
+          else
+            prepend_args
+          end
+        else
+          args
+        end
+      end
   end
 end

data/lib/{safe_class.rb → ruby_less/safe_class.rb}

@@ -1,52 +1,51 @@
 module RubyLess
   module SafeClass
-    @@_safe_methods     ||= {} # defined for each class
-    @@_safe_methods_all ||= {} # full list with inherited attributes
+    @@_safe_methods         ||= {} # defined for each class
+    @@_safe_methods_parsed  ||= {} # full list with inherited attributes
+    @@_safe_literal_classes ||= {}
 
     # List of safe methods for a specific class.
     def self.safe_methods_for(klass)
-      @@_safe_methods_all[klass] ||= build_safe_methods_list(klass)
+      # Caching safe_methods_all is bad when modules are dynamically added / removed.
+      @@_safe_methods_parsed[klass] ||= build_safe_methods_list(klass)
     end
 
     # Return method type (options) if the given signature is a safe method for the class.
     def self.safe_method_type_for(klass, signature)
-      if type = safe_methods_for(klass)[signature]
-        type
-      else
-        # Signature might be ['name', {:mode => String, :type => Number}].
-
-        # Replace all hashes in signature by Hash class and check for arguments
-        signature_args = []
-        signature = signature.map do |s|
-          if s.kind_of?(Hash)
-            signature_args << s
-            Hash
-          else
-            signature_args << nil
-            s
-          end
-        end
-
-        if type = safe_methods_for(klass)[signature]
-          unless allowed_args = type[:hash_args]
-            # All arguments allowed
-            return type
-          end
+      # Signature might be ['name', {:mode => String, :type => Number}].
+      # build signature arguments
 
-          # Verify arguments
-          signature_args.each_with_index do |args, i|
-            next unless args
-            # verify for each position: ({:a => 3}, {:x => :y})
-            return nil unless allowed_args_for_position = allowed_args[i]
-            args.each do |k,v|
-              return nil unless allowed_args_for_position[k] == v
-            end
-          end
-          type
+      # Replace all hashes in signature by Hash class and check for arguments
+      signature_args = []
+      signature = signature.map do |s|
+        if s.kind_of?(Hash)
+          signature_args << s
+          Hash
         else
-          nil
+          signature_args << nil
+          s
+        end
+      end
+      # Find safe method in all ancestry
+      klass.ancestors.each do |ancestor|
+        return nil if ancestor == RubyLess::SafeClass
+        if type = safe_method_with_hash_args(ancestor, signature, signature_args)
+          return type
         end
       end
+      nil
+    end
+
+    def self.literal_class_for(klass)
+      @@_safe_literal_classes[klass]
+    end
+
+    def self.safe_literal_class(hash)
+      @@_safe_literal_classes.merge!(hash)
+    end
+
+    def self.all_safe_methods
+      @@_safe_methods
     end
 
     # Declare a safe method for a given class ( same as #safe_method)
@@ -107,6 +106,10 @@ module RubyLess
           safe_method(methods_hash)
         end
 
+        def self.safe_literal_class(hash)
+          RubyLess::SafeClass.safe_literal_class(hash)
+        end
+
         # Declare a safe method to access a list of attributes.
         # This method should only be used when the class is linked with a database table and provides
         # proper introspection to detect types and the possibility of NULL values.
@@ -129,6 +132,30 @@ module RubyLess
           end
         end
 
+        # Declare a safe method to access a list of properties.
+        # This method should only be used in conjunction with the Property gem.
+        def self.safe_property(*properties)
+          columns = schema.columns
+          properties.each do |att|
+            if col = columns[att.to_s]
+              opts = {}
+              opts[:nil]   = col.default.nil?
+              if col.number?
+                opts[:class] = Number
+              elsif col.text?
+                opts[:class] = String
+              else
+                opts[:class] = col.klass
+              end
+              opts[:method] = "prop['#{att.to_s.gsub("'",'')}']"
+              safe_method att.to_sym => opts
+            else
+              puts "Warning: could not declare safe_property '#{att}' (No property column with this name found in class #{self})"
+            end
+          end
+        end
+
+
         # Declare a safe method for a given class
         def self.safe_method_for(klass, signature)
           SafeClass.safe_method_for(klass, signature)
@@ -160,7 +187,7 @@ module RubyLess
 
     # Return the type if the given signature corresponds to a safe method for the object's class.
     def safe_method_type(signature)
-      if type = self.class.safe_method_type(signature)
+      if type = SafeClass.safe_method_type_for(self.class, signature)
         type[:class].kind_of?(Symbol) ? self.send(type[:class], signature) : type
       end
     end
@@ -190,7 +217,7 @@ module RubyLess
       end
 
       def self.build_safe_methods_list(klass)
-        list = klass.superclass.respond_to?(:safe_methods) ? klass.superclass.safe_methods : {}
+        list = SignatureHash.new
         (@@_safe_methods[klass] || {}).map do |signature, return_value|
           if return_value.kind_of?(Hash)
             return_value[:class] = parse_class(return_value[:class])
@@ -221,5 +248,27 @@ module RubyLess
           end
         end
       end
+
+      def self.safe_method_with_hash_args(klass, signature, hash_args)
+        if type = safe_methods_for(klass)[signature]
+          unless allowed_args = type[:hash_args]
+            # All arguments allowed
+            return type
+          end
+
+          # Verify arguments
+          hash_args.each_with_index do |args, i|
+            next unless args
+            # verify for each position: ({:a => 3}, {:x => :y})
+            return nil unless allowed_args_for_position = allowed_args[i]
+            args.each do |k,v|
+              return nil unless v.ancestors.include?(allowed_args_for_position[k])
+            end
+          end
+          type
+        else
+          nil
+        end
+      end
   end
 end

data/lib/ruby_less/signature_hash.rb

@@ -0,0 +1,33 @@
+
+module RubyLess
+  class SignatureHash < Hash
+    alias get []
+
+    def [](signature)
+      if type = get(signature)
+        # fastest: all keys are equal
+        return type
+      elsif signature.kind_of?(Array)
+        size = signature.size
+        ancestors = signature.map {|k| k.kind_of?(Class) ? k.ancestors : [k]}
+
+        each do |key, type|
+          next unless key.size == size
+          ok = true
+          key.each_with_index do |k, i|
+            if !ancestors[i].include?(k)
+              ok = false
+              break
+            end
+          end
+          if ok
+            # insert in cache
+            self[signature] = type
+            return type
+          end
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/ruby_less/syntax_error.rb

@@ -0,0 +1,4 @@
+module RubyLess
+  class SyntaxError < RubyLess::Error
+  end
+end