rubyless 0.5.0 → 0.6.0

data/History.txt

@@ -1,3 +1,14 @@
+== 0.6.0 2010-07-22
+
+* Major enhancements
+  * Added 'safe_eval' method.
+  * Added 'safe_eval_string' method.
+  * Better handling of syntax errors.
+  * Support for constants.
+
+* Minor enhancements
+  * Added safe methods on Time (compare, add/subtract number).
+
 == 0.5.0 2010-05-27
 
 * Major enhancements

data/lib/ruby_less/basic_types.rb

@@ -22,6 +22,17 @@ RubyLess::SafeClass.safe_method_for( Number,
   [:% , Number] => Number,  [:"-@"]       => Number
 )
 
+RubyLess::SafeClass.safe_method_for( Time,
+  [:==, Time] => Boolean, [:< , Time] => Boolean, [:> , Time] => Boolean,
+  [:<=, Time] => Boolean, [:>=, Time] => Boolean,
+  [:- , Number] => Time,  [:+ , Number] => Time
+)
+
 RubyLess::SafeClass.safe_method_for( String,
   [:==, String] => Boolean
 )
+
+RubyLess::SafeClass.safe_method_for( NilClass,
+  [:==, String] => Boolean,
+  [:==, Number] => Boolean
+)

data/lib/ruby_less/info.rb

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

data/lib/ruby_less/processor.rb

@@ -10,8 +10,13 @@ module RubyLess
     PREFIX_OPERATOR   = ['-@']
 
     def self.translate(string, helper)
-      sexp = RubyParser.new.parse(string)
-      self.new(helper).process(sexp)
+      if sexp = RubyParser.new.parse(string)
+        self.new(helper).process(sexp)
+      elsif string.size == 0
+        ''
+      else
+        raise RubyLess::SyntaxError.new("Syntax error")
+      end
     rescue Racc::ParseError => err
       raise RubyLess::SyntaxError.new(err.message)
     end
@@ -38,12 +43,26 @@ module RubyLess
       # send("process_#{method}", exp)
     end
 
+    def process_const(exp)
+      const_name = exp.pop.to_s
+      if opts = @helper.respond_to?(:safe_const_type) ? @helper.safe_const_type(const_name) : nil
+        t opts[:method], opts
+      else
+        raise RubyLess::Error.new("Unknown constant '#{const_name}'.")
+      end
+    end
+
     def process_and(exp)
       t "(#{process(exp.shift)} and #{process(exp.shift)})", Boolean
     end
 
     def process_or(exp)
-      t "(#{process(exp.shift)} or #{process(exp.shift)})", Boolean
+      left, right = process(exp.shift), process(exp.shift)
+      if left.klass == right.klass
+        t "(#{left} or #{right})", :class => right.klass, :nil => right.could_be_nil?
+      else
+        t "(#{left} or #{right})", Boolean
+      end
     end
 
     def process_not(exp)
@@ -109,7 +128,7 @@ module RubyLess
     def process_vcall(exp)
       var_name = exp.shift
       unless opts = get_method([var_name], @helper, false)
-        raise RubyLess::NoMethodError.new("Unknown variable or method '#{var_name}'.")
+        raise RubyLess::Error.new("Unknown variable or method '#{var_name}'.")
       end
       method = opts[:method]
       if args = opts[:prepend_args]
@@ -258,7 +277,8 @@ module RubyLess
         method = opts[:method]
         arg_list = args ? args.list : []
 
-        if receiver.could_be_nil? && opts != SafeClass.safe_method_type_for(NilClass, signature)
+        if receiver.could_be_nil? &&
+           !(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}

data/lib/ruby_less/safe_class.rb

@@ -73,125 +73,127 @@ module RubyLess
       end
     end
 
-    def self.included(base)
-      base.class_eval do
-
-        # Declare safe methods. By providing
-        #
-        # The methods hash has the following format:
-        #  signature => return type
-        # or
-        #  signature => options
-        # or
-        #  signature => lambda {|h| ... }
-        #
-        # The lambda expression will be called with @helper as argument during compilation.
-        #
-        # 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.
-        #
-        # The return type can be a string with the class name or a class.
-        #
-        # Options are:
-        # :class  the return type (class name)
-        # :nil    set this to true if the method could return nil
-        def self.safe_method(methods_hash)
-          RubyLess::SafeClass.safe_method_for(self, methods_hash)
-        end
+    # Return a safe type from a column
+    def self.safe_method_type_for_column(col, is_property = false)
+      opts = {}
+      opts[:nil]   = col.default.nil?
+      if col.number?
+        opts[:class] = Number
+      elsif col.text?
+        opts[:class] = String
+      else
+        opts[:class] = col.klass
+      end
+      if is_property
+        opts[:method] = "prop['#{col.name.gsub("'",'')}']"
+      else
+        opts[:method] = col.name
+      end
 
-        # A safe context is simply a safe method that can return nil in some situations. The rest of the
-        # syntax is the same as #safe_method. We call it a safe context because it enables syntaxes such
-        # as: if var = my_context(...) ---> enter context.
-        def self.safe_context(methods_hash)
-          methods_hash[:defaults] ||= {}
-          methods_hash[:defaults][:nil] = true
-          safe_method(methods_hash)
-        end
+      opts
+    end
 
-        def self.safe_literal_class(hash)
-          RubyLess::SafeClass.safe_literal_class(hash)
-        end
+    module ClassMethods
 
-        # Declare a safe method to access a list of attributes.
-        # This method should only be used when the class is linked with a database table and provides
-        # proper introspection to detect types and the possibility of NULL values.
-        def self.safe_attribute(*attributes)
-          attributes.each do |att|
-            if col = columns_hash[att.to_s]
-              opts = {}
-              opts[:nil]   = col.default.nil?
-              if col.number?
-                opts[:class] = Number
-              elsif col.text?
-                opts[:class] = String
-              else
-                opts[:class] = col.klass
-              end
-              safe_method att.to_sym => opts
-            else
-              puts "Warning: could not declare safe_attribute '#{att}' (No column with this name found in class #{self})"
-            end
+      # Declare safe methods. By providing
+      #
+      # The methods hash has the following format:
+      #  signature => return type
+      # or
+      #  signature => options
+      # or
+      #  signature => lambda {|h| ... }
+      #
+      # The lambda expression will be called with @helper as argument during compilation.
+      #
+      # 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.
+      #
+      # The return type can be a string with the class name or a class.
+      #
+      # Options are:
+      # :class  the return type (class name)
+      # :nil    set this to true if the method could return nil
+      def safe_method(methods_hash)
+        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
+      # syntax is the same as #safe_method. We call it a safe context because it enables syntaxes such
+      # as: if var = my_context(...) ---> enter context.
+      def safe_context(methods_hash)
+        methods_hash[:defaults] ||= {}
+        methods_hash[:defaults][:nil] = true
+        safe_method(methods_hash)
+      end
+
+      def safe_literal_class(hash)
+        RubyLess::SafeClass.safe_literal_class(hash)
+      end
+
+      # Declare a safe method to access a list of attributes.
+      # This method should only be used when the class is linked with a database table and provides
+      # proper introspection to detect types and the possibility of NULL values.
+      def safe_attribute(*attributes)
+        attributes.each do |att|
+          if col = columns_hash[att.to_s]
+            safe_method att.to_sym => SafeClass.safe_method_type_for_column(col)
+          else
+            puts "Warning: could not declare safe_attribute '#{att}' (No column with this name found in class #{self})"
           end
         end
+      end
 
-        # Declare a safe method to access a list of properties.
-        # This method should only be used in conjunction with the Property gem.
-        def self.safe_property(*properties)
-          columns = schema.columns
-          properties.each do |att|
-            if col = columns[att.to_s]
-              opts = {}
-              opts[:nil]   = col.default.nil?
-              if col.number?
-                opts[:class] = Number
-              elsif col.text?
-                opts[:class] = String
-              else
-                opts[:class] = col.klass
-              end
-              opts[:method] = "prop['#{att.to_s.gsub("'",'')}']"
-              safe_method att.to_sym => opts
-            else
-              puts "Warning: could not declare safe_property '#{att}' (No property column with this name found in class #{self})"
-            end
+      # Declare a safe method to access a list of properties.
+      # This method should only be used in conjunction with the Property gem.
+      def safe_property(*properties)
+        columns = schema.columns
+        properties.each do |att|
+          if col = columns[att.to_s]
+            safe_method att.to_sym => SafeClass.safe_method_type_for_column(col, true)
+          else
+            puts "Warning: could not declare safe_property '#{att}' (No property column with this name found in class #{self})"
           end
         end
+      end
 
+      # Declare a safe method for a given class
+      def safe_method_for(klass, signature)
+        SafeClass.safe_method_for(klass, signature)
+      end
 
-        # Declare a safe method for a given class
-        def self.safe_method_for(klass, signature)
-          SafeClass.safe_method_for(klass, signature)
-        end
+      # Hash of all safe methods defined for the class.
+      def safe_methods
+        SafeClass.safe_methods_for(self)
+      end
 
-        # Hash of all safe methods defined for the class.
-        def self.safe_methods
-          SafeClass.safe_methods_for(self)
-        end
+      # Return the type if the given signature corresponds to a safe method for the class.
+      def safe_method_type(signature)
+        SafeClass.safe_method_type_for(self, signature)
+      end
 
-        # Return the type if the given signature corresponds to a safe method for the class.
-        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 safe_class?
+        true
+      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 disable_safe_read
+        undef_method(:safe_read)
+      end
+    end # ClassMethods
 
-        # 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
+    def self.included(base)
+      base.extend ClassMethods
     end  # included
 
 
@@ -203,12 +205,25 @@ module RubyLess
     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 ?
+    # 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])
     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)
+      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)
+      eval(ruby)
+    end
+
     private
       def self.build_signature(key)
         keys = key.kind_of?(Array) ? key : [key]

data/lib/ruby_less.rb

@@ -24,6 +24,12 @@ module RubyLess
 
   def self.translate(string, helper)
     RubyLessProcessor.translate(string, helper)
+  rescue Exception => err
+    if err.kind_of?(RubyLess::Error)
+      raise err
+    else
+      raise RubyLess::Error.new("Error parsing \"#{string}\": #{err.message.strip}")
+    end
   end
 
   def self.translate_string(string, helper)
@@ -32,8 +38,12 @@ module RubyLess
     else
       TypedString.new(string.inspect, :class => String, :literal => string)
     end
-  rescue => err
-    raise RubyLess::Error.new("Error parsing string \"#{string}\": #{err.message.strip}")
+  rescue Exception => err
+    if err.kind_of?(RubyLess::Error)
+      raise err
+    else
+      raise RubyLess::Error.new("Error parsing string \"#{string}\": #{err.message.strip}")
+    end
   end
 end
 

data/rubyless.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.5.0"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2010-05-27}
+  s.date = %q{2010-07-22}
   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 = [
@@ -41,6 +41,7 @@ Gem::Specification.new do |s|
      "test/RubyLess/errors.yml",
      "test/RubyLess/hash.yml",
      "test/RubyLess/string.yml",
+     "test/RubyLess/time.yml",
      "test/RubyLess_test.rb",
      "test/mock/active_record_mock.rb",
      "test/mock/dummy_class.rb",

data/test/RubyLess/basic.yml

@@ -1,6 +1,6 @@
 empty:
   src: ""
-  tem: null
+  tem: ""
 
 numbers:
   src: "id > 45 and (3 > -id or 3+3)"
@@ -184,4 +184,21 @@ build_finder:
 
 methods_on_nil:
   src: 'dictionary[:foo].blank?'
-  tem: 'get_dict[:foo].blank?'
+  tem: 'get_dict[:foo].blank?'
+
+equality_on_nil:
+  src: 'dictionary[:foo] == "yo"'
+  tem: '(get_dict[:foo]=="yo")'
+
+or_same_class:
+  src: "vowel_count(dictionary[:bar] || 'aeiou')"
+  tem: 'vowel_count((get_dict[:bar] or "aeiou"))'
+  res: '5'
+
+class:
+  src: "@foo.kind_of?(Page)"
+  tem: "node.kind_of?(Page)"
+
+class_map_as_string:
+  src: "@foo.kind_of?(Document)"
+  tem: "node.is_like?(\"DOC\")"

data/test/RubyLess/errors.yml

@@ -55,3 +55,23 @@ hash_arguments_wrong_type:
 mixed_array:
   src: "[3, '4']"
   tem: 'Mixed Array not supported ([Number,String]).'
+
+hash_odd_keys_syntax_error:
+  src: '{text}'
+  tem: 'Syntax error'
+
+syntax_error:
+  src: "3 * / * 5"
+  tem: "/nterminated string meets end of file/"
+
+no_lasagna_in_rubyless:
+  src: "foo = system"
+  tem: "'lasgn' not available in RubyLess."
+
+call_on_class:
+  src: "Page.name"
+  tem: "unknown method 'name()' for 'Page' of type Class."
+
+unknown_constant:
+  src: "RubyLess"
+  tem: "Unknown constant 'RubyLess'."

data/test/RubyLess/time.yml

@@ -0,0 +1,15 @@
+minus:
+  src: "now - 4"
+  tem: "(Time.now-4)"
+
+plus:
+  src: "now + 2* 3600"
+  tem: "(Time.now+(2*3600))"
+  
+compare:
+  src: "now == now"
+  tem: "(Time.now==Time.now)"
+  
+compare:
+  src: "now > now"
+  tem: "(Time.now>Time.now)"

data/test/RubyLess_test.rb

@@ -26,6 +26,8 @@ class RubyLessTest < Test::Unit::TestCase
 
   safe_method_for Time, [:strftime, String] => String
 
+  safe_method :now => {:method => 'Time.now', :class => Time}
+
   safe_method :@foo => {:class => Dummy, :method => "node"}
   safe_method :sub => SubDummy
   safe_method :str => SubString
@@ -46,12 +48,22 @@ class RubyLessTest < Test::Unit::TestCase
   # methods on nil
   safe_method_for Object, :blank? => Boolean
 
+  def safe_const_type(constant)
+    if constant == 'Page'
+      {:method => 'Page', :class => Class}
+    elsif constant =~ /^D/
+      {:method => constant[0..2].upcase.inspect, :class => String, :literal => constant}
+    else
+      nil
+    end
+  end
+
   # Example to dynamically rewrite method calls during compilation
   def safe_method_type(signature)
     unless res = super
       if signature == ['prepend_test', Number]
         res ={:class => Number, :prepend_args => RubyLess::TypedString.new('10', :class => Number), :method => 'add'}
-      elsif res = context[:node_class].safe_method_type(signature)
+      elsif context && res = context[:node_class].safe_method_type(signature)
         # try to execute method in the current var "var.method"
         res = res.call(self, signature) if res.kind_of?(Proc)
         res = res.merge(:method => "#{context[:node]}.#{res[:method] || signature[0]}")

data/test/mock/active_record_mock.rb

@@ -4,6 +4,10 @@ module RubyLess
       @opts = opts
     end
 
+    def name
+      @opts[:name]
+    end
+
     def default
       @opts[:default]
     end
@@ -42,10 +46,10 @@ module RubyLess
 
   class ActiveRecordMock
     COLUMNS = {
-      'format' => ColumnMock.new(:default => '%d.%m.%Y', :type   => :text),
-      'age'    => ColumnMock.new(:default => 5,  :type => :float),
-      'friend_id' => ColumnMock.new(:type => :integer),
-      'log_at' => ColumnMock.new(:type => :datetime),
+      'format' => ColumnMock.new(:default => '%d.%m.%Y', :type   => :text, :name => 'format'),
+      'age'    => ColumnMock.new(:default => 5,  :type => :float, :name => 'age'),
+      'friend_id' => ColumnMock.new(:type => :integer, :name => 'friend_id'),
+      'log_at' => ColumnMock.new(:type => :datetime, :name => 'log_at'),
     }
     def self.columns_hash
       COLUMNS

data/test/mock/dummy_class.rb

@@ -16,7 +16,10 @@ class Dummy < RubyLess::ActiveRecordMock
                :id                  => {:class => Number, :method => :zip},
                :name                => String,
                :foo                 => :bar,
-               [:width, {:mode => String, :type => String, 'nice' => Boolean}] => String
+               [:width, {:mode => String, :type => String, 'nice' => Boolean}] => String,
+               [:kind_of?, Class]   => Boolean,
+               [:kind_of?, String]  => {:method => 'is_like?', :class  => Boolean}
+
   safe_context :spouse  => 'Dummy',
                :husband => {:class => 'Dummy', :context => {:clever => 'no'}}
 

data/test/safe_class_test.rb

@@ -12,5 +12,32 @@ class SafeClassTest < Test::Unit::TestCase
     should 'have an associated SignatureHash for safe methods' do
       assert_kind_of RubyLess::SignatureHash, Dummy.safe_methods
     end
-  end
+  end # A safe model
+
+  context 'An instance of a safe model' do
+    subject do
+      Dummy.new
+    end
+
+    context 'on safe_eval' do
+      should 'evaluate RubyLess' do
+        assert_equal 'Biscotte', subject.safe_eval("dog_name")
+      end
+
+      should 'raise NoMethodError on missing method' do
+        assert_raise(RubyLess::NoMethodError) { subject.safe_eval("bad_method('Bp Oil Spill')") }
+      end
+    end # on safe_eval
+
+    context 'on safe_eval_string' do
+      should 'evaluate RubyLess as dstring' do
+        assert_equal 'my Biscotte', subject.safe_eval_string('my #{dog_name}')
+      end
+
+      should 'raise NoMethodError on missing method' do
+        assert_raise(RubyLess::NoMethodError) { subject.safe_eval_string("their \#{bad_method('Bp Oil Spill')}") }
+      end
+    end # on safe_eval
+
+  end # An instance of a safe model
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-27 00:00:00 +02:00
+date: 2010-07-22 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,6 +105,7 @@ files:
 - test/RubyLess/errors.yml
 - test/RubyLess/hash.yml
 - test/RubyLess/string.yml
+- test/RubyLess/time.yml
 - test/RubyLess_test.rb
 - test/mock/active_record_mock.rb
 - test/mock/dummy_class.rb