rubyless 0.3.2 → 0.3.3

data/History.txt

@@ -1,3 +1,8 @@
+== 0.3.3 2009-10-26
+
+* 1 minor enhancement
+  * added support for symbols (only used with helper)
+
 == 0.3.2 2009-10-15
 
 * 1 minor enhancement

data/lib/processor.rb

@@ -210,8 +210,8 @@ module RubyLess
 
       def get_method(signature, receiver, is_method = true)
         res = receiver.respond_to?(:safe_method_type) ? receiver.safe_method_type(signature) : SafeClass.safe_method_type_for(receiver, signature)
-        res = res.call(@helper) if res.kind_of?(Proc)
-        res
+        res = res.call(@helper, signature) if res.kind_of?(Proc)
+        res.kind_of?(Symbol) ? nil : res # Symbols not allowed here (should be resolved in receiver.safe_method_type)
       end
   end
 end

data/lib/rubyless.rb

@@ -6,7 +6,7 @@ require 'processor'
 =begin rdoc
 =end
 module RubyLess
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 
   def self.translate(string, helper)
     RubyLessProcessor.translate(string, helper)

data/lib/safe_class.rb

@@ -10,11 +10,7 @@ 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 res = safe_methods_for(klass)[signature]
-        res.dup
-      else
-        nil
-      end
+      safe_methods_for(klass)[signature]
     end
 
     # Declare a safe method for a given class
@@ -65,7 +61,7 @@ module RubyLess
             if v.kind_of?(Hash)
               v = defaults.merge(v)
               v[:method] = v[:method] ? v[:method].to_s : k.first.to_s
-            elsif v.kind_of?(Proc)
+            elsif v.kind_of?(Proc) || v.kind_of?(Symbol)
               # cannot merge defaults
             else
               v = defaults.merge(:class => v, :method => k.first.to_s)
@@ -106,22 +102,21 @@ module RubyLess
           SafeClass.safe_methods_for(self)
         end
 
-        # Return true if the given signature corresponds to a safe method for the class.
+        # Return the type if the given signature corresponds to a safe method for the class.
         def self.safe_method_type(signature)
-          if res = SafeClass.safe_method_type_for(self, signature)
-            res.dup # TODO: replace by freeze
-          else
-            nil
-          end
-        end
-
-        # Return the method type (options) if the given signature is a safe method for the class.
-        def safe_method_type(signature)
-          self.class.safe_method_type(signature)
+          SafeClass.safe_method_type_for(self, signature)
         end
       end  # base.class_eval
     end  # included
 
+
+    # 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)
+        type.kind_of?(Symbol) ? self.send(type, signature) : type
+      end
+    end
+
     # Safe attribute reader used when 'safe_readable?' could not be called because the class
     # is not known during compile time.
     def safe_read(key)
@@ -135,12 +130,14 @@ module RubyLess
         (@@_safe_methods[klass] || {}).map do |signature, return_value|
           if return_value.kind_of?(Hash)
             return_value[:class] = parse_class(return_value[:class])
-          elsif !return_value.kind_of?(Proc)
+          elsif return_value.kind_of?(Proc) || return_value.kind_of?(Symbol)
+            # keep
+          else
             return_value = {:class => return_value}
           end
           method = signature.shift
           signature = [method] + signature.map {|e| parse_class(e)}
-          list[signature] = return_value
+          list[signature] = return_value.freeze
         end
         list
       end

data/rubyless.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.3.1"
+  s.version = "0.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2009-10-03}
+  s.date = %q{2009-10-26}
   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}

data/test/RubyLess/basic.yml

@@ -86,4 +86,8 @@ multi_arg_method_arguments_can_be_nil_same_condition:
 
 literal_argument_for_method:
   src: "vowel_count('ruby')"
-  res: "2"
+  res: "2"
+
+safe_method_defined_as_symbol:
+  src: "foo"
+  tem: "contextual_foo"

data/test/RubyLess/errors.yml

@@ -10,7 +10,7 @@ zero_div:
   src: "1/(id-10)"
   tem: "(1/(var1.zip-10) rescue nil)"
   res: ""
-  
+
 looping:
   src: "while(true) do puts 'flood' end"
   res: 'Bug! Unknown node-type :while to RubyLess::RubyLessProcessor'
@@ -29,4 +29,8 @@ number_argument:
 
 string_argument:
   src: "dictionary[spouse.name]"
-  res: "'get_dict' does not respond to '[](String)'."
+  res: "'get_dict' does not respond to '[](String)'."
+
+symbol_type_not_used_out_of_helper:
+  src: "node.foo"
+  res: "'var1' does not respond to 'foo()'."

data/test/RubyLess_test.rb

@@ -12,28 +12,33 @@ class SimpleHelper < Test::Unit::TestCase
   include RubyLess::SafeClass
   safe_method :prev => {:class => Dummy, :method => 'previous'}
   safe_method :main => {:class => Dummy, :method => '@node'}
-  safe_method :node => lambda {|h| {:class => h.context[:node_class], :method => h.context[:node]}}
+  safe_method :node => lambda {|h, 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'}
   safe_method [:vowel_count, String]    => Number
   safe_method [:log_info, Dummy, String]    => String
+  safe_method :foo => :contextual_method, :bar => :contextual_method
   safe_method_for String, [:==, String] => Boolean
   safe_method_for String, [:to_s] => String
   safe_method_for Time, [:strftime, String] => String
 
   # Example to dynamically rewrite method calls during compilation
   def safe_method_type(signature)
-    unless res = self.class.safe_method_type(signature)
+    unless res = super
       # try to execute method in the current var "var.method"
       if res = context[:node_class].safe_method_type(signature)
-        res = res.call(self) if res.kind_of?(Proc)
-        res[:method] = "#{context[:node]}.#{res[:method] || signature[0]}"
+        res = res.call(self, signature) if res.kind_of?(Proc)
+        res = res.merge(:method => "#{context[:node]}.#{res[:method] || signature[0]}")
       end
     end
     res
   end
 
+  def contextual_method(signature)
+    {:method => "contextual_#{signature[0]}", :class => String}
+  end
+
   def var1
     Dummy.new
   end
@@ -75,7 +80,7 @@ class SimpleHelper < Test::Unit::TestCase
   rescue => err
     # puts "\n\n#{err.message}"
     # puts err.backtrace
-    err.message
+   err.message
   end
 
   yt_make

data/test/mock/dummy_class.rb

@@ -3,37 +3,38 @@ require File.dirname(__FILE__) + '/active_record_mock'
 class Dummy < RubyLess::ActiveRecordMock
   attr_reader :name
   include RubyLess::SafeClass
-  
+
   safe_method  [:ancestor?, Dummy]  => Boolean
   safe_method  :parent              => {:class => 'Dummy', :special_option => 'foobar'},
                :children            => ['Dummy'],
                :project             => 'Dummy',
                :id                  => {:class => Number, :method => :zip},
-               :name                => String
+               :name                => String,
+               :foo                 => :bar
   safe_method  :defaults => {:nil => true},
                :spouse        => 'Dummy',
                :husband       => {:class => 'Dummy'}
-             
+
   safe_attribute :age, :friend_id, :log_at, :format
-  
+
   def initialize(name = 'dummy')
     @name = name
   end
-  
+
   # This method returns pseudo-nil and does not need to be declared with :nil => true
   def project
     Dummy.new('project')
   end
-  
+
   # This method can return nil and must be declared with :nil => true
   def spouse
     nil
   end
-  
+
   def husband
     nil
   end
-  
+
   def zip
     10
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyless
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-15 00:00:00 +02:00
+date: 2009-10-26 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency