wireless 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 875d0a0704d8e905a826e1a171d887877990c1c90e92b73026305efd419337d2
-  data.tar.gz: 0ea0ce2e1f08e7b923361514eb2529a57ca6787beb182285bd3be8298ae62d92
+  metadata.gz: 15c44fc9bf9e10af9c1a9d8d0241e2a808a7dfabdadd895581271f6fa076fdbc
+  data.tar.gz: 3159342e5f335e4a9b92fd6c09556c4fbb39af17bc5fada60737e0ad3150ac0f
 SHA512:
-  metadata.gz: 330cfceecbc844ecf795d8f6b102ba00da16d5a512f3125c061d364b19e7d9d2635e1bd06c4872c8337fad46de99586acb997a35ca1f9bee5a966493ad3a773c
-  data.tar.gz: 94390e87a8b56cd0d31ce37bde2f47ce1162a84639ef345464a9eb7e6e20644ffcf415b306b3fff407f2e6778eebc2f674624d4ba3bae83c6e54a8f22b9b7782
+  metadata.gz: 0ded107266b0b9cf0d6a279a5609e102603b9e14e9a09a8b72684d5239b3bae6b61e623bf20297dba65b92d93e93f5c3a66ef5b7197b5d1030778c213eafec93
+  data.tar.gz: 22276968eb991723ced37a404b4e8aa0a805ccf3ca5b69746431712323bd3290235fd91b7535e9c59180ea82c40badfc59df8bec29ac2e93d736f2809fbf2d0d

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.0.2 - 2018-06-17
+
+* fix import aliasing
+
 ## 0.0.1 - 2018-06-16
 
 * initial release

data/README.md

@@ -109,7 +109,7 @@ which has the following features:
 
 ## Why Wireless?
 
-I wanted a simple service locator like [DiFTW](https://github.com/jhollinger/ruby-diftw),
+I wanted a simple service locator like [DiFtw](https://github.com/jhollinger/ruby-diftw),
 with cycle detection and control over the [visibility of getters](https://github.com/jhollinger/ruby-diftw/issues/1).
 
 ## Why Service Locators?
@@ -127,17 +127,17 @@ Examples include:
 Rather than wiring these dependencies together manually, service locators allow them to be
 registered and retrieved in a declarative way. This is similar to the difference between
 imperative build tools like Ant or Gulp and declarative build tools like Make or Rake, which
-allow prerequisites to be acquired on-demand, without micromanaging their creation and connections.
+allow prerequisites to be acquired on-demand, without micromanaging their construction or connections.
 
 # VERSION
 
-0.0.1
+0.0.2
 
 # SEE ALSO
 
 ## Gems
 
-- [Canister](https://github.com/mlibrary/canister) -  a simple Service Locator for Ruby inspired by Jim Weirich's [article](https://archive.li/shxeA) on Dependency Injection
+- [Canister](https://github.com/mlibrary/canister) - a simple service-locator inspired by Jim Weirich's [article](https://archive.li/shxeA) on Dependency Injection
 - [DiFtw](https://github.com/jhollinger/ruby-diftw) - the original inspiration for this module: a similar API with a focus on testing/mocking
 
 ## Articles

data/lib/wireless.rb

@@ -6,7 +6,26 @@
 module Wireless
   class Error < StandardError; end
   class CycleError < Error; end
-  class NameError < Error; end
+
+  # Raised when an attempt is made to:
+  #
+  #   - retrieve a value from a key-indexed store when the key doesn't exist
+  #   - write a value when the key exists and the store doesn't allow replacements
+  #
+  # Can be passed a message, the receiver the lookup failed on and the key. All
+  # are optional and default to nil.
+  #
+  # XXX eventually (i.e. in ruby 2.6), this can be a subclass of (or replaced by)
+  # the core KeyError class: https://bugs.ruby-lang.org/issues/14313
+  class KeyError < Wireless::Error
+    def initialize(message = nil, receiver: nil, key: nil)
+      super(message)
+      @receiver = receiver
+      @key = key
+    end
+
+    attr_reader :key, :receiver
+  end
 
   # a shortcut which allows:
   #

data/lib/wireless/fetch.rb

@@ -10,7 +10,7 @@ module Wireless
   # @seen is an immutable Set of symbols, which is used to detect dependency cycles.
   module Fetch
     # Fetches the dependency with the specified name. Creates the dependency if
-    # it doesn't exist. Raises a Wireless::NameError if the dependency is not
+    # it doesn't exist. Raises a Wireless::KeyError if the dependency is not
     # defined or a Wireless::CycleError if resolving the dependency results in
     # a cycle.
     def fetch(name)
@@ -22,7 +22,11 @@ module Wireless
       end
 
       unless (resolver = @registry[name])
-        raise Wireless::NameError, "dependency not found: #{name}"
+        raise Wireless::KeyError.new(
+          "dependency not found: #{name}",
+          key: name,
+          receiver: self
+        )
       end
 
       fetcher = lambda do

data/lib/wireless/fetcher.rb

@@ -11,10 +11,5 @@ module Wireless
       @registry = registry
       @seen = seen
     end
-
-    def to_s
-      hash = { registry: @registry.keys, seen: @seen.to_a }
-      "#<#{self.class}: #{hash.inspect}>"
-    end
   end
 end

data/lib/wireless/registry.rb

@@ -4,12 +4,12 @@ require 'set'
 require_relative 'synchronized_store'
 
 module Wireless
-  # The hash-like object which is the public API of the dependency provider
-  # (AKA service locator). It maps names (symbols) to dependencies (objects) via blocks
-  # which resolve the dependency either every time (factory) or once (singleton).
+  # The public API of the dependency provider (AKA service locator). A hash-like
+  # object which maps names (symbols) to dependencies (objects) via blocks
+  # which either resolve the dependency every time (factory) or once (singleton).
   #
-  # The block can be supplied as a class, in which case it is equivalent to a block
-  # which calls +new+ on the class e.g.:
+  # A class can be supplied instead of the block, in which case it is equivalent to
+  # a block which calls +new+ on the class e.g.:
   #
   #   WL = Wireless.new do
   #     on(:foo, Foo)
@@ -26,17 +26,17 @@ module Wireless
 
     include Fetch
 
-    def initialize(args = DEFAULT_VISIBILITY, &block)
-      @default_visibility = args
-      @module_cache = {}
-      @registry = SynchronizedStore.new
+    def initialize(default_visibility = DEFAULT_VISIBILITY, &block)
+      @default_visibility = default_visibility
+      @module_cache = SynchronizedStore.new(type: :module)
+      @registry = SynchronizedStore.new(type: :resolver)
       @seen = Set.new
       instance_eval(&block) if block
     end
 
     # Registers a dependency which is resolved every time its value is fetched.
     def factory(name, klass = nil, &block)
-      register(Resolver::Factory, name, block || klass)
+      @registry[name.to_sym] = Resolver::Factory.new(block || klass)
     end
 
     # Returns true if a service with the specified name has been registered, false
@@ -48,7 +48,7 @@ module Wireless
     # Registers a dependency which is only resolved the first time its value is
     # fetched. On subsequent fetches, the cached value is returned.
     def singleton(name, klass = nil, &block)
-      register(Resolver::Singleton, name, block || klass)
+      @registry[name.to_sym] = Resolver::Singleton.new(block || klass)
     end
 
     # Takes an array or hash specifying the dependencies to export, and returns
@@ -99,22 +99,24 @@ module Wireless
       #
       #   { :foo => :foo, :bar => :baz, :quux => :quux }
 
-      # XXX transform_values isn't available on ruby 2.3 and we don't want to
-      # pull in ActiveSupport for just one method in this case
+      # XXX transform_values isn't available in ruby 2.3 and we don't want to
+      # pull in ActiveSupport just for one method (on this occasion)
       #
       # args = DEFAULT_EXPORTS.merge(args).transform_values do |exports|
-      #     Array(exports).reduce({}) do |a, b|
+      #     exports = [exports] unless exports.is_a?(Array)
+      #     exports.reduce({}) do |a, b|
       #         a.merge(b.is_a?(Hash) ? b : { b => b })
       #     end
       # end
 
       args = DEFAULT_EXPORTS.merge(args).each_with_object({}) do |(key, exports), merged|
-        merged[key] = Array(exports).reduce({}) do |a, b|
+        exports = [exports] unless exports.is_a?(Array)
+        merged[key] = exports.reduce({}) do |a, b|
           a.merge(b.is_a?(Hash) ? b : { b => b })
         end
       end
 
-      @module_cache[args] ||= module_for(args)
+      @module_cache.get!(args) { module_for(args) }
     end
 
     alias on factory
@@ -147,11 +149,5 @@ module Wireless
 
       mod
     end
-
-    # Assign a locator for the specified dependency name
-    def register(locator, name, block)
-      name = name.to_sym
-      @registry[name] = locator.new(block)
-    end
   end
 end

data/lib/wireless/resolver.rb

@@ -3,17 +3,17 @@
 module Wireless
   # The registry is a key/value store (Hash) whose keys are symbols and whose values
   # are instances of this class. Resolvers are responsible for returning their
-  # dependencies, which they do by calling their corresponding block. They can wrap
+  # dependencies, which they do by calling their corresponding blocks. They can wrap
   # additional behaviors around this call e.g. singletons (Wireless::Resolver::Singleton)
   # cache the result so that the block is only called once.
   class Resolver
     def initialize(block = nil)
-      if block.is_a?(Class)
+      if block.respond_to?(:call)
+        @block = block
+      elsif block.is_a?(Class)
         @block = proc { block.new }
-      elsif !block.respond_to?(:call)
-        raise ArgumentError, "invalid argument: expected a class or a block, got: #{block.class}"
       else
-        @block = block
+        raise ArgumentError, "invalid argument: expected a block or a class, got: #{block.class}"
       end
     end
 

data/lib/wireless/synchronized_store.rb

@@ -1,32 +1,78 @@
 # frozen_string_literal: true
 
 module Wireless
-  # A Hash wrapper which synchronizes get ([]), set ([]=) and include? methods.
-  # Implemented as a wrapper rather than a subclass so we don't have to worry about
-  # every possible mutator.
+  # A Hash wrapper with synchronized get, set and check methods.
   class SynchronizedStore
-    def initialize
-      @store = {}
+    def initialize(store = {}, replace: false, type: :key)
+      @type = type
+      @replace = replace
+      @store = store
       @lock = Mutex.new
     end
 
-    # Retrieve a new value from the underlying hash in a thread-safe way
+    # Retrieve a value from the store
+    #
+    # A synchronized version of:
+    #
+    #   store[key]
+    #
     def [](key)
       @lock.synchronize { @store[key] }
     end
 
-    # Assign a new value to the underlying hash in a thread-safe way
+    # Add a key/value to the store
+    #
+    # A synchronized version of:
+    #
+    #   store[key] = value
+    #
     def []=(key, value)
       @lock.synchronize do
-        if @store.include?(key)
-          raise Wireless::NameError, "resolver already exists: #{key}"
+        if !@replace && @store.include?(key)
+          # XXX don't expose the receiver as this class is an internal
+          # implementation detail
+          raise Wireless::KeyError.new(
+            "#{@type} already exists: #{key}",
+            key: key
+          )
         end
 
         @store[key] = value
       end
     end
 
-    # Returns true if the underlying hash contains the key, false otherwise
+    # Retrieve a value from the store. If it doesn't exist and a block is
+    # supplied, create and return it; otherwise, raise a KeyError.
+    #
+    # A synchronized version of:
+    #
+    #   store[key] ||= value
+    #
+    def get_or_create(key)
+      @lock.synchronize do
+        if @store.include?(key)
+          @store[key]
+        elsif block_given?
+          @store[key] = yield
+        else
+          # XXX don't expose the receiver as this class is an internal
+          # implementation detail
+          raise Wireless::KeyError.new(
+            "#{@type} not found: #{key}",
+            key: key
+          )
+        end
+      end
+    end
+
+    alias get! get_or_create
+
+    # Returns true if the store contains the key, false otherwise
+    #
+    # A synchronized version of:
+    #
+    #   store.include?(key)
+    #
     def include?(key)
       @lock.synchronize { @store.include?(key) }
     end

data/lib/wireless/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wireless
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wireless
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - chocolateboy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-15 00:00:00.000000000 Z
+date: 2018-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler