interactify 0.1.0.pre.alpha.1 → 0.2.0.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bbf811a8d9e44f85d4e0c5b36f4ad3291cbc8f5aa52e5d2dd31ecbdd753a256
-  data.tar.gz: 92ed7413e2ea370d388c43d9993928652d9bc23a3139d3fa083050243bc30695
+  metadata.gz: 4c2dffe1928c3b1653ea12057fd660eacbef1d8fbd946d1bdbddef00494a8c8b
+  data.tar.gz: 7078fe7a6b217febd47f4598eb2e88fdcfb8affcd434dba239ee86a39a072176
 SHA512:
-  metadata.gz: 1d9e01fc12b9b02bdc9d897b81866c7d668f94cf0fafd51e018cded3ec2892d5452848000672a9c4ac139f1c1dc3d30aa23e1c16b0dcaf66afd901c4586d8eae
-  data.tar.gz: b33dc94b10b26cf1b4baeace46168641d88121bf05fe2a4c8c37098d3b5bc678667e0ff253f620def1798846b9b95533f943ef4c80726abe08a1a41662c338c0
+  metadata.gz: 9e3eb106e5b896965c6b1fbfea135c62f4eb7f95779041c121bcb2040fd8568c54e94b4f77a3e1bcca6d922d8a8bdfcacda354d3a6396e19a49fbfce78f39af1
+  data.tar.gz: 3f998d9f35105a47becc0555ed80dff264fad2e5fe58f93ec0c731b8cab4281e457da9e3fc00d0e4709e1b62b4e2416a8a75b66f56723b610531bca8fd458ea3

data/.rubocop.yml

@@ -0,0 +1,23 @@
+AllCops:
+  NewCops: enable
+  Exclude:
+    - 'spec/fixtures/**/*'
+    - 'tmp/**/*'
+    - '.git/**/*'
+    - 'bin/*'
+Style/ClassAndModuleChildren:
+  Exclude: 
+    - 'spec/**/*'
+Metrics/BlockLength:
+  Exclude: 
+    - 'spec/**/*'
+    - '*.gemspec'
+Metrics/MethodLength:
+  Enabled: false
+Lint/ConstantDefinitionInBlock:
+  Exclude: 
+    - 'spec/**/*'
+Style/Documentation:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -3,3 +3,7 @@
 ## [0.1.0] - 2023-12-16
 
 - Initial release
+
+## [0.2.0] - 2023-12-27
+
+- Added support for Interactify.promising syntax in organizers

data/README.md

@@ -1,11 +1,50 @@
 # Interactify
 
-Interactors are a great way to encapsulate business logic in a Rails application. 
+[Interactors](https://github.com/collectiveidea/interactor) are a great way to encapsulate business logic in a Rails application. 
 However, sometimes in complex interactor chains, the complex debugging happens at one level up from your easy to read and test interactors.
 
-Interactify wraps the interactor and interactor-contract gem and provides additional functionality making chaining and understanding interactor chains easier.
+[interactor-contracts](https://github.com/michaelherold/interactor-contracts) does a fantastic job of making your interactor chains more reliable.
+
+Interactify wraps the interactor and interactor-contracts gem and provides additional functionality making chaining and understanding interactor chains easier.
+
+This is a bells and whistles gem and assumes you are working in a Rails project with Sidekiq.
+However, I'm open to the idea of making it more focused and making these more pluggable.
+
+## Installation
+
+```Gemfile
+gem 'interactify'
+```
+
+## Usage
+
+### Initializer
+```ruby
+# in config/initializers/interactify.rb
+Interactify.configure do |config|
+  # default
+  # config.root = Rails.root / 'app'
+end
+
+Interactify.on_contract_breach do |context, attrs|
+  # maybe add context to Sentry or Honeybadger etc here
+end
+
+Interactify.before_raise do |exception|
+  # maybe add context to Sentry or Honeybadger etc here
+end
+```
+
+### Using the RSpec matchers
+```ruby
+# e.g. in spec/supoort/interactify.rb
+require 'interactify/rspec/matchers'
+```
 
 ### Syntactic Sugar
+- Everything is an Organizer/Interactor and supports interactor-contracts.
+- Concise syntax for most common scenarios with `expects` and `promises`. Verifying the presence of the keys/values.
+- Automatic delegation of expected and promised keys to the context.
 
 ```ruby
 # before
@@ -16,6 +55,8 @@ class LoadOrder
 
   expects do
     required(:id).filled
+    required(:something_else).filled
+    required(:a_boolean_flag)
   end
 
   promises do
@@ -35,7 +76,8 @@ end
 class LoadOrder
   include Interactify
 
-  expect :id
+  expect :id, :something_else
+  expect :a_boolean_flag, filled: false
   promise :order
 
   def call
@@ -63,7 +105,7 @@ organize \
 
 Sometimes we want an interactor for each item in a collection.
 But it gets unwieldy. 
-It was complex procedural code and is now broken into neat SRP classes (Single Responsibility Principle). 
+It was complex procedural code and is now broken into neat [SRP classes](https://en.wikipedia.org/wiki/Single_responsibility_principle). 
 But there is still boilerplate and jumping around between files to follow the orchestration.
 It's easy to get lost in the orchestration code that occurs across say 7 or 8 files.
 
@@ -208,6 +250,90 @@ class SomeOrganizer
     EitherWayDoThis
 end
 
+```
+### Contract validation failures
+Sometimes contract validation fails at runtime as an exception. It's something unexpected and you'll have an `Interactor::Failure` sent to rollbar/sentry/honeybadger.
+If the context is large it's often hard to spot what the actual problem is or where it occurred.
+
+#### before 
+```
+Interactor::Failure
+
+#<Interactor::Context output_destination="DataExportSystem", output_format=:xml, region_code="XX", custom_flag=false, process_mode="sample", cache_identifier="GenericProcessorSample-XML-XX-0", data_key="GenericProcessorSample", data_version=0, last_process_time=2023-12-26 04:00:18.953000000 GMT +00:00, process_start_time=2023-12-26 06:45:17.915237484 UTC, updated_ids=[BSON::ObjectId('123f77a58444201ff1f0611a'), BSON::ObjectId('123f78148444201fd62a2e9b'), BSON::ObjectId('12375d8084442038712ba40e')], lock_info=#<Processing::Lock _id: 123a767d7b944674cc069064, created_at: 2023-12-26 06:45:17.992417809 UTC, updated_at: 2023-12-26 06:45:17.992417809 UTC, processor: "DataExportSystem", format: "xml", type: "sample">, expired_cache_ids=[], jobs=['jobs must be filled'] items=#<Mongoid::Criteria (Interactor::Failure)
+, tasks=[]>
+```
+
+#### after with call 
+```
+#<Interactor::Context output_destination="DataExportSystem", output_format=:xml, region_code="XX", custom_flag=false, process_mode="sample", cache_identifier="GenericProcessorSample-XML-XX-0", data_key="GenericProcessorSample", data_version=0, last_process_time=2023-12-26 04:00:18.953000000 GMT +00:00, process_start_time=2023-12-26 06:45:17.915237484 UTC, updated_ids=[BSON::ObjectId('123f77a58444201ff1f0611a'), BSON::ObjectId('123f78148444201fd62a2e9b'), BSON::ObjectId('12375d8084442038712ba40e')], lock_info=#<Processing::Lock _id: 123a767d7b944674cc069064, created_at: 2023-12-26 06:45:17.992417809 UTC, updated_at: 2023-12-26 06:45:17.992417809 UTC, processor: "DataExportSystem", format: "xml", type: "sample">, expired_cache_ids=[], tasks=['tasks must be filled'] items=#<Mongoid::Criteria (Interactor::Failure)
+, tasks=[], contract_failures={:tasks=>["tasks must be filled"]}>
+```
+
+#### after with call!
+```
+#<SomeSpecificInteractor::ContractFailure output_destination="DataExportSystem", output_format=:xml, region_code="XX", custom_flag=false, process_mode="sample", cache_identifier="GenericProcessorSample-XML-XX-0", data_key="GenericProcessorSample", data_version=0, last_process_time=2023-12-26 04:00:18.953000000 GMT +00:00, process_start_time=2023-12-26 06:45:17.915237484 UTC, updated_ids=[BSON::ObjectId('123f77a58444201ff1f0611a'), BSON::ObjectId('123f78148444201fd62a2e9b'), BSON::ObjectId('12375d8084442038712ba40e')], lock_info=#<Processing::Lock _id: 123a767d7b944674cc069064, created_at: 2023-12-26 06:45:17.992417809 UTC, updated_at: 2023-12-26 06:45:17.992417809 UTC, processor: "DataExportSystem", format: "xml", type: "sample">, expired_cache_ids=[], tasks=['tasks must be filled'] items=#<Mongoid::Criteria (Interactor::Failure)
+, tasks=[], contract_failures={:tasks=>["tasks must be filled"]}>
+```
+
+### Promising
+You can annotate your interactors in the organize arguments with their promises.
+This then acts as executable documentation that is validated at load time and enforced to stay in sync with the interactor.
+
+A writer of an organizer may quite reasonably expect `LoadOrder` to promise `:order`, but for the reader, it's not always as immediately obvious
+which interactor in the chain is responsible for provides which key.
+
+```ruby
+organize \
+  LoadOrder.promising(:order), 
+  TakePayment.promising(:payment_transaction)
+```
+
+This will be validated at load time against the interactors promises.
+An example of a failure would be:
+
+```
+SomeOrganizer::DoStep1 does not promise:
+step_1
+
+Actual promises are:
+step1
+```
+
+
+### Interactor wiring specs
+Sometimes you have an interactor chain that fails because something is expected deeper down the chain and not provided further up the chain. 
+The existing way to solve this is with enough integration specs to catch them, hunting and sticking a `byebug`, `debugger` or `binding.pry` in at suspected locations and inferring where in the chain the wiring went awry.
+
+But we can do better than that if we always `promise` something that is later `expect`ed.
+
+In order to detect these wiring issues, stick a spec in your test suite like this:
+
+```ruby
+RSpec.describe 'InteractorWiring' do
+  it 'validates the interactors in the whole app', :aggregate_failures do
+    errors = Interactify.validate_app(ignore: [/Priam/])
+
+    expect(errors).to eq ''
+  end
+end
+```
+
+```
+    Missing keys: :order_id
+              in: AssignOrderToUser
+             for: PlaceOrder
+```
+
+This allows you to quickly see exactly where you missed assigning something to the context.
+Combine with lambda debugging `->(ctx) { byebug if ctx.order_id.nil?},` in your chains to drop into the exact
+location in the chain to find where to make the change.
+
+### RSpec matchers
+Easily add [low value, low cost](https://noelrappin.com/blog/2017/02/high-cost-tests-and-high-value-tests/) specs for your expects and promises.
+
+```ruby
+expect(described_class).to expect_inputs(:order_id)
+expect(described_class).to promise_outputs(:order)
 ```
 
 ### Sidekiq Jobs
@@ -230,10 +356,11 @@ clsas SomeInteractorJob
     SomeInteractor.call(*args)
   end
 end
+```
 
-SomeInteractor.call(*args)
-code is changed to
-SomeInteractorJob.perform_async(*args)
+```diff
+-SomeInteractor.call(*args)
++SomeInteractorJob.perform_async(*args)
 ```
 
 ```ruby
@@ -245,14 +372,22 @@ class SomeInteractor
     # ...
   end
 end
+```
 
-# no need to manually create a job class or handle the perform/call impedance mismatch
-SomeInteractor::Async.call(*args)
+No need to manually create a job class or handle the perform/call impedance mismatch
 
-# This also makes it easy to add cron jobs to run interactors. As any interactor can be asyncified.
-# By using it's internal Async class.
+```diff
+-SomeInteractor.call!(*args)
++SomeInteractor::Async.call!(*args)
 ```
 
+This also makes it easy to add cron jobs to run interactors. As any interactor can be asyncified.
+By using it's internal Async class.
+
+N.B. as your class is now executing asynchronously you can no longer rely on its promises later on in the chain.
+
+
+
 ## FAQs
 - This is ugly isn't it?
 
@@ -305,7 +440,14 @@ When I've used service objects, I've found them to be more complex to test and c
 I can't see a clean way that using service objects to compose interactors could work well without losing some of the aforementioned benefits.
 
 ### TODO
-We want to add support for explicitly specifying promises in organizers. The benefit here is on clarifying the contract between organizers and interactors.
+We want to add support for explicitly specifying promises in organizers. 
+
+The benefit here is on clarifying the contract between organizers and interactors.
+
+This is another variation of the "interactors themselves are great but their coordination and finding where things happen is hard in large applications".
+
+By adding promise notation to organizers, we can signal to the reader that 'here in this part of the chain is the thing you are looking for'.
+
 A writer of an organizer may expect LoadOrder to promise :order, but for the reader, it's not quite as explicit.
 The expected syntax will be
 
@@ -317,36 +459,6 @@ organize \
 
 This will be validated at test time against the interactors promises.
 
-## Installation
-
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
-
-## Usage
-
-```ruby
-# e.g. in spec/supoort/interactify.rb
-require 'interactify/rspec/matchers'
-
-Interactify.configure do |config|
-  config.root = Rails.root '/app'
-end
-
-Interactify.on_contract_breach do |context, attrs|
-  # maybe add context to Sentry or Honeybadger etc here
-end
-
-Interactify.before_raise do |exception|
-  # maybe add context to Sentry or Honeybadger etc here
-end
-```
 
 ## Development
 

data/lib/interactify/async_job_klass.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Interactify
+  class AsyncJobKlass
+    attr_reader :container_klass, :klass_suffix
+
+    def initialize(container_klass:, klass_suffix:)
+      @container_klass = container_klass
+      @klass_suffix = klass_suffix
+    end
+
+    def async_job_klass
+      klass = Class.new do
+        include Interactor
+        include Interactor::Contracts
+      end
+
+      attach_call(klass)
+      attach_call!(klass)
+
+      klass
+    end
+
+    def attach_call(async_job_klass)
+      # e.g. SomeInteractor::AsyncWithSuffix.call(foo: 'bar')
+      async_job_klass.send(:define_singleton_method, :call) do |context|
+        call!(context)
+      end
+    end
+
+    def attach_call!(async_job_klass)
+      this = self
+
+      # e.g. SomeInteractor::AsyncWithSuffix.call!(foo: 'bar')
+      async_job_klass.send(:define_singleton_method, :call!) do |context|
+        # e.g. SomeInteractor::JobWithSuffix
+        job_klass = this.container_klass.const_get("Job#{this.klass_suffix}")
+
+        # e.g. SomeInteractor::JobWithSuffix.perform_async({foo: 'bar'})
+        job_klass.perform_async(this.args(context))
+      end
+    end
+
+    def args(context)
+      args = context.to_h.stringify_keys
+
+      return args unless container_klass.respond_to?(:expected_keys)
+
+      restrict_to_optional_or_keys_from_contract(args)
+    end
+
+    def restrict_to_optional_or_keys_from_contract(args)
+      keys = container_klass.expected_keys.map(&:to_s)
+
+      optional = Array(container_klass.optional_attrs).map(&:to_s)
+      keys += optional
+
+      args.slice(*keys)
+    end
+  end
+end

data/lib/interactify/call_wrapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Interactify
   module CallWrapper
     # https://github.com/collectiveidea/interactor/blob/57b2af9a5a5afeb2c01059c40b792485cc21b052/lib/interactor.rb#L114

data/lib/interactify/contract_failure.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Interactify
+  class ContractFailure < ::Interactor::Failure
+  end
+end

data/lib/interactify/contract_helpers.rb

@@ -1,6 +1,9 @@
-require 'interactify/jobable'
-require 'interactify/call_wrapper'
-require 'interactify/organizer_call_monkey_patch'
+# frozen_string_literal: true
+
+require "interactify/jobable"
+require "interactify/call_wrapper"
+require "interactify/organizer_call_monkey_patch"
+require "interactify/contract_failure"
 
 module Interactify
   module ContractHelpers
@@ -39,14 +42,11 @@ module Interactify
       end
     end
 
-    class ContractFailure < ::Interactor::Failure
-    end
-
     included do
       c = Class.new(ContractFailure)
-      # example self is Shopkeeper::Fetch
-      # failure class:  Shopkeeper::Fetch::InteractorContractFailure
-      const_set 'InteractorContractFailure', c
+      # example self is Whatever::SomeInteractor
+      # failure class:  Whatever::SomeInteractor::InteractorContractFailure
+      const_set "InteractorContractFailure", c
       prepend CallWrapper
       include OrganizerCallMonkeyPatch if ancestors.include? Interactor::Organizer
 

data/lib/interactify/dsl.rb

@@ -1,5 +1,7 @@
-require 'interactify/each_chain'
-require 'interactify/if_interactor'
+# frozen_string_literal: true
+
+require "interactify/each_chain"
+require "interactify/if_interactor"
 
 module Interactify
   module Dsl

data/lib/interactify/each_chain.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Interactify
   class EachChain
     attr_reader :each_loop_klasses, :plural_resource_name, :evaluating_receiver

data/lib/interactify/if_interactor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Interactify
   class IfInteractor
     attr_reader :condition, :success_interactor, :failure_interactor, :evaluating_receiver
@@ -56,7 +58,7 @@ module Interactify
     end
 
     def if_klass_name
-      name = condition.is_a?(Proc) ? 'Proc' : condition
+      name = condition.is_a?(Proc) ? "Proc" : condition
 
       "If#{name.to_s.camelize}".to_sym
     end

data/lib/interactify/interactor_wiring/callable_representation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "interactify/interactor_wiring/error_context"
+
+module Interactify
+  class InteractorWiring
+    class CallableRepresentation
+      attr_reader :filename, :klass, :wiring
+
+      delegate :interactor_lookup, to: :wiring
+
+      def initialize(filename:, klass:, wiring:)
+        @filename = filename
+        @klass = klass
+        @wiring = wiring
+      end
+
+      def validate_callable(error_context: ErrorContext.new)
+        if organizer?
+          assign_previously_defined(error_context:)
+          validate_children(error_context:)
+        end
+
+        validate_self(error_context:)
+      end
+
+      def expected_keys
+        klass.respond_to?(:expected_keys) ? Array(klass.expected_keys) : []
+      end
+
+      def promised_keys
+        klass.respond_to?(:promised_keys) ? Array(klass.promised_keys) : []
+      end
+
+      def all_keys
+        expected_keys.concat(promised_keys)
+      end
+
+      def inspect
+        "#<#{self.class.name}#{object_id} @filename=#{filename}, @klass=#{klass.name}>"
+      end
+
+      def organizer?
+        klass.respond_to?(:organized) && klass.organized.any?
+      end
+
+      def assign_previously_defined(error_context:)
+        return unless contract?
+
+        error_context.append_previously_defined_keys(all_keys)
+      end
+
+      def validate_children(error_context:)
+        klass.organized.each do |interactor|
+          interactor_as_callable = interactor_lookup[interactor]
+          next if interactor_as_callable.nil?
+
+          error_context = interactor_as_callable.validate_callable(error_context:)
+        end
+
+        error_context
+      end
+
+      private
+
+      def contract?
+        klass.ancestors.include? Interactor::Contracts
+      end
+
+      def validate_self(error_context:)
+        return error_context unless contract?
+
+        error_context.infer_missing_keys(self)
+        error_context.add_promised_keys(promised_keys)
+        error_context
+      end
+    end
+  end
+end

data/lib/interactify/interactor_wiring/constants.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Interactify
+  class InteractorWiring
+    class Constants
+      attr_reader :root, :organizer_files, :interactor_files
+
+      def initialize(root:, organizer_files:, interactor_files:)
+        @root = root.is_a?(Pathname) ? root : Pathname.new(root)
+        @organizer_files = organizer_files
+        @interactor_files = interactor_files
+      end
+
+      def organizers
+        @organizers ||= organizer_files.flat_map do |f|
+          callables_in_file(f)
+        end.compact.select(&:organizer?)
+      end
+
+      def interactors
+        @interactors ||= interactor_files.flat_map do |f|
+          callables_in_file(f)
+        end.compact.reject(&:organizer?)
+      end
+
+      def interactor_lookup
+        @interactor_lookup ||= (interactors + organizers).index_by(&:klass)
+      end
+
+      private
+
+      def callables_in_file(filename)
+        @callables_in_file ||= {}
+
+        @callables_in_file[filename] ||= _callables_in_file(filename)
+      end
+
+      def _callables_in_file(filename)
+        constant = constant_for(filename)
+        return if constant == Interactify
+
+        internal_klasses = internal_constants_for(constant)
+
+        ([constant] + internal_klasses).map do |k|
+          new_callable(filename, k, self)
+        end
+      end
+
+      def internal_constants_for(constant)
+        constant
+          .constants
+          .map { |sym| constant_from_symbol(constant, sym) }
+          .select { |pk| interactor_klass?(pk) }
+      end
+
+      def constant_from_symbol(constant, symbol)
+        constant.module_eval do
+          symbol.to_s.constantize
+        rescue StandardError
+          begin
+            "#{constant.name}::#{symbol}".constantize
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def interactor_klass?(object)
+        return unless object.is_a?(Class) && object.ancestors.include?(Interactor)
+        return if object.is_a?(Sidekiq::Job)
+
+        true
+      end
+
+      def new_callable(filename, klass, wiring)
+        CallableRepresentation.new(filename:, klass:, wiring:)
+      end
+
+      def constant_for(filename)
+        require filename
+
+        underscored_klass_name = underscored_klass_name(filename)
+        underscored_klass_name = trim_rails_design_pattern_folder underscored_klass_name
+
+        klass_name = underscored_klass_name.classify
+
+        should_pluralize = filename[underscored_klass_name.pluralize]
+        klass_name = klass_name.pluralize if should_pluralize
+
+        Object.const_get(klass_name)
+      end
+
+      # Example:
+      # trim_rails_folder("app/interactors/namespace/sub_namespace/class_name.rb")
+      # => "namespace/sub_namespace/class_name.rb"
+      def trim_rails_design_pattern_folder(filename)
+        rails_folders.each do |folder|
+          regexable_folder = Regexp.quote("#{folder}/")
+          regex = /^#{regexable_folder}/
+
+          return filename.gsub(regex, "") if filename.match?(regex)
+        end
+
+        filename
+      end
+
+      def rails_folders = Dir.glob(root / "*").map { Pathname.new _1 }.select(&:directory?).map { |f| File.basename(f) }
+
+      # Example:
+      # "/home/code/something/app/interactors/namespace/sub_namespace/class_name.rb"
+      # "/namespace/sub_namespace/class_name.rb"
+      #  ['', 'namespace', 'sub_namespace', 'class_name.rb']
+      #  ['namespace', 'sub_namespace', 'class_name.rb']
+      def underscored_klass_name(filename)
+        filename.to_s # "/home/code/something/app/interactors/namespace/sub_namespace/class_name.rb"
+                .gsub(root.to_s, "")   # "/namespace/sub_namespace/class_name.rb"
+                .gsub("/concerns", "") #  concerns directory is ignored by Zeitwerk
+                .split("/")            # "['', 'namespace', 'sub_namespace', 'class_name.rb']
+                .compact_blank         # "['namespace', 'sub_namespace', 'class_name.rb']
+                .join("/")             # 'namespace/sub_namespace/class_name.rb'
+                .gsub(/\.rb\z/, "")     # 'namespace/sub_namespace/class_name'
+      end
+    end
+  end
+end