rubyless 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 2009-06-02
+
+* 1 major enhancement:
+  * Initial alpha release

data/README.rdoc

@@ -0,0 +1,92 @@
+= RubyLess
+
+* http://zenadmin.org/546
+
+== 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. The goals:
+
+ 1. give ruby scripting access to users without any security risk
+ 2. rewrite variable names depending on compilation context
+ 3. never raise runtime errors through compile time type checking and powerful nil handling 
+
+This library is based on Ruby2Ruby by Ryan Davis, thanks to him for sharing his work.
+
+== SYNOPSIS:
+  
+For every class that will be involved in your RubyLess scripts, you need to declare safe methods with the 'safe_method' macro if
+you want to enable methods from this class. You have to specify the return type of the method. If you have some methods that
+return 'nil' instead of the declared output, you need to wrap your final ruby 'eval' with a rescue clause.
+
+ # signature is made of [method, arg_class, arg_class, ...]
+ class Node
+   include RubyLess::SafeClass
+   safe_method [:ancestor?, Node] => RubyLess::Boolean
+ end
+ 
+ # methods defined in helper
+ 
+ # global methods
+ include RubyLess::SafeClass
+ 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
+ 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
+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").
+
+You can now parse some ruby code:
+
+ RubyLess.translate("!prev.ancestor?(main) && !node.ancestor?(main)", self)
+ => "(not previous.ancestor?(@node) and not var1.ancestor?(@node))"
+ 
+ RubyLess.translate("id > 45 and (3 > -id or 3+3)", self)
+ => "(var1.zip>45 and ((3>-var1.zip) or (3+3)))"
+ 
+ RubyLess.translate("strftime(now, '%Y')", self)
+ => "strftime(Time.now, \"%Y\")"
+ 
+ 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:
+
+http://zenadmin.org/community
+  
+== REQUIREMENTS:
+
+* parse_tree
+
+== INSTALL:
+
+sudo gem install rubyless
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Gaspard Bucher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,124 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "lib/RubyLess"
+
+task :default => :test
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+  
+  # Change these as appropriate
+  s.name              = "rubyless"
+  s.version           = RubyLess::VERSION
+  s.summary           = %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.author            = "Gaspard Bucher"
+  s.email             = "gaspard@teti.ch"
+  s.homepage          = "http://zenadmin.org/546"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.rdoc)
+  s.rdoc_options      = %w(--main README.rdoc)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(History.txt Rakefile README.rdoc rubyless.gemspec) + Dir.glob("{test,lib}/**/*")
+   
+  s.require_paths     = ["lib"]
+  
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  # s.add_dependency("some_other_gem", "~> 0.1.0")
+  
+  # If your tests use any gems, include them here
+  # s.add_development_dependency("mocha")
+
+  # If you want to publish automatically to rubyforge, you'll may need
+  # to tweak this, and the publishing task below too.
+  s.rubyforge_project = "rubyless"
+end
+
+# This task actually builds the gem. We also regenerate a static 
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  
+  # Generate the gemspec file for github.
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end
+
+# If you want to publish to RubyForge automatically, here's a simple 
+# task to help do that. If you don't, just get rid of this.
+# Be sure to set up your Rubyforge account details with the Rubyforge
+# gem; you'll need to run `rubyforge setup` and `rubyforge config` at
+# the very least.
+begin
+  require "rake/contrib/sshpublisher"
+  namespace :rubyforge do
+    
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+    
+    namespace :release do
+      desc "Release a new version of this gem"
+      task :gem => [:package] do
+        require 'rubyforge'
+        rubyforge = RubyForge.new
+        rubyforge.configure
+        rubyforge.login
+        rubyforge.userconfig['release_notes'] = spec.summary
+        path_to_gem = File.join(File.dirname(__FILE__), "pkg", "#{spec.name}-#{spec.version}.gem")
+        puts "Publishing #{spec.name}-#{spec.version.to_s} to Rubyforge..."
+        rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version.to_s, path_to_gem)
+      end
+    
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+ 
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/rubyless/" # Should be the same as the rubyforge project name
+        local_dir = 'rdoc'
+ 
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/RubyLess.rb

@@ -0,0 +1,304 @@
+$:.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
+
+  class RubyLessProcessor < SexpProcessor
+    attr_reader :ruby
+
+    INFIX_OPERATOR = [:"<=>", :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%]
+    PREFIX_OPERATOR   = [:"-@"]
+
+    def self.translate(string, helper)
+      sexp = ParseTree.translate(string)
+      self.new(helper).process(sexp)
+    end
+
+    def initialize(helper)
+      super()
+      @helper     = helper
+      @indent     = "  "
+      self.auto_shift_type = true
+      self.strict = true
+      self.expected = TypedString
+    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
+    end
+
+    def process_not(exp)
+      t "not #{process(exp.shift)}", Boolean
+    end
+    
+    def process_if(exp)
+      cond      = process(exp.shift)
+      true_res  = process(exp.shift)
+      false_res = process(exp.shift)
+      
+      if true_res && false_res && true_res.klass != false_res.klass
+        raise "Error in conditional expression: '#{true_res}' and '#{false_res}' do not return results of same type (#{true_res.klass} != #{false_res.klass})."
+      end
+      raise "Error in conditional expression." unless true_res || false_res
+      opts = {}
+      opts[:nil] = true_res.nil? || true_res.could_be_nil? || false_res.nil? || false_res.could_be_nil?
+      opts[:class] = true_res ? true_res.klass : false_res.klass
+      t "#{cond} ? #{true_res || 'nil'} : #{false_res || 'nil'}", opts
+    end
+
+    def process_call(exp)
+      receiver_node_type = exp.first.nil? ? nil : exp.first.first
+      receiver = process exp.shift
+
+      # receiver = t("(#{receiver})", receiver.klass) if
+      #   Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
+
+      method_call(receiver, exp)
+    end
+
+    def process_fcall(exp)
+      method_call(nil, exp)
+    end
+
+    def process_arglist(exp)
+      code = t("")
+      until exp.empty? do
+        code << process(exp.shift)
+      end
+      code
+    end
+
+    def process_array(exp)
+      res = process_arglist(exp)
+      exp.size > 1 ? t("[#{res}]", res.opts) : res
+    end
+
+    def process_vcall(exp)
+      var_name = exp.shift
+      unless opts = get_method([var_name], @helper, false)
+        raise "Unknown variable or method '#{var_name}'."
+      end
+      method = opts[:method] || var_name.to_s
+      t method, opts
+    end
+
+    def process_lit(exp)
+      t exp.shift.to_s, Number
+    end
+
+    def process_str(exp)
+      t exp.shift.inspect, String
+    end
+
+    def process_dstr(exp)
+      t "\"#{parse_dstr(exp)}\"", String
+    end
+
+    def process_evstr(exp)
+      exp.empty? ? t('', String) : process(exp.shift)
+    end
+
+    private
+      def t(content, opts = nil)
+        if opts.nil?
+          opts = {:class => String}
+        elsif !opts.kind_of?(Hash)
+          opts = {:class => opts}
+        end
+        TypedString.new(content, opts)
+      end
+      
+      def t_if(cond, true_res, opts)
+        if cond != []
+          if cond.size > 1
+            condition = "(#{cond.join(' && ')})"
+          else
+            condition = cond.join('')
+          end
+          
+          # we can append to 'raw'
+          if opts[:nil]
+            # applied method could produce a nil value (so we cannot concat method on top of 'raw' and only check previous condition)
+            t "(#{condition} ? #{true_res} : nil)", opts
+          else
+            # we can keep on checking only 'condition' and appending methods to 'raw'
+            t "(#{condition} ? #{true_res} : nil)", opts.merge(:nil => true, :cond => cond, :raw => true_res)
+          end
+        else
+          t true_res, opts
+        end
+      end
+
+      def method_call(receiver, exp)
+        method = exp.shift
+        if args = exp.shift rescue nil
+          args = process args || []
+          signature = [method] + [args.klass].flatten ## FIXME: error prone !
+          # execution conditional
+          cond = args.cond || []
+        else
+          args = []
+          signature = [method]
+          cond = []
+        end
+        
+        if receiver
+          if receiver.could_be_nil?
+            cond += receiver.cond
+          end
+          raise "'#{receiver}' does not respond to '#{method}(#{args.raw})'." unless opts = get_method(signature, receiver.klass)
+          method = opts[:method] if 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
+          else
+            args = "(#{args.raw})" if args != []
+            t_if cond, "#{receiver.raw}.#{method}#{args}", opts
+          end
+        else
+          raise "Unknown method '#{method}(#{args.raw})'." unless opts = get_method(signature, @helper, false)
+          method = opts[:method] if opts[:method]
+          args = "(#{args.raw})" if args != []
+          t_if cond, "#{method}#{args}", opts
+        end
+      end
+
+      def parse_dstr(exp, in_regex = false)
+        res = escape_str(exp.shift, in_regex)
+
+        while part = exp.shift
+          case part.first
+          when :str then
+            res << escape_str(part.last, in_regex)
+          else
+            res << '#{' << process(part) << '}'
+          end
+        end
+        res
+      end
+
+      def escape_str(str, in_regex = false)
+        res = str.gsub(/"/, '\"').gsub(/\n/, '\n')
+        res.gsub!(/\//, '\/') if in_regex
+        res
+      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 = res.call(@helper) if res.kind_of?(Proc)
+        res
+      end
+  end
+end

data/lib/SafeClass.rb

@@ -0,0 +1,98 @@
+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

data/rubyless.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rubyless}
+  s.version = "0.1.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.has_rdoc = true
+  s.homepage = %q{http://zenadmin.org/546}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rubyless}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %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}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/RubyLess/basic.yml

@@ -0,0 +1,81 @@
+empty:
+  src: ""
+  tem: null
+
+numbers:
+  src: "id > 45 and (3 > -id or 3+3)"
+  tem: "((var1.zip>45) and ((3>-var1.zip) or (3+3)))"
+
+global_method:
+  src: "strftime(now, '%Y')"
+  tem: "strftime(Time.now, \"%Y\")"
+
+dynamic_string:
+  src: "strftime(now, \"#{name}\")"
+  tem: "strftime(Time.now, \"#{var1.name}\")"
+
+dynamic_string_again:
+  src: "strftime(now, \"#{name}\")"
+  tem: "strftime(Time.now, \"#{var1.name}\")"
+
+rewrite_variables:
+  src: "!prev.ancestor?(main) && !node.ancestor?(main)"
+  tem: "(not previous.ancestor?(@node) and not var1.ancestor?(@node))"
+
+method_can_return_nil:
+  src: "spouse.name"
+  tem: "(var1.spouse ? var1.spouse.name : nil)"
+
+method_on_method_can_return_nil:
+  src: "spouse.name == 'yo'"
+  tem: "(var1.spouse ? (var1.spouse.name==\"yo\") : nil)"
+  res: ""
+
+nil_greater_then:
+  src: "spouse.id > 1"
+  tem: "(var1.spouse ? (var1.spouse.zip>1) : nil)"
+
+nil_ternary_op:
+  src: "spouse ? 'foo' : 'bar'"
+  tem: "var1.spouse ? \"foo\" : \"bar\""
+  res: 'bar'
+
+nested_ternary_op:
+  src: "spouse.name == 'Adam' ? 'man' : 'not a man'"
+  tem: "(var1.spouse ? (var1.spouse.name==\"Adam\") : nil) ? \"man\" : \"not a man\""
+  res: "not a man"
+
+method_on_method:
+  src: "project.name.to_s"
+  tem: "var1.project.name.to_s"
+  res: 'project'
+  
+comp_ternary_op:
+  src: "1 > 2 ? 'foo' : 'bar'"
+  tem: "(1>2) ? \"foo\" : \"bar\""
+  res: "bar"
+  
+method_ternary_op:
+  src: "id > 2 ? 'foo' : 'bar'"
+  tem: "(var1.zip>2) ? \"foo\" : \"bar\""
+  res: "foo"
+
+method_argument_can_be_nil:
+  src: "vowel_count(spouse.name)"
+  tem: "(var1.spouse ? vowel_count(var1.spouse.name) : nil)"
+  
+multi_arg_method_argument_can_be_nil:
+  src: "log_info(spouse, 'foobar')"
+  tem: "(var1.spouse ? log_info(var1.spouse, \"foobar\") : nil)"
+  
+multi_arg_method_arguments_can_be_nil:
+  src: "log_info(husband, spouse.name)"
+  tem: "((var1.husband && var1.spouse) ? log_info(var1.husband, var1.spouse.name) : nil)"
+  
+multi_arg_method_arguments_can_be_nil_same_condition:
+  src: "log_info(spouse, spouse.name)"
+  tem: "(var1.spouse ? log_info(var1.spouse, var1.spouse.name) : nil)"
+
+literal_argument_for_method:
+  src: "vowel_count('ruby')"
+  res: "2"

data/test/RubyLess/errors.yml

@@ -0,0 +1,16 @@
+unknown_global_method:
+  src: "system('echo date')"
+  res: "Unknown method 'system(\"echo date\")'."
+
+bad_argument_types:
+  src: "strftime(34,'ffoo')"
+  res: "Unknown method 'strftime(34, \"ffoo\")'."
+
+zero_div:
+  src: "1/(id-10)"
+  tem: "(1/(var1.zip-10) rescue nil)"
+  res: ""
+  
+no_looping:
+  src: "while(true) do puts 'flood' end"
+  res: 'Bug! Unknown node-type :while to RubyLess::RubyLessProcessor'

data/test/RubyLess_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class SimpleHelper < Test::Unit::TestCase
+  attr_reader :context
+  yamltest :src_from_title => false
+  include RubyLess::SafeClass
+  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 [: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
+  
+  def safe_method?(signature)
+    unless res = self.class.safe_method?(signature)
+      # try to execute method in the current var "var.method"
+      if res = context[:node_class].safe_method?(signature)
+        res = res.call(self) if res.kind_of?(Proc)
+        res[:method] = "#{context[:node]}.#{res[:method] || signature[0]}"
+      end
+    end
+    res
+  end
+  
+  def var1
+    Dummy.new
+  end
+  
+  def vowel_count(str)
+    str.tr('^aeiouy', '').size
+  end
+  
+  def log_info(obj, msg)
+    "[#{obj.name}] #{msg}"
+  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)
+      yt_assert yt_get(key,file,test), parse(key, file, test, context)
+    end
+  end
+  
+  def parse(key, file, test, opts)
+    @context = {:node => 'var1', :node_class => Dummy}
+    source = yt_get('src', file, test)
+    case key
+    when 'tem'
+      source ? RubyLess.translate(source, self) : yt_get('tem', file, test)
+    when 'res'
+      eval(source ? RubyLess.translate(source, self) : yt_get('tem', file, test)).to_s
+    else
+      "Unknown key '#{key}'. Should be 'tem' or 'res'."
+    end
+  rescue => err
+    # puts "\n\n#{err.message}"
+    # puts err.backtrace
+    err.message
+  end
+  
+  yt_make
+end

data/test/mock/dummy_class.rb

@@ -0,0 +1,35 @@
+class Dummy
+  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
+  
+  def initialize(name = 'dummy')
+    @name = name
+  end
+  
+  # This method returns pseudo-nil and does not need to be declared with :nil => true
+  def project
+    Dummy.new('project')
+  end
+  
+  # This method can return nil and must be declared with :nil => true
+  def spouse
+    nil
+  end
+  
+  def husband
+    nil
+  end
+  
+  def zip
+    10
+  end
+end

data/test/test_helper.rb

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

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rubyless
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Gaspard Bucher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-02 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: gaspard@teti.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+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
+has_rdoc: true
+homepage: http://zenadmin.org/546
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubyless
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: 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
+test_files: []
+