wireless 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 875d0a0704d8e905a826e1a171d887877990c1c90e92b73026305efd419337d2
+  data.tar.gz: 0ea0ce2e1f08e7b923361514eb2529a57ca6787beb182285bd3be8298ae62d92
+SHA512:
+  metadata.gz: 330cfceecbc844ecf795d8f6b102ba00da16d5a512f3125c061d364b19e7d9d2635e1bd06c4872c8337fad46de99586acb997a35ca1f9bee5a966493ad3a773c
+  data.tar.gz: 94390e87a8b56cd0d31ce37bde2f47ce1162a84639ef345464a9eb7e6e20644ffcf415b306b3fff407f2e6778eebc2f674624d4ba3bae83c6e54a8f22b9b7782

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1 - 2018-06-16
+
+* initial release

data/LICENSE.md

@@ -0,0 +1,192 @@
+The Artistic License 2.0
+========================
+
+_Copyright © 2000-2006, The Perl Foundation._
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+### Preamble
+
+This license establishes the terms under which a given free software
+Package may be copied, modified, distributed, and/or redistributed.
+The intent is that the Copyright Holder maintains some artistic
+control over the development of that Package while still keeping the
+Package available as open source and free software.
+
+You are always permitted to make arrangements wholly outside of this
+license directly with the Copyright Holder of a given Package.  If the
+terms of this license do not permit the full use that you propose to
+make of the Package, you should contact the Copyright Holder and seek
+a different licensing arrangement.
+
+### Definitions
+
+“Copyright Holder” means the individual(s) or organization(s)
+named in the copyright notice for the entire Package.
+
+“Contributor” means any party that has contributed code or other
+material to the Package, in accordance with the Copyright Holder's
+procedures.
+
+“You” and “your” means any person who would like to copy,
+distribute, or modify the Package.
+
+“Package” means the collection of files distributed by the
+Copyright Holder, and derivatives of that collection and/or of
+those files. A given Package may consist of either the Standard
+Version, or a Modified Version.
+
+“Distribute” means providing a copy of the Package or making it
+accessible to anyone else, or in the case of a company or
+organization, to others outside of your company or organization.
+
+“Distributor Fee” means any fee that you charge for Distributing
+this Package or providing support for this Package to another
+party.  It does not mean licensing fees.
+
+“Standard Version” refers to the Package if it has not been
+modified, or has been modified only in ways explicitly requested
+by the Copyright Holder.
+
+“Modified Version” means the Package, if it has been changed, and
+such changes were not explicitly requested by the Copyright
+Holder.
+
+“Original License” means this Artistic License as Distributed with
+the Standard Version of the Package, in its current version or as
+it may be modified by The Perl Foundation in the future.
+
+“Source” form means the source code, documentation source, and
+configuration files for the Package.
+
+“Compiled” form means the compiled bytecode, object code, binary,
+or any other form resulting from mechanical transformation or
+translation of the Source form.
+
+### Permission for Use and Modification Without Distribution
+
+**(1)**  You are permitted to use the Standard Version and create and use
+Modified Versions for any purpose without restriction, provided that
+you do not Distribute the Modified Version.
+
+### Permissions for Redistribution of the Standard Version
+
+**(2)**  You may Distribute verbatim copies of the Source form of the
+Standard Version of this Package in any medium without restriction,
+either gratis or for a Distributor Fee, provided that you duplicate
+all of the original copyright notices and associated disclaimers.  At
+your discretion, such verbatim copies may or may not include a
+Compiled form of the Package.
+
+**(3)**  You may apply any bug fixes, portability changes, and other
+modifications made available from the Copyright Holder.  The resulting
+Package will still be considered the Standard Version, and as such
+will be subject to the Original License.
+
+### Distribution of Modified Versions of the Package as Source
+
+**(4)**  You may Distribute your Modified Version as Source (either gratis
+or for a Distributor Fee, and with or without a Compiled form of the
+Modified Version) provided that you clearly document how it differs
+from the Standard Version, including, but not limited to, documenting
+any non-standard features, executables, or modules, and provided that
+you do at least ONE of the following:
+
+* **(a)**  make the Modified Version available to the Copyright Holder
+of the Standard Version, under the Original License, so that the
+Copyright Holder may include your modifications in the Standard
+Version.
+* **(b)**  ensure that installation of your Modified Version does not
+prevent the user installing or running the Standard Version. In
+addition, the Modified Version must bear a name that is different
+from the name of the Standard Version.
+* **(c)**  allow anyone who receives a copy of the Modified Version to
+make the Source form of the Modified Version available to others
+under
+        * **(i)**  the Original License or
+        * **(ii)**  a license that permits the licensee to freely copy,
+        modify and redistribute the Modified Version using the same
+        licensing terms that apply to the copy that the licensee
+        received, and requires that the Source form of the Modified
+        Version, and of any works derived from it, be made freely
+        available in that license fees are prohibited but Distributor
+        Fees are allowed.
+
+### Distribution of Compiled Forms of the Standard Version
+###  or Modified Versions without the Source
+
+**(5)**  You may Distribute Compiled forms of the Standard Version without
+the Source, provided that you include complete instructions on how to
+get the Source of the Standard Version.  Such instructions must be
+valid at the time of your distribution.  If these instructions, at any
+time while you are carrying out such distribution, become invalid, you
+must provide new instructions on demand or cease further distribution.
+If you provide valid instructions or cease distribution within thirty
+days after you become aware that the instructions are invalid, then
+you do not forfeit any of your rights under this license.
+
+**(6)**  You may Distribute a Modified Version in Compiled form without
+the Source, provided that you comply with Section 4 with respect to
+the Source of the Modified Version.
+
+### Aggregating or Linking the Package
+
+**(7)**  You may aggregate the Package (either the Standard Version or
+Modified Version) with other packages and Distribute the resulting
+aggregation provided that you do not charge a licensing fee for the
+Package.  Distributor Fees are permitted, and licensing fees for other
+components in the aggregation are permitted. The terms of this license
+apply to the use and Distribution of the Standard or Modified Versions
+as included in the aggregation.
+
+**(8)** You are permitted to link Modified and Standard Versions with
+other works, to embed the Package in a larger work of your own, or to
+build stand-alone binary or bytecode versions of applications that
+include the Package, and Distribute the result without restriction,
+provided the result does not expose a direct interface to the Package.
+
+### Items That are Not Considered Part of a Modified Version
+
+**(9)** Works (including, but not limited to, modules and scripts) that
+merely extend or make use of the Package, do not, by themselves, cause
+the Package to be a Modified Version.  In addition, such works are not
+considered parts of the Package itself, and are not subject to the
+terms of this license.
+
+### General Provisions
+
+**(10)**  Any use, modification, and distribution of the Standard or
+Modified Versions is governed by this Artistic License. By using,
+modifying or distributing the Package, you accept this license. Do not
+use, modify, or distribute the Package, if you do not accept this
+license.
+
+**(11)**  If your Modified Version has been derived from a Modified
+Version made by someone other than you, you are nevertheless required
+to ensure that your Modified Version complies with the requirements of
+this license.
+
+**(12)**  This license does not grant you the right to use any trademark,
+service mark, tradename, or logo of the Copyright Holder.
+
+**(13)**  This license includes the non-exclusive, worldwide,
+free-of-charge patent license to make, have made, use, offer to sell,
+sell, import and otherwise transfer the Package with respect to any
+patent claims licensable by the Copyright Holder that are necessarily
+infringed by the Package. If you institute patent litigation
+(including a cross-claim or counterclaim) against any party alleging
+that the Package constitutes direct or contributory patent
+infringement, then this Artistic License to you shall terminate on the
+date that such litigation is filed.
+
+**(14)**  **Disclaimer of Warranty:**
+
+THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
+NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL
+LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,157 @@
+# Wireless
+
+[![Build Status](https://travis-ci.org/chocolateboy/wireless.svg)](https://travis-ci.org/chocolateboy/wireless)
+[![Gem Version](https://img.shields.io/gem/v/wireless.svg)](https://rubygems.org/gems/wireless)
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [NAME](#name)
+- [INSTALLATION](#installation)
+- [SYNOPSIS](#synopsis)
+- [DESCRIPTION](#description)
+- [WHY?](#why)
+  - [Why Wireless?](#why-wireless)
+  - [Why Service Locators?](#why-service-locators)
+- [VERSION](#version)
+- [SEE ALSO](#see-also)
+  - [Gems](#gems)
+  - [Articles](#articles)
+- [AUTHOR](#author)
+- [COPYRIGHT AND LICENSE](#copyright-and-license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# NAME
+
+Wireless - a lightweight, declarative dependency-provider
+
+# INSTALLATION
+
+```ruby
+gem "wireless"
+```
+
+# SYNOPSIS
+
+```ruby
+require "wireless"
+
+WL = Wireless.new do
+  count = 0
+
+  # factory: return a new value every time
+  on(:foo) do
+    [:foo, count += 1]
+  end
+
+  # singleton: return the cached value
+  once(:bar) do
+    [:bar, 42]
+  end
+
+  # depend on other dependencies
+  on(:baz) do |wl|
+    [:baz, wl[:foo], wl[:bar]]
+  end
+end
+
+# factory
+WL[:foo] # [:foo, 1]
+WL[:foo] # [:foo, 2]
+
+# singleton
+WL[:bar] # [:bar, 42]
+WL[:bar] # [:bar, 42]
+
+# dependencies
+WL[:baz] # [:baz, [:foo, 3], [:bar, 42]]
+WL[:baz] # [:baz, [:foo, 4], [:bar, 42]]
+
+# mixin
+class Example
+  include WL.mixin %i[foo bar baz]
+
+  def test
+    foo # [:foo, 5]
+    bar # [:bar, 42]
+    baz # [:baz, [:foo, 6], [:bar, 42]]
+  end
+end
+```
+
+# DESCRIPTION
+
+Wireless is a declarative dependency-provider (AKA [service locator](https://en.wikipedia.org/wiki/Service_locator_pattern)),
+which has the following features:
+
+* Simplicity
+
+    It's just an object which dependencies can be added to and retrieved from. It can
+    be passed around and stored like any other object. No "injection", no containers,
+    no framework, no dependencies.
+
+* Inclusion
+
+    Inclusion of dependency getters into a class or module with control over their visibility.
+
+* Laziness
+
+    As well as dependencies being resolved lazily, they can also be *registered* lazily i.e.
+    at the point of creation, rather than forcing everything to be declared up-front.
+
+* Safety
+
+    Dependency resolution is thread-safe. Dependency cycles are checked and raise a fatal
+    error as soon as they are detected.
+
+# WHY?
+
+## Why Wireless?
+
+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?
+
+Service locators make it easy to handle shared (AKA
+[cross-cutting](https://en.wikipedia.org/wiki/Cross-cutting_concern)) dependencies i.e.
+values and services that are required by multiple otherwise-unrelated parts of a system.
+Examples include:
+
+* logging
+* configuration data
+* storage backends
+* authorisation
+
+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.
+
+# VERSION
+
+0.0.1
+
+# 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
+- [DiFtw](https://github.com/jhollinger/ruby-diftw) - the original inspiration for this module: a similar API with a focus on testing/mocking
+
+## Articles
+
+- Martin Fowler - [Inversion of Control Containers and the Dependency Injection pattern](https://www.martinfowler.com/articles/injection.html) [2004]
+- Jim Weirich - [Dependency Injection in Ruby](https://archive.li/shxeA) [2004]
+
+# AUTHOR
+
+[chocolateboy](mailto:chocolate@cpan.org)
+
+# COPYRIGHT AND LICENSE
+
+Copyright © 2018 by chocolateboy.
+
+This is free software; you can redistribute it and/or modify it under the
+terms of the [Artistic License 2.0](http://www.opensource.org/licenses/artistic-license-2.0.php).

data/lib/wireless.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# The Wireless namespace houses the top-level dependency-provider/service-locator
+# object (Wireless::Registry) and also exposes a static method, Wireless.new, which
+# forwards to and instantiates the registry.
+module Wireless
+  class Error < StandardError; end
+  class CycleError < Error; end
+  class NameError < Error; end
+
+  # a shortcut which allows:
+  #
+  #   WL = Wireless::Registry.new do
+  #     # ...
+  #   end
+  #
+  # to be written as:
+  #
+  #   WL = Wireless.new do
+  #     # ...
+  #   end
+  def self.new(*args, &block)
+    Wireless::Registry.new(*args, &block)
+  end
+end
+
+require_relative 'wireless/version'
+require_relative 'wireless/resolver'
+require_relative 'wireless/resolver/factory'
+require_relative 'wireless/resolver/singleton'
+require_relative 'wireless/fetch'
+require_relative 'wireless/registry'
+require_relative 'wireless/fetcher'

data/lib/wireless/fetch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Wireless
+  # A mixin which provides the #fetch method (and #[] alias) shared by Wireless::Registry
+  # and the cut-down version, Wireless::Fetcher, which is passed to the blocks used
+  # to resolve dependencies.
+  #
+  # In both cases, @registry and @seen need to be defined as instance variables.
+  # @registry is a hash of { name (Symbol) => dependency (Object) } pairs, and
+  # @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
+    # defined or a Wireless::CycleError if resolving the dependency results in
+    # a cycle.
+    def fetch(name)
+      name = name.to_sym
+
+      if @seen.include?(name)
+        path = [*@seen, name].join(' -> ')
+        raise Wireless::CycleError, "cycle detected: #{path}"
+      end
+
+      unless (resolver = @registry[name])
+        raise Wireless::NameError, "dependency not found: #{name}"
+      end
+
+      fetcher = lambda do
+        seen = @seen.dup
+        seen.add(name)
+        Fetcher.new(registry: @registry, seen: seen)
+      end
+
+      resolver.resolve(fetcher)
+    end
+
+    alias [] fetch
+  end
+end

data/lib/wireless/fetcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wireless
+  # The object passed to the factory (`on`) or singleton (`once`) block:
+  # a cut-down version of Wireless::Registry which only provides read access
+  # (via #fetch or its #[] alias) to the underlying dependency store
+  class Fetcher
+    include Fetch
+
+    def initialize(registry:, seen:)
+      @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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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 block can be supplied as a class, in which case it is equivalent to a block
+  # which calls +new+ on the class e.g.:
+  #
+  #   WL = Wireless.new do
+  #     on(:foo, Foo)
+  #   end
+  #
+  # is equivalent to:
+  #
+  #   WL = Wireless.new do
+  #     on(:foo) { Foo.new }
+  #   end
+  class Registry
+    DEFAULT_EXPORTS = { private: [], protected: [], public: [] }
+    DEFAULT_VISIBILITY = :private
+
+    include Fetch
+
+    def initialize(args = DEFAULT_VISIBILITY, &block)
+      @default_visibility = args
+      @module_cache = {}
+      @registry = SynchronizedStore.new
+      @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)
+    end
+
+    # Returns true if a service with the specified name has been registered, false
+    # otherwise
+    def include?(key)
+      @registry.include?(key)
+    end
+
+    # 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)
+    end
+
+    # Takes an array or hash specifying the dependencies to export, and returns
+    # a module which exposes those dependencies as getters.
+    #
+    #   class Test
+    #     # hash (specify visibilities)
+    #     include Services.mixin private: :foo, protected: %i[bar baz], public: :quux
+    #
+    #     # or an array of imports using the default visibility (:private by default)
+    #     include Services.mixin %i[foo bar baz quux]
+    #
+    #     def test
+    #       foo + bar + baz + quux # access the dependencies
+    #     end
+    #   end
+    #
+    # The visibility of the generated getters can be controlled by passing a hash
+    # with { visibility => imports } pairs, where imports is an array of import
+    # specifiers. An import specifier is a symbol (method name == dependency name)
+    # or a hash with { dependency_name => method_name } pairs (aliases). If
+    # there's only one import specifier, its enclosing array can be omitted e.g.:
+    #
+    #   include Services.mixin(private: :foo, protected: { :baz => :quux })
+    #
+    # is equivalent to:
+    #
+    #   include Services.mixin(private: [:foo], protected: [{ :baz => :quux }])
+    #
+    def mixin(args)
+      # normalize the supplied argument (array or hash) into a hash of
+      # { visibility => exports } pairs, where `visibility` is a symbol and
+      # `exports` is a hash of { dependency_name => method_name } pairs
+      if args.is_a?(Array)
+        args = { @default_visibility => args }
+      elsif !args.is_a?(Hash)
+        raise ArgumentError, "invalid mixin argument: expected array or hash, got: #{args.class}"
+      end
+
+      # slurp each array of name (symbol) or name => alias (hash) imports into
+      # a normalized hash of { dependency_name => method_name } pairs e.g.:
+      #
+      # before:
+      #
+      #   [:foo, { :bar => :baz }, :quux]
+      #
+      # after:
+      #
+      #   { :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
+      #
+      # args = DEFAULT_EXPORTS.merge(args).transform_values do |exports|
+      #     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|
+          a.merge(b.is_a?(Hash) ? b : { b => b })
+        end
+      end
+
+      @module_cache[args] ||= module_for(args)
+    end
+
+    alias on factory
+    alias once singleton
+
+    private
+
+    # Create a module with the specified exports
+    def module_for(args)
+      registry = self
+      mod = Module.new
+
+      args.each do |visibility, exports|
+        exports.each do |dependency_name, method_name|
+          # equivalent to (e.g.):
+          #
+          #   def foo
+          #     registry.fetch(:foo)
+          #   end
+          mod.send(:define_method, method_name) do
+            registry.fetch(dependency_name)
+          end
+
+          # equivalent to (e.g.):
+          #
+          #   private :foo
+          mod.send(visibility, method_name)
+        end
+      end
+
+      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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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
+  # 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)
+        @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
+      end
+    end
+
+    # Abstract method: must be implemented in subclasses
+    def resolve(_fetcher)
+      raise NotImplementedError, '#resolve is an abstract method'
+    end
+  end
+end

data/lib/wireless/resolver/factory.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Wireless
+  class Resolver
+    # A dependency resolver which runs its block every time the value is fetched.
+    class Factory < Resolver
+      # return the dependency provided by the block
+      def resolve(fetcher)
+        @block.call(fetcher.call)
+      end
+    end
+  end
+end

data/lib/wireless/resolver/singleton.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Wireless
+  class Resolver
+    # A dependency resolver which only runs its block the first time the value
+    # is read. On subsequent reads, the cached value is returned.
+    class Singleton < Resolver
+      def initialize(block)
+        super(block)
+        @lock = Mutex.new
+        @seen = false
+        @value = nil
+      end
+
+      # Resolve the dependency once. On subsequent calls, return the cached
+      # version.
+      def resolve(fetcher)
+        @lock.synchronize do
+          unless @seen
+            @value = @block.call(fetcher.call)
+            @seen = true
+          end
+
+          @value
+        end
+      end
+    end
+  end
+end

data/lib/wireless/synchronized_store.rb

@@ -0,0 +1,34 @@
+# 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.
+  class SynchronizedStore
+    def initialize
+      @store = {}
+      @lock = Mutex.new
+    end
+
+    # Retrieve a new value from the underlying hash in a thread-safe way
+    def [](key)
+      @lock.synchronize { @store[key] }
+    end
+
+    # Assign a new value to the underlying hash in a thread-safe way
+    def []=(key, value)
+      @lock.synchronize do
+        if @store.include?(key)
+          raise Wireless::NameError, "resolver already exists: #{key}"
+        end
+
+        @store[key] = value
+      end
+    end
+
+    # Returns true if the underlying hash contains the key, false otherwise
+    def include?(key)
+      @lock.synchronize { @store.include?(key) }
+    end
+  end
+end

data/lib/wireless/version.rb

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

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: wireless
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- chocolateboy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: minitest-power_assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+description: 
+email: chocolate@cpan.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/wireless.rb
+- lib/wireless/fetch.rb
+- lib/wireless/fetcher.rb
+- lib/wireless/registry.rb
+- lib/wireless/resolver.rb
+- lib/wireless/resolver/factory.rb
+- lib/wireless/resolver/singleton.rb
+- lib/wireless/synchronized_store.rb
+- lib/wireless/version.rb
+homepage: https://github.com/chocolateboy/wireless
+licenses:
+- Artistic-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/chocolateboy/wireless/issues
+  changelog_uri: https://github.com/chocolateboy/wireless/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/chocolateboy/wireless
+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.7.7
+signing_key: 
+specification_version: 4
+summary: A lightweight, declarative dependency-provider
+test_files: []