singleton.new 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65b54a973d037d87002124ad29b0228d032352cd
+  data.tar.gz: 114e5eda16c7d078d2d38f51544bf1b37716c6c2
+SHA512:
+  metadata.gz: 3616647580ae0b913f0bd9feb6f4eb85fc45a4339ddbcf5164b985268001132c16b755fa78185d460e495a57145593cbc6735ad64f359d87ab1d4fd53693e9e4
+  data.tar.gz: a2e800558504172f88899bc19fa7491db5bb375f604a0f9fe6be47f5cd2e5c4acbc6a330b4c7b42a589a5198da99f3fe7c65c03a390a27e439cddd00a3aae0af

data/lib/singleton.new.rb

@@ -0,0 +1,181 @@
+require 'thread'
+
+# The Singleton module implements the Singleton pattern.
+#
+# == Usage
+#
+# To use Singleton, include the module in your class.
+#
+#    class Klass
+#       include Singleton
+#       # ...
+#    end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#      a,b  = Klass.new, Klass.new
+#
+#      a == b
+#      # => true
+#
+#      Klass.new
+#      # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#      class OtherKlass
+#        include Singleton
+#        # ...
+#      end
+#
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 0
+#
+#      OtherKlass.new
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 1
+#
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# == Implementation
+#
+# This above is achieved by:
+#
+# *  Making Klass.allocate private.
+#
+# *  Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#    Singleton properties are kept when inherited and cloned.
+#
+# *  Providing the Klass.new() method that returns the same object each
+#    time it is called.
+#
+# *  Overriding Klass._load(str) to call Klass.new().
+#
+# *  Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#    cloning or duping.
+#
+# == Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables and taint
+# state, from the instance. Classes using Singleton can provide custom
+# _load(str) and _dump(depth) methods to retain some of the previous state of
+# the instance.
+#
+#    require 'singleton'
+#
+#    class Example
+#      include Singleton
+#      attr_accessor :keep, :strip
+#      def _dump(depth)
+#        # this strips the @strip information from the instance
+#        Marshal.dump(@keep, depth)
+#      end
+#
+#      def self._load(str)
+#        instance.keep = Marshal.load(str)
+#        instance
+#      end
+#    end
+#
+#    a = Example.new
+#    a.keep = "keep this"
+#    a.strip = "get rid of this"
+#    a.taint
+#
+#    stored_state = Marshal.dump(a)
+#
+#    a.keep = nil
+#    a.strip = nil
+#    b = Marshal.load(stored_state)
+#    p a == b  #  => true
+#    p a.keep  #  => "keep this"
+#    p a.strip #  => nil
+#
+module Singleton
+  # Raises a TypeError to prevent cloning.
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  # Raises a TypeError to prevent duping.
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  # By default, do not retain any state when marshalling.
+  def _dump(depth = -1)
+    ''
+  end
+
+  module SingletonClassMethods # :nodoc:
+
+    def clone # :nodoc:
+      Singleton.__init__(super)
+    end
+
+    # By default calls new(). Override to retain singleton state.
+    def _load(str)
+      new
+    end
+
+    private
+
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton # :nodoc:
+    def __init__ klass # :nodoc:
+      klass.instance_eval {
+        @singleton__instance__ = nil
+        @singleton__mutex__ = Mutex.new
+      }
+
+      if klass.methods.grep(:singleton_orig_new).empty?
+        class << klass
+          # https://web.archive.org/web/20120304144227/http://www.mindbucket.com/2009/02/11/ruby-overriding-classnew-to-make-custom-wrapper-pattern/
+          alias_method :singleton_orig_new, :new
+        end
+      end
+
+      klass.define_singleton_method :new do
+        return @singleton__instance__ if @singleton__instance__
+        @singleton__mutex__.synchronize {
+          return @singleton__instance__ if @singleton__instance__
+          @singleton__instance__ = singleton_orig_new
+        }
+        @singleton__instance__
+      end
+
+      klass
+    end
+
+    private
+
+    # extending an object with Singleton is a bad idea
+    undef_method :extend_object
+
+    def append_features(mod)
+      #  help out people counting on transitive mixins
+      unless mod.instance_of?(Class)
+        raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      super
+      klass.private_class_method :allocate
+      klass.extend SingletonClassMethods
+      Singleton.__init__ klass
+    end
+  end
+
+  ##
+  # :singleton-method: _load
+  #  By default calls new(). Override to retain singleton state.
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: singleton.new
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- c4605
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-06 00:00:00.000000000 Z
+dependencies: []
+description: Use .new instead of .instance
+email: bolasblack@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/singleton.new.rb
+homepage: http://rubygems.org/gems/singleton.new
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Use .new instead of .instance
+test_files: []