rufus-decision 0.9 → 1.0

data/lib/rufus/hashes.rb

@@ -8,10 +8,10 @@
 # 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
@@ -28,158 +28,193 @@
 # John Mettraux at openwfe.org
 #
 
-require 'rubygems'
-require 'rufus/eval'
+require 'rufus/treechecker'
 
 
 module Rufus
 
-    #
-    # In the Java world, this class would be considered abstract.
-    #
-    # It's used to build sequences of filter on hashes (or instances 
-    # that respond to the [], []=, has_key? methods).
-    #
-    # It relies on 'prefixed string keys' like "x:y", where the prefix is 'x'
-    # and the partial key is then 'y'.
-    #
-    # Rufus::EvalHashFilter is an implementation of an HashFilter.
-    #
-    class HashFilter
-
-        def initialize (parent_hash)
-
-            @parent_hash = parent_hash
-        end
+  #
+  # In the Java world, this class would be considered abstract.
+  #
+  # It's used to build sequences of filter on hashes (or instances
+  # that respond to the [], []=, has_key? methods).
+  #
+  # It relies on 'prefixed string keys' like "x:y", where the prefix is 'x'
+  # and the partial key is then 'y'.
+  #
+  # Rufus::EvalHashFilter is an implementation of an HashFilter.
+  #
+  class HashFilter
+
+    def initialize (parent_hash)
+
+      @parent_hash = parent_hash
+    end
 
-        def [] (key)
+    def [] (key)
 
-            p, k = do_split(key)
+      p, k = do_split(key)
 
-            do_lookup(key, p, k)
-        end
+      do_lookup(key, p, k)
+    end
 
-        def []= (key, value)
+    def []= (key, value)
 
-            p, v = do_split(value)
+      p, v = do_split(value)
 
-            do_put(key, value, p, v)
-        end
+      do_put(key, value, p, v)
+    end
 
-        protected
+    protected
 
-            def do_split (element)
+      def do_split (element)
 
-                return [ nil, element ] unless element.is_a?(String)
+        return [ nil, element ] unless element.is_a?(String)
 
-                a = element.split(':', 2)
-                return [ nil ] + a if a.length == 1
-                a
-            end
+        a = element.split(':', 2)
+        return [ nil ] + a if a.length == 1
+        a
+      end
 
-            def handles_prefix? (p)
+      def handles_prefix? (p)
 
-                false
-            end
+        false
+      end
 
-            def do_eval (key, p, k)
+      def do_eval (key, p, k)
 
-                raise NotImplementedError.new(
-                    "missing do_eval(key, p, k) implementation")
-            end
+        raise NotImplementedError.new(
+          "missing do_eval(key, p, k) implementation")
+      end
 
-            def do_lookup (key, p, k)
+      def do_lookup (key, p, k)
 
-                if handles_prefix?(p)
+        if handles_prefix?(p)
 
-                    do_eval(key, p, k)
+          do_eval(key, p, k)
 
-                elsif @parent_hash.respond_to?(:do_lookup)
+        elsif @parent_hash.respond_to?(:do_lookup)
 
-                    @parent_hash.do_lookup key, p, k
+          @parent_hash.do_lookup key, p, k
 
-                else
+        else
 
-                    @parent_hash[key]
-                end
-            end
+          @parent_hash[key]
+        end
+      end
 
-            def do_put (key, value, p, v)
+      def do_put (key, value, p, v)
 
-                val = value
+        val = value
 
-                if handles_prefix?(p)
+        if handles_prefix?(p)
 
-                    @parent_hash[key] = do_eval(value, p, v)
+          @parent_hash[key] = do_eval(value, p, v)
 
-                elsif @parent_hash.respond_to?(:do_put)
+        elsif @parent_hash.respond_to?(:do_put)
 
-                    @parent_hash.do_put key, value, p, v
+          @parent_hash.do_put key, value, p, v
 
-                else
+        else
 
-                    @parent_hash[key] = value
-                end
-            end
+          @parent_hash[key] = value
+        end
+      end
+  end
+
+  #
+  # Implements the r:, ruby: and reval: prefixes in lookups
+  #
+  #   require 'rubygems'
+  #   require 'rufus/hashes'
+  #
+  #   h = {}
+  #
+  #   eh = Rufus::EvalHashFilter.new(h, 0)
+  #
+  #   eh['a'] = :a
+  #   p h # => { 'a' => :a }
+  #
+  #   eh['b'] = "r:5 * 5"
+  #   p h # => { 'a' => :a, 'b' => 25 }
+  #
+  #   assert_equal :a, eh['a']
+  #   assert_equal 25, eh['b']
+  #   assert_equal 72, eh['r:36+36']
+  #
+  class EvalHashFilter < HashFilter
+
+    def initialize (parent_hash)
+
+      super parent_hash
     end
 
-    #
-    # Implements the r:, ruby: and reval: prefixes in lookups
-    # 
-    #     require 'rubygems'
-    #     require 'rufus/hashes'
-    #
-    #     h = {}
-    #
-    #     eh = Rufus::EvalHashFilter.new(h, 0)
-    #
-    #     eh['a'] = :a
-    #     p h # => { 'a' => :a }
-    #
-    #     eh['b'] = "r:5 * 5"
-    #     p h # => { 'a' => :a, 'b' => 25 }
-    #
-    #     assert_equal :a, eh['a']
-    #     assert_equal 25, eh['b']
-    #     assert_equal 72, eh['r:36+36']
-    #
-    class EvalHashFilter < HashFilter
-
-        def initialize (parent_hash, eval_safety_level=0)
-
-            super parent_hash
-            @safe_level = eval_safety_level
-        end
+    protected
 
-        protected
+      RP = [ 'r', 'ruby', 'reval' ]
 
-            RP = [ 'r', 'ruby', 'reval' ]
+      def handles_prefix? (prefix)
 
-            def handles_prefix? (prefix)
+        RP.include?(prefix)
+      end
 
-                RP.include?(prefix)
-            end
+      #
+      # Ready for override.
+      #
+      def get_binding
 
-            #
-            # Ready for override.
-            #
-            def get_binding
+        binding()
+      end
 
-                binding()
-            end
+      def do_eval (key, p, k)
 
-            def do_eval (key, p, k)
+        #Rufus::eval_safely(k, @safe_level, get_binding)
+        Rufus::check_and_eval(k, get_binding)
+      end
+  end
 
-                Rufus::eval_safely(k, @safe_level, get_binding)
-            end
-    end
+  TREECHECKER = Rufus::TreeChecker.new do
 
-    private
+    exclude_fvccall :abort, :exit, :exit!
+    exclude_fvccall :system, :fork, :syscall, :trap, :require, :load
 
-        def Rufus.unescape (text)
+    #exclude_call_to :class
+    exclude_fvcall :private, :public, :protected
 
-            text.gsub("\\\\\\$\\{", "\\${")
-        end
+    exclude_def               # no method definition
+    exclude_eval              # no eval, module_eval or instance_eval
+    exclude_backquotes        # no `rm -fR the/kitchen/sink`
+    exclude_alias             # no alias or aliast_method
+    exclude_global_vars       # $vars are off limits
+    exclude_module_tinkering  # no module opening
+    exclude_raise             # no raise or throw
+
+    exclude_rebinding Kernel # no 'k = Kernel'
+
+    exclude_access_to(
+      IO, File, FileUtils, Process, Signal, Thread, ThreadGroup)
+
+    exclude_class_tinkering
+
+    exclude_call_to :instance_variable_get, :instance_variable_set
+  end
+  TREECHECKER.freeze
+
+  def self.check_and_eval (ruby_code, bndng=binding())
+
+    TREECHECKER.check(ruby_code)
+
+    # OK, green for eval...
+
+    eval(ruby_code, bndng)
+  end
+
+  private
+
+    def Rufus.unescape (text)
+
+      text.gsub("\\\\\\$\\{", "\\${")
+    end
 
 end
 

data/lib/rufus-decision.rb

@@ -0,0 +1,3 @@
+
+require 'rufus/decision'
+