rubyless 0.6.0 → 0.7.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.7.0 2010-09-13
+
+* Major enhancements
+  * Warning: changed RubyLess.translate to use (helper, code) instead of (code, helper).
+  * Enable contextual method resolution by passing the receiver in method resolution.
+  * Enable translation starting with a TypedString: RubyLess.translate(typed_string, method).
+
 == 0.6.0 2010-07-22
 
 * Major enhancements

data/lib/ruby_less.rb

@@ -22,8 +22,8 @@ module RubyLess
     SafeClass.safe_method_type_for(klass, signature)
   end
 
-  def self.translate(string, helper)
-    RubyLessProcessor.translate(string, helper)
+  def self.translate(receiver, string)
+    RubyLessProcessor.translate(receiver, string)
   rescue Exception => err
     if err.kind_of?(RubyLess::Error)
       raise err
@@ -32,9 +32,9 @@ module RubyLess
     end
   end
 
-  def self.translate_string(string, helper)
+  def self.translate_string(receiver, string)
     if string =~ /\#\{/
-      translate("%Q{#{string}}", helper)
+      translate(receiver, "%Q{#{string}}")
     else
       TypedString.new(string.inspect, :class => String, :literal => string)
     end

data/lib/ruby_less/basic_types.rb

@@ -11,7 +11,6 @@ end
 class StringDictionary
   include RubyLess
   safe_method ['[]', Symbol] => {:class => String, :nil => true}
-  disable_safe_read # ?
 end
 
 RubyLess::SafeClass.safe_literal_class Fixnum => Number, Float => Number, Symbol => Symbol, Regexp => Regexp

data/lib/ruby_less/info.rb

@@ -1,3 +1,3 @@
 module RubyLess
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/ruby_less/processor.rb

@@ -9,9 +9,9 @@ module RubyLess
     INFIX_OPERATOR = ['<=>', '==', '<', '>', '<=', '>=', '-', '+', '*', '/', '%']
     PREFIX_OPERATOR   = ['-@']
 
-    def self.translate(string, helper)
+    def self.translate(receiver, string)
       if sexp = RubyParser.new.parse(string)
-        self.new(helper).process(sexp)
+        self.new(receiver).process(sexp)
       elsif string.size == 0
         ''
       else
@@ -85,17 +85,15 @@ module RubyLess
     end
 
     def process_call(exp)
-      receiver_node_type = exp.first.nil? ? nil : exp.first.first
-      receiver = process exp.shift
-
-      # receiver = t("(#{receiver})", receiver.klass) if
-      #   Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
+      unless receiver = process(exp.shift)
+        receiver = @helper.kind_of?(TypedString) ? @helper : nil
+      end
 
       method_call(receiver, exp)
     end
 
     def process_fcall(exp)
-      method_call(nil, exp)
+      method_call(@helper.kind_of?(TypedString) ? @helper : nil, exp)
     end
 
     def process_arglist(exp)
@@ -125,9 +123,10 @@ module RubyLess
       t "[#{list * ','}]", res.opts.merge(:literal => nil)
     end
 
+    # Is this used ?
     def process_vcall(exp)
       var_name = exp.shift
-      unless opts = get_method([var_name], @helper, false)
+      unless opts = get_method(nil, [var_name])
         raise RubyLess::Error.new("Unknown variable or method '#{var_name}'.")
       end
       method = opts[:method]
@@ -328,7 +327,7 @@ module RubyLess
       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)
+        type = klass.respond_to?(:safe_method_type) ? klass.safe_method_type(signature, receiver) : SafeClass.safe_method_type_for(klass, signature)
 
         if type.nil?
           # We try to match with the superclass of the arguments

data/lib/ruby_less/safe_class.rb

@@ -176,7 +176,7 @@ module RubyLess
       end
 
       # Return the type if the given signature corresponds to a safe method for the class.
-      def safe_method_type(signature)
+      def safe_method_type(signature, receiver = nil)
         SafeClass.safe_method_type_for(self, signature)
       end
 
@@ -184,43 +184,35 @@ module RubyLess
       def safe_class?
         true
       end
-
-      # Use this if you want to disable 'safe_read'. This is useful if you provided
-      # a mock as return type signature.
-      def disable_safe_read
-        undef_method(:safe_read)
-      end
     end # ClassMethods
 
     def self.included(base)
       base.extend ClassMethods
     end  # included
 
-
     # Return the type if the given signature corresponds to a safe method for the object's class.
-    def safe_method_type(signature)
+    def safe_method_type(signature, receiver = nil)
       if type = SafeClass.safe_method_type_for(self.class, signature)
         type[:class].kind_of?(Symbol) ? self.send(type[:class], signature) : type
       end
     end
 
-    # Safe attribute reader used when 'safe_readable?' could not be called because the class
-    # is not known during compile time.
-    # FIXME: Is this used anymore ?
-    def safe_read(key)
-      return "'#{key}' not readable" unless type = self.class.safe_method_type([key])
+    # Safe dynamic method dispatching when the method is not known during compile time. Currently this
+    # only works for methods without arguments.
+    def safe_send(method)
+      return nil unless type = self.class.safe_method_type([method])
       self.send(type[:method])
     end
 
     # Evaluate a RubyLess expression. This is just like 'eval' but with safe method checking and typing.
     def safe_eval(code)
-      ruby = RubyLessProcessor.translate(code, self)
+      ruby = RubyLessProcessor.translate(self, code)
       eval(ruby)
     end
 
     # Evaluate a RubyLess expression. This is just like 'eval' but with safe method checking and typing.
     def safe_eval_string(code)
-      ruby = RubyLess.translate_string(code, self)
+      ruby = RubyLess.translate_string(self, code)
       eval(ruby)
     end
 

data/rubyless.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2010-07-22}
+  s.date = %q{2010-09-14}
   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_test.rb

@@ -59,7 +59,7 @@ class RubyLessTest < Test::Unit::TestCase
   end
 
   # Example to dynamically rewrite method calls during compilation
-  def safe_method_type(signature)
+  def safe_method_type(signature, receiver = nil)
     unless res = super
       if signature == ['prepend_test', Number]
         res ={:class => Number, :prepend_args => RubyLess::TypedString.new('10', :class => Number), :method => 'add'}
@@ -120,14 +120,9 @@ class RubyLessTest < Test::Unit::TestCase
     "[#{obj.name}] #{msg}"
   end
 
-  def test_safe_read
-    assert_equal 10, Dummy.new.safe_read('id')
-    assert_equal "'rm' not readable", Dummy.new.safe_read('rm')
-  end
-
-  def test_disable_safe_read
-    assert Dummy.instance_methods.include?('safe_read')
-    assert !StringDictionary.instance_methods.include?('safe_read')
+  def test_safe_send
+    assert_equal 10, Dummy.new.safe_send('id')
+    assert_equal nil, Dummy.new.safe_send('rm')
   end
 
   def test_safe_method_type
@@ -136,6 +131,11 @@ class RubyLessTest < Test::Unit::TestCase
     assert_equal type_should_be, type
   end
 
+  def test_translate_with_typed_string
+    typed_string = RubyLess::TypedString.new('marsupilami', :class => SubDummy, :message => 'Hello')
+    assert_equal "marsupilami.says('Hello')", RubyLess.translate(typed_string, 'talk')
+  end
+
   def yt_do_test(file, test, context = yt_get('context',file,test))
     @@test_strings[file][test].keys.each do |key|
       next if ['src', 'context', 'str'].include?(key)
@@ -148,9 +148,9 @@ class RubyLessTest < Test::Unit::TestCase
     if source = yt_get('str', file, test)
       case key
       when 'tem'
-        source ? RubyLess.translate_string(source, self) : yt_get('tem', file, test)
+        source ? RubyLess.translate_string(self, source) : yt_get('tem', file, test)
       when 'res'
-        eval(source ? RubyLess.translate_string(source, self) : yt_get('tem', file, test)).to_s
+        eval(source ? RubyLess.translate_string(self, source) : yt_get('tem', file, test)).to_s
       when 'sxp'
         RubyParser.new.parse(source).inspect
       else
@@ -159,10 +159,10 @@ class RubyLessTest < Test::Unit::TestCase
     elsif source = yt_get('src', file, test)
       case key
       when 'tem'
-        source ? RubyLess.translate(source, self) : yt_get('tem', file, test)
+        source ? RubyLess.translate(self, source) : yt_get('tem', file, test)
       when 'res'
-        res = RubyLess.translate(source, self)
-        eval(source ? RubyLess.translate(source, self) : yt_get('tem', file, test)).to_s
+        res = RubyLess.translate(self, source)
+        eval(source ? RubyLess.translate(self, source) : yt_get('tem', file, test)).to_s
       when 'sxp'
         RubyParser.new.parse(source).inspect
       else

data/test/mock/dummy_class.rb

@@ -44,8 +44,17 @@ class Dummy < RubyLess::ActiveRecordMock
     }
   end
   # Mock Property ================= ]
+
   safe_property  :dog_name, :dog_age
 
+  def self.safe_method_type(signature, receiver = nil)
+    if signature == ['talk']
+      {:class => String, :method => "says('#{receiver.opts[:message]}')"}
+    else
+      super
+    end
+  end
+
   def width(opts = {})
     return 'nice!' if opts['nice']
     "mode: #{(opts[:mode] || 'none')}, type: #{(opts[:type] || 'none')}"

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-22 00:00:00 +02:00
+date: 2010-09-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency