rubyless 0.3.4 → 0.3.5

data/History.txt

@@ -1,3 +1,11 @@
+== 0.3.5 2009-11-08
+
+* 1 major enhancement
+  * added support for hash in signature: ['img', {'mode' => String, 'class' => String}]
+
+* 1 minor enhancement
+  * added 'disable_safe_read' method
+
 == 0.3.4 2009-11-05
 
 * 1 minor enhancement

data/lib/processor.rb

@@ -113,6 +113,30 @@ module RubyLess
       exp.empty? ? t('', String) : process(exp.shift)
     end
 
+    def process_hash(exp)
+      result = []
+      klass  = {}
+      until exp.empty?
+        key = exp.shift
+        if [:lit, :str].include?(key.first)
+          key = key[1]
+
+          rhs = exp.shift
+          type = rhs.first
+          rhs = process rhs
+          #rhs = "(#{rhs})" unless [:lit, :str].include? type # TODO: verify better!
+
+          result << "#{key.inspect} => #{rhs}"
+          klass[key] = rhs.klass
+        else
+          # ERROR: invalid key
+          raise "Invalid key type for hash (should be a literal value, was #{key.first.inspect})"
+        end
+      end
+
+      t "{#{result.join(', ')}}", :class => klass
+    end
+
     private
       def t(content, opts = nil)
         if opts.nil?
@@ -209,9 +233,10 @@ module RubyLess
       end
 
       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, signature) if res.kind_of?(Proc)
-        res.kind_of?(Symbol) ? nil : res # Symbols not allowed here (should be resolved in receiver.safe_method_type)
+        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.
+
+        type[:class].kind_of?(Proc) ? type[:class].call(@helper, signature) : type
       end
   end
 end

data/lib/rubyless.rb

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

data/lib/safe_class.rb

@@ -10,17 +10,56 @@ 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)
-      safe_methods_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
+
+          # 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
+        else
+          nil
+        end
+      end
     end
 
-    # Declare a safe method for a given class
-    def self.safe_method_for(klass, hash)
+    # Declare a safe method for a given class ( same as #safe_method)
+    def self.safe_method_for(klass, methods_hash)
+      defaults = methods_hash.delete(:defaults) || {}
+
       list = (@@_safe_methods[klass] ||= {})
-      hash.each do |k,v|
-        k = [k] unless k.kind_of?(Array)
-        k[0] = k[0].to_s
-        v = {:class => v} unless v.kind_of?(Hash) || v.kind_of?(Proc)
+      methods_hash.each do |k,v|
+        k, hash_args = build_signature(k)
+        v = {:class => v} unless v.kind_of?(Hash)
+        v = defaults.merge(v)
         v[:method] = v[:method] ? v[:method].to_s : k.first.to_s
+        v[:hash_args] = hash_args if hash_args
         list[k] = v
       end
     end
@@ -42,6 +81,11 @@ module RubyLess
         # The signature can be either a single symbol or an array containing the method name and type arguments like:
         #  [:strftime, Time, String]
         #
+        # If your method accepts variable arguments through a Hash, you should declare it with:
+        #  [:img, String, {:mode => String, :max_size => Number}]
+        #
+        # Make sure your literal values are of the right type: +:mode+ and +'mode'+ are not the same here.
+        #
         # If the signature is :defaults, the options defined are used as defaults for the other elements defined in the
         # same call.
         #
@@ -51,22 +95,7 @@ module RubyLess
         # :class  the return type (class name)
         # :nil    set this to true if the method could return nil
         def self.safe_method(methods_hash)
-          defaults = methods_hash.delete(:defaults) || {}
-
-          list = (@@_safe_methods[self] ||= {})
-          methods_hash.each do |k,v|
-            k = [k] unless k.kind_of?(Array)
-            k[0] = k[0].to_s
-            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) || v.kind_of?(Symbol)
-              # cannot merge defaults
-            else
-              v = defaults.merge(:class => v, :method => k.first.to_s)
-            end
-            list[k] = v
-          end
+          RubyLess::SafeClass.safe_method_for(self, methods_hash)
         end
 
         # A safe context is simply a safe method that can return nil in some situations. The rest of the
@@ -114,6 +143,17 @@ module RubyLess
         def self.safe_method_type(signature)
           SafeClass.safe_method_type_for(self, signature)
         end
+
+        # Return true if the class is safe (we can call safe_read on its instances)
+        def self.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 self.disable_safe_read
+          undef_method(:safe_read)
+        end
       end  # base.class_eval
     end  # included
 
@@ -121,7 +161,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)
-        type.kind_of?(Symbol) ? self.send(type, signature) : type
+        type[:class].kind_of?(Symbol) ? self.send(type[:class], signature) : type
       end
     end
 
@@ -133,6 +173,22 @@ module RubyLess
     end
 
     private
+      def self.build_signature(key)
+        keys = key.kind_of?(Array) ? key : [key]
+        keys[0] = keys[0].to_s
+        hash_args = []
+        signature = keys.map do |k|
+          if k.kind_of?(Hash)
+            hash_args << k
+            Hash
+          else
+            hash_args << nil
+            k
+          end
+        end
+        [signature, (hash_args.compact.empty? ? nil : hash_args)]
+      end
+
       def self.build_safe_methods_list(klass)
         list = klass.superclass.respond_to?(:safe_methods) ? klass.superclass.safe_methods : {}
         (@@_safe_methods[klass] || {}).map do |signature, return_value|

data/rubyless.gemspec

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

@@ -91,3 +91,13 @@ literal_argument_for_method:
 safe_method_defined_as_symbol:
   src: "foo"
   tem: "contextual_foo"
+
+optional_arguments:
+  src: "width(:mode => 'pv')"
+  tem: "var1.width({:mode => \"pv\"})"
+  res: "mode: pv, type: none"
+
+optional_arguments_string:
+  src: "width('nice' => 1 == 1)"
+  tem: "var1.width({\"nice\" => (1==1)})"
+  res: "nice!"

data/test/RubyLess/errors.yml

@@ -33,4 +33,17 @@ string_argument:
 
 symbol_type_not_used_out_of_helper:
   src: "node.foo"
-  res: "'var1' does not respond to 'foo()'."
+  tem: "'var1' does not respond to 'foo()'."
+
+optional_arguments_with_dynamic_string:
+  src: "spouse.width(\"nice#{spouse.name}\" => 'pv')"
+  tem: "Invalid key type for hash (should be a literal value, was :dstr)"
+
+
+optional_arguments_bad_type:
+  src: "width(:mode => 12)"
+  res: "Unknown method 'width({:mode => 12})'."
+
+optional_arguments_bad_argument:
+  src: "width(:xyz => 'pv')"
+  res: "Unknown method 'width({:xyz => \"pv\"})'."

data/test/RubyLess_test.rb

@@ -4,9 +4,10 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 class StringDictionary
   include RubyLess::SafeClass
   safe_method ['[]', Symbol] => {:class => String, :nil => true}
+  disable_safe_read
 end
 
-class SimpleHelper < Test::Unit::TestCase
+class RubyLessTest < Test::Unit::TestCase
   attr_reader :context
   yamltest :src_from_title => false
   include RubyLess::SafeClass
@@ -56,6 +57,17 @@ class SimpleHelper < Test::Unit::TestCase
     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')
+  end
+
+  def test_safe_method_type
+    type = Dummy.safe_method_type(['husband'])
+    type_should_be = {:class => Dummy, :method => 'husband', :nil => true, :context => {:clever => 'no'}}
+    assert_equal type_should_be, type
+  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'].include?(key)
@@ -78,9 +90,9 @@ class SimpleHelper < Test::Unit::TestCase
       "Unknown key '#{key}'. Should be 'tem' or 'res'."
     end
   rescue => err
-    # puts "\n\n#{err.message}"
-    # puts err.backtrace
-   err.message
+    #puts "\n\n#{err.message}"
+    #puts err.backtrace
+    err.message
   end
 
   yt_make

data/test/mock/dummy_class.rb

@@ -8,11 +8,13 @@ class Dummy < RubyLess::ActiveRecordMock
   safe_method  :parent              => {:class => 'Dummy', :special_option => 'foobar'},
                :children            => ['Dummy'],
                :project             => 'Dummy',
+               :image               => 'Dummy',
                :id                  => {:class => Number, :method => :zip},
                :name                => String,
-               :foo                 => :bar
+               :foo                 => :bar,
+               [:width, {:mode => String, :type => String, 'nice' => Boolean}]       => String
   safe_context :spouse  => 'Dummy',
-               :husband => {:class => 'Dummy'}
+               :husband => {:class => 'Dummy', :context => {:clever => 'no'}}
 
   safe_attribute :age, :friend_id, :log_at, :format
 
@@ -20,11 +22,20 @@ class Dummy < RubyLess::ActiveRecordMock
     @name = name
   end
 
+  def width(opts = {})
+    return 'nice!' if opts['nice']
+    "mode: #{(opts[:mode] || 'none')}, type: #{(opts[:type] || 'none')}"
+  end
+
   # This method returns pseudo-nil and does not need to be declared with :nil => true
   def project
     Dummy.new('project')
   end
 
+  def image
+    Dummy.new('image')
+  end
+
   # This method can return nil and must be declared with :nil => true
   def spouse
     nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyless
 version: !ruby/object:Gem::Version 
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-05 00:00:00 +01:00
+date: 2009-11-08 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency