sync_attr 0.0.1 → 0.1.0

data/Rakefile

@@ -18,7 +18,7 @@ task :gem  do |t|
     s.date        = Date.today.to_s
     s.summary     = "Thread safe accessors for Ruby class and instance attributes. Supports thread safe lazy loading of attributes"
     s.description = "SyncAttr is a mixin to read, write and lazy initialize both class and instance variables in a multi-threaded environment when the attribute could be modified by two threads at the same time, written in Ruby."
-    s.files       = FileList["./**/*"].exclude('*.gem', 'nbproject').map{|f| f.sub(/^\.\//, '')}
+    s.files       = FileList['**/*'].exclude('*.gem', /nbproject/)
     s.has_rdoc    = true
   end
   Gem::Builder.new(gemspec).build

data/examples/class_attribute.rb

@@ -3,7 +3,7 @@
 require 'sync_attr'
 
 # Sample class with lazy initialized Synchronized Class Attributes
-def Person
+class Person
   include SyncAttr
 
   # Thread safe Class Attribute reader for name
@@ -20,12 +20,11 @@ def Person
   end
 end
 
-person = Person.new
-puts "The person is #{person.name} with age #{person.age}"
+puts "The person is #{Person.name} with age #{Person.age}"
 
-person.age = 22
-puts "The person is #{person.name} now has age #{person.age}"
+Person.age = 22
+puts "The person is #{Person.name} now has age #{Person.age}"
 
-person.age = Proc.new {|age| age += 1 }
-puts "The person is #{person.name} now has age #{person.age}"
+Person.age = Proc.new {|age| age += 1 }
+puts "The person is #{Person.name} now has age #{Person.age}"
 

data/examples/instance_attribute.rb

@@ -0,0 +1,35 @@
+# Class Attribute Example
+#
+require 'sync_attr'
+
+# Sample class with lazy initialized Synchronized Class Attributes
+class Person
+  include SyncAttr
+
+  # Thread safe Instance Attribute reader for name
+  # Sets :name only when it is first called
+  # Ideal for when name is loaded after startup from a database or config file
+  sync_attr_reader :name do
+    "Joe Bloggs"
+  end
+
+  # Thread safe Instance Attribute reader and writer for age
+  # Sets :age only when it is first called
+  sync_attr_accessor :age do
+    21
+  end
+end
+
+person = Person.new
+puts "The person is #{person.name} with age #{person.age}"
+
+person.age = 22
+puts "The person is #{person.name} now has age #{person.age}"
+
+person.age = Proc.new {|age| age += 1 }
+puts "The person is #{person.name} now has age #{person.age}"
+
+# Changes to person above do not affect any changes to second_person
+# Also, the initial value that is lazy loaded into name is unaffected by person above
+second_person = Person.new
+puts "The second person is #{second_person.name} with age #{second_person.age}"

data/lib/sync_attr.rb

@@ -22,12 +22,14 @@
 require 'sync'
 require 'sync_attr/version'
 require 'sync_attr/class_attributes'
-#require 'sync_attr/instance_attributes'
+require 'sync_attr/instance_attributes'
 
 module SyncAttr
   # Add class methods and initialize mixin
   def self.included(base)
     base.extend(SyncAttr::ClassAttributes::ClassMethods)
-    base.send(:sync_attr_class_attr_init)
+    base.extend(SyncAttr::InstanceAttributes::ClassMethods)
+    base.send(:sync_cattr_init)
+    base.send(:sync_attr_init)
   end
 end

data/lib/sync_attr/class_attributes.rb

@@ -25,19 +25,26 @@ module SyncAttr
       #   end
       def sync_cattr_reader(*attributes, &block)
         attributes.each do |attribute|
-          self.class.send(:define_method, attribute.to_sym) do
-            var_name = "@@#{attribute}".to_sym
-            if class_variable_defined?(var_name)
-              sync_attr_sync.synchronize(:SH) { class_variable_get(var_name) }
-            else
-              return nil unless block
-              sync_attr_sync.synchronize(:EX) do
-                # Now that we have exclusive access make sure that another thread has
-                # not just initialized this attribute
-                if class_variable_defined?(var_name)
-                  class_variable_get(var_name)
+          metaclass.instance_eval do
+            define_method(attribute.to_sym) do
+              var_name = "@@#{attribute}".to_sym
+              if class_variable_defined?(var_name)
+                # If there is no writer then it is not necessary to protect reads
+                if self.respond_to?("#{attribute}=".to_sym, true)
+                  sync_cattr_sync.synchronize(:SH) { class_variable_get(var_name) }
                 else
-                  class_variable_set(var_name, class_eval(&block))
+                  class_variable_get(var_name)
+                end
+              else
+                return nil unless block
+                sync_cattr_sync.synchronize(:EX) do
+                  # Now that we have exclusive access make sure that another thread has
+                  # not just initialized this attribute
+                  if class_variable_defined?(var_name)
+                    class_variable_get(var_name)
+                  else
+                    class_variable_set(var_name, class_eval(&block))
+                  end
                 end
               end
             end
@@ -52,7 +59,7 @@ module SyncAttr
         attributes.each do |attribute|
           class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{attribute}=(value)
-          sync_attr_sync.synchronize(:EX) do
+          sync_cattr_sync.synchronize(:EX) do
             if value.is_a?(Proc)
               current_value = @@#{attribute} if defined?(@@#{attribute})
               @@#{attribute} = value.call(current_value)
@@ -67,21 +74,32 @@ module SyncAttr
 
       # Generate a class reader and writer for the attribute
       def sync_cattr_accessor(*attributes, &block)
-        sync_cattr_reader(*attributes, &block)
         sync_cattr_writer(*attributes)
+        sync_cattr_reader(*attributes, &block)
       end
 
-      private
+      # Returns the metaclass or eigenclass so that we
+      # can dynamically generate class methods
+      # With thanks, see: https://gist.github.com/1199817
+      def metaclass
+        class << self;
+          self
+        end
+      end
 
-      # Give each class that this module is mixed into it's own Sync
-      def sync_attr_class_attr_init
-        @sync_attr_sync = ::Sync.new
+      # Returns the sync used by the included class to synchronize access to the
+      # class attributes
+      def sync_cattr_sync
+        @sync_cattr_sync
       end
 
-      def sync_attr_sync
-        @sync_attr_sync
+      protected
+
+      # Give each class that this module is mixed into it's own Sync
+      def sync_cattr_init
+        @sync_cattr_sync = ::Sync.new
       end
 
     end
   end
-end
+end

data/lib/sync_attr/instance_attributes.rb

@@ -0,0 +1,101 @@
+      puts "Loaded sync_attr_reader"
+# Synchronize access and lazy initialize one or more attributes
+#
+# Author: Reid Morrison <reidmo@gmail.com>
+module SyncAttr
+  module InstanceAttributes
+    module ClassMethods
+      # Lazy load the specific attribute by calling the supplied block when
+      # the attribute is first read and then return the same value for all subsequent
+      # calls to the variable
+      #
+      # An optional block can be supplied to initialize the attribute
+      # when first read. Acts as a thread safe lazy initializer. The block will only
+      # be called once even if several threads call the reader at the same time
+      #
+      # Example:
+      #   class MyClass
+      #     include SyncAttr
+      #
+      #     # Generates a reader for the class attribute 'hello'
+      #     # and Lazy initializes the value to 'hello world' only on the first
+      #     # call to the reader
+      #     sync_attr_reader :hello do
+      #       'hello world'
+      #     end
+      #   end
+      def sync_attr_reader(*attributes, &block)
+        attributes.each do |attribute|
+          self.send(:define_method, attribute.to_sym) do
+            var_name = "@#{attribute}".to_sym
+            if instance_variable_defined?(var_name)
+              self.sync_attr_sync.synchronize(:SH) { instance_variable_get(var_name) }
+                # If there is no writer then it is not necessary to protect reads
+                if self.respond_to?("#{attribute}=".to_sym, true)
+                  self.sync_attr_sync.synchronize(:SH) { instance_variable_get(var_name) }
+                else
+                  instance_variable_get(var_name)
+                end
+            else
+              return nil unless block
+              self.sync_attr_sync.synchronize(:EX) do
+                # Now that we have exclusive access make sure that another thread has
+                # not just initialized this attribute
+                if instance_variable_defined?(var_name)
+                  instance_variable_get(var_name)
+                else
+                  instance_variable_set(var_name, instance_eval(&block))
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Generates a writer to set a synchronized attribute
+      # Supply a Proc ensure an attribute is not being updated by another thread:
+      #   my_object.count = Proc.new {|count| (count||0) + 1}
+      def sync_attr_writer(*attributes)
+        attributes.each do |attribute|
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{attribute}=(value)
+          self.sync_attr_sync.synchronize(:EX) do
+            if value.is_a?(Proc)
+              current_value = @#{attribute} if defined?(@#{attribute})
+              @#{attribute} = value.call(current_value)
+            else
+              @#{attribute} = value
+            end
+          end
+        end
+          EOS
+        end
+      end
+
+      # Generate a reader and writer for the attribute
+      def sync_attr_accessor(*attributes, &block)
+        sync_attr_reader(*attributes, &block)
+        sync_attr_writer(*attributes)
+      end
+
+      # Give every object instance that this module is mixed into it's own Sync
+      # I.e. At an object level, not class level
+      def sync_attr_init
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def sync_attr_sync
+        return @sync_attr_sync if @sync_attr_sync
+        # Use class sync_cattr_sync to ensure multiple @sync_attr_sync instances
+        # are not created when two or more threads call this method for the
+        # first time at the same time
+        self.class.sync_cattr_sync.synchronize(:EX) do
+          # In case another thread already created the sync
+          return @sync_attr_sync if @sync_attr_sync
+          @sync_attr_sync = ::Sync::new
+        end
+      end
+          EOS
+      end
+
+    end
+  end
+end

data/lib/sync_attr/version.rb

@@ -1,3 +1,3 @@
 module SyncAttr #:nodoc
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/class_attributes_test.rb

@@ -6,10 +6,10 @@ require 'test/unit'
 require 'shoulda'
 require 'sync_attr'
 
-class SynchAttrExample
+class SyncCAttrExample
   include SyncAttr
 
-  sync_cattr_reader :test do
+  sync_cattr_reader :test1 do
     'hello world'
   end
   sync_cattr_reader :test2
@@ -21,11 +21,11 @@ class SynchAttrExample
   sync_cattr_accessor :test5
 end
 
-class SynchAttrExample2
+class SyncCAttrExample2
   include SyncAttr
 
-  sync_cattr_reader :test do
-    'hello world'
+  sync_cattr_reader :test1 do
+    'another world'
   end
 end
 
@@ -33,43 +33,55 @@ class ClassAttributesTest < Test::Unit::TestCase
   context "with example" do
 
     should 'lazy initialize class attribute' do
-      assert_equal 'hello world', SynchAttrExample.test
+      assert_equal 'hello world', SyncCAttrExample.test1
     end
 
     should 'return nil on class attribute without initializer' do
-      assert_nil SynchAttrExample.test2
+      assert_nil SyncCAttrExample.test2
     end
 
     should 'set and then return a value for a class attribute without an initializer' do
-      assert_nil SynchAttrExample.test3
-      assert_equal 'test3', (SynchAttrExample.test3 = 'test3')
-      assert_equal 'test3', SynchAttrExample.test3
+      assert_nil SyncCAttrExample.test3
+      assert_equal 'test3', (SyncCAttrExample.test3 = 'test3')
+      assert_equal 'test3', SyncCAttrExample.test3
     end
 
     should 'lazy initialize class attribute and also have writer' do
-      assert_equal 'hello world 4', SynchAttrExample.test4
-      assert_equal 'test4', (SynchAttrExample.test4 = 'test4')
-      assert_equal 'test4', SynchAttrExample.test4
+      assert_equal 'hello world 4', SyncCAttrExample.test4
+      assert_equal 'test4', (SyncCAttrExample.test4 = 'test4')
+      assert_equal 'test4', SyncCAttrExample.test4
     end
 
     should 'support setting a Proc within a synch block' do
-      assert_nil SynchAttrExample.test5
+      assert_nil SyncCAttrExample.test5
 
       # Returns the Proc
-      SynchAttrExample.test5 = Proc.new {|val| (val||0) + 1}
-      assert_equal 1, SynchAttrExample.test5
+      SyncCAttrExample.test5 = Proc.new {|val| (val||0) + 1}
+      assert_equal 1, SyncCAttrExample.test5
 
-      SynchAttrExample.test5 = Proc.new {|val| (val||0) + 1}
-      assert_equal 2, SynchAttrExample.test5
+      SyncCAttrExample.test5 = Proc.new {|val| (val||0) + 1}
+      assert_equal 2, SyncCAttrExample.test5
     end
   end
 
   context "with example2" do
 
     should 'ensure that different classes have their own synch instances' do
-      assert ex1 = SynchAttrExample.new
-      assert ex2 = SynchAttrExample2.new
-      assert ex1.class.send(:sync_attr_sync).object_id != ex2.class.send(:sync_attr_sync).object_id
+      assert ex1 = SyncCAttrExample.new
+      assert ex2 = SyncCAttrExample2.new
+      assert ex1.class.send(:sync_cattr_sync).object_id != ex2.class.send(:sync_cattr_sync).object_id
+    end
+
+    should 'ensure that different classes have their own class attributes' do
+      assert ex1 = SyncCAttrExample.new
+      assert_equal 'hello world', ex1.class.test1
+      assert ex2 = SyncCAttrExample2.new
+      assert_equal 'another world', ex2.class.test1
+      assert_equal 'hello world', ex1.class.test1
+
+      assert !defined? ex2.class.test2
+      assert !defined? ex2.class.test3
+      assert !defined? ex2.class.test4
     end
   end
 end

data/test/instance_attributes_test.rb

@@ -0,0 +1,88 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'sync_attr'
+
+class SyncAttrExample
+  include SyncAttr
+
+  sync_attr_reader :test1 do
+    'hello world'
+  end
+  sync_attr_reader :test2
+  sync_attr_accessor :test3
+  sync_attr_accessor :test4 do
+    'hello world 4'
+  end
+
+  sync_attr_accessor :test5
+end
+
+# Ensure that class and instance attributes are distinct
+class SyncAttrExample2
+  include SyncAttr
+
+  sync_attr_reader :test1 do
+    'hello world instance'
+  end
+  sync_cattr_reader :test1 do
+    'hello world class'
+  end
+end
+
+class InstanceAttributesTest < Test::Unit::TestCase
+  context "with example" do
+
+    should 'lazy initialize attribute' do
+      assert_equal 'hello world', SyncAttrExample.new.test1
+    end
+
+    should 'return nil on attribute without initializer' do
+      assert_nil SyncAttrExample.new.test2
+    end
+
+    should 'set and then return a value for a class attribute without an initializer' do
+      assert example = SyncAttrExample.new
+      assert_nil example.test3
+      assert_equal 'test3', (example.test3 = 'test3')
+      assert_equal 'test3', example.test3
+    end
+
+    should 'lazy initialize attribute and also have writer' do
+      assert example = SyncAttrExample.new
+      assert_equal 'hello world 4', example.test4
+      assert_equal 'test4', (example.test4 = 'test4')
+      assert_equal 'test4', example.test4
+    end
+
+    should 'support setting a Proc within a synch block' do
+      assert example = SyncAttrExample.new
+      assert_nil example.test5
+
+      # Returns the Proc
+      example.test5 = Proc.new {|val| (val||0) + 1}
+      assert_equal 1, example.test5
+
+      example.test5 = Proc.new {|val| (val||0) + 1}
+      assert_equal 2, example.test5
+    end
+  end
+
+  context "with example2" do
+
+    should 'have distinct class and instance attributes when they have the same name' do
+      assert s = SyncAttrExample2.new
+      assert_equal 'hello world instance', s.test1
+      assert_equal 'hello world class', s.class.test1
+    end
+
+    should 'ensure that different classes have their own synch instances' do
+      assert ex1 = SyncAttrExample.new
+      assert ex2 = SyncAttrExample2.new
+      assert ex1.class.send(:sync_cattr_sync).object_id != ex2.class.send(:sync_cattr_sync).object_id
+    end
+  end
+end

metadata

@@ -1,22 +1,26 @@
 --- !ruby/object:Gem::Specification 
 name: sync_attr
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.1
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
-  - Reid Morrison
+- Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-02-20 00:00:00 -05:00
+date: 2012-03-05 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
 description: SyncAttr is a mixin to read, write and lazy initialize both class and instance variables in a multi-threaded environment when the attribute could be modified by two threads at the same time, written in Ruby.
 email: 
-  - reidmo@gmail.com
+- reidmo@gmail.com
 executables: []
 
 extensions: []
@@ -24,20 +28,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-  - LICENSE.txt
-  - Rakefile
-  - README.md
-  - examples/class_attribute.rb
-  - lib/sync_attr.rb
-  - lib/sync_attr/class_attributes.rb
-  - lib/sync_attr/version.rb
-  - nbproject/project.properties
-  - nbproject/project.xml
-  - nbproject/private/config.properties
-  - nbproject/private/private.properties
-  - nbproject/private/private.xml
-  - nbproject/private/rake-d.txt
-  - test/class_attributes_test.rb
+- examples/class_attribute.rb
+- examples/instance_attribute.rb
+- lib/sync_attr/class_attributes.rb
+- lib/sync_attr/instance_attributes.rb
+- lib/sync_attr/version.rb
+- lib/sync_attr.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+- test/class_attributes_test.rb
+- test/instance_attributes_test.rb
 has_rdoc: true
 homepage: https://github.com/ClarityServices/sync_attr
 licenses: []
@@ -46,23 +47,25 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Thread safe accessors for Ruby class and instance attributes. Supports thread safe lazy loading of attributes

data/nbproject/private/private.properties

@@ -1,4 +0,0 @@
-file.reference.synch_attr-examples=/Users/rmorrison/Sandbox/synch_attr/examples
-file.reference.synch_attr-lib=/Users/rmorrison/Sandbox/synch_attr/lib
-file.reference.synch_attr-test=/Users/rmorrison/Sandbox/synch_attr/test
-platform.active=JRuby_0

data/nbproject/private/private.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
-    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/1"/>
-</project-private>

data/nbproject/project.properties

@@ -1,10 +0,0 @@
-file.reference.synch_attr-examples=examples
-file.reference.synch_attr-lib=lib
-file.reference.synch_attr-test=test
-javac.classpath=
-main.file=
-platform.active=JRuby_0
-source.encoding=UTF-8
-src.examples.dir=examples
-src.lib.dir=lib
-test.test.dir=test

data/nbproject/project.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://www.netbeans.org/ns/project/1">
-    <type>org.netbeans.modules.ruby.rubyproject</type>
-    <configuration>
-        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
-            <name>sync_attr</name>
-            <source-roots>
-                <root id="src.lib.dir" name="Source Files"/>
-                <root id="src.examples.dir" name="Examples"/>
-            </source-roots>
-            <test-roots>
-                <root id="test.test.dir" name="Test Files"/>
-            </test-roots>
-        </data>
-    </configuration>
-</project>