acts_as_wrapped_class 1.0.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-10-22
+
+* Release of the initial version of the gem  
+	* BUG: missing constants
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/acts_as_wrapped_class.rb
+lib/wrapper_base.rb
+test/test_acts_as_wrapped_class.rb

data/README.txt

@@ -0,0 +1,63 @@
+ActsAsWrappedClass
+    by David Stevenson 
+    http://elctech.com/blog
+
+== DESCRIPTION:
+  
+ActsAsWrappedClass is designed to automatically generate a wrapper for an object that you don't want to be allowed to access certain methods in.  This is useful in cases where you want to sandbox what users' code can and can't do, by providing them access to the wrapper classes rather than the original classes.
+
+== FEATURES/PROBLEMS:
+  
+*  Wrappers do not dispatch const_missing yet, so constants are not accessible yet.
+
+== SYNOPSIS:
+
+class Something
+  acts_as_wrapped_class :methods => [:safe_method]
+  # SomethingWrapper is now defined
+  
+  def safe_method  # allowed to access this method through SomethingWrapper
+    Something.new
+  end
+
+  def unsafe_method  # not allowed to access this method through SomethingWrapper
+  end
+end
+
+s = Something.new
+wrapper = s.to_wrapper
+wrapper.safe_method    # returns a new SomethingWrapper
+wrapper.unsafe_method  # raises an exception
+
+== REQUIREMENTS:
+
+* none
+
+== INSTALL:
+
+* sudo gem install acts_as_wrapped_class
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 David Stevenson 
+
+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,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/acts_as_wrapped_class.rb'
+
+Hoe.new('acts_as_wrapped_class', ActsAsWrappedClass::VERSION) do |p|
+  p.rubyforge_name = 'acts_as_wrapped_class'
+  p.author = 'David Stevenson'
+  p.email = 'ds@elctech.com'
+  p.summary = 'automatically generate wrapper classes which restrict access to methods and constants in the wrapped class'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/acts_as_wrapped_class.rb

@@ -0,0 +1,144 @@
+require "erb"
+
+module ActsAsWrappedClass
+  VERSION = "1.0.0"
+  WRAPPED_CLASSES = []
+  
+  module InstanceMethods
+    def to_wrapper
+      eval("#{self.class.name}Wrapper").new(self)
+    end
+  end
+  
+  module ClassMethods
+    def wrapped_class?
+      true
+    end
+  end
+  
+  class WrapperFinder
+    SANDBOX_BASE_IMPORTS = ["Object", "Module", "Class", "Kernel", "Main", "Array", "Bignum", "Binding", "Comparable", "Cont", "Data", "Dir", "Enumerable", "Exception", "FalseClass", "FConst", "File", "FileTest", "Fixnum", "Float", "GC", "Hash", "Integer", "IO", "Marshal", "Math", "Match", "Method", "NilClass", "Numeric", "ObSpace", "Precision", "Proc", "Process", "ProcStatus", "ProcUID", "ProcGID", "ProcID_Syscall", "Range", "Regexp", "Stat", "String", "Struct", "Symbol", "Thread", "ThGroup", "Time", "Tms", "TrueClass", "UnboundMethod", "StandardError", "SystemExit", "Interrupt", "Signal", "Fatal", "ArgError", "EOFError", "IndexError", "RangeError", "RegexpError", "IOError", "RuntimeError", "SecurityError", "SystemCallError", "SysStackError", "ThreadError", "TypeError", "ZeroDivError", "NotImpError", "NoMemError", "NoMethodError", "FloatDomainError", "ScriptError", "NameError", "NameErrorMesg", "SyntaxError", "LoadError", "LocalJumpError", "Errno", "BoxedClass"]
+    @@special_handlers = {Array => Proc.new{ |object| object.collect{|val| find_wrapper_for(val)} },
+      Hash => Proc.new{ |object| object.inject({}){|h, key_val| h[find_wrapper_for(key_val[0])] = find_wrapper_for(key_val[1]); h } }}
+    
+    # Returns a wrapper for an instance of an object, if one exsits, or the original object if it's a core datatype.
+    # * This will first attempt to find a special handler for the type of object being wrapped and invoke it's block
+    # * Then it will look for a wrapper classes that fits the object's type (Something looks for SomethingWrapper)
+    # * Finally, it checks a list of "safe" classes that don't need wrapping
+    # If no match is found, an exception is raised
+    def self.find_wrapper_for(object)
+      wrapper_name = "#{object.class.name}Wrapper"
+      return nil if nil
+      
+      @@special_handlers.each do |key, value|
+        return value.call(object) if object.is_a?(key)
+      end            
+
+      return object if object.kind_of?(WrapperBase)
+      return eval(wrapper_name).new(object) if eval("defined?(#{wrapper_name})")
+      return object if SANDBOX_BASE_IMPORTS.include?(object.class.name)
+
+      raise "Can't find wrapper for class: #{object.class.name}"
+    end
+    
+    # Add a special handler for how to wrap certain types of classes.
+    # For example, if you wanted to wrap Arrays by wrapping each of their elements
+    def self.add_special_handler(klass, prc)
+      raise "1st arg must be a Class" unless klass.is_a?(Class)
+      raise "2st arg must be a Proc" unless prc.is_a?(Proc)
+      @@special_handlers[klass] = prc
+    end
+  end
+  
+  def wrapped_class?
+    false
+  end
+  
+  # Mark a class as wrapped, creating a wrapper class which allows access to certain methods specified by EITHER the :methods safe list of the :except_methods blacklist.  
+  # You cannot use both :methods and :except_methods at once.
+  # * options[:methods] contains a list of method names (symbols) to allow access to
+  # * options[:except_methods] contains a list of method names (symbols) to not allow access to
+  # * options[:constants] contains a list of constant names (symbols) to allow access to
+  # * options[:except_constants] contains a list of constant names (symbols) to not allow access to
+  def acts_as_wrapped_class(options = {})
+    raise "Can't specify methods to allow and to deny." if options[:methods] && options[:except_methods]
+    raise "Can't specify constants to allow and to deny." if options[:constants] && options[:except_constants]
+    options[:methods] ||= :all
+    options[:constants] ||= :all
+    
+    WRAPPED_CLASSES << self
+    
+    if options[:methods] == :all
+      options.delete(:methods)
+      options[:except_methods] = []
+    end
+
+    if options[:constants] == :all
+      options.delete(:constants)
+      options[:except_constants] = []
+    end
+    
+    meths = options[:methods] || options[:except_methods]
+    consts = options[:constants] || options[:except_constants]
+    
+    allowed_method_missing = options[:methods] ? options[:methods].include?(:method_missing) : !options[:except_methods].include?(:method_missing)
+    allowed_const_missing = options[:constants] ? options[:constants].include?(:cont_missing) : !options[:except_constants].include?(:const_missing)
+
+    self.send(:include, ActsAsWrappedClass::InstanceMethods)
+    self.send(:extend, ActsAsWrappedClass::ClassMethods)
+    
+    if allowed_method_missing
+      method_defs_erb = <<-EOF
+        def method_missing(meth, *args);
+          <% if options[:except_methods] %>
+            raise NameError.new("Method `"+meth.to_s+"' now allowed") if [<%= meths.collect {|m| ":\#{m}"}.join(", ") %>].include?(meth)
+          <% else %>
+            raise NameError.new("Method `"+meth.to_s+"' now allowed") unless [<%= meths.collect {|m| ":\#{m}"}.join(", ") %>].include?(meth) || !@wrapped_object.class.method_defined?(meth)
+          <% end %>
+          ActsAsWrappedClass::WrapperFinder.find_wrapper_for(@wrapped_object.send(meth, *args));
+        end
+        EOF
+    else      
+      method_defs_erb = <<-EOF
+        def method_missing(meth, *args);
+          raise NameError.new("Method `"+meth.to_s+"' now allowed") <%= options[:methods] ? "unless" : "if"%> [<%=meths.collect {|m| ":\#{m}"}.join(", ")%>].include?(meth)
+          ActsAsWrappedClass::WrapperFinder.find_wrapper_for(@wrapped_object.method(meth).call(*args));
+        end
+        EOF
+    end
+    
+    # if allowed_const_missing
+    #   const_defs_erb = <<-EOF
+    #     def const_missing(const, *args);
+    #       <% if options[:except_constants] %>
+    #         raise NameError.new("Constant `"+const.to_s+"' now allowed") if [<%= consts.collect {|c| ":\#{c}"}.join(", ") %>].include?(const)
+    #       <% else %>
+    #         raise NameError.new("Method `"+meth.to_s+"' now allowed") unless [<%= meths.collect {|c| ":\#{c}"}.join(", ") %>].include?(const) || !@wrapped_object.class.const_defined?(const)
+    #       <% end %>
+    #       @wrapped_object.const_get(const)
+    #     end
+    #     EOF
+    # else      
+    #   const_defs_erb = <<-EOF
+    #     def const_missing(const, *args);
+    #       raise NameError.new("Constant `"+const.to_s+"' now allowed") <%= options[:constants] ? "unless" : "if"%> [<%=consts.collect {|m| ":\#{m}"}.join(", ")%>].include?(const)
+    #       @wrapped_object.const_get(const)
+    #     end
+    #     EOF
+    # end
+    
+    method_defs = ERB.new(method_defs_erb).result(binding)
+    
+    wrapper_class_code = <<-EOF
+      class #{self.name}Wrapper < WrapperBase
+        #{method_defs}        
+      end
+EOF
+
+    eval wrapper_class_code, TOPLEVEL_BINDING
+  end
+end
+
+Object.send(:include, ActsAsWrappedClass)
+
+require File.join(File.dirname(__FILE__), "wrapper_base")

data/lib/wrapper_base.rb

@@ -0,0 +1,36 @@
+class WrapperBase
+  eval((public_instance_methods - ["__id__","__send__", "is_a?", "kind_of?", "hash", "class", "inspect"]).collect{|meth| "undef "+meth}.join("; "))
+
+  # Create a wrapper, passing in an object to wrap
+  def initialize(wrapped_object)
+    @wrapped_object = wrapped_object
+  end
+  
+  def hash
+    @wrapped_object.hash
+  end
+  
+  def ==(other)
+    return false if self.class != other.class
+    @wrapped_object == other._wrapped_object
+  end
+  
+  def <=>(other)
+    raise "Can't compare objects of different types" if self.class != other.class
+    @wrapped_object <=> other._wrapped_object
+  end
+    
+  def ===(other)
+    return false if self.class != other.class
+    @wrapped_object === other._wrapped_object
+  end  
+  
+  # Provide access to the wrapped object
+  def _wrapped_object
+    @wrapped_object
+  end 
+  
+  def self.wrapper_class?
+    true
+  end 
+end

data/test/test_acts_as_wrapped_class.rb

@@ -0,0 +1,128 @@
+require 'test/unit'
+require File.dirname(__FILE__) + "/../lib/acts_as_wrapped_class"
+
+class NotWrappedClass
+  def method1
+    6.383
+  end
+end
+
+class SampleClass  #SampleClassWrapper
+  acts_as_wrapped_class :methods => [:get_other_class, :other_method], :constants => [:API]
+
+  API = 3.1415
+
+  def get_other_class
+    OtherClass.new(rand)
+  end
+  
+  def other_method
+    5.5
+  end
+  
+  def unsafe_method
+    666
+  end
+end
+
+class OtherClass
+  SAMPLE_CLASS = SampleClass.new
+  
+  acts_as_wrapped_class :methods => :all, :constants => :all
+
+  attr_reader :value
+
+  def initialize(val)
+    @value = val
+  end  
+  
+  def get_sample_classes
+    [SampleClass.new] * 10
+  end
+  
+  def get_hash
+    {:a => SampleClass.new, OtherClass.new(11) => "hello", :array => [SampleClass.new, SampleClass.new, 10]}
+  end
+  
+  def another_method
+    6.6
+  end
+  
+  def hash
+    @value
+  end
+  
+  def ==(other)
+    other.value == value
+  end
+end
+
+class ActsAsWrappedCodeTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_wrappers_exist
+    assert defined?(OtherClassWrapper)
+    assert defined?(SampleClassWrapper)
+  end
+  
+  def test_unwrappers_to_wrapper
+    assert SampleClass.public_instance_methods.include?("to_wrapper")
+    assert OtherClass.public_instance_methods.include?("to_wrapper")
+  end
+  
+  def test_awrappers_clean
+    assert_contents_same ["method_missing"] + allowed_methods, SampleClassWrapper.public_instance_methods
+    assert_contents_same ["method_missing"] + allowed_methods, OtherClassWrapper.public_instance_methods
+  end
+  
+  def test_wrappers_method_missing_clean
+    wrap = SampleClass.new.to_wrapper
+    wrap.other_method
+    assert_raise(NameError) { wrap.unsafe_method }
+    assert_raise(NameError) { wrap.method_missing :unsafe_method }
+  end
+  
+  def test_class1_wrappers
+    wrap = SampleClass.new.to_wrapper
+    assert wrap.is_a?(SampleClassWrapper)
+    assert wrap.other_method.is_a?(Float)
+    assert_equal 5.5, wrap.other_method
+    assert wrap.get_other_class.is_a?(OtherClassWrapper)
+  end
+  
+  def test_hash_and_equals
+    wrap1 = OtherClass.new(11).to_wrapper
+    wrap2 = OtherClass.new(11).to_wrapper
+    assert_equal wrap1.hash, wrap2.hash
+    assert_equal wrap1, wrap2
+  end
+    
+  
+  def test_class2_wrappers
+    wrap = OtherClass.new(10.0).to_wrapper
+    assert wrap.is_a?(OtherClassWrapper)
+    assert_equal 10.0, wrap.value
+    assert_equal 6.6, wrap.another_method
+    array = wrap.get_sample_classes
+    array.each do |a|
+      assert a.is_a?(SampleClassWrapper)
+    end
+    hash = wrap.get_hash
+    assert hash[:a].is_a?(SampleClassWrapper)
+    assert_contents_same hash[:array].collect{|v| v.class.name}, ["SampleClassWrapper", "SampleClassWrapper", "Fixnum"]
+  end
+  
+  def test_wrapped_class?
+    assert SampleClass.wrapped_class?    
+    assert OtherClass.wrapped_class?    
+    assert !NotWrappedClass.wrapped_class?    
+  end
+  
+  def assert_contents_same(array1, array2)
+    assert_equal array1.length, array2.length, "#{array1.inspect} != #{array2.inspect}"
+    array1.each { |a| assert array2.include?(a), "#{array2.inspect} does not contain #{a.inspect}" }
+  end
+  
+  def allowed_methods
+    ["__id__", "__send__", "is_a?", "kind_of?", "class", "hash", "inspect", "==", "<=>", "===", "_wrapped_object"]
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: acts_as_wrapped_class
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-10-22 00:00:00 -07:00
+summary: automatically generate wrapper classes which restrict access to methods and constants in the wrapped class
+require_paths: 
+- lib
+email: ds@elctech.com
+homepage: "    by David Stevenson "
+rubyforge_project: acts_as_wrapped_class
+description: "== FEATURES/PROBLEMS:  *  Wrappers do not dispatch const_missing yet, so constants are not accessible yet.  == SYNOPSIS:  class Something acts_as_wrapped_class :methods => [:safe_method] # SomethingWrapper is now defined  def safe_method  # allowed to access this method through SomethingWrapper Something.new end  def unsafe_method  # not allowed to access this method through SomethingWrapper end end"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- David Stevenson
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/acts_as_wrapped_class.rb
+- lib/wrapper_base.rb
+- test/test_acts_as_wrapped_class.rb
+test_files: 
+- test/test_acts_as_wrapped_class.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: