rubyless 0.4.0 → 0.5.0

data/History.txt

@@ -1,6 +1,20 @@
+== 0.5.0 2010-05-27
+
+* Major enhancements
+  * Added 'accept_nil' option.
+  * Added 'append_hash' options.
+  * RubyLess activation is now enabled with 'include RubyLess' (no need for SafeClass).
+  * Added support for compile time literal args evaluation.
+  * Added support for compile time literal args evaluation on literal objects (strings for example).
+  * All method signatures that have an optional hash should accept calls without the last hash.
+  * Better error messages for missing methods.
+  * Added support for Array with Mixed array detection.
+  * Added support for pre_processing with helper method.
+  * Added support for method detection on NilClass.
+
 == 0.4.0 2010-03-21
 
-* 4 major enhancement
+* 4 major enhancements
   * 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").

data/README.rdoc

@@ -24,14 +24,14 @@ return 'nil' instead of the declared output, you need to wrap your final ruby 'e
 
  # signature is made of [method, arg_class, arg_class, ...]
  class Node
-   include RubyLess::SafeClass
+   include RubyLess
    safe_method [:ancestor?, Node] => Boolean
  end
 
  # methods defined in helper
 
  # global methods
- include RubyLess::SafeClass
+ include RubyLess
  safe_method :prev => {:class => Dummy, :method => 'previous', :nil => true}
  safe_method :node => lambda {|h| {:class => h.context[:node_class], :method => h.context[:node]}}
  safe_method [:strftime, Time, String] => String

data/Rakefile

@@ -16,7 +16,7 @@ begin
     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.add_development_dependency "yamltest", ">= 0.6.0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/TODO

@@ -0,0 +1,8 @@
+2010-03-28
+
+1. Write shoulda tests for TypedMethod, TypedArray and TypedHash
+2. Create sub-classes of TypedString: TypedMethod, TypedArray, TypedHash
+   A TypedMethod should have a TypedArray as arguments, eventually with a TypedHash as last argument
+3. Move list code from TypedString into TypedArray
+4. Move hash code from TypedString into TypedHash
+

data/lib/ruby_less/basic_types.rb

@@ -1,15 +1,27 @@
 require 'ruby_less/safe_class'
 
 
+# Dummy classes
 class Boolean
 end
 
 class Number
 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
 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 )
+  [:% , Number] => Number,  [:"-@"]       => Number
+)
+
+RubyLess::SafeClass.safe_method_for( String,
+  [:==, String] => Boolean
+)

data/lib/ruby_less/info.rb

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

data/lib/ruby_less/no_method_error.rb

@@ -9,7 +9,7 @@ module RubyLess
     end
 
     def message
-      "#{receiver_with_class}: #{error_message} '#{method_with_arguments}'."
+      "#{error_message} '#{method_with_arguments}' for #{receiver_with_class}."
     end
 
     def error_message
@@ -21,7 +21,8 @@ module RubyLess
     end
 
     def receiver_with_class
-      @receiver ? "#{@receiver} (#{@klass})" : "(#{@klass.class})"
+      klass = @klass.kind_of?(Class) ? @klass : @klass.class
+      @receiver ? "'#{@receiver}' of type #{@klass}" : klass
     end
 
     def method_with_arguments

data/lib/ruby_less/processor.rb

@@ -12,6 +12,8 @@ module RubyLess
     def self.translate(string, helper)
       sexp = RubyParser.new.parse(string)
       self.new(helper).process(sexp)
+    rescue Racc::ParseError => err
+      raise RubyLess::SyntaxError.new(err.message)
     end
 
     def initialize(helper)
@@ -86,8 +88,22 @@ module RubyLess
     end
 
     def process_array(exp)
-      res = process_arglist(exp)
-      exp.size > 1 ? t("[#{res}]", res.opts) : res
+      literal = true
+      list    = []
+      classes = []
+      while !exp.empty?
+        res = process(exp.shift)
+        content_class ||= res.opts[:class]
+        unless res.opts[:class] <= content_class
+          classes = list.map { content_class.name } + [res.opts[:class].name]
+          raise RubyLess::Error.new("Mixed Array not supported ([#{classes * ','}]).")
+        end
+        list << res
+      end
+
+      res.opts[:class] = Array
+      res.opts[:array_content_class] = content_class
+      t "[#{list * ','}]", res.opts.merge(:literal => nil)
     end
 
     def process_vcall(exp)
@@ -104,11 +120,12 @@ module RubyLess
 
     def process_lit(exp)
       lit = exp.shift
-      t lit.inspect, get_lit_class(lit.class)
+      t lit.inspect, get_lit_class(lit)
     end
 
     def process_str(exp)
-      t exp.shift.inspect, String
+      lit = exp.shift
+      t lit.inspect, :class => String, :literal => lit
     end
 
     def process_dstr(exp)
@@ -120,8 +137,7 @@ module RubyLess
     end
 
     def process_hash(exp)
-      result = []
-      klass  = {}
+      result = t "", String
       until exp.empty?
         key = exp.shift
         if [:lit, :str].include?(key.first)
@@ -131,16 +147,14 @@ module RubyLess
           type = rhs.first
           rhs = process rhs
           #rhs = "(#{rhs})" unless [:lit, :str].include? type # TODO: verify better!
-
-          result << "#{key.inspect} => #{rhs}"
-          klass[key] = rhs.klass
+          result.set_hash(key, rhs)
         else
           # ERROR: invalid key
           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
+      result.rebuild_hash
+      result
     end
 
     def process_ivar(exp)
@@ -198,30 +212,76 @@ module RubyLess
         end
 
         if receiver
-          if receiver.could_be_nil?
-            cond += receiver.cond
-          end
           opts = get_method(receiver, signature)
+          method_call_with_receiver(receiver, args, opts, cond, signature)
+        else
+          opts = get_method(nil, signature)
           method = opts[:method]
-          if method == '/'
-            t_if cond, "(#{receiver.raw}#{method}#{args.raw} rescue nil)", opts.merge(:nil => true)
-          elsif INFIX_OPERATOR.include?(method)
-            t_if cond, "(#{receiver.raw}#{method}#{args.raw})", opts
-          elsif PREFIX_OPERATOR.include?(method)
-            t_if cond, "#{method.to_s[0..0]}#{receiver.raw}", opts
-          elsif method == '[]'
-            t_if cond, "#{receiver.raw}[#{args.raw}]", opts
+          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))
+            else
+              res = @helper.send(proc, *args.list.map(&:literal))
+            end
+
+            return res.kind_of?(TypedString) ? res : t(res.inspect, :class => String, :literal => res)
+          end
+
+          if opts[:accept_nil]
+            method_call_accepting_nil(method, args, opts)
           else
-            args = args_with_prepend(args, opts)
             args = "(#{args.raw})" if args
-            t_if cond, "#{receiver.raw}.#{method}#{args}", opts
+            t_if cond, "#{method}#{args}", opts
           end
+        end
+      end
+
+      def method_call_accepting_nil(method, args, opts)
+        if args
+          args = args.list.map do |arg|
+            if !arg.could_be_nil? || arg.raw == arg.cond.to_s
+              arg.raw
+            else
+              "(#{arg.cond} ? #{arg.raw} : nil)"
+            end
+          end.join(', ')
+
+          t "#{method}(#{args})", opts
+        else
+          t method, opts
+        end
+      end
+
+      def method_call_with_receiver(receiver, args, opts, cond, signature)
+        method = opts[:method]
+        arg_list = args ? args.list : []
+
+        if receiver.could_be_nil? && opts != SafeClass.safe_method_type_for(NilClass, signature)
+          # 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.kind_of?(Proc)
+            res = proc.call([receiver.literal] + arg_list.map(&:literal))
+          else
+            res = receiver.literal.send(*([method] + arg_list.map(&:literal)))
+          end
+          return res.kind_of?(TypedString) ? res : t(res.inspect, :class => String, :literal => res)
+        end
+
+        if method == '/'
+          t_if cond, "(#{receiver.raw}#{method}#{args.raw} rescue nil)", opts.merge(:nil => true)
+        elsif INFIX_OPERATOR.include?(method)
+          t_if cond, "(#{receiver.raw}#{method}#{args.raw})", opts
+        elsif PREFIX_OPERATOR.include?(method)
+          t_if cond, "#{method.to_s[0..0]}#{receiver.raw}", opts
+        elsif method == '[]'
+          t_if cond, "#{receiver.raw}[#{args.raw}]", opts
         else
-          opts = get_method(nil, signature)
-          method = opts[:method]
           args = args_with_prepend(args, opts)
           args = "(#{args.raw})" if args
-          t_if cond, "#{method}#{args}", opts
+          t_if cond, "#{receiver.raw}.#{method}#{args}", opts
         end
       end
 
@@ -258,24 +318,36 @@ module RubyLess
         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)
+      def get_lit_class(lit)
+        unless lit_class = RubyLess::SafeClass.literal_class_for(lit.class)
           raise RubyLess::SyntaxError.new("#{klass} literal not supported by RubyLess.")
         end
-        lit_class
+        {:class => lit_class, :literal => lit}
       end
 
       def args_with_prepend(args, opts)
         if prepend_args = opts[:prepend_args]
           if args
             prepend_args.append_argument(args)
-            prepend_args
+            args = prepend_args
           else
-            prepend_args
+            args = prepend_args
           end
-        else
-          args
         end
+
+        if append_hash = opts[:append_hash]
+          last_arg = args.list.last
+          unless last_arg.klass.kind_of?(Hash)
+            last_arg = t "", String
+            args.append_argument(last_arg)
+          end
+          append_hash.each do |key, value|
+            last_arg.set_hash(key, value)
+          end
+          last_arg.rebuild_hash
+          args.rebuild_arguments
+        end
+        args
       end
   end
 end

data/lib/ruby_less/safe_class.rb

@@ -26,9 +26,10 @@ module RubyLess
           s
         end
       end
+
       # Find safe method in all ancestry
       klass.ancestors.each do |ancestor|
-        return nil if ancestor == RubyLess::SafeClass
+        # FIXME: find a way to optimize this search !
         if type = safe_method_with_hash_args(ancestor, signature, signature_args)
           return type
         end
@@ -53,13 +54,22 @@ module RubyLess
       defaults = methods_hash.delete(:defaults) || {}
 
       list = (@@_safe_methods[klass] ||= {})
-      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
+      methods_hash.each do |signature, type|
+        signature, hash_args = build_signature(signature)
+        type = {:class => type} unless type.kind_of?(Hash)
+        type = defaults.merge(type)
+        type[:method] = type[:method] ? type[:method].to_s : signature.first.to_s
+        if hash_args
+          type[:hash_args] = hash_args
+          list[signature] = type
+          if hash_args.last.kind_of?(Hash)
+            # Also build signature without last hash. This enables the common idiom
+            # method(arg, arg, opts = {})
+            list[signature[0..-2]] = type.dup
+          end
+        else
+          list[signature] = type
+        end
       end
     end
 
@@ -193,7 +203,7 @@ module RubyLess
     end
 
     # Safe attribute reader used when 'safe_readable?' could not be called because the class
-    # is not known during compile time.
+    # 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])
       self.send(type[:method])

data/lib/ruby_less/typed_method.rb

@@ -0,0 +1,50 @@
+module RubyLess
+  class TypedMethod
+    attr_accessor :name, :args
+
+    def initialize(*args)
+      @name = args.shift
+      @args = args
+    end
+
+    def add_argument(arg, klass_or_opts = nil)
+      if klass_or_opts
+        @args << TypedString.new(arg.to_s, klass_or_opts)
+      elsif arg.kind_of?(TypedString)
+        @arg << arg
+      else
+        raise Exception.new("Cannot add #{arg} to TypedMethod '#{name}' (no type and not a TypedString)")
+      end
+    end
+
+    def set_hash(key, value, klass_or_opts)
+      if last_is_hash?
+        hash = @args.last
+      else
+        hash = TypedString.new
+        @args << hash
+      end
+
+      hash.set_hash(key, TypedString.new(value, klass_or_opts))
+    end
+
+    def last_is_hash?
+      @args.last.kind_of?(TypedString) && !@args.last.hash.empty?
+    end
+
+    def to_s
+      if @args.empty?
+        @name
+      elsif last_is_hash?
+        args = @args[0..-2].map(&:to_s)
+        hash = @args.last
+        hash.rebuild_hash
+        hash = hash.to_s[1..-2]
+        args += [hash]
+        "#{@name}(#{args.join(', ')})"
+      else
+        "#{@name}(#{@args.join(', ')})"
+      end
+    end
+  end
+end

data/lib/ruby_less/typed_string.rb

@@ -1,29 +1,29 @@
 module RubyLess
-  
+
   # This is a special kind of string containing ruby code that retains some information from the
   # elements that compose it.
   class TypedString < String
     attr_reader :klass, :opts
 
-    def initialize(content = "", opts = nil)
-      opts ||= {:class => String}
+    def initialize(content = "", klass_or_opts = nil)
+      klass_or_opts ||= {:class => String}
       replace(content)
-      @opts = opts.dup
+      @opts = klass_or_opts.kind_of?(Hash) ? klass_or_opts.dup : {:class => klass_or_opts}
       if could_be_nil? && !@opts[:cond]
         @opts[:cond] = [self.to_s]
       end
     end
-    
+
     # Resulting class of the evaluated ruby code if it is not nil.
     def klass
       @opts[:class]
     end
-    
+
     # Returns true if the evaluation of the ruby code represented by the string could be 'nil'.
     def could_be_nil?
       @opts[:nil]
     end
-    
+
     # Condition that could yield a nil result in the whole expression.
     # For example in the following expression:
     #  node.spouse.name == ''
@@ -31,15 +31,39 @@ module RubyLess
     def cond
       @opts[:cond]
     end
-    
+
+    # Return the literal value (string before inspect, number)
+    def literal
+      @opts[:literal]
+    end
+
+    # List of typed_strings that form the argument list. This is only used
+    # to resolve nil when the receiver of the arguments accepts nil values.
+    def list
+      @list ||= self.empty? ? [] : [self]
+    end
+
+    # Hash arguments. This is only used to resolve parameter insertion with
+    # append_hash.
+    def hash
+      @hash ||= {}
+    end
+
+    # Used to keep hash order (this is useful for testing).
+    def keys
+      @hash_keys ||= []
+    end
+
     # raw result without nil checking:
     # "node.spouse.name" instead of "(node.spouse ? node.spouse.name : nil)"
     def raw
       @opts[:raw] || self.to_s
     end
-    
+
     # Append a typed string to build an argument list
     def append_argument(typed_string)
+      self.list << typed_string
+
       append_opts(typed_string)
       if self.empty?
         replace(typed_string.raw)
@@ -47,7 +71,28 @@ module RubyLess
         replace("#{self.raw}, #{typed_string.raw}")
       end
     end
-    
+
+    def rebuild_arguments
+      replace(list.map {|arg| arg.raw}.join(', ')) if @list
+    end
+
+    def set_hash(key, value)
+      self.hash[key] = value
+      self.keys << key unless self.keys.include?(key)
+      @opts[:class] = {} unless self.klass.kind_of?(Hash)
+      self.klass[key] = value.klass
+    end
+
+    def rebuild_hash
+      if @hash
+        result = []
+        @hash_keys.each do |k|
+          result << "#{k.inspect} => #{@hash[k]}"
+        end
+        replace "{#{result.join(', ')}}"
+      end
+    end
+
     private
       def append_opts(typed_string)
         if self.empty?
@@ -61,7 +106,7 @@ module RubyLess
           append_cond(typed_string.cond) if typed_string.could_be_nil?
         end
       end
-    
+
       def append_cond(condition)
         @opts[:cond] ||= []
         @opts[:cond] += [condition].flatten

data/lib/ruby_less.rb

@@ -1,27 +1,40 @@
 =begin rdoc
 =end
 require 'ruby_less/info'
-require 'ruby_less/basic_types'
 require 'ruby_less/signature_hash'
 require 'ruby_less/error'
 require 'ruby_less/no_method_error'
 require 'ruby_less/syntax_error'
 require 'ruby_less/typed_string'
+require 'ruby_less/typed_method'
 require 'ruby_less/safe_class'
 require 'ruby_less/processor'
 
 module RubyLess
+  def self.included(base)
+    base.class_eval do
+      include SafeClass
+    end
+  end
+
+  # Return method type (options) if the given signature is a safe method for the class.
+  def self.safe_method_type_for(klass, signature)
+    SafeClass.safe_method_type_for(klass, signature)
+  end
+
   def self.translate(string, helper)
     RubyLessProcessor.translate(string, helper)
   end
 
   def self.translate_string(string, helper)
     if string =~ /\#\{/
-      ::RubyLess.translate("%Q{#{string}}", helper)
+      translate("%Q{#{string}}", helper)
     else
-      string.inspect
+      TypedString.new(string.inspect, :class => String, :literal => string)
     end
   rescue => err
-    raise ::RubyLess::Error.new("Error parsing string \"#{string}\": #{err.message.strip}")
+    raise RubyLess::Error.new("Error parsing string \"#{string}\": #{err.message.strip}")
   end
 end
+
+require 'ruby_less/basic_types'

data/rubyless.gemspec

@@ -5,21 +5,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.4.0"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2010-03-21}
+  s.date = %q{2010-05-27}
   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 = [
-    "README.rdoc"
+    "README.rdoc",
+     "TODO"
   ]
   s.files = [
     ".gitignore",
      "History.txt",
      "README.rdoc",
      "Rakefile",
+     "TODO",
      "lib/ruby_less.rb",
      "lib/ruby_less/basic_types.rb",
      "lib/ruby_less/error.rb",
@@ -29,6 +31,7 @@ Gem::Specification.new do |s|
      "lib/ruby_less/safe_class.rb",
      "lib/ruby_less/signature_hash.rb",
      "lib/ruby_less/syntax_error.rb",
+     "lib/ruby_less/typed_method.rb",
      "lib/ruby_less/typed_string.rb",
      "lib/rubyless.rb",
      "rails/init.rb",
@@ -36,6 +39,7 @@ Gem::Specification.new do |s|
      "test/RubyLess/active_record.yml",
      "test/RubyLess/basic.yml",
      "test/RubyLess/errors.yml",
+     "test/RubyLess/hash.yml",
      "test/RubyLess/string.yml",
      "test/RubyLess_test.rb",
      "test/mock/active_record_mock.rb",
@@ -44,7 +48,9 @@ Gem::Specification.new do |s|
      "test/mock/property_column.rb",
      "test/safe_class_test.rb",
      "test/signature_hash_test.rb",
-     "test/test_helper.rb"
+     "test/test_helper.rb",
+     "test/typed_method_test.rb",
+     "test/typed_string_test.rb"
   ]
   s.homepage = %q{http://zenadmin.org/546}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -59,7 +65,9 @@ Gem::Specification.new do |s|
      "test/RubyLess_test.rb",
      "test/safe_class_test.rb",
      "test/signature_hash_test.rb",
-     "test/test_helper.rb"
+     "test/test_helper.rb",
+     "test/typed_method_test.rb",
+     "test/typed_string_test.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -70,18 +78,18 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<ruby_parser>, [">= 2.0.4"])
       s.add_runtime_dependency(%q<sexp_processor>, [">= 3.0.1"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<yamltest>, [">= 0.5.3"])
+      s.add_development_dependency(%q<yamltest>, [">= 0.6.0"])
     else
       s.add_dependency(%q<ruby_parser>, [">= 2.0.4"])
       s.add_dependency(%q<sexp_processor>, [">= 3.0.1"])
       s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<yamltest>, [">= 0.5.3"])
+      s.add_dependency(%q<yamltest>, [">= 0.6.0"])
     end
   else
     s.add_dependency(%q<ruby_parser>, [">= 2.0.4"])
     s.add_dependency(%q<sexp_processor>, [">= 3.0.1"])
     s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<yamltest>, [">= 0.5.3"])
+    s.add_dependency(%q<yamltest>, [">= 0.6.0"])
   end
 end
 

data/test/RubyLess/basic.yml

@@ -22,10 +22,6 @@ symbol:
   src: ":foobar"
   sxp: 's(:lit, :foobar)'
 
-hash_access:
-  src: "dictionary[:key]"
-  tem: "get_dict[:key]"
-
 rewrite_variables:
   src: "!prev.ancestor?(main) && !node.ancestor?(main)"
   tem: "(not previous.ancestor?(@node) and not node.ancestor?(@node))"
@@ -138,4 +134,54 @@ match_on_subclass:
 
 optional_argument_subclass:
   src: "width(:mode => str)"
-  tem: "node.width({:mode => str})"
+  tem: "node.width({:mode => str})"
+
+simple_accept_nil:
+  src: "accept_nil(dictionary[:foo])"
+  tem: "accept_nil(get_dict[:foo])"
+
+accept_nil_many_arguments:
+  src: "accept_nil(dictionary[:foo], dictionary[:bar])"
+  tem: "accept_nil(get_dict[:foo], get_dict[:bar])"
+  res: "[\"Foo\", nil]"
+
+accept_nil_many_arguments_no_all_nil:
+  src: "accept_nil('hop', dictionary[:bar])"
+  tem: "accept_nil(\"hop\", get_dict[:bar])"
+  res: "[\"hop\", nil]"
+
+no_nil_in_accept_nil:
+  src: "accept_nil(no_nil(dictionary[:foo]))"
+  tem: "accept_nil((get_dict[:foo] ? no_nil(get_dict[:foo]) : nil))"
+  res: "[\"Foo\", nil]"
+
+two_no_nil_in_accept_nil:
+  src: "accept_nil(no_nil(dictionary[:foo]), no_nil(dictionary[:bar]))"
+  tem: "accept_nil((get_dict[:foo] ? no_nil(get_dict[:foo]) : nil), (get_dict[:bar] ? no_nil(get_dict[:bar]) : nil))"
+  res: "[\"Foo\", nil]"
+
+accept_nil_in_no_nil:
+  src: "no_nil(accept_nil(dictionary[:foo]))"
+  tem: "no_nil(accept_nil(get_dict[:foo]))"
+
+parse_array:
+  src: "[3, 6]"
+  tem: '[3,6]'
+
+noop_method:
+  src: 'no_op("hello")'
+  tem: '("hello")'
+  res: 'hello'
+
+noop_other_signature:
+  src: 'no_op(45)'
+  tem: 'transform(45)'
+
+build_finder:
+  # This test shows a way to 'pre_process' literal content with a helper method that should return a TypedString
+  src: 'find("one two")'
+  tem: 'secure(Node) { Node.find("one two") }'
+
+methods_on_nil:
+  src: 'dictionary[:foo].blank?'
+  tem: 'get_dict[:foo].blank?'

data/test/RubyLess/errors.yml

@@ -1,10 +1,10 @@
 unknown_global_method:
   src: "system('echo date')"
-  res: "(RubyLessTest): unknown method 'system(String)'."
+  res: "unknown method 'system(String)' for RubyLessTest."
 
 bad_argument_types:
   src: "strftime(34,'ffoo')"
-  res: "(RubyLessTest): unknown method 'strftime(Number, String)'."
+  res: "unknown method 'strftime(Number, String)' for RubyLessTest."
 
 zero_div:
   src: "1/(id-10)"
@@ -17,23 +17,23 @@ looping:
 
 add_two_strings:
   src: "name + 14"
-  res: "node.name (String): unknown method '+(Number)'."
+  res: "unknown method '+(Number)' for 'node.name' of type String."
 
 two_arguments_in_hash:
   src: "dictionary[:one, :two]"
-  res: "get_dict (StringDictionary): unknown method '[](Symbol, Symbol)'."
+  res: "unknown method '[](Symbol, Symbol)' for 'get_dict' of type StringDictionary."
 
 number_argument:
   src: "dictionary[43]"
-  res: "get_dict (StringDictionary): unknown method '[](Number)'."
+  res: "unknown method '[](Number)' for 'get_dict' of type StringDictionary."
 
 string_argument:
   src: "dictionary[spouse.name]"
-  res: "get_dict (StringDictionary): unknown method '[](String)'."
+  res: "unknown method '[](String)' for 'get_dict' of type StringDictionary."
 
 symbol_type_not_used_out_of_helper:
   src: "node.foo"
-  tem: "node (Dummy): unknown method 'foo()'."
+  tem: "unknown method 'foo()' for 'node' of type Dummy."
 
 optional_arguments_with_dynamic_string:
   src: "spouse.width(\"nice#{spouse.name}\" => 'pv')"
@@ -42,8 +42,16 @@ optional_arguments_with_dynamic_string:
 
 optional_arguments_bad_type:
   src: "width(:mode => 12)"
-  res: "(RubyLessTest): unknown method 'width(:mode=>Number)'."
+  res: "unknown method 'width(:mode=>Number)' for RubyLessTest."
 
 optional_arguments_bad_argument:
   src: "width(:xyz => 'pv')"
-  res: "(RubyLessTest): unknown method 'width(:xyz=>String)'."
+  res: "unknown method 'width(:xyz=>String)' for RubyLessTest."
+
+hash_arguments_wrong_type:
+  src: "hash_args('name' => 45)"
+  tem: "unknown method 'hash_args(\"name\"=>Number)' for RubyLessTest."
+
+mixed_array:
+  src: "[3, '4']"
+  tem: 'Mixed Array not supported ([Number,String]).'

data/test/RubyLess/hash.yml

@@ -0,0 +1,19 @@
+parse_hash:
+  src: "{'one' => 1, 2 => 'two'}"
+  tem: "{\"one\" => 1, 2 => \"two\"}"
+
+hash_access:
+  src: "dictionary[:key]"
+  tem: "get_dict[:key]"
+
+append_hash:
+  src: "append_hash(5, 'foo' => 'Foo')"
+  tem: "add(5, {\"foo\" => \"Foo\", :xyz => bar})"
+
+append_hash_on_empty:
+  src: "append_hash(5)"
+  tem: "add(5, {:xyz => bar})"
+
+hash_arguments:
+  src: "hash_args('name' => str, 'age' => 13)"
+  tem: "hash_args({\"name\" => str, \"age\" => 13})"

data/test/RubyLess/string.yml

@@ -9,3 +9,20 @@ text:
 dynamic_string:
   str: 'one #{name} two'
   tem: '"one #{node.name} two"'
+
+concat_static:
+  src: "concat('hello ', 'World!')"
+  tem: '"hello World!"'
+
+gsub_static:
+  src: "'one.one'.gsub(/\\./,';')"
+  tem: '"one;one"'
+
+upcase_static:
+  src: "'one.one'.gsub(/\\./,';').upcase"
+  tem: '"ONE;ONE"'
+
+equal:
+  src: "str == 'str'"
+  tem: '(str=="str")'
+  res: 'true'

data/test/RubyLess_test.rb

@@ -1,12 +1,6 @@
 require 'date'
 require 'test_helper'
 
-class StringDictionary
-  include RubyLess::SafeClass
-  safe_method ['[]', Symbol] => {:class => String, :nil => true}
-  disable_safe_read
-end
-
 # Used to test sub-classes in optional arguments
 class SubString < String
 end
@@ -14,7 +8,7 @@ end
 class RubyLessTest < Test::Unit::TestCase
   attr_reader :context
   yamltest :src_from_title => false
-  include RubyLess::SafeClass
+  include RubyLess
   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]}}
@@ -24,14 +18,34 @@ class RubyLessTest < Test::Unit::TestCase
   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 String, [:gsub, Regexp, String] => 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, :upcase => {:class => String, :pre_processor => true}
+
   safe_method_for Time, [:strftime, String] => String
+
   safe_method :@foo => {:class => Dummy, :method => "node"}
   safe_method :sub => SubDummy
   safe_method :str => SubString
 
+  safe_method [:accept_nil, String] => {:class => String, :accept_nil => true}
+  safe_method [:accept_nil, String, String] => {:class => String, :accept_nil => true}
+  safe_method [:no_nil, String] => String
+
+  safe_method [:no_op, String] => {:class => String, :method => ''}
+  safe_method [:no_op, Number] => {:class => String, :method => 'transform'}
+
+  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 [:find, String] => {:class => NilClass, :method => 'nil', :pre_processor => :build_finder}
+
+  # methods on nil
+  safe_method_for Object, :blank? => Boolean
+
   # Example to dynamically rewrite method calls during compilation
   def safe_method_type(signature)
     unless res = super
@@ -46,6 +60,26 @@ class RubyLessTest < Test::Unit::TestCase
     res
   end
 
+  def make_append_hash(signature = {})
+    {:class => Number, :append_hash => {:xyz => RubyLess::TypedString.new('bar', :class => Dummy)}, :method => 'add'}
+  end
+
+  def build_finder(string)
+    TypedString.new("secure(Node) { Node.find(#{string.inspect}) }", :class => Dummy )
+  end
+
+  def accept_nil(foo, bar=nil)
+    [foo, bar].inspect
+  end
+
+  def no_nil(foo)
+    foo
+  end
+
+  def get_dict
+    {:foo => 'Foo'}
+  end
+
   def contextual_method(signature)
     {:method => "contextual_#{signature[0]}", :class => String}
   end

data/test/mock/dummy_class.rb

@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/property_column'
 
 class Dummy < RubyLess::ActiveRecordMock
   include DummyModule
-  include RubyLess::SafeClass
+  include RubyLess
 
   attr_reader :name
 
@@ -16,8 +16,7 @@ class Dummy < RubyLess::ActiveRecordMock
                :id                  => {:class => Number, :method => :zip},
                :name                => String,
                :foo                 => :bar,
-               [:width, {:mode => String, :type => String, 'nice' => Boolean}] => String,
-               [:width]             => String
+               [:width, {:mode => String, :type => String, 'nice' => Boolean}] => String
   safe_context :spouse  => 'Dummy',
                :husband => {:class => 'Dummy', :context => {:clever => 'no'}}
 

data/test/mock/dummy_module.rb

@@ -1,5 +1,5 @@
 module DummyModule
-  include RubyLess::SafeClass
+  include RubyLess
   safe_method :maze => {:class => String, :method => 'mazette'}
 
   def mazette

data/test/typed_method_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class TypedMethodTest < Test::Unit::TestCase
+  TypedMethod = RubyLess::TypedMethod
+
+  context 'A method' do
+    subject do
+      TypedMethod.new('foo')
+    end
+
+    should 'render with name' do
+      assert_equal 'foo', subject.to_s
+    end
+
+    should 'accept new arguments with add_argument' do
+      assert_nothing_raised { subject.add_argument(1, Number) }
+    end
+
+    should 'accept new hash arguments' do
+      subject.set_hash(:foo, 'bar', Dummy)
+      assert_equal 'foo(:foo => bar)', subject.to_s
+    end
+
+    context 'with arguments' do
+      subject do
+        TypedMethod.new('foo', '1', '2')
+      end
+
+      should 'render with arguments' do
+        assert_equal 'foo(1, 2)', subject.to_s
+      end
+    end
+
+    context 'with a hash as last argument' do
+      subject do
+        m = TypedMethod.new('foo')
+        m.add_argument('1', Number)
+        m.set_hash(:foo, 'bar', Dummy)
+        m
+      end
+
+      should 'use ruby last hash syntax' do
+        assert_equal 'foo(1, :foo => bar)', subject.to_s
+      end
+    end
+  end
+end

data/test/typed_string_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TypedStringTest < Test::Unit::TestCase
+  TypedString = RubyLess::TypedString
+
+  context 'A typed string' do
+    subject do
+      TypedString.new('foo', Number)
+    end
+
+    should 'render with name' do
+      assert_equal 'foo', subject.to_s
+    end
+    
+    should 'return class of content on klass' do
+      assert_equal Number, subject.klass
+    end
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-21 00:00:00 +01:00
+date: 2010-05-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -66,9 +66,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 5
-        - 3
-        version: 0.5.3
+        - 6
+        - 0
+        version: 0.6.0
   type: :development
   version_requirements: *id004
 description: 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.
@@ -79,11 +79,13 @@ extensions: []
 
 extra_rdoc_files: 
 - README.rdoc
+- TODO
 files: 
 - .gitignore
 - History.txt
 - README.rdoc
 - Rakefile
+- TODO
 - lib/ruby_less.rb
 - lib/ruby_less/basic_types.rb
 - lib/ruby_less/error.rb
@@ -93,6 +95,7 @@ files:
 - lib/ruby_less/safe_class.rb
 - lib/ruby_less/signature_hash.rb
 - lib/ruby_less/syntax_error.rb
+- lib/ruby_less/typed_method.rb
 - lib/ruby_less/typed_string.rb
 - lib/rubyless.rb
 - rails/init.rb
@@ -100,6 +103,7 @@ files:
 - test/RubyLess/active_record.yml
 - test/RubyLess/basic.yml
 - test/RubyLess/errors.yml
+- test/RubyLess/hash.yml
 - test/RubyLess/string.yml
 - test/RubyLess_test.rb
 - test/mock/active_record_mock.rb
@@ -109,6 +113,8 @@ files:
 - test/safe_class_test.rb
 - test/signature_hash_test.rb
 - test/test_helper.rb
+- test/typed_method_test.rb
+- test/typed_string_test.rb
 has_rdoc: true
 homepage: http://zenadmin.org/546
 licenses: []
@@ -148,3 +154,5 @@ test_files:
 - test/safe_class_test.rb
 - test/signature_hash_test.rb
 - test/test_helper.rb
+- test/typed_method_test.rb
+- test/typed_string_test.rb