equilibrium 0.1.0

data/lib/equilibrium/cli.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require_relative "../equilibrium"
+require_relative "schema_validator"
+require_relative "schemas/expected_actual"
+require_relative "summary_formatter"
+
+module Equilibrium
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "analyze", "Compare expected vs actual tags and generate remediation plan"
+    option :expected, type: :string, required: true, desc: "Expected tags JSON file"
+    option :actual, type: :string, required: true, desc: "Actual tags JSON file"
+    option :registry, type: :string, desc: "Repository URL for output"
+    option :format, type: :string, default: "summary", enum: ["json", "summary"], desc: "Output format"
+    def analyze
+      # Load and validate data files
+      expected_data = load_and_validate_json_file(options[:expected])
+      actual_data = load_and_validate_json_file(options[:actual])
+
+      analyzer = Analyzer.new
+      analysis = analyzer.analyze(expected_data, actual_data)
+
+      case options[:format]
+      when "json"
+        puts JSON.pretty_generate(analysis)
+      when "summary"
+        formatter = SummaryFormatter.new
+        formatter.print_analysis_summary(analysis)
+      end
+    rescue => e
+      error_and_exit(e.message)
+    end
+
+    desc "expected REPOSITORY_URL", "Output expected mutable tags to stdout"
+    option :format, type: :string, default: "summary", enum: ["json", "summary"], desc: "Output format"
+    def expected(registry)
+      client = RegistryClient.new
+      processor = TagProcessor.new
+
+      full_repository_url = validate_repository_url(registry)
+      all_tags = client.list_tags(full_repository_url)
+      semantic_tags = processor.filter_semantic_tags(all_tags)
+      virtual_tags_result = processor.compute_virtual_tags(semantic_tags)
+
+      # Extract repository name from URL
+      repository_name = extract_repository_name(full_repository_url)
+
+      output = {
+        "repository_url" => full_repository_url,
+        "repository_name" => repository_name,
+        "digests" => virtual_tags_result["digests"],
+        "canonical_versions" => virtual_tags_result["canonical_versions"]
+      }
+
+      # Validate output against schema before writing
+      validate_expected_actual_schema(output)
+
+      case options[:format]
+      when "json"
+        puts JSON.pretty_generate(output)
+      when "summary"
+        formatter = SummaryFormatter.new
+        formatter.print_tags_summary(output, "expected")
+      end
+    rescue Thor::Error
+      raise  # Let Thor::Error bubble up for validation errors
+    rescue RegistryClient::Error => e
+      raise StandardError, e.message  # Convert for test compatibility
+    rescue => e
+      error_and_exit(e.message)
+    end
+
+    desc "actual REPOSITORY_URL", "Output actual mutable tags to stdout"
+    option :format, type: :string, default: "summary", enum: ["json", "summary"], desc: "Output format"
+    def actual(registry)
+      client = RegistryClient.new
+      processor = TagProcessor.new
+
+      full_repository_url = validate_repository_url(registry)
+      all_tags = client.list_tags(full_repository_url)
+      mutable_tags = processor.filter_mutable_tags(all_tags)
+
+      # Get semantic tags to create canonical mapping for actual mutable tags
+      semantic_tags = processor.filter_semantic_tags(all_tags)
+      canonical_versions = {}
+
+      # For each actual mutable tag, find its canonical version by digest matching
+      mutable_tags.each do |mutable_tag, digest|
+        # Find semantic tag with same digest
+        canonical_version = semantic_tags.find { |_, sem_digest| sem_digest == digest }&.first
+        canonical_versions[mutable_tag] = canonical_version if canonical_version
+      end
+
+      # Extract repository name from URL
+      repository_name = extract_repository_name(full_repository_url)
+
+      output = {
+        "repository_url" => full_repository_url,
+        "repository_name" => repository_name,
+        "digests" => mutable_tags,
+        "canonical_versions" => canonical_versions
+      }
+
+      # Validate output against schema before writing
+      validate_expected_actual_schema(output)
+
+      case options[:format]
+      when "json"
+        puts JSON.pretty_generate(output)
+      when "summary"
+        formatter = SummaryFormatter.new
+        formatter.print_tags_summary(output, "actual")
+      end
+    rescue Thor::Error
+      raise  # Let Thor::Error bubble up for validation errors
+    rescue RegistryClient::Error => e
+      raise StandardError, e.message  # Convert for test compatibility
+    rescue => e
+      error_and_exit(e.message)
+    end
+
+    desc "catalog [FILE]", "Convert expected tags JSON to catalog format (reads from file or stdin)"
+    def catalog(file_path = nil)
+      # Read from file or stdin
+      if file_path
+        unless File.exist?(file_path)
+          error_and_exit("File not found: #{file_path}")
+        end
+        input = File.read(file_path).strip
+      else
+        input = $stdin.read.strip
+        if input.empty?
+          error_and_exit("No input provided. Use: equilibrium expected registry | equilibrium catalog")
+        end
+      end
+
+      data = JSON.parse(input)
+
+      # Validate against expected/actual schema
+      validate_expected_actual_schema(data)
+
+      builder = CatalogBuilder.new
+      catalog = builder.build_catalog(data)
+
+      puts JSON.pretty_generate(catalog)
+    rescue JSON::ParserError => e
+      error_and_exit("Invalid JSON input: #{e.message}")
+    rescue => e
+      error_and_exit(e.message)
+    end
+
+    desc "version", "Show version information"
+    def version
+      say "Equilibrium v#{Equilibrium::VERSION}"
+      say "Container tag validation tool"
+    end
+
+    private
+
+    def load_and_validate_json_file(file_path)
+      unless File.exist?(file_path)
+        raise "File not found: #{file_path}"
+      end
+
+      data = JSON.parse(File.read(file_path))
+      validate_expected_actual_schema(data)
+      data
+    rescue JSON::ParserError => e
+      raise "Invalid JSON in #{file_path}: #{e.message}"
+    end
+
+    def validate_repository_url(repository_url)
+      # Repository URL must include registry host, project/namespace, and image name
+      # Format: [REGISTRY_HOST]/[PROJECT_OR_NAMESPACE]/[IMAGE_NAME]
+      unless repository_url.include?("/")
+        raise Thor::Error, "Repository URL must be full format (e.g., 'gcr.io/project-id/image-name'), not '#{repository_url}'"
+      end
+
+      repository_url
+    end
+
+    def extract_repository_name(repository_url)
+      # Extract repository name from repository URL
+      # Examples:
+      #   gcr.io/project-id/repository-name -> repository-name
+      #   registry.com/namespace/repository-name -> repository-name
+      repository_url.split("/").last
+    end
+
+    def validate_expected_actual_schema(data)
+      SchemaValidator.validate!(data, Equilibrium::Schemas::EXPECTED_ACTUAL, error_prefix: "Schema validation failed")
+    rescue SchemaValidator::ValidationError => e
+      error_and_exit(e.message)
+    end
+
+    def error_and_exit(message, usage = nil)
+      error message
+      if usage
+        say usage, :red
+      end
+      exit 1
+    end
+  end
+end

data/lib/equilibrium/registry_client.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+require "net/http"
+require_relative "schema_validator"
+require_relative "schemas/registry_api"
+
+module Equilibrium
+  # Registry client for Docker Registry v2 API
+  #
+  # Supports fetching container image tags from various registry providers.
+  # Currently designed for registries that allow anonymous access (like public GCR).
+  #
+  # Google Container Registry (GCR) Pros and Cons:
+  # ✅ Pros: Simple anonymous access for public repos, provides digest info via non-standard 'manifest' field
+  # ❌ Cons: Being deprecated in favor of Artifact Registry, non-standard API extensions may not be portable
+  #
+  # Other registries require complex authentication and don't provide manifest field,
+  # making it difficult to get digest information without separate API calls per tag:
+  # - GitHub Container Registry (GHCR): Requires Bearer token auth
+  # - Docker Hub: Requires token exchange auth flow
+  # - AWS ECR Public: Requires AWS credentials even for public repos
+  #
+  # Note: The 'manifest' field in responses is a non-standard extension only provided
+  # by some registries (like GCR). Most registries follow the Docker Registry v2 spec
+  # which only returns 'name' and 'tags' fields. To get digest information, separate
+  # calls to /v2/<name>/manifests/<tag> are required per the official specification.
+  class RegistryClient
+    class Error < StandardError; end
+
+    def list_tags(registry)
+      url = build_api_url(registry)
+      data = fetch_tags_data(url)
+      parse_response(data)
+    end
+
+    private
+
+    def build_api_url(registry)
+      parts = registry.split("/")
+      raise Error, "Invalid GCR registry format: #{registry}" if parts.length < 3
+
+      host, project, *image = parts
+
+      "https://#{host}/v2/#{project}/#{image.join("/")}/tags/list"
+    end
+
+    def fetch_tags_data(url)
+      uri = URI(url)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.read_timeout = 30
+      http.open_timeout = 10
+
+      response = http.request(Net::HTTP::Get.new(uri))
+
+      raise Error, "API request failed: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      validate_registry_response(data)
+      data
+    rescue JSON::ParserError => e
+      raise Error, "Invalid JSON response: #{e.message}"
+    rescue => e
+      raise Error, "Request failed: #{e.message}"
+    end
+
+    def validate_registry_response(data)
+      SchemaValidator.validate!(data, Equilibrium::Schemas::REGISTRY_API_RESPONSE, error_prefix: "Registry API response validation failed")
+    rescue SchemaValidator::ValidationError => e
+      raise Error, e.message
+    end
+
+    def parse_response(data)
+      # Data is already validated by schema, safe to process
+      tags = data["tags"]
+
+      # The 'manifest' field is a non-standard extension provided by some registries (like GCR)
+      # Most registries (GHCR, Docker Hub, ECR) only return 'name' and 'tags' per Docker Registry v2 spec
+      # When manifest data is missing, digest information is not available from the tags endpoint
+      tag_to_digest = build_digest_mapping(data["manifest"] || {})
+
+      tags.each_with_object({}) do |tag, result|
+        # Map tags to their digests. For registries without manifest data, digest will be nil
+        # This is expected behavior - digest info requires separate manifest API calls per tag
+        result[tag] = tag_to_digest[tag]
+      end
+    end
+
+    def build_digest_mapping(manifests)
+      # Build mapping from tag names to their SHA256 digests
+      # Only works when registry provides non-standard 'manifest' field in tags response
+      manifests.each_with_object({}) do |(digest, manifest_info), mapping|
+        tags = manifest_info["tag"]
+        tags.each { |tag| mapping[tag] = digest }
+      end
+    end
+  end
+end

data/lib/equilibrium/schema_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json_schemer"
+
+module Equilibrium
+  # Reusable schema validation utility
+  # Centralizes JSON Schema validation logic across the application
+  class SchemaValidator
+    class ValidationError < StandardError; end
+
+    # Validates data against a JSON Schema
+    # @param data [Hash] The data to validate
+    # @param schema [Hash] The JSON Schema to validate against
+    # @param error_prefix [String] Prefix for error messages (optional)
+    # @raise [ValidationError] If validation fails
+    def self.validate!(data, schema, error_prefix: "Schema validation failed")
+      schemer = JSONSchemer.schema(schema)
+      errors = schemer.validate(data).to_a
+
+      return if errors.empty?
+
+      error_messages = errors.map do |error|
+        "#{error["data_pointer"]}: #{error["details"] || error["error"]}"
+      end
+
+      raise ValidationError, "#{error_prefix}:\n#{error_messages.join("\n")}"
+    end
+  end
+end

data/lib/equilibrium/schemas/analyzer_output.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Equilibrium
+  module Schemas
+    # JSON Schema for analyzer output format
+    # Used by `equilibrium analyze --format=json` command
+    #
+    # Example output (perfect equilibrium):
+    # {
+    #   "repository_url": "gcr.io/datadoghq/apm-inject",
+    #   "expected_count": 28,
+    #   "actual_count": 28,
+    #   "missing_tags": {},
+    #   "unexpected_tags": {},
+    #   "mismatched_tags": {},
+    #   "status": "perfect",
+    #   "remediation_plan": []
+    # }
+    #
+    # Example output (requires remediation):
+    # {
+    #   "repository_url": "gcr.io/datadoghq/example",
+    #   "expected_count": 3,
+    #   "actual_count": 2,
+    #   "missing_tags": {
+    #     "latest": "sha256:abc123ef456789..."
+    #   },
+    #   "unexpected_tags": {
+    #     "dev": "sha256:xyz789ab123456..."
+    #   },
+    #   "mismatched_tags": {
+    #     "0.1": {
+    #       "expected": "sha256:def456ab789123...",
+    #       "actual": "sha256:old123ef456789..."
+    #     }
+    #   },
+    #   "status": "missing_tags",
+    #   "remediation_plan": [
+    #     {
+    #       "action": "create_tag",
+    #       "tag": "latest",
+    #       "digest": "sha256:abc123ef456789...",
+    #       "command": "gcloud container images add-tag gcr.io/datadoghq/example@sha256:abc123... gcr.io/datadoghq/example:latest"
+    #     }
+    #   ]
+    # }
+    ANALYZER_OUTPUT = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "title" => "Equilibrium Analyzer Output Schema",
+      "description" => "Schema for output from 'equilibrium analyze --format=json' command",
+      "type" => "object",
+      "required" => ["repository_url", "expected_count", "actual_count", "missing_tags", "unexpected_tags", "mismatched_tags", "status", "remediation_plan"],
+      "properties" => {
+        "repository_url" => {"type" => "string"},
+        "expected_count" => {"type" => "integer", "minimum" => 0},
+        "actual_count" => {"type" => "integer", "minimum" => 0},
+        "status" => {"enum" => ["perfect", "missing_tags", "mismatched", "extra_tags"]},
+        "missing_tags" => {
+          "type" => "object",
+          "patternProperties" => {
+            ".*" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"}
+          }
+        },
+        "unexpected_tags" => {
+          "type" => "object",
+          "patternProperties" => {
+            ".*" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"}
+          }
+        },
+        "mismatched_tags" => {
+          "type" => "object",
+          "patternProperties" => {
+            ".*" => {
+              "type" => "object",
+              "required" => ["expected", "actual"],
+              "properties" => {
+                "expected" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"},
+                "actual" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"}
+              }
+            }
+          }
+        },
+        "remediation_plan" => {
+          "type" => "array",
+          "items" => {
+            "type" => "object",
+            "required" => ["action", "tag", "command"],
+            "properties" => {
+              "action" => {"enum" => ["create_tag", "update_tag", "remove_tag"]},
+              "tag" => {"type" => "string"},
+              "digest" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"},
+              "old_digest" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"},
+              "new_digest" => {"type" => "string", "pattern" => "^sha256:[a-f0-9]{64}$"},
+              "command" => {"type" => "string"}
+            }
+          }
+        }
+      }
+    }.freeze
+  end
+end

data/lib/equilibrium/schemas/catalog.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Equilibrium
+  module Schemas
+    # JSON Schema for catalog output format
+    # Used by `equilibrium catalog` command
+    #
+    # Example output:
+    # {
+    #   "images": [
+    #     {
+    #       "name": "apm-inject",
+    #       "tag": "latest",
+    #       "digest": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #       "canonical_version": "0.43.2"
+    #     },
+    #     {
+    #       "name": "apm-inject",
+    #       "tag": "0",
+    #       "digest": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #       "canonical_version": "0.43.2"
+    #     },
+    #     {
+    #       "name": "apm-inject",
+    #       "tag": "0.43",
+    #       "digest": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #       "canonical_version": "0.43.1"
+    #     }
+    #   ]
+    # }
+    CATALOG = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "title" => "Tag Resolver Schema",
+      "description" => "Schema for Resolve tag",
+      "type" => "object",
+      "properties" => {
+        "images" => {
+          "type" => "array",
+          "items" => {
+            "type" => "object",
+            "required" => [
+              "name",
+              "tag",
+              "digest",
+              "canonical_version"
+            ],
+            "properties" => {
+              "name" => {
+                "type" => "string",
+                "description" => "The name of the image"
+              },
+              "tag" => {
+                "type" => "string",
+                "description" => "The mutable tag of the image"
+              },
+              "digest" => {
+                "type" => "string",
+                "description" => "The full digest of the image",
+                "pattern" => "^sha256:[a-f0-9]{64}$"
+              },
+              "canonical_version" => {
+                "type" => "string",
+                "description" => "The canonical semantic version for this mutable tag",
+                "pattern" => "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$"
+              }
+            },
+            "additionalProperties" => false
+          }
+        }
+      },
+      "additionalProperties" => false
+    }.freeze
+  end
+end

data/lib/equilibrium/schemas/expected_actual.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Equilibrium
+  module Schemas
+    # JSON Schema for expected/actual command output format
+    # Used by `equilibrium expected` and `equilibrium actual` commands
+    #
+    # Example output:
+    # {
+    #   "repository_url": "gcr.io/datadoghq/apm-inject",
+    #   "repository_name": "apm-inject",
+    #   "digests": {
+    #     "latest": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #     "0": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #     "0.43": "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c",
+    #     "0.42": "sha256:c7a822d271eb72e6c3bee2aaf579c8a3732eda9710d27effdca6beb3f5f63b0e"
+    #   },
+    #   "canonical_versions": {
+    #     "latest": "0.43.2",
+    #     "0": "0.43.2",
+    #     "0.43": "0.43.1",
+    #     "0.42": "0.42.3"
+    #   }
+    # }
+    EXPECTED_ACTUAL = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "title" => "Equilibrium Expected/Actual Output Schema",
+      "description" => "Schema for output from 'equilibrium expected' and 'equilibrium actual' commands",
+      "type" => "object",
+      "required" => ["repository_url", "repository_name", "digests", "canonical_versions"],
+      "properties" => {
+        "repository_url" => {
+          "type" => "string",
+          "description" => "Full repository URL (e.g., 'gcr.io/project-id/image-name', 'registry.example.com/namespace/repository')",
+          "minLength" => 1,
+          "pattern" => "^[a-zA-Z0-9.-]+(/[a-zA-Z0-9._-]+)*$"
+        },
+        "repository_name" => {
+          "type" => "string",
+          "description" => "Repository name extracted from URL (e.g., 'apm-inject')",
+          "minLength" => 1,
+          "pattern" => "^[a-zA-Z0-9._-]+$"
+        },
+        "digests" => {
+          "type" => "object",
+          "description" => "Mapping of mutable tags to their SHA256 digests",
+          "minProperties" => 1,
+          "patternProperties" => {
+            "^(latest|[0-9]+(\\.[0-9]+)*)$" => {
+              "type" => "string",
+              "description" => "SHA256 digest for the tag",
+              "pattern" => "^sha256:[a-f0-9]{64}$"
+            }
+          },
+          "additionalProperties" => false
+        },
+        "canonical_versions" => {
+          "type" => "object",
+          "description" => "Mapping of mutable tags to their canonical semantic versions",
+          "minProperties" => 1,
+          "patternProperties" => {
+            "^(latest|[0-9]+(\\.[0-9]+)*)$" => {
+              "type" => "string",
+              "description" => "Canonical semantic version for the mutable tag",
+              "pattern" => "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$"
+            }
+          },
+          "additionalProperties" => false
+        }
+      },
+      "additionalProperties" => false
+    }.freeze
+  end
+end

data/lib/equilibrium/schemas/registry_api.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Equilibrium
+  module Schemas
+    # JSON Schema for Docker Registry v2 API tags/list endpoint response
+    # Used by RegistryClient to validate API responses
+    # Endpoint: https://docs.docker.com/registry/spec/api/#listing-image-tags
+    #
+    # Example response:
+    # {
+    #   "name": "datadoghq/apm-inject",
+    #   "tags": ["0.42.0", "0.42.1", "0.43.0", "latest"],
+    #   "manifest": {
+    #     "sha256:5fcfe7ac14f6eeb0fe086ac7021d013d764af573b8c2d98113abf26b4d09b58c": {
+    #       "tag": ["latest", "0.43.0", "0"]
+    #     },
+    #     "sha256:c7a822d271eb72e6c3bee2aaf579c8a3732eda9710d27effdca6beb3f5f63b0e": {
+    #       "tag": ["0.42.1", "0.42"]
+    #     }
+    #   }
+    # }
+    REGISTRY_API_RESPONSE = {
+      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+      "title" => "Docker Registry v2 Tags List Response Schema",
+      "description" => "Schema for response from Docker Registry v2 API /v2/{name}/tags/list endpoint",
+      "type" => "object",
+      "required" => ["name", "tags"],
+      "properties" => {
+        "name" => {
+          "type" => "string",
+          "description" => "Repository name"
+        },
+        "tags" => {
+          "type" => "array",
+          "description" => "List of tag names",
+          "items" => {
+            "type" => "string"
+          }
+        },
+        "manifest" => {
+          "type" => "object",
+          "description" => "Manifest data mapping digests to tag metadata",
+          "patternProperties" => {
+            "^sha256:[a-f0-9]{64}$" => {
+              "type" => "object",
+              "properties" => {
+                "tag" => {
+                  "type" => "array",
+                  "items" => {
+                    "type" => "string"
+                  }
+                }
+              },
+              "additionalProperties" => true
+            }
+          },
+          "additionalProperties" => false
+        }
+      },
+      "additionalProperties" => true
+    }.freeze
+  end
+end

data/lib/equilibrium/semantic_version.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Equilibrium
+  module SemanticVersion
+    # Strictly validate MAJOR.MINOR.PATCH format where:
+    # - MAJOR, MINOR, PATCH are non-negative integers
+    # - No leading zeros (except for '0' itself)
+    # - No prefixes (like 'v1.2.3', 'release-1.2.3')
+    # - No suffixes (like '1.2.3-alpha', '1.2.3+build')
+    # - No prereleases (like '1.2.3-rc.1', '1.2.3-beta.2')
+    def self.valid?(tag)
+      # Strict regex: each component must be either '0' or a number without leading zeros
+      return false unless tag.match?(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/)
+
+      # Additional validation: ensure it's a valid Gem::Version
+      begin
+        Gem::Version.new(tag)
+        true
+      rescue ArgumentError
+        false
+      end
+    end
+  end
+end