manana 0.0.2 → 0.1.0

data/README.md

@@ -54,7 +54,24 @@ Or install it yourself as:
 
 ## Usage
 
-See the [samples](https://github.com/coldnebo/manana/blob/master/samples) for examples of use.
+```ruby
+require 'manana'
+
+# initialization...
+client = Manana.deferred_init {
+  Weather.setup    # web service adapter setup
+  Weather          # return the class instance
+}
+
+runtime_loop {
+  #   wait for next interval
+  weather = client.city_weather("02201")    # deferred initialization happens here once
+  puts "At %s the temperature is currently %s F and the humidity is %s." % [weather.city, weather.temperature, weather.relative_humidity]
+}
+```
+
+
+See the [samples](https://github.com/coldnebo/manana/blob/master/samples) for more detailed examples of use.
 
 ## Contributing
 

data/lib/manana/version.rb

@@ -1,3 +1,3 @@
 class Manana
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/manana.rb

@@ -4,7 +4,7 @@ require "manana/version"
 # *Manana* lets you defer the initialization of an object until its methods are called.
 # @example basic usage - see {https://github.com/coldnebo/manana/blob/master/samples/self_healing.rb samples/self_healing.rb}
 #   #   initialization...
-#   client = Manana.wrap {
+#   client = Manana.deferred_init {
 #     Weather.setup
 #     Weather
 #   }
@@ -16,17 +16,17 @@ require "manana/version"
 #   }
 #
 class Manana
-
-  # wraps an object initialization block so that it can be deferred to a later time when object methods are called.
+  
+  # wraps an initialization block so that it can be deferred to a later time when object methods are called.
   # @example wrap an object - see {https://github.com/coldnebo/manana/blob/master/samples/self_healing.rb samples/self_healing.rb}
-  #   client = Manana.wrap {
+  #   client = Manana.deferred_init {
   #     Weather.setup  # initialize the class 
   #     Weather        # return the Weather class
   #   }
   # 
   # @param initialization_block [Proc] object initialization. the block must return the object to be wrapped.
   # @return [Manana] a wrapped version of the object.
-  def self.wrap(&initialization_block)
+  def self.deferred_init(&initialization_block)
     Manana.new(&initialization_block)
   end 
 
@@ -38,16 +38,23 @@ class Manana
   #   weather = client.city_weather("02201")
   #
   def method_missing(method, *args, &block)
-    instance = get_instance
+    instance = safe_get_instance
     instance.send(method, *args, &block);
   end
 
   private
 
   def initialize(&initialization_block)
+    @mutex = Mutex.new
     @deferred_initialization = initialization_block
   end
 
+  def safe_get_instance
+    @mutex.synchronize do 
+      get_instance
+    end
+  end
+
   def get_instance
     if @instance.nil?
       @instance = @deferred_initialization.call
@@ -55,5 +62,4 @@ class Manana
     @instance
   end
 
-
 end

data/samples/exponential_backoff.rb

@@ -31,7 +31,7 @@ end
 
 # ------------ initialization code
 
-client = Manana.wrap {
+client = Manana.deferred_init {
   # exponential backkoff logic in the initialization block
   retries = 0
   obj = nil

data/samples/fast_startup.rb

@@ -44,7 +44,7 @@ mini_death_star = nil
 puts "[Vader]: requsition a new DeathStar and make it snappy!"
 # boss said requisitions have to be faster*!  Manana to the rescue!
 puts Benchmark.measure {
-  mini_death_star = Manana.wrap {
+  mini_death_star = Manana.deferred_init {
     DeathStar.new
   }
 }

data/samples/self_healing.rb

@@ -47,7 +47,7 @@ end
 
 # Before we start, we use Manana to wrap the client setup so that method calls on the client can be self-healing in case of failure.
 # NOTE: that the caller doesn't have to deal with whether or not this initialization succeeded, they can just call the client methods repeatedly.
-client = Manana.wrap {
+client = Manana.deferred_init {
   Weather.setup
   Weather
 }

data/test/klass.rb

@@ -0,0 +1,32 @@
+class Klass
+  INITIALIZE_MESSAGE   = "initialized!"
+  DO_SOMETHING_MESSAGE = "I did something!"
+  RAISE_MESSAGE        = "kablooey!"
+  
+  def self.incr
+    @count ||= 0
+    @count += 1
+    @count
+  end
+
+  def self.count
+    @count ||= 0
+    @count
+  end
+
+  def self.reset 
+    @count = 0
+  end
+
+  def initialize
+    puts INITIALIZE_MESSAGE
+  end
+
+  def do_something
+    DO_SOMETHING_MESSAGE
+  end
+
+  def raise_something
+    raise RAISE_MESSAGE
+  end
+end

data/test/minitest_helper.rb

@@ -1,7 +1,9 @@
 unless ENV["TRAVIS"] == "1"
   require 'simplecov'
   require 'pry'
-  SimpleCov.start
+  SimpleCov.start do
+    add_filter "/test/"
+  end
 end
 
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)

data/test/test_manana.rb

@@ -1,41 +1,26 @@
 require 'minitest_helper'
+require 'klass'
 
-class TestManana < MiniTest::Unit::TestCase
+class TestManana < Minitest::Test
   def test_that_it_has_a_version_number
     refute_nil ::Manana::VERSION
   end
 
-  # initialize a very generic example object that does some stuff in initialization and has some instance methods you can call.
+  # initialize a very generic example object that does some stuff in initialization 
+  # and has some instance methods you can call.
   def setup
-    @klass = Class.new
-    @klass.class_eval {
-      def initialize
-        puts "class initialized!"
-      end
-
-      def do_something
-        "I did something!"      # simulate an arbitrary method
-      end
-
-      def add_something(x,y)
-        x+y                     # simulate a method with params
-      end
-
-      def raise_something
-        raise "kablooey!"       # simulate a call that raises an exception
-      end
-    }
   end
 
   # sanity check
   def test_that_things_work_without_manana
     obj = nil
+
     out, err = capture_io do
-      obj = @klass.new
+      obj = Klass.new
     end
-    assert_match(%r%class initialized!%, out)
+    assert_match(/#{Klass::INITIALIZE_MESSAGE}/, out)
     assert_instance_of(String, obj.do_something)
-    assert_equal(5, obj.add_something(2,3))
+    assert_match(/#{Klass::DO_SOMETHING_MESSAGE}/, obj.do_something)
     assert_raises RuntimeError do 
       obj.raise_something
     end
@@ -44,42 +29,60 @@ class TestManana < MiniTest::Unit::TestCase
       obj.raise_something
     rescue Exception => e
       # make sure we get an appropriate stack trace at the point of raise.
-      assert_match(/test_manana.rb:25:in .raise_something./, e.backtrace.first)
+      assert_match(/.*klass.rb:\d+:in .raise_something./, e.backtrace.first)
     end
-
   end
 
   def test_deferred_init
-    handle = nil
+    obj = nil
     out, err = capture_io do
-      # the idea here is that we use the 'Strategy' pattern to store the method of initialization.
-      # in this case, it's really simple, but in a network service, it might be a config + some class method calls 
-      # to fully setup a service instance.
-      handle = Manana.wrap {
-        obj = @klass.new
+      obj = Manana.deferred_init {
+        Klass.new
       }
     end
     # make sure the init isn't executed until we call...
-    refute_match(%r%class initialized!%, out)
-    
+    refute_match(/#{Klass::INITIALIZE_MESSAGE}/, out)
+
+    # now call a method on the object...
     result = nil
     out, err = capture_io do
-      result = handle.do_something
+      result = obj.do_something
     end
-    # now it should have been inited
-    assert_match(%r%class initialized!%, out)
-    # and the method we called used
+    # and make sure the init was called
+    assert_match(/#{Klass::INITIALIZE_MESSAGE}/, out)
+    # and that we got the desired result
     assert_instance_of(String, result)
-
+    assert_match(/#{Klass::DO_SOMETHING_MESSAGE}/, result)
+    assert_raises RuntimeError do 
+      obj.raise_something
+    end
 
     begin
-      handle.raise_something
+      obj.raise_something
     rescue Exception => e
       # make sure we get an appropriate stack trace at the point of raise.
-      assert_match(/test_manana.rb:25:in .raise_something./, e.backtrace.first)
+      assert_match(/.*klass.rb:\d+:in .raise_something./, e.backtrace.first)
     end
+  end
+
+  # https://github.com/coldnebo/manana/issues/1 
+  def test_that_init_is_threadsafe
+    Klass.reset
+
+    klass = Manana.deferred_init {
+      sleep(1)
+      Klass.incr
+      Klass
+    }
 
+    t1 = Thread.new{klass.count}
+    t2 = Thread.new{klass.count}
+    t3 = Thread.new{klass.count}
+    t1.join
+    t2.join
+    t3.join
 
+    assert_equal(1,klass.count)
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: manana
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-15 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,7 @@ files:
 - samples/exponential_backoff.rb
 - samples/fast_startup.rb
 - samples/self_healing.rb
+- test/klass.rb
 - test/minitest_helper.rb
 - test/test_manana.rb
 homepage: https://github.com/coldnebo/manana
@@ -100,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1234298163661349463
+      hash: -3306959934859244204
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -109,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1234298163661349463
+      hash: -3306959934859244204
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -118,6 +119,7 @@ specification_version: 3
 summary: provides a simple way to defer initialization of an object until its methods
   are called
 test_files:
+- test/klass.rb
 - test/minitest_helper.rb
 - test/test_manana.rb
 has_rdoc: