attr_callback 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Infonium Inc.
+
+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.rdoc

@@ -0,0 +1,42 @@
+= attr_callback - Convenience method for providing user-definable callbacks.
+
+The attr_callback gem lets you conveniently create user-definable callback
+method attributes, using a single line of code.
+
+= Example Usage
+
+You can use attr_callback to define a callback attribute on an object:
+
+  require 'attr_callback'
+
+  class Foo
+    attr_callback :on_receive_message
+  end
+
+  f = Foo.new
+
+  # Getter and setter behave the same as they would using attr_attribute
+  f.on_receive_message = 1                           #=> 1
+  f.on_receive_message                               #=> 1
+
+  # Passing a block to the getter makes it behave as a setter
+  f.on_receive_message { |msg| puts msg }            #=> #<Proc:0x0006bfd0@(irb):1>
+  f.on_receive_message                               #=> #<Proc:0x0006bfd0@(irb):1>
+
+  # Invoking the callback
+  f.on_receive_message.call("hello world")
+
+= Options
+
+By default, a Mutex object will be used to guard access to the callback.  This
+Mutex is created the first time the attribute is accessed.  Use :lock=>false to
+disable this behaviour.
+
+By default, a no-op Proc is returned by the getter in place of nil.  Use
+:noop=>false to disable this behaviour.
+
+= License
+
+Copyright © 2010 Infonium Inc.
+
+License: See the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift "lib"
+require 'attr_callback/version'
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |t|
+  t.rdoc_files = Dir.glob(%w( README* MIT-LICENSE lib/**/*.rb *.rdoc )).uniq
+  t.main = "README.rdoc"
+  t.title = "attr_callback - RDoc Documentation"
+  t.options = %w( --charset -UTF-8 --line-numbers )
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :build do
+  system "gem build attr_callback.gemspec"
+end
+
+task :clobber do
+  rm_f "attr_callback-#{AttrCallback::VERSION}.gem"
+end
+
+task :default => :build

data/lib/attr_callback.rb

@@ -0,0 +1,80 @@
+module AttrCallback
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module Util
+    NoopProc = Proc.new{}
+
+    class <<self
+      def get_or_create_mutex(obj, name)
+        mutex = obj.instance_variable_get("@#{name}_lock")
+        if mutex.nil?
+          obj.instance_variable_set("@#{name}_lock", Mutex.new)
+        else
+          mutex
+        end
+      end
+
+      def define_callback_on_class(klass, name, options={})
+        name = name.to_sym
+        locking = options[:lock].nil? ? true : options[:lock]
+        noop = options[:noop].nil? ? true : options[:noop]
+
+        # Define the setter.  If the user specified :lock=>true, then the
+        # setter will synchronize on @name_lock; otherwise, we just use
+        # the standard attr_writer.
+        if locking
+          klass.__send__(:define_method, "#{name}=") do |value|
+            AttrCallback::Util.get_or_create_mutex(self, name).synchronize {
+              instance_variable_set("@#{name}", value)
+            }
+          end
+        else
+          klass.__send__(:attr_writer, name)
+        end
+
+        # Define the getter.  If the user specified :lock=>true, then the
+        # getter will synchronize on @name_lock; otherwise, it won't.
+        klass.__send__(:define_method, name) do |*args, &block|
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+
+          if block.nil?
+            if locking
+              callback = AttrCallback::Util.get_or_create_mutex(self, name).synchronize { instance_variable_get("@#{name}") }
+            else
+              callback = instance_variable_get("@#{name}")
+            end
+            if noop and callback.nil?
+              NoopProc
+            else
+              callback
+            end
+          else
+            __send__("#{name}=", block)
+          end
+        end
+      end
+    end
+  end
+
+  module ClassMethods
+    def attr_callback(*args)
+      # Last argument may be a hash of options.
+      if args[-1].is_a?(Hash)
+        options = args.pop
+      else
+        options = {}
+      end
+
+      for name in args
+        AttrCallback::Util.define_callback_on_class(self, name, options)
+      end
+    end
+  end
+
+end
+
+class Module
+  include AttrCallback::ClassMethods    # Make attr_callback available in every module.
+end

data/lib/attr_callback/version.rb

@@ -0,0 +1,3 @@
+module AttrCallback
+  VERSION='1.0.0'
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")

data/test/unit/attr_callback_test.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + "/../test_helper.rb"
+require 'attr_callback'
+
+class AttrCallbackTest < Test::Unit::TestCase
+  def test_simple
+    klass = Class.new do
+      attr_callback :cb
+    end
+    obj = klass.new
+    assert_equal AttrCallback::Util::NoopProc, obj.cb, "initial callback should be NoopProc"
+    assert_kind_of Mutex, obj.instance_variable_get("@cb_lock"), "lock should be created when :lock option is unspecified"
+
+    obj.cb = 1
+    assert_equal 1, obj.cb, "setter should work"
+
+    block = Proc.new{ nil }
+    obj.cb(&block)
+    assert_equal block, obj.cb, "block setter should work"
+  end
+
+  def test_simple_without_locking
+    klass = Class.new do
+      attr_callback :cb, :lock=>false
+    end
+    obj = klass.new
+    assert_equal AttrCallback::Util::NoopProc, obj.cb, "initial callback should be NoopProc"
+    assert_nil obj.instance_variable_get("@cb_lock"), "lock should not be created when :lock=>false"
+
+    obj.cb = 1
+    assert_equal 1, obj.cb, "setter should work"
+
+    block = Proc.new{ nil }
+    obj.cb(&block)
+    assert_equal block, obj.cb, "block setter should work"
+  end
+
+  def test_multiple_callbacks_should_be_independent
+    klass = Class.new do
+      attr_callback :a, :b
+      attr_callback :c, :d
+    end
+    obj = klass.new
+
+    obj.a = 1
+    obj.b = 2
+    obj.c = 3
+    obj.d = 4
+
+    assert_equal [1, 2, 3, 4], [obj.a, obj.b, obj.c, obj.d]
+  end
+
+  def test_multiple_callbacks_should_be_independent_without_locking
+    klass = Class.new do
+      attr_callback :a, :b, :lock=>false
+      attr_callback :c, :d, :lock=>false
+    end
+    obj = klass.new
+
+    obj.a = 1
+    obj.b = 2
+    obj.c = 3
+    obj.d = 4
+
+    assert_equal [1, 2, 3, 4], [obj.a, obj.b, obj.c, obj.d]
+  end
+
+  def test_no_noop
+    klass = Class.new do
+      attr_callback :cb, :noop=>false
+    end
+    obj = klass.new
+    assert_nil obj.cb
+    assert_kind_of Mutex, obj.instance_variable_get("@cb_lock"), "lock should be created when :lock option is unspecified"
+  end
+
+  def test_no_noop_without_locking
+    klass = Class.new do
+      attr_callback :cb, :noop=>false, :lock=>false
+    end
+    obj = klass.new
+    assert_nil obj.cb
+    assert_nil obj.instance_variable_get("@cb_lock"), "lock should not be created when :lock=>false"
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: attr_callback
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Dwayne Litzenberger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-19 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |
+  The attr_callback gem lets you create user-definable callback method attributes
+  conveniently.
+
+email: 
+- dlitz@infonium.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/attr_callback/version.rb
+- lib/attr_callback.rb
+- test/test_helper.rb
+- test/unit/attr_callback_test.rb
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/rubinaut/attr_callback
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Convenience method for providing user-definable callbacks.
+test_files: []
+