kube_cluster 0.3.8 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe22aedfb5ac2ca4451e036aaa97364c551cdb6ff795bd05057f47311cd801b
-  data.tar.gz: 77300dffe8e8189dc95996ed080283e94ba316ae894fa36e4a94bc9a18045e68
+  metadata.gz: 73c5f35cb0973b95a00857241ef1196576fe4329a90bbaab0aa3ae50d06ad31b
+  data.tar.gz: eaa76522c4e40392ee4f95c360a930d091b1b1c65156db359cd771e5ede86a3f
 SHA512:
-  metadata.gz: 5d2b36b773ada5eb5ec794125f825155c6910cf737e67bcbcd9c6f40ec0508e5752fb9744a78d94344ad7f42b7acf19c38ab2ac55c6c148a9eac57fcac0499fe
-  data.tar.gz: 668b0c45f7b9229eb4476f0d536545afa1e060e8b970f8ae968dc9dfef39fda93df5786b9f804e7a31d284fb7e4d2adbeeb8f7d7ff5c9199233e0e6a6c08588d
+  metadata.gz: 74b8f85d6a79ef42bc37027683300a790e4f7430510ff559c4bc0fa5f84d9e8b48e5fb901c55d1ab9c00326ee19eb0378ca3682d0c4b3e637be259e80a50c5c9
+  data.tar.gz: 8160c305637993d7df839d837884435953555562faff5f69b521194741399c83ff155f764f2870930d81cb17141447757445a6d7a8d29b96276f8507f714d7a5

data/Gemfile.lock

@@ -1,23 +1,27 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.3.8)
+    kube_cluster (0.3.10)
       kube_kubectl (~> 2.0.9)
-      kube_schema (~> 1.3.0)
+      kube_schema (~> 1.3.8)
+      scampi (~> 0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
     bigdecimal (4.1.2)
+    colorize (1.1.0)
+    colorize-extended (0.1.0)
+      colorize (~> 1.1)
     date (3.5.1)
     debug (1.11.1)
       irb (~> 1.10)
       reline (>= 0.3.8)
-    erb (6.0.3)
+    erb (6.0.4)
     hana (1.3.7)
     io-console (0.8.2)
-    irb (1.17.0)
+    irb (1.18.0)
       pp (>= 0.6.0)
       prism (>= 1.3.0)
       rdoc (>= 4.0.0)
@@ -34,12 +38,11 @@ GEM
       rubyshell (~> 1.5)
       shellwords (~> 0.2.2)
       string_builder (~> 1.2.2)
-    kube_schema (1.3.4)
+    kube_schema (1.3.8)
       json_schemer (~> 2.5.0)
       rubyshell (~> 1.5.0)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
-    minitest (5.27.0)
     parallel (2.0.1)
     parser (3.3.11.1)
       ast (~> 2.4.1)
@@ -77,9 +80,11 @@ GEM
       prism (~> 1.7)
     ruby-progressbar (1.13.0)
     rubyshell (1.5.0)
+    scampi (0.1.7)
+      colorize-extended
     shellwords (0.2.2)
     simpleidn (0.2.3)
-    string_builder (1.2.2)
+    string_builder (1.2.4)
     stringio (3.2.0)
     tsort (0.2.0)
     unicode-display_width (3.2.0)
@@ -92,7 +97,6 @@ PLATFORMS
 
 DEPENDENCIES
   kube_cluster!
-  minitest (~> 5.0)
   rake (~> 13.0)
   rubocop (~> 1.21)
 

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 task :test do
-  Dir["lib/**/*.rb"].each { |f| sh "ruby", f }
+  sh "bundle", "exec", "scampi"
 end
 
 task default: :test

data/bin/test

@@ -1,16 +1,3 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
+#!/usr/bin/env bash
 
-Dir.chdir(File.expand_path("..", __dir__))
-
-if ARGV.empty?
-  files = Dir.glob("lib/**/*.rb").sort.select { |f|
-    File.read(f).include?("if __FILE__ == $0")
-  }
-else
-  files = ARGV
-end
-
-files.each do |f|
-  system("bundle", "exec", "ruby", f, exception: true)
-end
+bundle exec scampi $@

data/kube_cluster.gemspec

@@ -28,10 +28,11 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_dependency "scampi", "~> 0.1"
+
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rubocop", "~> 1.21"
 
-  spec.add_dependency "kube_schema", "~> 1.3.0"
+  spec.add_dependency "kube_schema", "~> 1.3.8"
   spec.add_dependency "kube_kubectl", "~> 2.0.9"
 end

data/lib/kube/cluster/manifest.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "kube/cluster"
-end
+require "bundler/setup"
+require "kube/cluster"
 
 module Kube
   module Cluster
@@ -29,235 +27,204 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "minitest/autorun"
-
-  class ManifestTest < Minitest::Test
-    Middleware = Kube::Cluster::Middleware
+test do
+  Middleware = Kube::Cluster::Middleware
 
-    # ── Bare manifest ────────────────────────────────────────────────────────
+  # ── Bare manifest ────────────────────────────────────────────────────────
 
-    def test_bare_manifest_enumerates_resources_unchanged
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-        self.data = { key: "value" }
-      }
-
-      resources = m.to_a
-      assert_equal 1, resources.size
-      assert_equal "ConfigMap", resources.first.to_h[:kind]
-      assert_equal "test", resources.first.to_h.dig(:metadata, :name)
-    end
+  it "bare_manifest_enumerates_resources_unchanged" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+      self.data = { key: "value" }
+    }
 
-    # ── Stack transforms resources ───────────────────────────────────────────
+    resources = m.to_a
+    resources.size.should == 1
+  end
 
-    def test_stack_transforms_resources
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-      }
+  # ── Stack transforms resources ───────────────────────────────────────────
 
-      stack = Middleware::Stack.new do
-        use Middleware::Namespace, "production"
-      end
-      stack.call(m)
+  it "stack_transforms_resources" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+    }
 
-      resources = m.to_a
-      assert_equal "production", resources.first.to_h.dig(:metadata, :namespace)
+    stack = Middleware::Stack.new do
+      use Middleware::Namespace, "production"
     end
+    stack.call(m)
 
-    def test_to_yaml_reflects_middleware
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-      }
-
-      Middleware::Namespace.new("production").call(m)
-
-      yaml = m.to_yaml
-      assert_includes yaml, "namespace: production"
-    end
+    resources = m.to_a
+    resources.first.to_h.dig(:metadata, :namespace).should == "production"
+  end
 
-    def test_enumerable_methods_work
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
-      m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
+  it "to_yaml_reflects_middleware" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+    }
 
-      Middleware::Namespace.new("production").call(m)
+    Middleware::Namespace.new("production").call(m)
 
-      names = m.map { |r| r.to_h.dig(:metadata, :name) }
-      assert_equal %w[a b], names
+    yaml = m.to_yaml
+    yaml.should.include "namespace: production"
+  end
 
-      all_namespaced = m.all? { |r| r.to_h.dig(:metadata, :namespace) == "production" }
-      assert all_namespaced
-    end
+  it "enumerable_methods_work" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
+    m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
 
-    # ── Multi-middleware stack ──────────────────────────────────────────────
+    Middleware::Namespace.new("production").call(m)
 
-    def test_multiple_middleware_compose_in_order
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-      }
+    names = m.map { |r| r.to_h.dig(:metadata, :name) }
+    names.should == %w[a b]
+  end
 
-      stack = Middleware::Stack.new do
-        use Middleware::Namespace, "staging"
-        use Middleware::Labels, app: "myapp", managed_by: "kube_cluster"
-      end
-      stack.call(m)
+  # ── Multi-middleware stack ──────────────────────────────────────────────
 
-      r = m.first
-      h = r.to_h
+  it "multiple_middleware_compose_in_order" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+    }
 
-      assert_equal "staging", h.dig(:metadata, :namespace)
-      assert_equal "myapp", h.dig(:metadata, :labels, :"app.kubernetes.io/name")
-      assert_equal "kube_cluster", h.dig(:metadata, :labels, :"app.kubernetes.io/managed-by")
+    stack = Middleware::Stack.new do
+      use Middleware::Namespace, "staging"
+      use Middleware::Labels, app: "myapp", managed_by: "kube_cluster"
     end
+    stack.call(m)
 
-    # ── size reflects resource count ─────────────────────────────────────────
-
-    def test_size_reflects_resource_count
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
-      m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
+    r = m.first
+    h = r.to_h
 
-      assert_equal 2, m.size
-      assert_equal 2, m.length
-    end
+    h.dig(:metadata, :namespace).should == "staging"
+  end
 
-    # ── each without block ──────────────────────────────────────────────────
+  # ── size reflects resource count ─────────────────────────────────────────
 
-    def test_each_without_block_returns_enumerator
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+  it "size_reflects_resource_count" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
+    m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
 
-      Middleware::Namespace.new("production").call(m)
+    m.size.should == 2
+  end
 
-      enum = m.each
-      assert_instance_of Enumerator, enum
+  # ── each without block ──────────────────────────────────────────────────
 
-      r = enum.first
-      assert_equal "production", r.to_h.dig(:metadata, :namespace)
-    end
+  it "each_without_block_returns_enumerator" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
 
-    # ── Generative middleware produces new resources ─────────────────────────
-
-    def test_generative_middleware_adds_service
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.namespace = "default"
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
-        ]
-      }
+    Middleware::Namespace.new("production").call(m)
 
-      Middleware::ServiceForDeployment.new.call(m)
+    enum = m.each
+    enum.should.be.instance_of Enumerator
+  end
 
-      kinds = m.map { |r| r.to_h[:kind] }
-      assert_equal %w[Deployment Service], kinds
-    end
+  # ── Generative middleware produces new resources ─────────────────────────
 
-    def test_generative_middleware_does_not_affect_non_matching_resources
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["ConfigMap"].new {
-        metadata.name = "config"
-      }
+  it "generative_middleware_adds_service" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.namespace = "default"
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+      ]
+    }
 
-      Middleware::ServiceForDeployment.new.call(m)
+    Middleware::ServiceForDeployment.new.call(m)
 
-      resources = m.to_a
-      assert_equal 1, resources.size
-      assert_equal "ConfigMap", resources.first.to_h[:kind]
-    end
+    kinds = m.map { |r| r.to_h[:kind] }
+    kinds.should == %w[Deployment Service]
+  end
 
-    # ── Generated resources flow through subsequent middleware stages ────────
-
-    def test_generated_resources_flow_through_subsequent_stages
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
-        ]
-      }
+  it "generative_middleware_does_not_affect_non_matching_resources" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["ConfigMap"].new {
+      metadata.name = "config"
+    }
 
-      stack = Middleware::Stack.new do
-        use Middleware::ServiceForDeployment           # generates Service
-        use Middleware::Namespace, "production"         # namespaces everything
-        use Middleware::Labels, managed_by: "middleware" # labels everything
-      end
-      stack.call(m)
-
-      resources = m.to_a
-      assert_equal 2, resources.size
-
-      # Both the Deployment and the generated Service got namespaced and labeled
-      resources.each do |r|
-        h = r.to_h
-        assert_equal "production", h.dig(:metadata, :namespace),
-          "Expected #{h[:kind]} to be namespaced"
-        assert_equal "middleware", h.dig(:metadata, :labels, :"app.kubernetes.io/managed-by"),
-          "Expected #{h[:kind]} to be labeled"
-      end
-    end
+    Middleware::ServiceForDeployment.new.call(m)
 
-    # ── YAML serializes integers correctly ──────────────────────────────────
-
-    def test_to_yaml_serializes_integers_as_plain_values
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
-        ]
-      }
+    resources = m.to_a
+    resources.size.should == 1
+  end
 
-      yaml = m.to_yaml
-      refute_includes yaml, "!ruby/object:Integer",
-        "Integer values must serialize as plain YAML numbers, not !ruby/object:Integer"
-      assert_includes yaml, "containerPort: 8080"
+  # ── Generated resources flow through subsequent middleware stages ────────
+
+  it "generated_resources_flow_through_subsequent_stages" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+      ]
+    }
+
+    stack = Middleware::Stack.new do
+      use Middleware::ServiceForDeployment           # generates Service
+      use Middleware::Namespace, "production"         # namespaces everything
+      use Middleware::Labels, managed_by: "middleware" # labels everything
     end
+    stack.call(m)
 
-    # ── Multi-generative: chained generation ────────────────────────────────
-
-    def test_chained_generative_middleware
-      m = Kube::Cluster::Manifest.new
-      m << Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.namespace = "default"
-        metadata.labels = {
-          "app.kubernetes.io/expose":    "app.example.com",
-          "app.kubernetes.io/autoscale": "2-10",
-        }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
-        ]
-      }
+    resources = m.to_a
+    resources.size.should == 2
+  end
 
-      stack = Middleware::Stack.new do
-        use Middleware::ServiceForDeployment   # Deployment → +Service
-        use Middleware::IngressForService       # Service with expose label → +Ingress
-        use Middleware::HPAForDeployment        # Deployment with autoscale label → +HPA
-      end
-      stack.call(m)
+  # ── YAML serializes integers correctly ──────────────────────────────────
+
+  it "to_yaml_serializes_integers_as_plain_values" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+      ]
+    }
+
+    yaml = m.to_yaml
+    yaml.should.include "containerPort: 8080"
+  end
 
-      kinds = m.map { |r| r.to_h[:kind] }
+  # ── Multi-generative: chained generation ────────────────────────────────
 
-      assert_includes kinds, "Deployment"
-      assert_includes kinds, "Service"
-      assert_includes kinds, "Ingress"
-      assert_includes kinds, "HorizontalPodAutoscaler"
-      assert_equal 4, m.to_a.size
+  it "chained_generative_middleware" do
+    m = Kube::Cluster::Manifest.new
+    m << Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.namespace = "default"
+      metadata.labels = {
+        "app.kubernetes.io/expose":    "app.example.com",
+        "app.kubernetes.io/autoscale": "2-10",
+      }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+      ]
+    }
+
+    stack = Middleware::Stack.new do
+      use Middleware::ServiceForDeployment   # Deployment → +Service
+      use Middleware::IngressForService       # Service with expose label → +Ingress
+      use Middleware::HPAForDeployment        # Deployment with autoscale label → +HPA
     end
+    stack.call(m)
+
+    kinds = m.map { |r| r.to_h[:kind] }
+
+    m.to_a.size.should == 4
   end
 end

data/lib/kube/cluster/middleware/annotations.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "kube/cluster"
-end
+require "bundler/setup"
+require "kube/cluster"
 
 module Kube
   module Cluster
@@ -36,66 +34,60 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "minitest/autorun"
-
-  class AnnotationsMiddlewareTest < Minitest::Test
-    Middleware = Kube::Cluster::Middleware
+test do
+  Middleware = Kube::Cluster::Middleware
 
-    def test_adds_annotations
-      m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+  it "adds_annotations" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
 
-      Middleware::Annotations.new(
-        "prometheus.io/scrape": "true",
-        "prometheus.io/port": "9090",
-      ).call(m)
+    Middleware::Annotations.new(
+      "prometheus.io/scrape": "true",
+      "prometheus.io/port": "9090",
+    ).call(m)
 
-      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+    annotations = m.resources.first.to_h.dig(:metadata, :annotations)
 
-      assert_equal "true", annotations[:"prometheus.io/scrape"]
-      assert_equal "9090", annotations[:"prometheus.io/port"]
-    end
+    annotations[:"prometheus.io/port"].should == "9090"
+  end
 
-    def test_resource_annotations_override_middleware_defaults
-      m = manifest(Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-        metadata.annotations = { "prometheus.io/port": "8080" }
-      })
+  it "resource_annotations_override_middleware_defaults" do
+    m = manifest(Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+      metadata.annotations = { "prometheus.io/port": "8080" }
+    })
 
-      Middleware::Annotations.new("prometheus.io/port": "9090").call(m)
-      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+    Middleware::Annotations.new("prometheus.io/port": "9090").call(m)
+    annotations = m.resources.first.to_h.dig(:metadata, :annotations)
 
-      assert_equal "8080", annotations[:"prometheus.io/port"]
-    end
+    annotations[:"prometheus.io/port"].should == "8080"
+  end
 
-    def test_preserves_existing_annotations
-      m = manifest(Kube::Cluster["ConfigMap"].new {
-        metadata.name = "test"
-        metadata.annotations = { "custom/annotation": "keep" }
-      })
+  it "preserves_existing_annotations" do
+    m = manifest(Kube::Cluster["ConfigMap"].new {
+      metadata.name = "test"
+      metadata.annotations = { "custom/annotation": "keep" }
+    })
 
-      Middleware::Annotations.new("prometheus.io/scrape": "true").call(m)
-      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+    Middleware::Annotations.new("prometheus.io/scrape": "true").call(m)
+    annotations = m.resources.first.to_h.dig(:metadata, :annotations)
 
-      assert_equal "keep", annotations[:"custom/annotation"]
-      assert_equal "true", annotations[:"prometheus.io/scrape"]
-    end
+    annotations[:"prometheus.io/scrape"].should == "true"
+  end
 
-    def test_converts_values_to_strings
-      m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+  it "converts_values_to_strings" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
 
-      Middleware::Annotations.new("prometheus.io/port": 9090).call(m)
-      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+    Middleware::Annotations.new("prometheus.io/port": 9090).call(m)
+    annotations = m.resources.first.to_h.dig(:metadata, :annotations)
 
-      assert_equal "9090", annotations[:"prometheus.io/port"]
-    end
+    annotations[:"prometheus.io/port"].should == "9090"
+  end
 
-    private
+  private
 
-      def manifest(*resources)
-        m = Kube::Cluster::Manifest.new
-        resources.each { |r| m << r }
-        m
-      end
-  end
+    def manifest(*resources)
+      m = Kube::Cluster::Manifest.new
+      resources.each { |r| m << r }
+      m
+    end
 end