rubyless 0.8.0 → 0.8.1

data/History.txt

@@ -1,3 +1,12 @@
+== 0.8.1 2011-01-15
+
+* Major enhancements
+  * Added support for Array method on list types.
+  * Changed API for Proc types (we now send 'helper, this, args').
+  * Passing receiver on pre_processor resolution.
+  * Enable receiver rewrite.
+  * Added support for pre-processing on elements that can be nil.
+
 == 0.8.0 2010-11-15
 
 * Major enhancements

data/lib/ruby_less.rb

@@ -28,6 +28,8 @@ module RubyLess
     if err.kind_of?(RubyLess::Error)
       raise err
     else
+      #puts err
+      #puts err.backtrace
       raise RubyLess::Error.new("Error parsing \"#{string}\": #{err.message.strip}")
     end
   end

data/lib/ruby_less/basic_types.rb

@@ -35,3 +35,7 @@ RubyLess::SafeClass.safe_method_for( NilClass,
   [:==, String] => Boolean,
   [:==, Number] => Boolean
 )
+
+RubyLess::SafeClass.safe_method_for( Array,
+  :size => Number
+)

data/lib/ruby_less/info.rb

@@ -1,3 +1,3 @@
 module RubyLess
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 end

data/lib/ruby_less/processor.rb

@@ -119,7 +119,7 @@ module RubyLess
       end
 
       res.opts[:class] = Array
-      res.opts[:array_content_class] = content_class
+      res.opts[:elem] = content_class
       t "[#{list * ','}]", res.opts.merge(:literal => nil)
     end
 
@@ -229,17 +229,26 @@ module RubyLess
           cond = []
         end
 
+        opts = get_method(receiver, signature)
+
+        # method type can rewrite receiver
+        if opts[:receiver]
+          if receiver
+            receiver = "#{receiver}.#{opts[:receiver]}"
+          else
+            receiver = opts[:receiver]
+          end
+        end
+
         if receiver
-          opts = get_method(receiver, signature)
           method_call_with_receiver(receiver, args, opts, cond, signature)
         else
-          opts = get_method(nil, signature)
           method = opts[:method]
           args = args_with_prepend(args, opts)
 
           if (proc = opts[:pre_processor]) && !args.list.detect {|a| !a.literal}
             if proc.kind_of?(Proc)
-              res = proc.call(*args.list.map(&:literal))
+              res = proc.call(*([receiver] + args.list.map(&:literal)))
             else
               res = @helper.send(proc, *args.list.map(&:literal))
             end
@@ -280,13 +289,27 @@ module RubyLess
            !(opts == SafeClass.safe_method_type_for(NilClass, signature) && receiver.cond == [receiver])
           # Do not add a condition if the method applies on nil
           cond += receiver.cond
-        elsif receiver.literal && (proc = opts[:pre_processor]) && !arg_list.detect {|a| !a.literal}
+          if (proc = opts[:pre_processor]) && !arg_list.detect {|a| !a.literal}
+            # pre-processor on element that can be nil
+            if proc.kind_of?(Proc)
+              res = proc.call([receiver] + arg_list.map(&:literal))
+              return t_if cond, res, res.opts
+            end
+          end
+        elsif (proc = opts[:pre_processor]) && !arg_list.detect {|a| !a.literal}
           if proc.kind_of?(Proc)
-            res = proc.call([receiver.literal] + arg_list.map(&:literal))
-          else
+            res = proc.call([receiver] + arg_list.map(&:literal))
+          elsif receiver.literal
             res = receiver.literal.send(*([method] + arg_list.map(&:literal)))
           end
-          return res.kind_of?(TypedString) ? res : t(res.inspect, :class => String, :literal => res)
+          if res
+            if res.opts.nil?
+              # This can happen if we use native methods on TypedString (like gsub) that return a new
+              # typedstring without calling initialize....
+              res.instance_variable_set(:@opts, :class => String, :literal => res)
+            end
+            return res.kind_of?(TypedString) ? res : t(res.inspect, :class => String, :literal => res)
+          end
         end
 
         if method == '/'
@@ -334,7 +357,7 @@ module RubyLess
         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
+        type[:class].kind_of?(Proc) ? type[:class].call(@helper, receiver ? receiver.klass : @helper, signature) : type
       end
 
       def get_lit_class(lit)

data/lib/ruby_less/safe_class.rb

@@ -12,6 +12,10 @@ module RubyLess
 
     # Return method type (options) if the given signature is a safe method for the class.
     def self.safe_method_type_for(klass, signature)
+      if klass.kind_of?(Array)
+        return safe_method_type_for(Array, signature)
+      end
+
       # Signature might be ['name', {:mode => String, :type => Number}].
       # build signature arguments
 
@@ -26,7 +30,7 @@ module RubyLess
           s
         end
       end
-      
+
       # Find safe method in all ancestry
       klass.ancestors.each do |ancestor|
         # FIXME: find a way to optimize this search !
@@ -267,7 +271,7 @@ module RubyLess
       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

data/rubyless.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.8.0"
+  s.version = "0.8.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2010-11-15}
+  s.date = %q{2011-01-15}
   s.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.}
   s.email = %q{gaspard@teti.ch}
   s.extra_rdoc_files = [

data/test/RubyLess/basic.yml

@@ -206,3 +206,20 @@ class_map_as_string:
 proc_to_resolve_class:
   src: "author"
   tem: "node.author"
+
+method_on_array:
+  src: "@foo.genitors.size"
+  tem: "node.genitors.size"
+
+method_on_array_with_nil:
+  src: "@foo.children.size"
+  tem: "(node.children ? node.children.size : nil)"
+
+map_allowed_method:
+  src: "%w{45 52}.map(:to_i)"
+  tem: "[\"45\",\"52\"].map(&:to_i).compact"
+  res: "4552"
+
+map_forbidden_method:
+  src: "%w{45 52}.map(:foo)"
+  tem: "unknown method 'map(:foo)' for '[\"45\",\"52\"]' of type Array."

data/test/RubyLess_test.rb

@@ -9,9 +9,31 @@ class RubyLessTest < Test::Unit::TestCase
   attr_reader :context
   yamltest :src_from_title => false
   include RubyLess
+
+  # Dynamic resolution of map
+  def self.map_proc
+    @@map_proc ||= Proc.new do |receiver, method|
+      if elem = receiver.opts[:elem] || receiver.klass.first
+        if type = RubyLess::safe_method_type_for(elem, [method.to_s])
+          if type[:method] =~ /\A\w+\Z/
+            res = "#{receiver.raw}.map(&#{type[:method].to_sym.inspect}).compact"
+          else
+            res = "#{receiver.raw}.map{|_map_obj| _map_obj.#{type[:method]}}.compact"
+          end
+          res = RubyLess::TypedString.new(res, :class => [type[:class]])
+        else
+          raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['map', method])
+        end
+      else
+        # should never happen
+        raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['map', method])
+      end
+    end
+  end
+
   safe_method :prev => {:class => Dummy, :method => 'previous'}
   safe_method :main => {:class => Dummy, :method => '@node'}
-  safe_method :node => lambda {|h, s| {:class => h.context[:node_class], :method => h.context[:node]}}
+  safe_method :node => Proc.new {|h, r, s| {:class => h.context[:node_class], :method => h.context[:node]}}
   safe_method :now   => {:class => Time,  :method => "Time.now"}
   safe_method :birth => {:class => Time, :method => "Date.parse('2009-06-02 18:44')"}
   safe_method 'dictionary' => {:class => StringDictionary, :method => 'get_dict'}
@@ -21,7 +43,18 @@ class RubyLessTest < Test::Unit::TestCase
 
   safe_method_for String, [:==, String] => Boolean
   safe_method_for String, [:to_s] => String
-  safe_method_for String, [:gsub, Regexp, String] => {:class => String, :pre_processor => Proc.new {|this, reg, str| this.gsub(reg, str)}}
+  safe_method_for String, [:to_i] => {:class => Number, :pre_processor => true}
+  safe_method_for String, [:gsub, Regexp, String] => {:class => String, :pre_processor => Proc.new {|this, reg, str|
+    # We have to test if 'this' is a literal
+    if literal = this.literal
+      this.gsub(reg, str)
+    else
+      # abort pre-processing
+      nil
+    end}}
+
+  safe_method_for Array, [:map, Symbol] => {:method => 'nil', :class => nil, :pre_processor => self.map_proc}
+
   safe_method_for String, :upcase => {:class => String, :pre_processor => true}
 
   safe_method_for Time, [:strftime, String] => String
@@ -42,7 +75,7 @@ class RubyLessTest < Test::Unit::TestCase
   safe_method [:hash_args, {'age' => Number, 'name' => String}] => String
   safe_method [:append_hash, Number, {'foo' => String}] => :make_append_hash
 
-  safe_method [:concat, String, String] => {:class => String, :pre_processor => Proc.new{|a,b| a + b }}
+  safe_method [:concat, String, String] => {:class => String, :pre_processor => Proc.new{|this,a,b| a + b }}
   safe_method [:find, String] => {:class => NilClass, :method => 'nil', :pre_processor => :build_finder}
 
   # methods on nil
@@ -175,5 +208,12 @@ class RubyLessTest < Test::Unit::TestCase
     err.message
   end
 
+  def test_proc
+    x = RubyLess.translate(self, 'main.proc_test')
+    assert_equal self, x.opts[:h]
+    assert_equal Dummy, x.opts[:r]
+    assert_equal ['proc_test'], x.opts[:s]
+  end
+
   yt_make
 end

data/test/mock/dummy_class.rb

@@ -10,7 +10,8 @@ class Dummy < RubyLess::ActiveRecordMock
 
   safe_method  [:ancestor?, Dummy]  => Boolean
   safe_method  :parent              => {:class => 'Dummy', :special_option => 'foobar'},
-               :children            => ['Dummy'],
+               :genitors            => ['Dummy'],
+               :children            => {:class => ['Dummy'], :nil => true},
                :project             => 'Dummy',
                :image               => 'Dummy',
                :id                  => {:class => Number, :method => :zip},
@@ -19,9 +20,13 @@ class Dummy < RubyLess::ActiveRecordMock
                [:width, {:mode => String, :type => String, 'nice' => Boolean}] => String,
                [:kind_of?, Class]   => Boolean,
                [:kind_of?, String]  => {:method => 'is_like?', :class  => Boolean},
-               :author => (Proc.new do |h, s| {:method => 'author', :class => Dummy} end)
+               # helper, receiver, signature
+               :author => (Proc.new do |h, r, s| {:method => 'author', :class => Dummy} end)
                #:author => {:method => 'author', :class => Dummy}
 
+               # just to test Proc.call
+               safe_method :proc_test =>  Proc.new {|h, r, s| {:class => String, :method => '""', :h => h, :r => r, :s => s}}
+
   safe_context :spouse  => 'Dummy',
                :husband => {:class => 'Dummy', :context => {:clever => 'no'}}
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubyless
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 61
   prerelease: false
   segments: 
   - 0
   - 8
-  - 0
-  version: 0.8.0
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-15 00:00:00 +01:00
+date: 2011-01-15 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency