ace-support-config 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 74836504f416d8c5df7893889c12e585be26efe4fd8888e0ab12822b3a89dee3
+  data.tar.gz: 32061d2ab3f3185f8534416bea5ee77a556247b7a877cc75387dbc7116e3739d
+SHA512:
+  metadata.gz: a06c49acfec49bdc87f26074ed6fd5a09250690a20fa69759eee4d31802576c52ae0c0bb0b9d676d40323e71ffe02640ad0d81bd05f39bd4a97004c1d25b4e89
+  data.tar.gz: 452c2e9b2e674cc8235dfbafd81a8cd0ab9844f7c4e737144b3244c5ecd1da12199037ac7eadbdb99cdc3edf1c4ecb69df31d4b7a3051047576a6ae85b733870

data/.ace-defaults/config/config.yml

@@ -0,0 +1,23 @@
+# ace-config default configuration
+# This file provides defaults for the ace-config gem itself
+
+config:
+  # Default configuration folder name
+  config_dir: ".ace"
+
+  # Default gem defaults folder name
+  defaults_dir: ".ace-defaults"
+
+  # Cascade settings
+  cascade:
+    enabled: true
+    merge_strategy: replace
+
+  # Default project root markers
+  project_markers:
+    - .git
+    - Gemfile
+    - package.json
+    - Cargo.toml
+    - pyproject.toml
+    - go.mod

data/CHANGELOG.md

@@ -0,0 +1,224 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.9.0] - 2026-03-23
+
+### Technical
+- Removed phantom `handbook/**/*` glob from gemspec (no handbook directory exists).
+
+## [0.8.5] - 2026-03-22
+
+### Technical
+- Updated README examples to use `resolve_file` instead of deprecated `resolve_for`.
+
+## [0.8.4] - 2026-03-22
+
+### Technical
+- Refreshed README structure with consistent tagline, corrected package naming, installation, basic usage, API overview, and ACE project footer
+
+## [0.8.3] - 2026-03-05
+
+### Technical
+- Document `ProjectConfigScanner` in README with molecule list and comparison table vs `ConfigFinder`
+
+## [0.8.2] - 2026-03-05
+
+### Fixed
+- Narrow `Errno::EACCES` rescue in `ProjectConfigScanner#find_ace_dirs` to per-path scope so a permission error on one directory does not abort the entire scan
+
+### Technical
+- Add test for graceful degradation when a subdirectory is permission-restricted
+
+## [0.8.1] - 2026-03-05
+
+### Fixed
+- Expand `SKIP_DIRS` in `ProjectConfigScanner` to include `.bundle`, `_legacy`, `.ace-local`, `.ace-tasks`, `.ace-taskflow` preventing false-positive config discovery in monorepo-ignored paths
+- Memoize `scan` results to avoid repeated full filesystem traversals on multiple calls
+- Deduplicate symlinked `.ace` directories using `File.realpath` tracking
+- Use portable positional flags form for `Dir.glob` (`File::FNM_DOTMATCH` as positional arg)
+
+## [0.8.0] - 2026-03-05
+
+### Added
+- `ProjectConfigScanner` molecule for downward project tree traversal to discover all `.ace` config folders across a monorepo
+
+## [0.7.2] - 2026-02-23
+
+### Technical
+- Updated internal dependency version constraints to current releases
+
+## [0.7.1] - 2026-02-12
+
+### Fixed
+- Stabilize performance test threshold for `resolve_namespace` overhead (2.0x → 3.0x) to reduce CI flakiness
+
+## [0.7.0] - 2026-01-27
+
+### Added
+- Path rules support for configuration resolution with glob pattern matching
+- Project scanning capability to discover nested package configurations
+- `PathRuleMatcher` atom for matching file paths against glob patterns
+- Support for glob arrays in path rules configuration
+
+### Changed
+- Enhanced `ConfigResolver` to support path-based configuration splitting
+- Refactored config resolution to enable scoped configuration per file path
+
+## [0.6.0] - 2026-01-11
+
+### Breaking Changes
+- **Gem renamed** from `ace-config` to `ace-support-config`
+- **Namespace changed** from `Ace::Config` to `Ace::Support::Config`
+- Update gemspec dependency from `ace-config ~> 0.5` to `ace-support-config ~> 0.6`
+- Update require statements from `require "ace/config"` to `require "ace/support/config"`
+- Update class references from `Ace::Config` to `Ace::Support::Config`
+
+### Migration Guide
+```ruby
+# Before
+require 'ace/config'
+config = Ace::Config.create
+Ace::Config.test_mode = true
+
+# After
+require 'ace/support/config'
+config = Ace::Support::Config.create
+Ace::Support::Config.test_mode = true
+```
+
+For gem maintainers:
+```ruby
+# In your gemspec, change:
+spec.add_dependency 'ace-config', '~> 0.5'
+# To:
+spec.add_dependency 'ace-support-config', '~> 0.6'
+
+# In your code, change:
+require 'ace/config'
+# To:
+require 'ace/support/config'
+
+# And update class references:
+Ace::Config.create → Ace::Support::Config.create
+Ace::Config.test_mode = → Ace::Support::Config.test_mode =
+```
+
+## [0.5.1] - 2026-01-05
+
+### Fixed
+- Stabilize performance tests and adjust thresholds for CI consistency
+- Improve command default behavior and fix flaky test
+
+## [0.5.0] - 2026-01-03
+
+### Changed
+- **BREAKING**: Minimum Ruby version raised to 3.3.0 (was 3.2.0)
+- Standardized gemspec file patterns with deterministic Dir.glob
+- Added MIT LICENSE file
+
+## [0.4.3] - 2026-01-03
+
+### Changed
+- Optimized performance test execution time from 11.77s to 1.64s (85% improvement)
+- Reduced loop iterations in performance tests (100-1000 → 10-50)
+- Reduced cascade depth from 5 to 2 levels for faster tests
+- Reduced file count from 50 to 10 in file-based tests
+- Extracted iteration count constants (CASCADE_ITERATIONS, GLOB_ITERATIONS, FINDER_ITERATIONS, TEST_MODE_ITERATIONS)
+- Implemented median-based timing metrics instead of average for robustness with small sample sizes
+- Added deep cascade correctness test to maintain coverage at depth 5
+
+### Technical
+- Added performance measurement helpers (`measure_iterations`, `median_time`, `format_time`)
+- Separated constants for I/O-bound vs CPU-bound operations tuning
+
+## [0.4.2] - 2026-01-02
+
+### Added
+- Test mode for faster test execution (`Ace::Config.test_mode = true`)
+- `ACE_CONFIG_TEST_MODE` environment variable for CI/test runner integration (case-insensitive)
+- `mock_config` parameter to `Ace::Config.create` for providing mock data in tests
+- `test_mode` parameter to `Ace::Config.create` for explicit test mode control
+- Thread-safe test mode state using `Thread.current` for parallel test environments
+- Test mode short-circuit in `resolve_type` and `find_configs` methods
+
+## [0.4.1] - 2025-12-31
+
+### Technical
+- Add comprehensive edge case and custom path tests (Task 157.10)
+
+## [0.4.0] - 2025-12-30
+
+### Added
+- `merge()` method on Config model as the primary method for merging configuration data
+- `with()` remains as an alias for backward compatibility
+
+## [0.3.0] - 2025-12-30
+
+### Added
+- `resolve_namespace(*segments, filename: "config")` method to ConfigResolver for simplified namespace-based config resolution
+  - Uses `File.join` for cross-platform path construction
+  - Sanitizes segments (flatten, compact, stringify, strip whitespace, reject empty)
+  - Documented in README and usage.md
+- Runtime dependency on `ace-support-fs` for filesystem utilities (PathExpander, ProjectRootFinder, DirectoryTraverser)
+- `class_get_env` class method on PathExpander for consistent ENV access pattern across class and instance methods
+- Documentation section on directory naming conventions (`.ace-defaults/` vs `.ace/` vs `.ace.example/`)
+- `glob_to_regex` now supports bracket character classes (`[a-z]`, `[abc]`)
+- Documentation for `resolve_for` clarifying it's intentionally not memoized
+- `Date` class to permitted YAML classes for parsing date values in config files
+
+### Changed
+- Reorganized ConfigResolver methods: all public methods grouped together before private section
+
+### Breaking Changes
+- None
+
+### Fixed
+- Gemfile.lock version mismatch (was 0.1.0, now correctly shows 0.2.0)
+
+## [0.2.0] - 2025-12-28
+
+### Added
+- Initial release of ace-config gem
+- Generic configuration cascade with customizable folder names
+- `Ace::Config.create` factory method for creating resolvers
+- `Ace::Config.virtual_resolver` factory method for virtual filesystem view
+- Configurable `config_dir` and `defaults_dir` parameters
+- Support for gem defaults via `gem_path` parameter
+- Deep merging with configurable array strategies (:replace, :concat, :union)
+- Project root detection with customizable markers
+- Path expansion with environment variable and protocol support
+- YAML parsing with error handling
+- Virtual config resolver for cascade filesystem view
+- Memoization for `resolve()` and `get()` methods in ConfigResolver
+- Windows compatibility via `File::ALT_SEPARATOR` support
+
+### Fixed
+- ConfigFinder uses stable `start_path` instead of mutable `Dir.pwd`
+- `find_file`/`find_all_files` now respect `use_traversal` parameter
+- YamlLoader `merge_strategy` parameter properly applied
+- PathExpander raises exception instead of returning error hash
+
+### Changed
+- Gemspec excludes `test/` directory from built gem
+- ENV access extracted to protected `get_env` method for testability
+
+### Components Extracted from ace-support-core
+- **Atoms**: DeepMerger, YamlParser, PathExpander
+- **Molecules**: ConfigFinder, DirectoryTraverser, ProjectRootFinder, YamlLoader
+- **Organisms**: ConfigResolver, VirtualConfigResolver
+- **Models**: Config, CascadePath
+- **Errors**: ConfigNotFoundError, YamlParseError, PathError, MergeStrategyError
+
+## [0.1.0] - 2025-12-28
+
+### Added
+- Initial gem structure
+- Public API design with `Ace::Config.create` factory
+- Full configuration cascade implementation
+- Zero runtime dependencies (stdlib only)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 ACE Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+<div align="center">
+  <h1> ACE - Support Config </h1>
+
+  Shared configuration cascade primitives for ACE libraries and tools.
+
+  <img src="https://raw.githubusercontent.com/cs3b/ace/main/docs/brand/AgenticCodingEnvironment.Logo.XS.jpg" alt="ACE Logo" width="480">
+  <br><br>
+
+  <a href="https://rubygems.org/gems/ace-support-config"><img alt="Gem Version" src="https://img.shields.io/gem/v/ace-support-config.svg" /></a>
+  <a href="https://www.ruby-lang.org"><img alt="Ruby" src="https://img.shields.io/badge/Ruby-3.2+-CC342D?logo=ruby" /></a>
+  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-blue.svg" /></a>
+
+</div>
+
+> Works with: Claude Code, Codex CLI, OpenCode, Gemini CLI, pi-agent, and more.
+
+[Usage Guide](docs/usage.md)
+`ace-support-config` provides layered configuration loading and merging for ACE, resolving values from `.ace` project files, user home defaults, and gem-bundled defaults with deterministic precedence. Used by [ace-llm](../ace-llm), [ace-search](../ace-search), [ace-review](../ace-review), and most other ACE packages.
+
+## How It Works
+
+1. A resolver builds a configuration cascade from the nearest `.ace` directory up to user-home and gem-default layers.
+2. Resolved values are merged using configurable merge strategies with deterministic precedence.
+3. Consumers access resolved config by namespace, file path, or direct lookup.
+
+## Use Cases
+
+**Load layered configuration safely** - combine project, user, and default values with deterministic precedence for any ACE package.
+
+**Support project-specific overrides** - place `.ace` files near the execution context to customize behavior while keeping defaults stable across tools like [ace-llm](../ace-llm) and [ace-review](../ace-review).
+
+**Resolve namespaces consistently** - access configuration across tools using shared resolver methods, so [ace-llm-providers-cli](../ace-llm-providers-cli) and [ace-search](../ace-search) get the same cascade behavior.
+
+---
+[Usage Guide](docs/usage.md) | Part of [ACE](https://github.com/cs3b/ace)

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+# Alias for CI compatibility
+task spec: :test
+
+task default: :test

data/lib/ace/support/config/atoms/deep_merger.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Config
+      module Atoms
+        # Pure deep merge functions for hashes
+        module DeepMerger
+          module_function
+
+          # Deep merge two hashes
+          #
+          # @param base [Hash] Base hash
+          # @param other [Hash] Hash to merge into base
+          # @param options [Hash] Merge options
+          # @option options [Symbol] :array_strategy How to handle arrays
+          #   :replace - Replace base array with overlay (default)
+          #   :concat - Concatenate arrays
+          #   :union - Set union (dedupe by value)
+          #   :coerce_union - Coerce scalars to arrays, union, filter blanks
+          # @return [Hash] Merged hash (new object)
+          #
+          # @note Uses shallow dup at top level (standard Ruby pattern). Nested hashes
+          #   are recursively merged into new objects, so mutation risk is minimal.
+          #   For a completely isolated deep copy, use: `merge({}, original_hash)`
+          def merge(base, other, options = {})
+            return other.dup if base.nil?
+            return base.dup if other.nil?
+
+            array_strategy = options[:array_strategy] || :replace
+
+            result = base.dup
+
+            other.each do |key, other_value|
+              base_value = result[key]
+
+              result[key] = if base_value.is_a?(Hash) && other_value.is_a?(Hash)
+                merge(base_value, other_value, options)
+              elsif array_strategy == :coerce_union
+                merge_with_coercion(base_value, other_value)
+              elsif base_value.is_a?(Array) && other_value.is_a?(Array)
+                merge_arrays(base_value, other_value, array_strategy)
+              else
+                other_value
+              end
+            end
+
+            result
+          end
+
+          # Deep merge multiple hashes in order
+          # @param hashes [Array<Hash>] Hashes to merge
+          # @param options [Hash] Merge options
+          # @return [Hash] Merged result
+          def merge_all(*hashes, **options)
+            hashes = hashes.flatten.compact
+            return {} if hashes.empty?
+
+            hashes.reduce({}) do |result, hash|
+              merge(result, hash, options)
+            end
+          end
+
+          # Check if value is mergeable
+          # @param value [Object] Value to check
+          # @return [Boolean] true if value can be deep merged
+          def mergeable?(value)
+            value.is_a?(Hash) || value.is_a?(Array)
+          end
+
+          # Merge two arrays based on strategy
+          # @param base_array [Array] Base array
+          # @param other_array [Array] Array to merge
+          # @param strategy [Symbol] Merge strategy
+          # @return [Array] Merged array
+          def merge_arrays(base_array, other_array, strategy)
+            case strategy
+            when :concat
+              base_array + other_array
+            when :union
+              base_array | other_array
+            when :replace
+              other_array
+            else
+              raise MergeStrategyError, "Unknown array merge strategy: #{strategy}"
+            end
+          end
+
+          # Merge values with scalar-to-array coercion for :coerce_union strategy
+          # @param base_value [Object] Base value (may be array, scalar, or nil)
+          # @param other_value [Object] Overlay value
+          # @return [Object] Merged result
+          def merge_with_coercion(base_value, other_value)
+            base_arr = coerce_to_array(base_value)
+            other_arr = coerce_to_array(other_value)
+
+            # New key with scalar: keep as scalar
+            return other_value if base_arr.nil? && !other_value.is_a?(Array)
+            # New key with array: normalize
+            return normalize_array(other_arr) if base_arr.nil?
+            # Existing key, new value nil: keep existing normalized
+            return normalize_array(base_arr) if other_arr.nil?
+
+            # Both have values: union and normalize
+            normalize_array(base_arr | other_arr)
+          end
+
+          # Coerce value to array if not nil
+          # @param value [Object] Value to coerce
+          # @return [Array, nil] Array or nil if value was nil
+          def coerce_to_array(value)
+            return nil if value.nil?
+            value.is_a?(Array) ? value : [value]
+          end
+
+          # Normalize array: remove nil/empty, deduplicate
+          # @param arr [Array] Array to normalize
+          # @return [Array] Normalized array
+          def normalize_array(arr)
+            arr.reject { |v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }.uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/config/atoms/path_rule_matcher.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Config
+      module Atoms
+        # Match file paths against path-based config rules
+        class PathRuleMatcher
+          MatchResult = Struct.new(:name, :config, keyword_init: true)
+
+          # @param path_rules [Hash] Path rules with optional _config_root metadata
+          # @param project_root [String, nil] Project root for relative path calculation
+          def initialize(path_rules, project_root: nil)
+            @path_rules = path_rules || {}
+            @project_root = project_root
+          end
+
+          # Match file path against configured rules
+          # @param file_path [String] File path relative to project root
+          # @return [MatchResult, nil] Match result or nil
+          def match(file_path)
+            return nil if @path_rules.nil? || @path_rules.empty?
+            return nil if file_path.nil? || file_path.to_s.empty?
+
+            normalized = normalize_path(file_path)
+
+            @path_rules.each do |name, rule|
+              next unless rule.is_a?(Hash)
+
+              glob = rule["glob"] || rule[:glob]
+              globs = Array(glob).compact.map(&:to_s).reject(&:empty?)
+              next if globs.empty?
+
+              # Calculate path relative to rule's config root
+              # Returns nil if file is outside config root's scope
+              path_to_match = path_relative_to_config(normalized, rule)
+              next if path_to_match.nil?
+
+              globs.each do |glob_pattern|
+                next unless File.fnmatch?(glob_pattern, path_to_match, match_flags(glob_pattern))
+
+                return MatchResult.new(
+                  name: name.to_s,
+                  config: extract_config(rule)
+                )
+              end
+            end
+
+            nil
+          end
+
+          private
+
+          def normalize_path(path)
+            path.to_s.sub(%r{\A\./}, "")
+          end
+
+          # Convert file path to be relative to the rule's config root
+          # @param file_path [String] Path relative to project root
+          # @param rule [Hash] Rule with optional _config_root
+          # @return [String, nil] Path relative to config root, or nil if file is outside scope
+          def path_relative_to_config(file_path, rule)
+            config_root = rule["_config_root"]
+            return file_path unless config_root && @project_root
+
+            # Config root is absolute, project root is absolute
+            # File path is relative to project root
+            # We need to make file path relative to config root
+            project_root_normalized = normalize_directory(@project_root)
+            config_root_normalized = normalize_directory(config_root)
+
+            # If config root equals project root, no adjustment needed
+            return file_path if config_root_normalized == project_root_normalized
+
+            # Get config root as relative path from project root
+            config_relative = relative_path(config_root_normalized, project_root_normalized)
+            return file_path if config_relative.nil? || config_relative.empty?
+
+            # If file path starts with config relative, strip it
+            # Otherwise, file is outside this config's scope - return nil to skip this rule
+            prefix = config_relative + "/"
+            if file_path.start_with?(prefix)
+              file_path.sub(prefix, "")
+            end
+          end
+
+          # Get relative path from base to target
+          def relative_path(target, base)
+            return nil if target == base
+            return nil unless target.start_with?(base + "/")
+
+            target.sub("#{base}/", "")
+          end
+
+          def normalize_directory(path)
+            File.expand_path(path.to_s)
+          end
+
+          def extract_config(rule)
+            rule.each_with_object({}) do |(key, value), acc|
+              # Skip internal metadata and glob
+              next if key.to_s == "glob"
+              next if key.to_s.start_with?("_")
+
+              acc[key.to_s] = value
+            end
+          end
+
+          def match_flags(glob)
+            flags = File::FNM_DOTMATCH | File::FNM_EXTGLOB
+            flags |= File::FNM_PATHNAME unless glob.to_s.include?("**")
+            flags
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/config/atoms/path_validator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Config
+      module Atoms
+        # Validates path segments for security
+        # Prevents path traversal attacks via ".." and absolute paths (Unix and Windows)
+        #
+        # This module provides pure validation functions that check path segments
+        # for potentially dangerous patterns without any side effects.
+        #
+        # @example Validate a namespace segment
+        #   PathValidator.validate_segment!("valid_name")  # => true
+        #   PathValidator.validate_segment!("..")          # => raises ArgumentError
+        #   PathValidator.validate_segment!("/absolute")   # => raises ArgumentError
+        #   PathValidator.validate_segment!("C:\\path")    # => raises ArgumentError
+        #
+        # @example Validate multiple segments
+        #   PathValidator.validate_segments!(["config", "nested", "file"])  # => true
+        #   PathValidator.validate_segments!(["config", "..", "secret"])    # => raises ArgumentError
+        #
+        module PathValidator
+          class << self
+            # Validate a single path segment for security
+            # @param segment [String] Segment to validate
+            # @raise [ArgumentError] If segment contains invalid characters
+            # @return [true] If validation passes
+            def validate_segment!(segment)
+              if segment.include?("..")
+                raise ArgumentError, "Invalid path segment: #{segment.inspect} (path traversal not allowed)"
+              end
+              if segment.start_with?("/")
+                raise ArgumentError, "Invalid path segment: #{segment.inspect} (absolute paths not allowed)"
+              end
+              # Windows-style absolute paths: drive letters (C:) or UNC paths (\\server)
+              if segment.start_with?("\\") || segment.match?(/\A[A-Za-z]:/)
+                raise ArgumentError, "Invalid path segment: #{segment.inspect} (absolute paths not allowed)"
+              end
+              true
+            end
+
+            # Validate multiple path segments for security
+            # @param segments [Array<String>] Segments to validate
+            # @raise [ArgumentError] If any segment contains invalid characters
+            # @return [true] If validation passes
+            def validate_segments!(segments)
+              segments.each { |segment| validate_segment!(segment) }
+              true
+            end
+
+            # Check if a segment is valid (non-raising version)
+            # @param segment [String] Segment to check
+            # @return [Boolean] true if valid, false otherwise
+            def valid_segment?(segment)
+              validate_segment!(segment)
+              true
+            rescue ArgumentError
+              false
+            end
+
+            # Check if all segments are valid (non-raising version)
+            # @param segments [Array<String>] Segments to check
+            # @return [Boolean] true if all valid, false otherwise
+            def valid_segments?(segments)
+              validate_segments!(segments)
+              true
+            rescue ArgumentError
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end