rubyless 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,12 @@
+== 0.2.0 2009-06-02
+
+* 1 major enhancement:
+  * Added support for ActiveRecord attributes
+
+* 2 minor enhancement:
+  * Better documentation
+  * Removed eval (this means safe methods are globally declared)
+
 == 0.1.0 2009-06-02
 
 * 1 major enhancement:

data/README.rdoc

@@ -35,10 +35,15 @@ return 'nil' instead of the declared output, you need to wrap your final ruby 'e
  safe_method_for String, [:==, String] => RubyLess::Boolean
  safe_method_for String, [:to_s] => String
 
-You can also redefine 'safe_method?' for any class or for the main helper in order to do some more complicated renaming. Note
+You can also redefine 'safe_method_type' for any class or for the main helper in order to do some more complicated renaming. Note
 also that you should add ':nil => true' declaration to any method that could return a nil value so that RubyLess can render
 code that will not break during runtime (adding nil checking in the form of "foo ? foo.name : nil").
 
+Or you can group all declarations in a single place with 'safe_method_for':
+
+ RubyLess::SafeClass.safe_method_for Dummy, :prev => {:class => Dummy, :method => 'previous', :nil => true},
+                                            :node => lambda {|h| {:class => h.context[:node_class], :method => h.context[:node]}}
+
 You can now parse some ruby code:
 
  RubyLess.translate("!prev.ancestor?(main) && !node.ancestor?(main)", self)
@@ -53,8 +58,7 @@ You can now parse some ruby code:
  RubyLess.translate("log_info(spouse, spouse.name)", self)
  => "(var1.spouse ? log_info(var1.spouse, var1.spouse.name) : nil)"
 
-Since most of the code in SafeClass is string evaluated (to scope class variables), there is not much to parse for rdoc. You
-can look at the tests for an idea of how to declare things. If you have more questions, ask on zena's mailing list:
+You can look at the tests for an idea of how to declare things. If you have more questions, ask on zena's mailing list:
 
 http://zenadmin.org/community
   

data/Rakefile

@@ -1,7 +1,7 @@
 require "rubygems"
 require "rake/gempackagetask"
 require "rake/rdoctask"
-require "lib/RubyLess"
+require "lib/rubyless"
 
 task :default => :test
 

data/lib/basic_types.rb

@@ -0,0 +1,39 @@
+require 'safe_class'
+
+module RubyLess
+  
+  class Boolean
+  end
+  
+  class Number
+    include SafeClass
+    safe_method( [:==, Number] => Boolean, [:< , Number] => Boolean, [:> , Number] => Boolean, [:<=, Number] => Boolean, [:>=, Number] => Boolean,
+                 [:- , Number] => Number,  [:+ , Number] => Number,  [:* , Number] => Number,  [:/ , Number] => Number,
+                 [:% , Number] => Number,  [:"-@"]       => Number )
+  end
+  
+  
+  class Missing
+    [:==, :< , :> , :<=, :>=, :"?"].each do |sym|
+      define_method(sym) do |arg|
+        false
+      end
+    end
+    
+    def to_s
+      ''
+    end
+    
+    def nil?
+      true
+    end
+    
+    def method_missing(*meth)
+      self
+    end
+  end
+  
+  Nil = Missing.new
+
+  
+end

data/lib/{RubyLess.rb → processor.rb}

@@ -1,113 +1,11 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 require 'rubygems'
 require 'parse_tree'
-require 'SafeClass'
-=begin rdoc
-=end
-module RubyLess
-  VERSION = '0.1.0'
-  
-  def self.translate(string, helper)
-    RubyLessProcessor.translate(string, helper)
-  end
-  
-  class Boolean
-  end
-  
-  class Number
-    include SafeClass
-    safe_method( [:==, Number] => Boolean, [:< , Number] => Boolean, [:> , Number] => Boolean, [:<=, Number] => Boolean, [:>=, Number] => Boolean,
-                 [:- , Number] => Number,  [:+ , Number] => Number,  [:* , Number] => Number,  [:/ , Number] => Number,
-                 [:% , Number] => Number,  [:"-@"]       => Number )
-  end
-  
-  
-  class Missing
-    [:==, :< , :> , :<=, :>=, :"?"].each do |sym|
-      define_method(sym) do |arg|
-        false
-      end
-    end
-    
-    def to_s
-      ''
-    end
-    
-    def nil?
-      true
-    end
-    
-    def method_missing(*meth)
-      self
-    end
-  end
-  
-  Nil = Missing.new
-
-  class TypedString < String
-    attr_reader :klass, :opts
 
-    def initialize(content = "", opts = nil)
-      opts ||= {:class => String}
-      replace(content)
-      @opts = opts.dup
-      if could_be_nil? && !@opts[:cond]
-        @opts[:cond] = [self.to_s]
-      end
-    end
-    
-    def klass
-      @opts[:class]
-    end
-    
-    def could_be_nil?
-      @opts[:nil]
-    end
-    
-    # condition when 'could_be_nil' comes from a different method then the last one:
-    # var1.spouse.name == ''
-    # "var1.spouse" would be the condition that inserted 'could_be_nil?'.
-    def cond
-      @opts[:cond]
-    end
-    
-    # raw result without nil checking:
-    # "var1.spouse.name" instead of "(var1.spouse ? var1.spouse.name : nil)"
-    def raw
-      @opts[:raw] || self.to_s
-    end
-
-    def <<(typed_string)
-      append_opts(typed_string)
-      if self.empty?
-        replace(typed_string.raw)
-      else
-        replace("#{self.raw}, #{typed_string.raw}")
-      end
-    end
-    
-    def append_opts(typed_string)
-      if self.empty?
-        @opts = typed_string.opts.dup
-      else
-        if klass.kind_of?(Array)
-          klass << typed_string.klass
-        else
-          @opts[:class] = [klass, typed_string.klass]
-        end
-        append_cond(typed_string.cond) if typed_string.could_be_nil?
-      end
-    end
-    
-    def append_cond(condition)
-      @opts[:cond] ||= []
-      @opts[:cond] += [condition].flatten
-      @opts[:cond].uniq!
-    end
-  end
+require 'basic_types'
+require 'typed_string'
+require 'safe_class'
 
+module RubyLess  
   class RubyLessProcessor < SexpProcessor
     attr_reader :ruby
 
@@ -172,7 +70,7 @@ module RubyLess
     def process_arglist(exp)
       code = t("")
       until exp.empty? do
-        code << process(exp.shift)
+        code.append_argument(process(exp.shift))
       end
       code
     end
@@ -296,7 +194,7 @@ module RubyLess
       end
       
       def get_method(signature, receiver, is_method = true)
-        res = receiver.respond_to?(:safe_method?) ? receiver.safe_method?(signature) : @helper.class.safe_method_for?(receiver, signature)
+        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
       end

data/lib/rubyless.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'processor'
+
+=begin rdoc
+=end
+module RubyLess
+  VERSION = '0.2.0'
+  
+  def self.translate(string, helper)
+    RubyLessProcessor.translate(string, helper)
+  end
+end

data/lib/safe_class.rb

@@ -0,0 +1,140 @@
+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]
+        res.dup
+      else
+        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)
+        v = {:class => v} unless v.kind_of?(Hash) || v.kind_of?(Proc)
+        list[k] = v
+      end
+    end
+    
+    def self.included(base)
+      base.class_eval do
+        
+        # Declare a safe method through a hash of either
+        #  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]
+        #
+        # 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(hash)
+          list = (@@_safe_methods[self] ||= {})
+          hash.each do |k,v|
+            k = [k] unless k.kind_of?(Array)
+            v = {:class => v} unless v.kind_of?(Hash) || v.kind_of?(Proc)
+            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.
+        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] = RubyLess::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"
+              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
+          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
+          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   
+      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|
+          if return_value.kind_of?(Hash)
+            return_value[:class] = parse_class(return_value[:class])
+          elsif !return_value.kind_of?(Proc)
+            return_value = {:class => return_value}
+          end
+          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)
+            [Module::const_get(klass[0])]
+          else
+            klass
+          end
+        else
+          if klass.kind_of?(String)
+            Module::const_get(klass)
+          else
+            klass
+          end
+        end
+      end
+  end
+end

data/lib/typed_string.rb

@@ -0,0 +1,71 @@
+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}
+      replace(content)
+      @opts = opts.dup
+      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:
+    #  var1.spouse.name == ''
+    # "var1.spouse" would be the condition that could yield 'nil'.
+    def cond
+      @opts[:cond]
+    end
+    
+    # raw result without nil checking:
+    # "var1.spouse.name" instead of "(var1.spouse ? var1.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)
+      append_opts(typed_string)
+      if self.empty?
+        replace(typed_string.raw)
+      else
+        replace("#{self.raw}, #{typed_string.raw}")
+      end
+    end
+    
+    private
+      def append_opts(typed_string)
+        if self.empty?
+          @opts = typed_string.opts.dup
+        else
+          if klass.kind_of?(Array)
+            klass << typed_string.klass
+          else
+            @opts[:class] = [klass, typed_string.klass]
+          end
+          append_cond(typed_string.cond) if typed_string.could_be_nil?
+        end
+      end
+    
+      def append_cond(condition)
+        @opts[:cond] ||= []
+        @opts[:cond] += [condition].flatten
+        @opts[:cond].uniq!
+      end
+  end
+end

data/rubyless.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyless}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
   s.date = %q{2009-06-02}
   s.email = %q{gaspard@teti.ch}
   s.extra_rdoc_files = ["README.rdoc"]
-  s.files = ["History.txt", "Rakefile", "README.rdoc", "rubyless.gemspec", "test/mock", "test/mock/dummy_class.rb", "test/RubyLess", "test/RubyLess/basic.yml", "test/RubyLess/errors.yml", "test/RubyLess_test.rb", "test/test_helper.rb", "lib/RubyLess.rb", "lib/SafeClass.rb"]
+  s.files = ["History.txt", "Rakefile", "README.rdoc", "rubyless.gemspec", "test/mock", "test/mock/active_record_mock.rb", "test/mock/dummy_class.rb", "test/RubyLess", "test/RubyLess/active_record.yml", "test/RubyLess/basic.yml", "test/RubyLess/errors.yml", "test/RubyLess_test.rb", "test/test_helper.rb", "lib/basic_types.rb", "lib/processor.rb", "lib/rubyless.rb", "lib/safe_class.rb", "lib/typed_string.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://zenadmin.org/546}
   s.rdoc_options = ["--main", "README.rdoc"]

data/test/RubyLess/active_record.yml

@@ -0,0 +1,19 @@
+time_type_from_columns:
+  src: 'log_at.strftime("%Y")'
+  tem: "(var1.log_at ? var1.log_at.strftime(\"%Y\") : nil)"
+
+text_type_from_columns:
+  src: 'birth.strftime(format)'
+  tem: "Date.parse('2009-06-02 18:44').strftime(var1.format)"
+  res: '02.06.2009'
+
+number_type_from_columns:
+  src: "age + 15"
+  tem: "(var1.age+15)"
+  res: "20"
+
+number_type_from_columns_no_default:
+  src: "friend_id + 15"
+  tem: "(var1.friend_id ? (var1.friend_id+15) : nil)"
+  res: ""
+

data/test/RubyLess/basic.yml

@@ -7,16 +7,16 @@ numbers:
   tem: "((var1.zip>45) and ((3>-var1.zip) or (3+3)))"
 
 global_method:
-  src: "strftime(now, '%Y')"
-  tem: "strftime(Time.now, \"%Y\")"
+  src: "now.strftime('%Y')"
+  tem: "Time.now.strftime(\"%Y\")"
 
 dynamic_string:
-  src: "strftime(now, \"#{name}\")"
-  tem: "strftime(Time.now, \"#{var1.name}\")"
+  src: "now.strftime(\"#{name}\")"
+  tem: "Time.now.strftime(\"#{var1.name}\")"
 
 dynamic_string_again:
-  src: "strftime(now, \"#{name}\")"
-  tem: "strftime(Time.now, \"#{var1.name}\")"
+  src: "now.strftime(\"#{name}\")"
+  tem: "Time.now.strftime(\"#{var1.name}\")"
 
 rewrite_variables:
   src: "!prev.ancestor?(main) && !node.ancestor?(main)"

data/test/RubyLess/errors.yml

@@ -11,6 +11,10 @@ zero_div:
   tem: "(1/(var1.zip-10) rescue nil)"
   res: ""
   
-no_looping:
+looping:
   src: "while(true) do puts 'flood' end"
-  res: 'Bug! Unknown node-type :while to RubyLess::RubyLessProcessor'
+  res: 'Bug! Unknown node-type :while to RubyLess::RubyLessProcessor'
+
+add_two_strings:
+  src: "name + 14"
+  res: "'var1.name' does not respond to '+(14)'."

data/test/RubyLess_test.rb

@@ -1,3 +1,4 @@
+require 'date'
 require File.dirname(__FILE__) + '/test_helper.rb'
 
 class SimpleHelper < Test::Unit::TestCase
@@ -7,17 +8,19 @@ class SimpleHelper < Test::Unit::TestCase
   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 :now  => {:class => Time,  :method => 'Time.now'}
-  safe_method [:strftime, Time, String] => String
+  safe_method :now   => {:class => Time,  :method => "Time.now"}
+  safe_method :birth => {:class => Time, :method => "Date.parse('2009-06-02 18:44')"}
   safe_method [:vowel_count, String]    => RubyLess::Number
   safe_method [:log_info, Dummy, String]    => String
   safe_method_for String, [:==, String] => RubyLess::Boolean
   safe_method_for String, [:to_s] => String
+  safe_method_for Time, [:strftime, String] => String
   
-  def safe_method?(signature)
-    unless res = self.class.safe_method?(signature)
+  # Example to dynamically rewrite method calls during compilation
+  def safe_method_type(signature)
+    unless res = self.class.safe_method_type(signature)
       # try to execute method in the current var "var.method"
-      if res = context[:node_class].safe_method?(signature)
+      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]}"
       end

data/test/mock/active_record_mock.rb

@@ -0,0 +1,37 @@
+module RubyLess
+  class ColumnMock
+    def initialize(opts = {})
+      @opts = opts
+    end
+
+    def default
+      @opts[:default]
+    end
+
+    def text?
+      @opts[:text]
+    end
+
+    def number?
+      @opts[:number]
+    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,
+    }
+    def self.columns_hash
+      COLUMNS
+    end
+    
+    COLUMNS.each do |k, v|
+      define_method(k) do
+        v.default
+      end
+    end
+  end
+end

data/test/mock/dummy_class.rb

@@ -1,15 +1,19 @@
-class Dummy
+require File.dirname(__FILE__) + '/active_record_mock'
+
+class Dummy < RubyLess::ActiveRecordMock
   attr_reader :name
   include RubyLess::SafeClass
   
   safe_method [:ancestor?, Dummy]  => RubyLess::Boolean
-  safe_method :parent              => {:class => 'Dummy', :special_option => 'foobar'}
-  safe_method :children            => ['Dummy']
-  safe_method :project             => 'Dummy'
-  safe_method :spouse              => {:class => 'Dummy', :nil => true}
-  safe_method :husband             => {:class => 'Dummy', :nil => true}
-  safe_method :id                  => {:class => RubyLess::Number, :method => :zip}
-  safe_method :name                => String
+  safe_method :parent              => {:class => 'Dummy', :special_option => 'foobar'},
+              :children            => ['Dummy'],
+              :project             => 'Dummy',
+              :spouse              => {:class => 'Dummy', :nil => true},
+              :husband             => {:class => 'Dummy', :nil => true},
+              :id                  => {:class => RubyLess::Number, :method => :zip},
+              :name                => String
+             
+  safe_attribute :age, :friend_id, :log_at, :format
   
   def initialize(name = 'dummy')
     @name = name

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 require 'stringio'
 require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/RubyLess'
+require File.dirname(__FILE__) + '/../lib/rubyless'
 require File.dirname(__FILE__) + '/mock/dummy_class'
 require 'rubygems'
 require 'yamltest'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyless
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -27,14 +27,19 @@ files:
 - README.rdoc
 - rubyless.gemspec
 - test/mock
+- test/mock/active_record_mock.rb
 - test/mock/dummy_class.rb
 - test/RubyLess
+- test/RubyLess/active_record.yml
 - test/RubyLess/basic.yml
 - test/RubyLess/errors.yml
 - test/RubyLess_test.rb
 - test/test_helper.rb
-- lib/RubyLess.rb
-- lib/SafeClass.rb
+- lib/basic_types.rb
+- lib/processor.rb
+- lib/rubyless.rb
+- lib/safe_class.rb
+- lib/typed_string.rb
 has_rdoc: true
 homepage: http://zenadmin.org/546
 post_install_message: 

data/lib/SafeClass.rb

@@ -1,98 +0,0 @@
-module RubyLess
-  module SafeClass
-    def self.included(base)
-      # add all methods from the module "AddActsAsMethod" to the 'base' module
-      base.class_eval <<-END
-        @@_safe_methods     ||= {} # defined for each class
-        @@_safe_methods_all ||= {} # full list with inherited attributes
-
-        def self.safe_method(hash)
-          list = (@@_safe_methods[self] ||= {})
-          hash.each do |k,v|
-            k = [k] unless k.kind_of?(Array)
-            v = {:class => v} unless v.kind_of?(Hash) || v.kind_of?(Proc)
-            list[k] = v
-          end
-        end
-
-        def self.safe_methods
-          safe_methods_for(self)
-        end
-        
-        def self.safe_methods_for(klass)
-          @@_safe_methods_all[klass] ||= build_safe_methods_list(klass)
-        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|
-            if return_value.kind_of?(Hash)
-              return_value[:class] = parse_class(return_value[:class])
-            elsif !return_value.kind_of?(Proc)
-              return_value = {:class => return_value}
-            end
-            signature.map! {|e| parse_class(e)}
-            list[signature] = return_value
-          end
-          list
-        end
-        
-        def self.safe_method?(signature)
-          if res = safe_methods[signature]
-            res.dup
-          else
-            nil
-          end
-        end
-        
-        def self.safe_method_for?(klass, signature)
-          if res = safe_methods_for(klass)[signature]
-            res.dup
-          else
-            nil
-          end
-        end
-        
-        def safe_method?(signature)
-          self.class.safe_methods[signature]
-        end
-        
-        def self.safe_method_for(klass, hash)
-          list = (@@_safe_methods[klass] ||= {})
-          hash.each do |k,v|
-            k = [k] unless k.kind_of?(Array)
-            v = {:class => v} unless v.kind_of?(Hash) || v.kind_of?(Proc)
-            list[k] = v
-          end
-        end
-        
-        def self.parse_class(klass)
-          if klass.kind_of?(Array)
-            if klass[0].kind_of?(String)
-              [Module::const_get(klass[0])]
-            else
-              klass
-            end
-          else
-            if klass.kind_of?(String)
-              Module::const_get(klass)
-            else
-              klass
-            end
-          end
-        end
-
-        def self.safe_attribute?(sym)
-          column_names.include?(sym) || zafu_readable?(sym) || safe_attribute_list.include?(sym.to_s)
-        end
-
-        def self.zafu_readable?(sym)
-          if sym.to_s =~ /(.*)_zips?$/
-            return true if self.ancestors.include?(Node) && RelationProxy.find_by_role($1.singularize)
-          end
-          self.zafu_readable_attributes.include?(sym.to_s)
-        end
-      END
-    end
-  end
-end