providers 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ae45a99a137a22b85a607817e9a75b18de4ec52dcce7e6655da647ebc7d6c47d
+  data.tar.gz: 451913f8ad2f29c3412a82c215dabe79ffe1be35c8b82c7a8057496bdfc04512
+SHA512:
+  metadata.gz: 98903d9d7bf948baba13e56f28499ff80e37f0c292be508c495e273f846d1810d369469562bebee89c26532e7bb569db1bd457a119c33b8ee3f845633da23a4d
+  data.tar.gz: 0650357e620e054d1606854f5b272331a21ecbf8dc91b1a5b324547d9213434e28a32ec48197f6b0b3aee830a46acdb13a3d48a6049ab9bd420513375b94019e

data/lib/config/config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if ENV['DEV_MODE'] == '1'
+  LowType.configure do |config|
+    config.output_mode = :value
+  end
+end

data/lib/dependencies.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'config/config'
+require_relative 'expressions/dependency'
+require_relative 'factories/dependency_factory'
+require_relative 'repositories/dependencies'
+require_relative 'providers'
+
+class Dependencies
+  class << self
+    def provide(key, &block)
+      Low::Dependencies.provide(key:, &block)
+    end
+
+    # Usage: "include Dependencies[:dependency]"
+    def [](*dependencies)
+      class_dependencies = Low::DependencyFactory.parse([*dependencies])
+
+      # "include" doesn't know the class that did the include, however "included" happens immediately after.
+      Low::Dependencies.push(class_dependencies:)
+
+      included_hook
+    end
+
+    def included_hook
+      Module.new do
+        def self.included(klass)
+          klass.class_eval do
+            # "include" doesn't know the class that did the include, however "included" happens immediately after.
+            @low_dependencies = Low::Dependencies.pop
+
+            class << self
+              attr_reader :low_dependencies
+            end
+
+            def initialize
+              self.class.low_dependencies.each do |dependency|
+                provider = Low::Providers.find(dependency.provider_key)
+                raise StandardError, "Provider #{dependency.provider_key} not found" if provider.nil?
+
+                var_name = Providers.var_name_via_namespace(dependency.var_name)
+                instance_variable_set("@#{var_name}", provider.result)
+              end
+            end
+
+            Providers.define_readers(@low_dependencies, self)
+          end
+        end
+      end
+    end
+
+    def define_readers(dependencies, klass)
+      dependencies.each do |dependency|
+        var_name = var_name_via_namespace(dependency.var_name)
+
+        klass.define_method(var_name) do
+          instance_variable_get("@#{var_name}")
+        end
+      end
+    end
+
+    def var_name_via_namespace(namespace)
+      return namespace.split('.').last if namespace.is_a?(String)
+
+      namespace
+    end
+  end
+end

data/lib/expressions/dependency.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'expressions'
+
+module Low
+  # A Dependency Expression requires LowType in order to be injected via a constructor.
+  # See "Dependencies[:dependency]" for traditional dependency injection without LowType.
+  class Dependency < ::Expressions::Expression
+    attr_reader :provider_key, :var_name
+
+    def initialize(provider_key: nil, var_name: nil)
+      super()
+
+      @provider_key = provider_key || var_name
+      @var_name = var_name
+    end
+
+    def required?
+      false
+    end
+
+    # Inject dependency via LowType's default value.
+    def default_value
+      Providers[@provider_key]
+    end
+
+    # Ignore LowType's validation of arguments of type Dependency.
+    def validate!(value:, proxy:); end
+
+    private
+
+    def union_value(value)
+      @provider_key = value
+      @var_name = Dependencies.var_name_via_namespace(value)
+    end
+  end
+end

data/lib/factories/dependency_factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../expressions/dependency'
+
+module Low
+  class DependencyFactory
+    class << self
+      def parse(dependencies)
+        class_dependencies = []
+
+        dependencies.each do |dependency|
+          case dependency
+          when Hash
+            provider_key = dependency.keys.first
+            dependency = dependency[provider_key]
+          else
+            provider_key = dependency
+          end
+
+          class_dependencies << (Dependency.new(var_name: dependency) | provider_key)
+        end
+
+        class_dependencies
+      end
+    end
+  end
+end

data/lib/models/provider.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Low
+  class Provider
+    attr_reader :key
+
+    def initialize(key:, &block)
+      @key = key
+      @proc = block
+      @result = nil
+    end
+
+    def result
+      @result ||= @proc.call
+    end
+  end
+end

data/lib/providers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../models/provider'
+
+class Providers
+  class MissingProviderError < StandardError; end
+
+  class << self
+    def provide(key:, &block)
+      providers[key] = Provider.new(key:, &block)
+    end
+
+    def providers
+      @providers ||= {}
+      @providers
+    end
+
+    def find(provider_key)
+      providers[provider_key]
+    end
+
+    # Providers[] are hard to stub in tests and should only be used when dependency injection isn't possible.
+    # TODO: Make Providers[] easy to stub in tests and look into feature where we get providers from another Ecosystem.
+    def [](provider_key)
+      provider = providers[provider_key]
+      raise(MissingProviderError, "Provider #{provider_key.inspect} not found") if provider.nil?
+
+      provider.result
+    end
+
+    def all
+      providers
+    end
+
+    def clear
+      @providers = {}
+    end
+  end
+end

data/lib/repositories/dependencies.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Low
+  class Dependencies
+    class << self
+      def stack
+        @stack ||= []
+        @stack
+      end
+
+      def push(class_dependencies:)
+        stack << class_dependencies
+      end
+
+      def pop
+        stack.pop
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Low
+  DEPENDENCY_VERSION = '0.3.1'
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: providers
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- maedi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: expressions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Automatic Dependency Injection where you get to see and keep control
+  of the constructor
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/config/config.rb
+- lib/dependencies.rb
+- lib/expressions/dependency.rb
+- lib/factories/dependency_factory.rb
+- lib/models/provider.rb
+- lib/providers.rb
+- lib/repositories/dependencies.rb
+- lib/version.rb
+homepage: https://github.com/raindeer-rb/providers
+licenses: []
+metadata:
+  homepage_uri: https://github.com/raindeer-rb/providers
+  source_code_uri: https://github.com/raindeer-rb/providers/src/branch/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Dependency Injection in crisp and clear syntax
+test_files: []