contxtlservice 0.1.1

data/lib/contxtlservice.rb

@@ -0,0 +1,171 @@
+# The ContextualService library makes it easy to manage and set services to a 
+# single, global resource such as a database or file system. By defining a 
+# service to be a child of ContextualService::Service, you
+# * lock off access to instantiation, so all access have to go through the
+#   service's get method,
+# * and provide a simple way to set the instance, most likely for testing.
+#
+# For example, Lafcadio ( http://lafcadio.rubyforge.org ) uses 
+# ContextualService to manage access to the ObjectStore, which controls access 
+# to a database.
+#
+#   class Lafcadio::ObjectStore < ContextualService::Service
+#     def initialize
+#       ...
+#     end
+#   end
+#
+# ObjectStore.new will raise an error. To get an instance of ObjectStore, you 
+# call ObjectStore.get_object_store. If no instance has been previously set, 
+# this will instantiate the ObjectStore and save the instance for future 
+# accesses. If a mock instance has been previously set with set_object_store,
+# it will simply return that mock instance.
+#
+# Since access to the global service is attached to the class, there's no need
+# to pass in a mock service as an argument to any method that needs it. This
+# can simplify testing considerably if you've got highly decomposed code that 
+# needs to access a global service from many places. Also, since the Context 
+# object is hidden, clients of the service don't have to be conscious of it.
+# 
+#   def some_method
+#     os = Lafcadio::ObjectStore.get_object_store
+#     # do something with the object store here
+#     some_other_method
+#   end
+#
+#   def some_other_method
+#     os = Lafcadio::ObjectStore.get_object_store
+#     # do something with the object store here, too
+#   end
+#
+#   class TestSomeMethod < Test::Unit::TestCase
+#     def test1
+#       mock_object_store = Lafcadio::MockObjectStore.new
+#       Lafcadio::ObjectStore.set_object_store mock_object_store
+#       some_method
+#       # assert something happened 
+#     end
+#   end
+#
+# The project page can be found at
+# http://rubyforge.org/projects/contxtlservice .
+
+require 'englishext'
+require 'extensions/all'
+require 'singleton'
+
+module ContextualService
+	Version = '0.1.0'
+	
+	# Context controls the various Service instances. It's a Singleton, so if you 
+	# want to use Context, you'll have to call Context.instance instead of
+	# Context.new.
+	class Context
+		include Singleton
+	
+		def initialize #:nodoc:
+			flush
+			@init_procs = {}
+		end
+		
+		def create_instance( service_class, *init_args ) #:nodoc:
+			if ( proc = @init_procs[service_class] )
+				proc.call( *init_args )
+			else
+				service_class.new( *init_args )
+			end
+		end
+		
+		# Flushes all cached Services.
+		def flush
+			@resources_by_class = Hash.new { |hash, key| hash[key] = {} }
+		end
+	
+		def get_resource( service_class, *init_args ) #:nodoc:
+			resource = @resources_by_class[service_class][init_args]
+			unless resource
+				resource = create_instance( service_class, *init_args )
+				set_resource( service_class, resource, *init_args )
+			end
+			resource
+		end
+		
+		def set_init_proc( service_class, proc ) #:nodoc:
+			@init_procs[service_class] = proc
+		end
+		
+		def set_resource( service_class, resource, *init_args ) #:nodoc:
+			@resources_by_class[service_class][init_args] = resource
+		end
+	end
+	
+	# A Service is the point of access to the global service itself. Using
+	# ContextualService mostly means creating subclasses of Service and then 
+	# adding your domain-specific functionality to that subclass.
+	#
+	# To get a Service, call its get_< service_name > method:
+	#   object_store = ObjectStore.get_object_store
+	#
+	# To set a Service, call its set_< service_name > method:
+	#   ObjectStore.set_object_store MockObjectStore.new
+	class Service
+		# Flushes the currently saved instance of the Service in the Context; the
+		# next time Service.get_< service_name > is called, Context will
+		# re-intantiate the Service from scratch.
+		def self.flush; Context.instance.set_resource( self, nil ); end
+	
+		def self.method_missing( symbol, *args ) #:nodoc:
+			method_name = symbol.id2name
+			target = nil
+			if method_name =~ /^get_(.*)/
+				target = :get_resource if $1.underscore_to_camel_case == basename
+			elsif method_name =~ /^set_(.*)/
+				target = :set_resource if $1.underscore_to_camel_case == basename
+			end
+			if target
+				Context.instance.send( target, self, *args )
+			else
+				super
+			end
+		end
+	
+		# Sets what happens when Context is asked for a Service that hasn't yet been set or saved. By default, Context simply creates that Service and passes it on, but you can override that with a proc of some kind.
+		#
+		#   ObjectStore.set_init_proc { MockObjectStore.new }
+		#   
+		# Most of the time, it will just be simpler to use 
+		# Service.set_< service_name > instead.
+		def self.set_init_proc
+			proc = proc { yield }
+			Context.instance.set_init_proc( self, proc )
+		end
+	
+		# A Service can only be initialized through the Context instance: This 
+		# behavior is enforced during initialization. So if you child class has its 
+		# own initialize method, you should make sure to call super() to keep this 
+		# restriction.
+		def initialize
+			regexp = %r{[^_]contxtlservice\.rb.*create_instance}
+			unless caller.any? { |line| line =~ regexp }
+				raise ArgumentError,
+				"#{ self.class.name.to_s } should be instantiated by calling " +
+						self.class.name.to_s + ".get_" + self.class.name.camel_case_to_underscore,
+				caller
+			end
+		end
+	end
+end
+
+class String
+	unless method_defined?( :camel_case_to_underscore )
+		def camel_case_to_underscore
+			( gsub( /(.)([A-Z])/ ) { $1 + '_' + $2.downcase } ).downcase
+		end
+	end
+
+	unless method_defined?( :underscore_to_camel_case )
+		def underscore_to_camel_case
+			capitalize.gsub( /_([a-zA-Z0-9]+)/ ) { |s| s[1,s.size - 1].capitalize }
+		end
+	end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.6
+specification_version: 1
+name: contxtlservice
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+date: 2005-07-04
+summary: "The ContextualService library makes it easy to manage and set services to a
+  single, global resource such as a database or file system."
+require_paths: 
+  - lib
+email: sera@fhwang.net
+homepage: http://contxtlservice.rubyforge.org/
+rubyforge_project: 
+description: "The ContextualService library makes it easy to manage and set services to a 
+  single, global resource such as a database or file system."
+autorequire: contxtlservice
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Francis Hwang
+files: 
+  - lib/contxtlservice.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: englishext
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: extensions
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: