hub_kernel 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a20cf973f68397694b8434e58918a40c31619eb8936aad87f8a183122aad47f4
-  data.tar.gz: 38a563f62a0c9bf630e72823b94c5cdba0cfe71bfe8c54d45d00a7129e8b5f32
+  metadata.gz: 269ad669e7c014af9175190d416dbf7be82bfb8d797eb3a25107bf87b99b1344
+  data.tar.gz: 808639ddaca46f8d8cbe9f187a7d59ae9d50b704f773bf4f255bae731d4339a7
 SHA512:
-  metadata.gz: 13453ee9d42aa2ac1fe4d3e95ad216867f27d9d2b13f9e71cfa52fe244add5f32e7dbb1a43912af43aba99fa060f3d564746265bb5e973ab4064399beb01e7bd
-  data.tar.gz: c55bce27f9ef2d71959cf39102a38a0c8b471f1d35665fedfa16c3325e96d2676cef36dc57f90c8da167cdfdd64d9bd248b029edf496f60f4e471b1d11e798f1
+  metadata.gz: 3c94024970cd0ae83bf695824439a959b6b03061eb39f92268f483ca769fbf323d4210710f805f052028590e65b87a84b43b8801cac1a9b927a9402205f1fd55
+  data.tar.gz: 307661997442f598ee6d2e931540336986a567794113298d496864f86d3ac19e2788ee091e75b8bc9434bd1c61bd3aa1df095b71af29d2479b7898869dfd416b

data/README.md

@@ -116,6 +116,54 @@ Supplies.exposed("record_purchase").takes # => [:supplier_id, :bought_on, :lines
 Supplies.exposed("delete_everything")     # => nil
 ```
 
+### The exposed-list check
+A hub's own test can check its exposed list, so a listed method the hub lacks, or one
+listed with values it does not take, shows in the suite rather than on a caller's
+request:
+
+```ruby
+require "hub_kernel/conformance/exposed"
+
+class SuppliesHubTest < ActiveSupport::TestCase
+  include HubKernel::Conformance::Exposed
+
+  hub { Supplies }
+end
+```
+
+The test fails and names each problem. A method that takes `**` values accepts any
+values it is listed with, as long as it is listed with each value it requires.
+
+### The crossing check
+A host's test can check that no hub's code names a class another hub owns. The host
+passes a map of which classes each hub owns, and the test fails listing each file and
+the class it names:
+
+```ruby
+require "hub_kernel/conformance/crossings"
+
+class HubCrossingsTest < ActiveSupport::TestCase
+  include HubKernel::Conformance::Crossings
+
+  crossings files: "app/{models,controllers,jobs,views}/shop/**/*.{rb,erb}", except: [ "app/models/shop/hubs.rb" ] do
+    HubKernel::Crossings.new(
+      owners: { supplies: %w[Shop::Purchase Shop::PurchasesController], finance: %w[Shop::Expense], shop: %w[Shop::Home] },
+      shared: %w[Shop::BaseController],
+      host_layer: :shop,
+      interfaces: { supplies: "Shop::Hubs::Supplies", finance: "Shop::Hubs::Finance" }
+    )
+  end
+end
+```
+
+- A constant inside another hub's class counts as naming that class.
+- A name no hub owns, such as a namespace, is not a crossing, and neither is a class on
+  the `shared` list.
+- A view belongs to the hub that owns its controller, then to the hub that owns the
+  record its folder is named after, and otherwise to the `host_layer`.
+- The host's layer may name any hub's interface module, and a hub naming another hub's
+  interface module is a crossing.
+
 ## Installation
 Add this line to your application's Gemfile:
 

data/lib/hub_kernel/conformance/crossings.rb

@@ -0,0 +1,28 @@
+require "active_support/concern"
+require "hub_kernel/crossings"
+
+module HubKernel
+  module Conformance
+    module Crossings
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def crossings(root: nil, files: "app/**/*.{rb,erb}", except: [], &block)
+          define_method(:the_crossings, &block)
+          define_method(:crossing_root) { root || Rails.root }
+          define_method(:crossing_files) { files }
+          define_method(:crossing_exceptions) { except }
+        end
+      end
+
+      included do
+        test "no file names a class another hub owns" do
+          found = (Dir.glob(crossing_files, base: crossing_root) - crossing_exceptions).sort.flat_map do |path|
+            the_crossings.in(path, File.read(File.join(crossing_root, path))).map { |name| "#{path} names #{name}" }
+          end
+          flunk found.join("\n") if found.any?
+        end
+      end
+    end
+  end
+end

data/lib/hub_kernel/conformance/exposed.rb

@@ -0,0 +1,22 @@
+require "active_support/concern"
+
+module HubKernel
+  module Conformance
+    module Exposed
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def hub(&block)
+          define_method(:the_hub, &block)
+        end
+      end
+
+      included do
+        test "every method the hub exposes exists and takes the values it is listed with" do
+          problems = the_hub.exposure_problems
+          flunk problems.join("\n") if problems.any?
+        end
+      end
+    end
+  end
+end

data/lib/hub_kernel/crossings.rb

@@ -0,0 +1,40 @@
+require "active_support/core_ext/string/inflections"
+
+module HubKernel
+  class Crossings
+    def initialize(owners:, shared: [], host_layer: nil, interfaces: {})
+      @owners = owners
+      @shared = shared
+      @host_layer = host_layer
+      @interfaces = interfaces
+    end
+
+    def in(path, source)
+      hub = owner_of_file(path)
+      source.scan(/[A-Z]\w*(?:::[A-Z]\w*)*/).filter_map { |name| owned_class_in(name) }.uniq.select { |name| crossing?(name, hub) }
+    end
+
+    private
+
+    def crossing?(name, hub)
+      return false if @shared.include?(name) || owner_of(name) == hub
+
+      !(hub == @host_layer && @interfaces.value?(name))
+    end
+
+    def owned_class_in(name)
+      parts = name.split("::")
+      parts.size.downto(1).map { |size| parts.first(size).join("::") }.find { |candidate| owner_of(candidate) }
+    end
+
+    def owner_of(class_name) = @interfaces.key(class_name) || @owners.find { |_hub, classes| classes.include?(class_name) }&.first
+
+    def owner_of_file(path)
+      return owner_of_view_folder(File.dirname(path.delete_prefix("app/views/")).camelize) if path.start_with?("app/views/")
+
+      owner_of(path.sub(%r{\Aapp/[^/]+/}, "").delete_suffix(".rb").camelize)
+    end
+
+    def owner_of_view_folder(folder) = owner_of("#{folder}Controller") || owner_of(folder) || @host_layer
+  end
+end

data/lib/hub_kernel/exposes.rb

@@ -8,8 +8,29 @@ module HubKernel
 
     def exposed(name) = exposed_methods[name.to_s]
 
+    def exposure_problems
+      exposed_methods.values.filter_map { |exposure| exposure_problem(exposure) }
+    end
+
     private
 
     def exposed_methods = @exposed_methods ||= {}
+
+    def exposing_hub = name.demodulize
+
+    def exposure_problem(exposure)
+      return "#{exposing_hub} exposes #{exposure.name}, which it has no method for" unless respond_to?(exposure.name)
+      return if takes_listed_values?(exposure)
+
+      "#{exposing_hub} exposes #{exposure.name} with #{exposure.takes.join(", ")}, but it takes #{keywords(exposure, :keyreq, :key).join(", ")}"
+    end
+
+    def takes_listed_values?(exposure)
+      (keywords(exposure, :keyreq) - exposure.takes).empty? && (takes_any_values?(exposure) || (exposure.takes - keywords(exposure, :keyreq, :key)).empty?)
+    end
+
+    def takes_any_values?(exposure) = method(exposure.name).parameters.any? { |kind, _| kind == :keyrest }
+
+    def keywords(exposure, *kinds) = method(exposure.name).parameters.filter_map { |kind, value| value if kinds.include?(kind) }
   end
 end

data/lib/hub_kernel/version.rb

@@ -1,3 +1,3 @@
 module HubKernel
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hub_kernel
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - tylercschneider
@@ -42,9 +42,12 @@ files:
 - lib/hub_kernel/answer.rb
 - lib/hub_kernel/authz.rb
 - lib/hub_kernel/conformance/action.rb
+- lib/hub_kernel/conformance/crossings.rb
+- lib/hub_kernel/conformance/exposed.rb
 - lib/hub_kernel/conformance/hub.rb
 - lib/hub_kernel/conformance/partial.rb
 - lib/hub_kernel/context.rb
+- lib/hub_kernel/crossings.rb
 - lib/hub_kernel/engine.rb
 - lib/hub_kernel/exposes.rb
 - lib/hub_kernel/follow_up.rb