multiton 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f0e0b23975e5dce8fb8e385fa2879c8ee613333
+  data.tar.gz: ded761377d1760ed824b859c1dd263bd537c2da2
+SHA512:
+  metadata.gz: 61f729a4af67b5f2d1c5f394a02355fdf55442d8f07c3c11335b114498f9c347a65e8d8463759c058ee0c226f07ba3d9146f11daba2b36cebaf26b2c798f2a1f
+  data.tar.gz: 3be1065d99e97adbeccbe76e114b319ab8b0ba6b83ec4a7b239f06d94f2639937cece8f4e40d89b6b32036556eb9bf9484b0d9e86ac9b67c933ae7624bb5fe05

data/lib/multiton.rb

@@ -0,0 +1,133 @@
+require 'thread'
+
+# The Multiton class extends Singleton Pattern to collection level
+# The main purpose is to have a collection of sole instanses of a particular class
+# Possible application: a cache mapped to some DB
+#
+# == Usage
+#
+# To use Multiton, include it in your class
+#   class Klass
+#     include Multiton
+#     # ...
+#   end
+#
+# A single instance identified by some <ID> is created upon the first call of Klass.create(<ID>)
+# This ensures that there's only one instance of the Klass for a given <ID>
+#
+#   a, b = Klass.create(:id), Klass.create(:id)
+#   a == b
+#   # => true
+#   a.id == b.id
+#   # => true
+#
+# Before the call to Klass.initialize, instance variable @id is assigned to <ID> obtained from Klass.create
+#   class Klass
+#     include Multiton
+#     attr_reader :ID
+#
+#     def initialize
+#       @ID = @id
+#     end
+#   end
+#
+#   a = Klass.create(:id)
+#   a.ID == a.id
+#   # => true
+#   a.ID == :id
+#   # => true
+#
+module Multiton
+  attr_reader :id
+
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  def _dump(depth = -1)
+    raise TypeError, "can't marshall instance of singleton #{self.class}"
+  end
+
+  class << self
+    def __init__(klass)
+      klass.instance_eval {
+        @multiton__instances__ = {}
+        @multiton__mutex__ = Mutex.new
+      }
+
+      def klass.new(id, *args, &blk)
+        o = allocate
+        o.instance_variable_set(:@id, id)
+        o.instance_eval{initialize(*args, &blk)}
+        o
+      end
+
+      def klass.inherited(sub)
+        super
+        Multiton.__init__(sub)
+      end
+
+      def klass.create(id, *args, &blk)
+        return @multiton__instances__[id] if @multiton__instances__[id]
+        @multiton__mutex__.synchronize {
+          return @multiton__instances__[id] if @multiton__instances__[id]
+          @multiton__instances__[id] = new(id, *args, &blk)
+        }
+        @multiton__instances__[id]
+      end
+
+      def klass.destroy(id)
+        @multiton__mutex__.synchronize {
+          return @multiton__instances__.delete id
+        }
+      end
+
+      def klass.has_key?(id)
+        @multiton__instances__.has_key? id
+      end
+
+      def klass.each(*args, &block)
+        __instances__ = nil
+        @multiton__mutex__.synchronize {
+          __instances__ = @multiton__instances__.clone
+        }
+        __instances__.each *args, &block
+      end
+
+      def klass.to_a
+        instances = []
+        each { |k, v| instances << v }
+        instances
+      end
+
+      def klass.[](id)
+        create id
+      end
+
+      klass
+    end
+
+    private
+
+    # extending an object with Multiton 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 Multiton module in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      super
+      Multiton.__init__(klass)
+      klass.private_class_method :new, :allocate, :inherited
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: multiton
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dmytro Milinevskyy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-28 00:00:00.000000000 Z
+dependencies: []
+description: The multiton pattern expands on the singleton concept to manage a map
+  of named instances as key-value pairs.
+email: milinevskyy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/multiton.rb
+homepage: https://github.com/niamster/multiton
+licenses:
+- Ruby License
+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.0.3
+signing_key: 
+specification_version: 4
+summary: The multiton pattern implementation
+test_files: []