smart_inject 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4d6bdfd2e40cc84906ab12e6e37eb7ae2db54be98ca5a18106a7d4de7cc47545
+  data.tar.gz: 757349ae540f1ffcfb5857814a79c8ed21906654790a81ed854b6f21fdb60b24
+SHA512:
+  metadata.gz: 9dfe7e53fd252c9bd8f8c162422aac075106bcbc4275afae916b184e86935a00ec250c30e5e8c737f1d5d13c3b04aac91a5208b39c053cbc4a335d67bb9cbad3
+  data.tar.gz: 6d60f6f4a659038127c6c2888ecb354667521f49ae160f9e9a285e910b3e3f45d16f07256f0912b4bca0c9c80e9255424c5d620139034b75c34900ad1db3caad

data/lib/smart_inject.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+#
+#                     SmartInject - Made DI deadly simple
+#
+# SmartInject is a minimalist, flexible and efficient dependency injection for
+# Ruby.
+#
+# Here, no DSL, no complex machinery, no dynamic change on the object model.
+# This is just a lightweight class that bring you DI using constructor, one of
+# the most used method for DI. You can use it without constraint on your design.
+#
+# SmartInject can be used in isolation within your Gem just by applying standard
+# ruby code: extend a class from SmartInject, and this is your new DI container.
+#
+# Feel free to see the code of SmartInject (very short), get the gem or
+# copy-past the SmartInject class file into your project... There is no external
+# dependency.
+#
+# SmartInject is intented to be under your control. No magic here.
+#
+class SmartInject
+  class SmartInjectError < StandardError; end
+
+  class ContainerError < SmartInjectError; end
+
+  class InjectionError < SmartInjectError; end
+
+  class << self
+    def services
+      @services ||= {}
+    end
+
+    def [](klass)
+      klass_name = klass.to_s
+
+      if @share_injections
+        service = running[klass_name]
+        return service if service
+      end
+
+      service = services.fetch(klass_name) { raise InjectionError, "service #{klass_name} unknown. Try to add #{name}.add(self) at the begining of #{klass_name} class." }
+      try_instanciate(service).tap do |instance|
+        running[klass_name] = instance if @share_injections
+      end
+    end
+
+    def remap(looked_klass, injected_klass)
+      (raise ContainerError, "the #{name} container is already started. No remap allowed") if frozen?
+      (raise ContainerError, "first argument must be a class. Found: #{looked_klass}") unless looked_klass.instance_of?(Class)
+      (raise ContainerError, "second argument must be a class. Found: #{injected_klass}") unless injected_klass.instance_of?(Class)
+
+      services[looked_klass.name] = injected_klass
+      self
+    end
+
+    def add(klass, &block)
+      (raise ContainerError, "the #{name} container is already started. No add allowed") if frozen?
+      (raise ContainerError, "first argument must be a class. Found: #{klass}") unless klass.instance_of?(Class)
+
+      services[klass.name] = block || klass
+      running.delete(klass.name)
+      self
+    end
+
+    def start_container!
+      return self if frozen?
+      return freeze if @share_injections
+
+      services.each do |(klass_name, service)|
+        next if running[klass_name]
+
+        try_instanciate(service).tap { |instance| running[klass_name] = instance }
+      end
+      freeze
+    end
+
+    def share_injections
+      (raise ContainerError, "the #{name} container is already started. No share_injections allowed") if frozen?
+
+      @share_injections = true
+      self
+    end
+
+    def share_injections?
+      !!(@share_injections)
+    end
+
+    private
+
+    def running
+      @running ||= {}
+    end
+
+    def try_instanciate(klass_or_callable)
+      if klass_or_callable.is_a?(Proc)
+        klass_or_callable.call
+      else
+        klass_or_callable.new
+      end
+    rescue ArgumentError
+      raise InjectionError, "automatic injection can't be done: all arguments of the constructor are not subject to injection. Try to #{name}.add(#{klass_or_callable}) { <BLOC TO INSTANTIATE YOUR CLASS WITH ARGUMENTS (OUTSIDE OF THOSE INJECTED)> }"
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: smart_inject
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Ludovic de Luna
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-03 00:00:00.000000000 Z
+dependencies: []
+description: |
+  SmartInject is a minimalist, flexible and efficient dependency injection
+  for Ruby based on constructor injection, one of the most used method for
+  DI.
+
+  SmartInject is intented to be under your control. No magic here.
+email: ludovic@deluna.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/smart_inject.rb
+homepage: https://rubygems.org/gems/smart_inject
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Made DI deadly simple
+test_files: []