friend 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Loren Segal
+ 
+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/README.md

@@ -0,0 +1,56 @@
+# Friend
+
+Adds fine-grained visibility semantics to Ruby, allowing you to make methods
+visible only to specific classes (and their subclasses).
+
+## Installing
+
+    $ [sudo] gem install friend
+    
+Or build it manually:
+
+    $ git clone git://github.com/lsegal/friend
+    $ cd friend
+    $ rake install
+
+## Using
+
+To use the library, require it and call `friend` (aka. `export`) from
+any module/class to export a method to a list of specific classes in the
+form:
+
+    export :methodname, Class1, Class2, ...
+
+## Example
+
+    require 'friend'
+    
+    class A; def bar; D.new.foo end end
+    class B; def bar; D.new.foo end end
+    class C; def bar; D.new.foo end end
+
+    class D
+      def foo; "HELLO WORLD!" end
+
+      # Export to A and B, but not C
+      export :foo, A, B 
+    end
+
+    puts A.new.bar
+    puts B.new.bar
+    puts C.new.bar
+
+    # Output:
+    # 
+    # HELLO WORLD!
+    # HELLO WORLD!
+    # export_features.rb:5:in `bar': `foo' is not accessible to C:Class (NoMethodError)
+    #   from export_features.rb.rb:16:in `<main>'
+    
+More examples can be found in the `example/` directory.
+
+## License & Author
+
+Friend is written by Loren Segal &copy; 2010, licensed under the BSD license.
+This software can be redistributed and modified so long as it maintains the
+copyright notice and `LICENSE` file. See `LICENSE` for more information.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/testtask'
+
+WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
+SUDO = WINDOWS ? '' : 'sudo'
+
+task :default => :test
+task :test => :build
+
+Rake::TestTask.new
+
+task :package => :build do
+  sh "gem build friend.gemspec"
+end
+
+desc "Install the gem locally"
+task :install => :package do 
+  sh "#{SUDO} gem install pkg/#{SPEC.name}-#{SPEC.version}.gem --local"
+  sh "rm -rf pkg/#{SPEC.name}-#{SPEC.version}" unless ENV['KEEP_FILES']
+end
+
+desc 'Build'
+task :build do
+  sh "cd ext && make"
+end

data/example/export_features.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../lib/friend'
+
+class A; def bar; D.new.foo end end
+class B; def bar; D.new.foo end end
+class C; def bar; D.new.foo end end
+
+class D
+  def foo; "HELLO WORLD!" end
+  
+  # Export to A and B, but not C
+  export :foo, A, B 
+end
+
+puts A.new.bar
+puts B.new.bar
+puts C.new.bar
+
+# Output:
+# 
+# HELLO WORLD!
+# HELLO WORLD!
+# export_features.rb:5:in `bar': `foo' is not accessible to C:Class (NoMethodError)
+#   from export_features.rb.rb:16:in `<main>'

data/example/friends.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../lib/friend'
+
+class Car
+  def initialize; @engine = Engine.new end
+  
+  def turn_on(key)
+    if key == "foo"
+      @engine.engage
+      puts "Car turned on!"
+    else
+      puts "Wrong key!"
+    end
+  end
+end
+
+class Engine
+  private
+  def engage; puts "Engine turned on!" end
+  friend :engage, Car
+end
+
+# We can enable the engine if we 
+# turn the car on with the right key
+car = Car.new
+car.turn_on("foo")
+
+# But we can't enable the engine directly
+car.instance_variable_get("@engine").engage
+
+# Output:
+# Engine turned on!
+# Car turned on!
+# export.rb:17:in `block in export': `engage' is not accessible outside 
+# Engine (NoMethodError)
+# 	from friends.rb:35:in `<main>'

data/ext/callsite.c

@@ -0,0 +1,30 @@
+#include "callsite.h"
+
+VALUE
+callsite_caller_class(VALUE self)
+{
+#ifdef RUBY19
+	rb_control_frame_t *cfp = ruby_current_thread->cfp;
+	/* pop 2 stack frames */
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+	
+	/* pop any block stack frames */
+	while (!cfp->iseq) cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+	
+	if (cfp->iseq != 0 && cfp->pc != 0) {
+		return cfp->iseq->klass;
+	}
+	return Qnil;
+#else /* RUBY18 */
+	struct FRAME *frame = ruby_frame->prev->prev;
+	if (frame->flags == 1) frame = frame->prev;
+	return frame->last_class;
+#endif /* RUBY19 */
+}
+
+void
+Init_callsite()
+{
+	rb_define_method(rb_mKernel, "caller_class", callsite_caller_class, 0);
+}

data/ext/callsite.h

@@ -0,0 +1,174 @@
+#include <ruby.h>
+
+#ifdef RUBY19
+
+#define VM_FRAME_MAGIC_METHOD 0x11
+#define VM_FRAME_MAGIC_BLOCK  0x21
+#define VM_FRAME_MAGIC_CLASS  0x31
+#define VM_FRAME_MAGIC_TOP    0x41
+#define VM_FRAME_MAGIC_FINISH 0x51
+#define VM_FRAME_MAGIC_CFUNC  0x61
+#define VM_FRAME_MAGIC_PROC   0x71
+#define VM_FRAME_MAGIC_IFUNC  0x81
+#define VM_FRAME_MAGIC_EVAL   0x91
+#define VM_FRAME_MAGIC_LAMBDA 0xa1
+#define VM_FRAME_MAGIC_MASK_BITS   8
+#define VM_FRAME_MAGIC_MASK   (~(~0<<VM_FRAME_MAGIC_MASK_BITS))
+
+#define VM_FRAME_TYPE(cfp) ((cfp)->flag & VM_FRAME_MAGIC_MASK)
+
+/* other frame flag */
+#define VM_FRAME_FLAG_PASSED 0x0100
+
+
+#define RUBYVM_CFUNC_FRAME_P(cfp) \
+  (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
+
+#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) (cfp+1)
+#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) (cfp-1)
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+struct rb_iseq_struct;
+
+struct rb_iseq_struct {
+    /***************/
+    /* static data */
+    /***************/
+
+    VALUE type;          /* instruction sequence type */
+    VALUE name;	         /* String: iseq name */
+    VALUE filename;      /* file information where this sequence from */
+    VALUE *iseq;         /* iseq (insn number and openrads) */
+    VALUE *iseq_encoded; /* encoded iseq */
+    unsigned long iseq_size;
+    VALUE mark_ary;	/* Array: includes operands which should be GC marked */
+    VALUE coverage;     /* coverage array */
+    unsigned short line_no;
+
+    /* insn info, must be freed */
+    void /*struct iseq_insn_info_entry*/ *insn_info_table;
+    unsigned long insn_info_size;
+
+    ID *local_table;		/* must free */
+    int local_table_size;
+
+    /* method, class frame: sizeof(vars) + 1, block frame: sizeof(vars) */
+    int local_size; 
+
+    /**
+     * argument information
+     *
+     *  def m(a1, a2, ..., aM,                    # mandatory
+     *        b1=(...), b2=(...), ..., bN=(...),  # optinal
+     *        *c,                                 # rest
+     *        d1, d2, ..., dO,                    # post
+     *        &e)                                 # block
+     * =>
+     *
+     *  argc           = M
+     *  arg_rest       = M+N+1 // or -1 if no rest arg
+     *  arg_opts       = N
+     *  arg_opts_tbl   = [ (N entries) ]
+     *  arg_post_len   = O // 0 if no post arguments
+     *  arg_post_start = M+N+2
+     *  arg_block      = M+N + 1 + O + 1 // -1 if no block arg
+     *  arg_simple     = 0 if not simple arguments.
+     *                 = 1 if no opt, rest, post, block.
+     *                 = 2 if ambiguos block parameter ({|a|}).
+     *  arg_size       = argument size.
+     */
+
+    int argc;
+    int arg_simple;
+    int arg_rest;
+    int arg_block;
+    int arg_opts;
+    int arg_post_len;
+    int arg_post_start;
+    int arg_size;
+    VALUE *arg_opt_table;
+
+    int stack_max; /* for stack overflow check */
+
+    /* catch table */
+    void /*struct iseq_catch_table_entry*/ *catch_table;
+    int catch_table_size;
+
+    /* for child iseq */
+    struct rb_iseq_struct *parent_iseq;
+    struct rb_iseq_struct *local_iseq;
+
+    /****************/
+    /* dynamic data */
+    /****************/
+
+    VALUE self;
+    VALUE orig;			/* non-NULL if its data have origin */
+
+    /* block inlining */
+    /* 
+     * NODE *node;
+     * void *special_block_builder;
+     * void *cached_special_block_builder;
+     * VALUE cached_special_block;
+     */
+
+    /* klass/module nest information stack (cref) */
+    void/*NODE*/ *cref_stack;
+    VALUE klass;
+
+    /* misc */
+    ID defined_method_id;	/* for define_method */
+
+    /* used at compile time */
+    void /*struct iseq_compile_data*/ *compile_data;
+};
+
+typedef struct {
+    VALUE *pc;			/* cfp[0] */
+    VALUE *sp;			/* cfp[1] */
+    VALUE *bp;			/* cfp[2] */
+    rb_iseq_t *iseq;		/* cfp[3] */
+    VALUE flag;			/* cfp[4] */
+    VALUE self;			/* cfp[5] / block[0] */
+    VALUE *lfp;			/* cfp[6] / block[1] */
+    VALUE *dfp;			/* cfp[7] / block[2] */
+    rb_iseq_t *block_iseq;	/* cfp[8] / block[3] */
+    VALUE proc;			/* cfp[9] / block[4] */
+    ID method_id;               /* cfp[10] saved in special case */
+    VALUE method_class;         /* cfp[11] saved in special case */
+} rb_control_frame_t;
+
+typedef struct rb_thread_struct
+{
+    VALUE self;
+    void *vm;
+
+    /* execution information */
+    VALUE *stack;		/* must free, must mark */
+    unsigned long stack_size;
+    rb_control_frame_t *cfp;
+
+	/* INCOMPLETE! */
+} rb_thread_t;
+
+extern rb_thread_t *ruby_current_thread;
+
+#else /* RUBY18 */
+
+extern struct FRAME {
+    VALUE self;
+    int argc;
+    ID last_func;
+    ID orig_func;
+    VALUE last_class;
+    struct FRAME *prev;
+    struct FRAME *tmp;
+    struct RNode *node;
+    int iter;
+    int flags;
+    unsigned long uniq;
+} *ruby_frame;
+
+#endif /* RUBY19 */

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CPPFLAGS += " -DRUBY19" if RUBY_VERSION =~ /1.9/
+create_makefile('callsite')

data/lib/friend.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../ext/callsite'
+
+module Friend
+  def friend_list
+    @__friends__ ||= {}
+  end
+  
+  def friend(meth, *classes)
+    meth, expmeth = meth.to_s, "__friends__#{meth}"
+    (friend_list[meth] ||= []).push(*classes)
+    alias_method expmeth, meth
+    private expmeth
+    public meth
+    define_method(meth) do |*args, &block|
+      cclass, classes = caller_class, self.class.friend_list[meth]
+      if cclass == false
+        raise NoMethodError, "`#{meth}' is not accessible outside #{self.class}"
+      elsif cclass != self.class && classes && !classes.any? {|k| cclass <= k }
+        raise NoMethodError, 
+          "`#{meth}' is not accessible to #{cclass.inspect}:#{cclass.class.inspect}",
+          caller
+      end
+      send(expmeth, *args, &block)
+    end
+  end
+  
+  alias export friend
+end
+
+(RUBY_VERSION >= "1.9.1" ? BasicObject : Object).send(:extend, Friend)

data/test/test_callsite.rb

@@ -0,0 +1,17 @@
+require "test/unit"
+require File.dirname(__FILE__) + '/../ext/callsite'
+
+class CA; def foo; caller_class end end
+class CB; def bar; CA.new.foo end end
+module CD; def zoo; define_method(:bar) {|*args, &block| CA.new.foo } end end
+class CC; extend CD; zoo end
+
+class TestCallsite < Test::Unit::TestCase
+  def test_callsite
+    assert_equal CB, CB.new.bar
+  end
+  
+  def test_callsite_from_define_method
+    assert_equal CC, CC.new.bar
+  end
+end

data/test/test_export.rb

@@ -0,0 +1,34 @@
+require "test/unit"
+require File.dirname(__FILE__) + '/../lib/friend'
+
+class EA; def bar; ED.new.foo end end
+class EB; def bar; ED.new.foo end end
+class EC; def bar; ED.new.foo end end
+class EE < EB; def bar; ED.new.foo end end
+class ED
+  def foo; "foobar" end
+  def bar; foo end
+  export :foo, EA, EB
+end
+
+class TestCallsite < Test::Unit::TestCase
+  def test_export_A
+    assert_equal "foobar", EA.new.bar
+  end
+
+  def test_export_B
+    assert_equal "foobar", EB.new.bar
+  end
+
+  def test_export_C
+    assert_raises(NoMethodError) { EC.new.bar }
+  end
+  
+  def test_export_E
+    assert_equal "foobar", EE.new.bar
+  end
+  
+  def test_local_call
+    assert_equal "foobar", ED.new.bar
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: friend
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-01 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lsegal@soen.ca
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/callsite.bundle
+- ext/callsite.c
+- ext/callsite.h
+- ext/callsite.o
+- ext/extconf.rb
+- lib/friend.rb
+- example/export_features.rb
+- example/friends.rb
+- test/test_callsite.rb
+- test/test_export.rb
+- LICENSE
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/lsegal/friend
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ext
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Friend adds fine grained visibility semantics to Ruby
+test_files: 
+- test/test_callsite.rb
+- test/test_export.rb