rubyless 0.3.0 → 0.3.1

data/History.txt

@@ -1,4 +1,14 @@
-== 0.3.0 2009-10-03
+== 0.3.1 2009-10-07
+
+* 3 major enhancements
+  * method name in signatures should always be a string
+  * type[:method] is always set and is always a string
+  * fixed how class type is guessed from ActiveRecord column
+
+* 1 minor enhancement
+  * added 'safe_read' method to objects
+
+== 0.3.1 2009-10-03
 
 * 1 major enhancement
   * Moved from ParseTree to RubyParser

data/lib/processor.rb

@@ -12,8 +12,8 @@ module RubyLess
   class RubyLessProcessor < SexpProcessor
     attr_reader :ruby
 
-    INFIX_OPERATOR = [:"<=>", :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%]
-    PREFIX_OPERATOR   = [:"-@"]
+    INFIX_OPERATOR = ['<=>', '==', '<', '>', '<=', '>=', '-', '+', '*', '/', '%']
+    PREFIX_OPERATOR   = ['-@']
 
     def self.translate(string, helper)
       sexp = RubyParser.new.parse(string)
@@ -94,7 +94,7 @@ module RubyLess
       unless opts = get_method([var_name], @helper, false)
         raise "Unknown variable or method '#{var_name}'."
       end
-      method = opts[:method] || var_name.to_s
+      method = opts[:method]
       t method, opts
     end
 
@@ -147,7 +147,7 @@ module RubyLess
       end
 
       def method_call(receiver, exp)
-        method = exp.shift
+        method = exp.shift.to_s
         arg_sexp = args = exp.shift # rescue nil
         if arg_sexp
           args = process(arg_sexp)
@@ -169,14 +169,14 @@ module RubyLess
             cond += receiver.cond
           end
           raise "'#{receiver}' does not respond to '#{method}(#{signature[1..-1].join(', ')})'." unless opts = get_method(signature, receiver.klass)
-          method = opts[:method] if opts[:method]
-          if method == :/
+          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 == :[]
+          elsif method == '[]'
             t_if cond, "#{receiver.raw}[#{args.raw}]", opts
           else
             args = "(#{args.raw})" if args != ''
@@ -184,7 +184,7 @@ module RubyLess
           end
         else
           raise "Unknown method '#{method}(#{args.raw})'." unless opts = get_method(signature, @helper, false)
-          method = opts[:method] if opts[:method]
+          method = opts[:method]
           args = "(#{args.raw})" if args != ''
           t_if cond, "#{method}#{args}", opts
         end

data/lib/rubyless.rb

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

data/lib/safe_class.rb

@@ -2,12 +2,12 @@ module RubyLess
   module SafeClass
     @@_safe_methods     ||= {} # defined for each class
     @@_safe_methods_all ||= {} # full list with inherited attributes
-    
+
     # List of safe methods for a specific class.
     def self.safe_methods_for(klass)
       @@_safe_methods_all[klass] ||= build_safe_methods_list(klass)
     end
-    
+
     # 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]
@@ -16,20 +16,22 @@ module RubyLess
         nil
       end
     end
-    
+
     # Declare a safe method for a given class
     def self.safe_method_for(klass, hash)
       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)
+        v[:method] = v[:method] ? v[:method].to_s : k.first.to_s
         list[k] = v
       end
     end
-    
+
     def self.included(base)
       base.class_eval do
-        
+
         # Declare safe methods. By providing
         #
         # The methods hash has the following format:
@@ -55,21 +57,23 @@ module RubyLess
         def self.safe_method(hash)
           methods_hash = 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)
               # cannot merge defaults
             else
-              v = defaults.merge(:class => v)
+              v = defaults.merge(:class => v, :method => k.first.to_s)
             end
             list[k] = v
           end
         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.
@@ -82,10 +86,8 @@ module RubyLess
                 opts[:class] = Number
               elsif col.text?
                 opts[:class] = String
-              elsif att.to_s =~ /_at$/
-                opts[:class] = Time
               else
-                raise "Could not declare safe_method for '#{att}': could not guess return type"
+                opts[:class] = col.klass
               end
               safe_method att.to_sym => opts
             else
@@ -93,34 +95,41 @@ module RubyLess
             end
           end
         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 self.safe_methods
           SafeClass.safe_methods_for(self)
         end
-        
+
         # Return true 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
+            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)
         end
       end  # base.class_eval
     end  # included
-  
-    private   
+
+    # Safe attribute reader used when 'safe_readable?' could not be called because the class
+    # is not known during compile time.
+    def safe_read(key)
+      return "'#{key}' not readable" unless type = self.class.safe_method_type([key])
+      self.send(type[:method])
+    end
+
+    private
       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|
@@ -129,12 +138,13 @@ module RubyLess
           elsif !return_value.kind_of?(Proc)
             return_value = {:class => return_value}
           end
-          signature.map! {|e| parse_class(e)}
+          method = signature.shift
+          signature = [method] + signature.map {|e| parse_class(e)}
           list[signature] = return_value
         end
         list
       end
-      
+
       def self.parse_class(klass)
         if klass.kind_of?(Array)
           if klass[0].kind_of?(String)

data/rubyless.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]

data/test/RubyLess_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 
 class StringDictionary
   include RubyLess::SafeClass
-  safe_method [:[], Symbol] => {:class => String, :nil => true}
+  safe_method ['[]', Symbol] => {:class => String, :nil => true}
 end
 
 class SimpleHelper < Test::Unit::TestCase
@@ -15,7 +15,7 @@ class SimpleHelper < Test::Unit::TestCase
   safe_method :node => lambda {|h| {: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 'dictionary' => {:class => StringDictionary, :method => 'get_dict'}
   safe_method [:vowel_count, String]    => Number
   safe_method [:log_info, Dummy, String]    => String
   safe_method_for String, [:==, String] => Boolean
@@ -46,6 +46,11 @@ class SimpleHelper < 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 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)
@@ -60,6 +65,7 @@ class SimpleHelper < Test::Unit::TestCase
     when 'tem'
       source ? RubyLess.translate(source, self) : 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
     when 'sxp'
       RubyParser.new.parse(source).inspect

data/test/mock/active_record_mock.rb

@@ -8,26 +8,49 @@ module RubyLess
       @opts[:default]
     end
 
+    def type
+      @opts[:type]
+    end
+
+    # Returns +true+ if the column is either of type string or text.
     def text?
-      @opts[:text]
+      type == :string || type == :text
     end
 
+    # Returns +true+ if the column is either of type integer, float or decimal.
     def number?
-      @opts[:number]
+      type == :integer || type == :float || type == :decimal
     end
+
+    # Returns the Ruby class that corresponds to the abstract data type.
+    def klass
+      case type
+        when :integer       then Fixnum
+        when :float         then Float
+        when :decimal       then BigDecimal
+        when :datetime      then Time
+        when :date          then Date
+        when :timestamp     then Time
+        when :time          then Time
+        when :text, :string then String
+        when :binary        then String
+        when :boolean       then Object
+      end
+    end
+
   end
 
   class ActiveRecordMock
     COLUMNS = {
-      'format' => ColumnMock.new(:default => '%d.%m.%Y', :text   => true),
-      'age'    => ColumnMock.new(:default => 5,  :number => true),
-      'friend_id' => ColumnMock.new(:number => true),
-      'log_at' => ColumnMock.new,
+      '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),
     }
     def self.columns_hash
       COLUMNS
     end
-    
+
     COLUMNS.each do |k, v|
       define_method(k) do
         v.default

metadata

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