sync_attr 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44a69c13e6128090ae353172baf6047190bdb0ad
-  data.tar.gz: 29dda506593efe254aabfd28327f853c8fb54f5f
+  metadata.gz: 6081ee6568e87da15f5739a7e0f9098e8697a4db
+  data.tar.gz: 45bc09a1ff0ce624b42fda4fd27d4c114a57492a
 SHA512:
-  metadata.gz: 14bce4c1073400855394d048455b1168eb94fd53cb6e67c9069eece654f0b784cfd174a966f8943922646cf8fd865b7da2d786074e9cff045c467307fe4d6b72
-  data.tar.gz: 7dc91d0083331bfdbf27999ffd3584cecd4f02b4b6f2b21ae7ef1e57a28f0188711ae4c985e8a0a5958babc1c75fc63993cef4e8841a389a2f12090958a9484b
+  metadata.gz: 4089d07c4d675212967e58cfe825b3f591b5535715ac6cc977f9aee24300c6d3a45503fbeb182681ee4f02f2f2b1e529d37d17206abe1033068dd3119703a668
+  data.tar.gz: 8aa44e84c312076143b0997f3140b8df9c9f4798e28e56c37ab3cbc2f671ac54b5f3d3aba5a605484b4230c92638cded73813aca06723f1153f487194780086b

data/LICENSE.txt

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2012 Clarity Services, Inc.
+   Copyright 2012, 2013, 2014 Reid Morrison
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -1,108 +1,164 @@
-sync_attr
+sync_attr [![Build Status](https://secure.travis-ci.org/reidmorrison/sync_attr.png?branch=master)](http://travis-ci.org/reidmorrison/sync_attr)
 =========
 
-Thread-safe Ruby class variables with lazy loaded default values and initializers
+Thread-safe Ruby class and instance attributes
 
-* http://github.com/ClarityServices/sync_attr
+* http://github.com/reidmorrison/sync_attr
 
-### Introduction
+## Status
 
-When working in a multithreaded environment it is important to ensure that
+Enterprise Production Ready - In daily use in large multi-threaded application
+
+## Introduction
+
+When working in a multi-threaded environment it is important to ensure that
 any attributes that are shared across threads are properly protected to ensure
-that inconsistent data is not created.
+that inconsistent data is not created. Lazy initializing these safe attributes
+improves startup times and only creates resources when they are needed.
 
 For example, without sync_attr if two threads attempt to write to the
 same attribute at the same time it is not deterministic what the results will be.
-This condition is made worse when two threads attempt to initialize class variables
-at the same time that could take a second or longer to complete.
+This condition is made worse when two threads attempt to initialize class instance
+attributes at the same time that could take a second or longer to complete.
+
+A `sync_cattr_reader` is ideal for holding data loaded from configuration files.
+Also, shared objects, such as connection pools can be safely initialized and
+shared in this way across hundreds of threads.
+Once initialized all reads are shared without locks since no writer is defined.
+
+Aside from safely sharing reads `sync_cattr_accessor` also ensures that data
+is not read while it is being modified. The writes are completely thread-safe
+ensuring that only one thread is modifying the value at a time and that reads
+are suspended until the write is complete.
 
-### Features
+## Features
 
-* Adds thread-safe accessors for class attributes
-* Allows shared read access to class and instance attributes. This allows
-  multiple threads to read the attribute, but will block all reads and writes whilst
-  the attribute is being modified.
+* Adds thread-safe accessors for class instance attributes.
+* Only one thread can read or write the value at any one time.
 * Prevents attributes from being read while it is being updated or initialized for
   the first time.
-* Thread-safe attribute lazy initialization
+* Thread-safe attribute lazy initialization.
   Lazy initialization allows class attributes to be loaded only when first read.
-  As a result it's value can be read for the first time from a database or config file
-  once and only when needed.
-* Avoids having to create yet another Rails initializer
-* Avoids costly startup initialization when the initialized data may never be accessed
-  For example when Rake tasks are run, they may not need access to everything in
-  the Rails environment
-* Not dependent on Rails
+  As a result it's value can be read for the first time from a database or
+  configuration file once and only when needed.
+* Avoids having to create yet another Rails initializer, when the data can be
+  fetched or held by a class instance attribute.
+* Avoids costly startup initialization when the initialized data may never be accessed.
+  For example, when Rake tasks are run, they may not need access to everything in
+  the Rails environment.
+* Works with Rails and regular Ruby.
+
+## Thread-safe Class Attribute example
+
+Create a reader for a class attribute and lazy initialize its value on the first
+attempt to read it. I.e. Lazy initialize the value.
+
+Very useful for initializing shared services that take time to initialize.
+In particular services that may not even be called in a specific process,
+for example when running rake, or when opening a console.
+
+An optional block can be supplied to initialize the synchronized class attribute
+when it is first read. The initializer is thread safe and will block all other
+reads to this attribute while it is being initialized. This ensures that the
+initializer is only run once and that all threads to call the reader receive the
+same value, regardless of how many threads call the reader at the same time.
+
+Example:
+
+```ruby
+require 'sync_attr'
+
+# Sample class with lazy initialized Thread-safe Class Attributes
+class Person
+  # Create a reader for the class attribute :name
+  # and lazy initialize the value to 'Joe Bloggs' only on the first
+  # call to the reader.
+  # Ideal for when :name is loaded from a database or configuration file.
+  sync_cattr_reader :name do
+    'Joe Bloggs'
+  end
+
+  # Create a reader and a writer for the class attribute :age
+  # and lazy initialize the value to 21 only on the first
+  # call to the reader.
+  sync_cattr_accessor :age do
+    21
+  end
+end
+
+puts "The person is #{Person.name} with age #{Person.age}"
+
+Person.age = 22
+puts "The person is #{Person.name} now has age #{Person.age}"
+
+# => The person is Joe Bloggs now has age 22
 
-### Synchronized Class Attribute example
+Person.age = Proc.new {|age| age += 1 }
+puts "The person is #{Person.name} now has age #{Person.age}"
 
-    require 'sync_attr'
+# => The person is Joe Bloggs now has age 23
+```
 
-    # Sample class with lazy initialized Synchronized Class Attributes
-    class Person
-      include SyncAttr
+## Thread-safe Instance Attribute example
 
-      # Thread safe Class Attribute reader for name
-      # with a default value
-      # Ideal for when name is loaded after startup from a database or config file
-      sync_cattr_reader :name do
-        "Joe Bloggs"
-      end
+Create a reader for an attribute and lazy initialize its value on the first
+attempt to read it. I.e. Lazy initialize the value.
 
-      # Thread safe Class Attribute reader and writer for age
-      # with a default value
-      sync_cattr_accessor :age do
-        21
-      end
-    end
+An optional block can be supplied to initialize the synchronized attribute
+when it is first read. The initializer is thread safe and will block all other
+reads to this attribute while it is being initialized. This ensures that the
+initializer is only run once per object and that all threads to call the reader
+receive the same value, regardless of how many threads call the reader at the same time.
 
-    puts "The person is #{Person.name} with age #{Person.age}"
+Example:
 
-    Person.age = 22
-    puts "The person is #{Person.name} now has age #{Person.age}"
+```ruby
+require 'sync_attr'
 
-    Person.age = Proc.new {|age| age += 1 }
-    puts "The person is #{Person.name} now has age #{Person.age}"
+# Sample class with lazy initialized Thread-safe attributes
+class Person
+  include SyncAttr::Attributes
 
-### Synchronized Instance Attribute example
+  # Create a reader for the thread-safe attribute :name
+  # and lazy initialize the value to 'Joe Bloggs' only on the first
+  # call to the reader.
+  sync_attr_reader :name do
+    'Joe Bloggs'
+  end
 
-    require 'sync_attr'
+  # Create a thread-safe reader and a writer for the attribute :age
+  # and lazy initialize the value to 21 only on the first
+  # call to the reader.
+  sync_attr_accessor :age do
+    21
+  end
+end
 
-    # Sample class with lazy initialized Synchronized Class Attributes
-    class Person
-      include SyncAttr
+person = Person.new
+puts "The person is #{person.name} with age #{person.age}"
 
-      # Thread safe Attribute reader for name
-      # with a default value
-      sync_attr_reader :name do
-        "Joe Bloggs"
-      end
+# => The person is Joe Bloggs with age 21
 
-      # Thread safe Attribute reader and writer for age
-      # with a default value
-      sync_attr_accessor :age do
-        21
-      end
-    end
+person.age = 22
+puts "The person is #{person.name} now has age #{person.age}"
 
-    person = Person.new
-    puts "The person is #{person.name} with age #{person.age}"
+# => The person is Joe Bloggs now has age 22
 
-    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}"
+# => The person is Joe Bloggs now has age 23
+```
 
-### Install
+## Install
 
   gem install sync_attr
 
 Meta
 ----
 
-* Code: `git clone git://github.com/ClarityServices/sync_attr.git`
-* Home: <https://github.com/ClarityServices/sync_attr>
+* Code: `git clone git://github.com/reidmorrison/sync_attr.git`
+* Home: <https://github.com/reidmorrison/sync_attr>
 * Bugs: <http://github.com/reidmorrison/sync_attr/issues>
 * Gems: <http://rubygems.org/gems/sync_attr>
 
@@ -116,7 +172,7 @@ Reid Morrison :: reidmo@gmail.com :: @reidmorrison
 License
 -------
 
-Copyright 2012 Clarity Services, Inc.
+Copyright 2012, 2013, 2014, 2015 Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,38 +1,28 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-
-require 'rubygems'
-require 'rubygems/package'
 require 'rake/clean'
 require 'rake/testtask'
-require 'date'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require 'sync_attr/version'
 
-desc "Build gem"
-task :gem  do |t|
-  gemspec = Gem::Specification.new do |s|
-    s.name        = 'sync_attr'
-    s.version     = SyncAttr::VERSION
-    s.platform    = Gem::Platform::RUBY
-    s.authors     = ['Reid Morrison']
-    s.email       = ['reidmo@gmail.com']
-    s.homepage    = 'https://github.com/ClarityServices/sync_attr'
-    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$/, /\.log$/,/nbproject/).map{|f| f.sub(/^\.\//, '')}
-    s.license     = "Apache License V2.0"
-    s.has_rdoc    = true
-  end
-  Gem::Package.build gemspec
+task :gem do
+  system "gem build sync_attr.gemspec"
+end
+
+task :publish => :gem do
+  system "git tag -a v#{SyncAttr::VERSION} -m 'Tagging #{SyncAttr::VERSION}'"
+  system "git push --tags"
+  system "gem push sync_attr-#{SyncAttr::VERSION}.gem"
+  system "rm sync_attr-#{SyncAttr::VERSION}.gem"
 end
 
 desc "Run Test Suite"
 task :test do
-  Rake::TestTask.new(:unit) do |t|
+  Rake::TestTask.new(:functional) do |t|
     t.test_files = FileList['test/*_test.rb']
     t.verbose    = true
   end
 
-  Rake::Task['unit'].invoke
+  Rake::Task['functional'].invoke
 end
+
+task :default => :test

data/lib/sync_attr.rb

@@ -1,35 +1,9 @@
-# Synchronize access and lazy initialize one or more variables in a class
-#
-# Load configuration files and thread connection pools on demand rather than
-# at start time or via a Rails initializer
-#
-# Locking: Shared reads and exclusive writes
-#   sync_attr ensures that all reads are shared, meaning that all
-#   reads to attributes can occur at the same time. All writes are exclusive, so
-#   all reads and other writes will be blocked whilst a write takes place.
-#
-# Example:
-# class MyClass
-#   include SyncAttr
-#
-#    # Create class variable @@http and initialize on the first access
-#    # protecting access by concurrent threads using a Semaphore
-#    sync_cattr_reader :http do
-#      PersistentHTTP.new()
-#    end
-#
-# Author: Reid Morrison <reidmo@gmail.com>
-require 'sync'
+require 'thread'
 require 'sync_attr/version'
 require 'sync_attr/class_attributes'
-require 'sync_attr/instance_attributes'
+require 'sync_attr/attributes'
 
+# include SyncAttr is deprecated. Not required for class instance attributes.
+# include SyncAttr::Attributes for object instance attributes.
 module SyncAttr
-  # Add class methods and initialize mixin
-  def self.included(base)
-    base.extend(SyncAttr::ClassAttributes::ClassMethods)
-    base.extend(SyncAttr::InstanceAttributes::ClassMethods)
-    base.send(:sync_cattr_init)
-    base.send(:sync_attr_init)
-  end
 end

data/lib/sync_attr/{instance_attributes.rb → attributes.rb}

@@ -1,12 +1,14 @@
-# Synchronize access and lazy initialize one or more attributes
-#
-# Author: Reid Morrison <reidmo@gmail.com>
 module SyncAttr
-  module InstanceAttributes
+  module Attributes
     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
+      # Thread-safe access to attributes in an object.
+      #
+      # Attributes protected with `sync_attr_reader`, `sync_attr_writer`, and/or
+      # `sync_attr_accessor` can be safely read and written across many threads.
+      #
+      # Additionally `sync_attr_reader` supports lazy loading the corresponding
+      # attribute in a thread-safe way. While the value is being calculated / loaded
+      # all other threads calling that attribute will block until the value is available
       #
       # An optional block can be supplied to initialize the attribute
       # when first read. Acts as a thread safe lazy initializer. The block will only
@@ -14,9 +16,9 @@ module SyncAttr
       #
       # Example:
       #   class MyClass
-      #     include SyncAttr
+      #     include SyncAttr::Attributes
       #
-      #     # Generates a reader for the class attribute 'hello'
+      #     # Generates a reader for the attribute 'hello'
       #     # and Lazy initializes the value to 'hello world' only on the first
       #     # call to the reader
       #     sync_attr_reader :hello do
@@ -25,19 +27,19 @@ module SyncAttr
       #   end
       def sync_attr_reader(*attributes, &block)
         attributes.each do |attribute|
+          raise NameError.new("invalid attribute name: #{attribute}") unless attribute =~ /^[_A-Za-z]\w*$/
           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
+              # If there is no writer then it is not necessary to protect reads
+              if respond_to?("#{attribute}=".to_sym, true)
+                sync_attr_sync(attribute) { instance_variable_get(var_name) }
+              else
+                instance_variable_get(var_name)
+              end
             else
               return nil unless block
-              self.sync_attr_sync.synchronize(:EX) do
+              sync_attr_sync(attribute) do
                 # Now that we have exclusive access make sure that another thread has
                 # not just initialized this attribute
                 if instance_variable_defined?(var_name)
@@ -56,17 +58,18 @@ module SyncAttr
       #   my_object.count = Proc.new {|count| (count||0) + 1}
       def sync_attr_writer(*attributes)
         attributes.each do |attribute|
+          raise NameError.new("invalid attribute name: #{attribute}") unless attribute =~ /^[_A-Za-z]\w*$/
           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
+            def #{attribute}=(value)
+              sync_attr_sync('#{attribute}') do
+                if value.is_a?(Proc)
+                  current_value = @#{attribute} if defined?(@#{attribute})
+                  @#{attribute} = value.call(current_value)
+                else
+                  @#{attribute} = value
+                end
+              end
             end
-          end
-        end
           EOS
         end
       end
@@ -76,25 +79,20 @@ module SyncAttr
         sync_attr_reader(*attributes, &block)
         sync_attr_writer(*attributes)
       end
+    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
+    def self.included(base)
+      base.extend(SyncAttr::Attributes::ClassMethods)
+    end
 
+    private
+
+    # Thread safe way of creating the instance sync
+    def sync_attr_sync(attribute, &block)
+      mutex_var_name = "@sync_attr_#{attribute}".to_sym
+      instance_variable_set(mutex_var_name, Mutex.new) unless instance_variable_defined?(mutex_var_name)
+      instance_variable_get(mutex_var_name).synchronize(&block)
     end
+
   end
 end

data/lib/sync_attr/class_attributes.rb

@@ -1,65 +1,67 @@
-# Synchronize access and lazy initialize one or more variables in a class
-#
-# Author: Reid Morrison <reidmo@gmail.com>
-module SyncAttr
-  module ClassAttributes
-    module ClassMethods
-      # Lazy load the specific class attribute by calling the supplied block when
-      # the attribute is first read and then return the same value for all subsequent
-      # calls to the class variable
-      #
-      # An optional block can be supplied to initialize the synchronized class 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_cattr_reader :hello do
-      #       'hello world'
-      #     end
-      #   end
-      def sync_cattr_reader(*attributes, &block)
-        attributes.each do |attribute|
-          metaclass.instance_eval do
-            define_method(attribute.to_sym) do
-              var_name = "@@#{attribute}".to_sym
+class Module
+  # Lazy load the specific class attribute by calling the supplied block when
+  # the attribute is first read and then return the same value for all subsequent
+  # calls to the class variable
+  #
+  # An optional block can be supplied to initialize the synchronized class 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:
+  #   require 'sync_attr'
+  #   class MyClass
+  #     # 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_cattr_reader :hello do
+  #       'hello world'
+  #     end
+  #   end
+  def sync_mattr_reader(*attributes, &block)
+    attributes.each do |attribute|
+      raise NameError.new("invalid attribute name: #{attribute}") unless attribute =~ /^[_A-Za-z]\w*$/
+      mutex_var_name = "@@sync_attr_#{attribute}".to_sym
+      class_variable_set(mutex_var_name, Mutex.new) unless class_variable_defined?(mutex_var_name)
+      # Class reader with lazy initialization for the first thread that calls this method
+      # Use metaclass/eigenclass to dynamically generate class methods
+      (class << self; self; end).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)
+              class_variable_get(mutex_var_name).synchronize { class_variable_get(var_name) }
+            else
+              class_variable_get(var_name)
+            end
+          else
+            return nil unless block
+            class_variable_get(mutex_var_name).synchronize do
+              # Now that we have exclusive access make sure that another thread has
+              # not just initialized this attribute
               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_get(var_name)
-                end
+                class_variable_get(var_name)
               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
+                class_variable_set(var_name, class_eval(&block))
               end
             end
           end
         end
       end
+    end
+  end
+  alias :sync_cattr_reader :sync_mattr_reader
 
-      # Generates a writer to set a synchronized attribute
-      # Supply a Proc ensure an attribute is not being updated by another thread:
-      #   MyClass.count = Proc.new {|count| (count||0) + 1}
-      def sync_cattr_writer(*attributes)
-        attributes.each do |attribute|
-          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+  # Generates a writer to set a synchronized attribute
+  # Supply a Proc ensure an attribute is not being updated by another thread:
+  #   MyClass.count = Proc.new {|count| (count||0) + 1}
+  def sync_mattr_writer(*attributes)
+    attributes.each do |attribute|
+      mutex_var_name = "@@sync_attr_#{attribute}".to_sym
+      class_variable_set(mutex_var_name, Mutex.new) unless class_variable_defined?(mutex_var_name)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{attribute}=(value)
-          sync_cattr_sync.synchronize(:EX) do
+          #{mutex_var_name}.synchronize do
             if value.is_a?(Proc)
               current_value = @@#{attribute} if defined?(@@#{attribute})
               @@#{attribute} = value.call(current_value)
@@ -68,38 +70,15 @@ module SyncAttr
             end
           end
         end
-          EOS
-        end
-      end
-
-      # Generate a class reader and writer for the attribute
-      def sync_cattr_accessor(*attributes, &block)
-        sync_cattr_writer(*attributes)
-        sync_cattr_reader(*attributes, &block)
-      end
-
-      # 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
-
-      # Returns the sync used by the included class to synchronize access to the
-      # class attributes
-      def sync_cattr_sync
-        @sync_cattr_sync ||= ::Sync.new
-      end
-
-      protected
-
-      # Give each class that this module is mixed into it's own Sync
-      def sync_cattr_init
-        @sync_cattr_sync = ::Sync.new
-      end
-
+      EOS
     end
   end
+  alias :sync_cattr_writer :sync_mattr_writer
+
+  # Generate a class reader and writer for the attribute
+  def sync_mattr_accessor(*attributes, &block)
+    sync_cattr_writer(*attributes)
+    sync_cattr_reader(*attributes, &block)
+  end
+  alias :sync_cattr_accessor :sync_mattr_accessor
 end

data/lib/sync_attr/version.rb

@@ -1,3 +1,3 @@
 module SyncAttr
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/test/{instance_attributes_test.rb → attributes_test.rb}

@@ -1,13 +1,7 @@
-# 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'
+require_relative 'test_helper'
 
 class SyncAttrExample
-  include SyncAttr
+  include SyncAttr::Attributes
 
   sync_attr_reader :test1 do
     'hello world'
@@ -23,7 +17,7 @@ end
 
 # Ensure that class and instance attributes are distinct
 class SyncAttrExample2
-  include SyncAttr
+  include SyncAttr::Attributes
 
   sync_attr_reader :test1 do
     'hello world instance'
@@ -33,7 +27,7 @@ class SyncAttrExample2
   end
 end
 
-class InstanceAttributesTest < Test::Unit::TestCase
+class InstanceAttributesTest < Minitest::Test
   context "with example" do
 
     should 'lazy initialize attribute' do
@@ -79,10 +73,23 @@ class InstanceAttributesTest < Test::Unit::TestCase
       assert_equal 'hello world class', s.class.test1
     end
 
-    should 'ensure that different classes have their own synch instances' do
+    should 'ensure that different class instances have their own synchs' 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
+      assert_equal 'hello world', ex1.test1
+      assert_equal 'hello world instance', ex2.test1
+    end
+
+    should 'ensure that different instances have their own synchs' do
+      assert ex1 = SyncAttrExample.new
+      assert ex2 = SyncAttrExample.new
+      assert_equal 'hello world', ex1.test1
+      assert_equal 'hello world', ex2.test1
+    end
+
+    should 'ensure that objects and classes have their own synchs' do
+      assert ex1 = SyncAttrExample.new
+      assert_equal 'hello world', ex1.test1
     end
   end
 end

data/test/class_attributes_test.rb

@@ -1,14 +1,6 @@
-# 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'
+require_relative 'test_helper'
 
 class SyncCAttrExample
-  include SyncAttr
-
   sync_cattr_reader :test1 do
     'hello world'
   end
@@ -22,14 +14,12 @@ class SyncCAttrExample
 end
 
 class SyncCAttrExample2
-  include SyncAttr
-
   sync_cattr_reader :test1 do
     'another world'
   end
 end
 
-class ClassAttributesTest < Test::Unit::TestCase
+class ClassAttributesTest < Minitest::Test
   context "with example" do
 
     should 'lazy initialize class attribute' do
@@ -66,12 +56,6 @@ class ClassAttributesTest < Test::Unit::TestCase
 
   context "with example2" do
 
-    should 'ensure that different classes have their own synch instances' do
-      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

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'yaml'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/stub_any_instance'
+require 'shoulda/context'
+require 'sync_attr'
+require 'awesome_print'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -1,38 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: sync_attr
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2015-03-31 00:00:00.000000000 Z
 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.
+description: When working in a multi-threaded environment it is important to ensure
+  that any attributes that are shared across threads are properly protected to ensure
+  that inconsistent data is not created. Lazy initializing these safe attributes improves
+  startup times and only creates resources when they are needed.
 email:
 - reidmo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
-- examples/class_attribute.rb
-- examples/instance_attribute.rb
 - lib/sync_attr.rb
+- lib/sync_attr/attributes.rb
 - lib/sync_attr/class_attributes.rb
-- lib/sync_attr/instance_attributes.rb
 - lib/sync_attr/version.rb
+- test/attributes_test.rb
 - test/class_attributes_test.rb
-- test/instance_attributes_test.rb
-homepage: https://github.com/ClarityServices/sync_attr
+- test/test_helper.rb
+homepage: https://github.com/reidmorrison/sync_attr
 licenses:
 - Apache License V2.0
 metadata: {}
@@ -42,19 +40,21 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Thread safe accessors for Ruby class and instance attributes. Supports thread
-  safe lazy loading of attributes
-test_files: []
+summary: Thread-safe class and instance attributes
+test_files:
+- test/attributes_test.rb
+- test/class_attributes_test.rb
+- test/test_helper.rb

data/Gemfile

@@ -1,6 +0,0 @@
-source 'http://rubygems.org'
-
-group :test do
-  gem "shoulda"
-end
-

data/Gemfile.lock

@@ -1,26 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.2.12)
-      i18n (~> 0.6)
-      multi_json (~> 1.0)
-    bourne (1.1.2)
-      mocha (= 0.10.5)
-    i18n (0.6.4)
-    metaclass (0.0.1)
-    mocha (0.10.5)
-      metaclass (~> 0.0.1)
-    multi_json (1.6.1)
-    shoulda (3.3.2)
-      shoulda-context (~> 1.0.1)
-      shoulda-matchers (~> 1.4.1)
-    shoulda-context (1.0.2)
-    shoulda-matchers (1.4.2)
-      activesupport (>= 3.0.0)
-      bourne (~> 1.1.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  shoulda

data/examples/class_attribute.rb

@@ -1,30 +0,0 @@
-# Class Attribute Example
-#
-require 'sync_attr'
-
-# Sample class with lazy initialized Synchronized Class Attributes
-class Person
-  include SyncAttr
-
-  # Thread safe Class 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_cattr_reader :name do
-    "Joe Bloggs"
-  end
-
-  # Thread safe Class Attribute reader and writer for age
-  # Sets :age only when it is first called
-  sync_cattr_accessor :age do
-    21
-  end
-end
-
-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}"
-

data/examples/instance_attribute.rb

@@ -1,35 +0,0 @@
-# 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}"