versionian 0.1.0

data/lib/versionian/schemes/pattern.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Versionian
+  module Schemes
+    class Pattern < VersionScheme
+      attr_reader :pattern, :pattern_regex
+
+      # Format template uses placeholders like {major}, {minor}, etc.
+      # Example: "{major}.{minor}.{patch}" or "{year}.{month}-{build}"
+
+      def initialize(name:, pattern:, component_definitions:, format_template: nil, description: nil)
+        # Process component_definitions first (convert hashes to ComponentDefinition objects)
+        processed_definitions = component_definitions.map do |d|
+          d.is_a?(Hash) ? ComponentDefinition.from_hash(d) : ComponentDefinition.new(**d)
+        end
+        validate_component_definitions!(processed_definitions)
+
+        # Derive or use provided format_template
+        template = format_template || derive_format_template(pattern)
+
+        # Call super with all parameters
+        super(
+          name: name,
+          description: description,
+          format_template: template,
+          component_definitions: processed_definitions
+        )
+
+        @pattern = pattern
+        @pattern_regex = compile_and_validate_pattern(pattern)
+      end
+
+      def validate_component_definitions!(definitions = @component_definitions)
+        raise Errors::InvalidSchemeError, "No component definitions provided" if definitions.empty?
+      end
+
+      def parse(version_string)
+        validate_version_string(version_string)
+
+        match = version_string.match(@pattern_regex)
+        raise Errors::ParseError, "Version '#{version_string}' does not match pattern #{@pattern}" unless match
+
+        components = extract_components(match)
+        validate_component_count(match.captures.length)
+
+        comparable_array = build_comparable_array(components)
+
+        VersionIdentifier.new(
+          raw_string: version_string,
+          scheme: self,
+          components: components,
+          comparable_array: comparable_array
+        )
+      end
+
+      def compare_arrays(a, b)
+        # Lexicographic comparison
+        max_len = [a.length, b.length].max
+        max_len.times do |i|
+          a_val = a[i]
+          b_val = b[i]
+
+          # Handle nil values (optional components)
+          a_val = 0 if a_val.nil?
+          b_val = 0 if b_val.nil?
+
+          cmp = a_val <=> b_val
+          return cmp if cmp != 0
+        end
+
+        a.length <=> b.length
+      end
+
+      def matches_range?(version_string, range)
+        version = parse(version_string)
+        comparable = version.comparable_array
+
+        case range.type
+        when :equals
+          comparable == parse(range.boundary).comparable_array
+        when :before
+          comparable < parse(range.boundary).comparable_array
+        when :after
+          comparable >= parse(range.boundary).comparable_array
+        when :between
+          comparable >= parse(range.from).comparable_array &&
+            comparable <= parse(range.to).comparable_array
+        end
+      end
+
+      def render(version)
+        # If no format template, return raw_string
+        return version.raw_string unless @format_template
+
+        # Reconstruct version from components using format template
+        # Format template supports optional segments with [] syntax
+        # Example: "{major}.{minor}.{patch}[.{patchlevel}]"
+        #          "{major}.{minor}.{patch}[-{stage}-{iteration}]"
+        result = @format_template.dup
+
+        # First, handle optional segments marked with []
+        # Process from innermost to outermost to handle nested optionals
+        loop do
+          # Find innermost optional segment
+          match = result.match(/\[([^\[\]]+)\]/)
+          break unless match
+
+          optional_segment = match[1]
+          placeholder = match[0]
+
+          # Check if any component placeholders in this segment have values
+          has_value = false
+          optional_segment.scan(/\{(\w+)\}/) do |component_name|
+            component = version.component(component_name.first.to_sym)
+            has_value = true if component
+          end
+
+          # Replace with content if has value, empty string otherwise
+          replacement = has_value ? optional_segment : ""
+          result = result.sub(placeholder, replacement)
+        end
+
+        # Then replace component values for all placeholders
+        @component_definitions.each do |comp_def|
+          component = version.component(comp_def.name)
+          type = ComponentTypes.resolve(comp_def.type)
+
+          # Build placeholder string, converting symbol name to string
+          placeholder = "{#{comp_def.name.to_s}}"
+
+          if component
+            formatted_value = type.format(component.value)
+            result = result.gsub(placeholder, formatted_value)
+          else
+            # Remove empty placeholder
+            result = result.gsub(placeholder, "")
+          end
+        end
+
+        # puts "After component replacement: #{result.inspect}"
+
+        # Clean up any remaining empty optional segment markers
+        # e.g., "[-{stage}-{iteration}]" where both stage and iteration are nil becomes "[-]"
+        result = result.gsub(/\[-\]/, "").gsub(/\[-/, "-").gsub(/-\]/, "-")
+
+        # Clean up any double separators or leading/trailing separators
+        result = result.gsub(/\.+/, ".").gsub(/^-/, "").gsub(/-$/, "").gsub(/^\.+/, "").gsub(/\.+$/, "")
+      end
+
+      private
+
+      def compile_and_validate_pattern(pattern_str)
+        # Basic ReDoS protection
+        # Check for dangerous patterns that can cause catastrophic backtracking
+        if pattern_str.include?("\\d+*") || pattern_str.include?('\d+*')
+          raise Errors::InvalidSchemeError, "Pattern may cause catastrophic backtracking"
+        end
+
+        if pattern_str =~ /\(\([^(]*\*\)[^)]*\*\)/ || pattern_str =~ /\(\([^(]*\+\)[^)]*\+\)/
+          raise Errors::InvalidSchemeError, "Pattern may cause catastrophic backtracking"
+        end
+
+        raise Errors::InvalidSchemeError, "Pattern has too many nested quantifiers" if pattern_str.scan(/\{/).length > 5
+
+        Regexp.new(pattern_str)
+      end
+
+      def derive_format_template(pattern_str)
+        # Derive format template from pattern by replacing capture groups with placeholders
+        # Pattern: ^(\d+)\.(\d+)\.(\d+)$ -> Format: {name1}.{name2}.{name3}
+
+        # Find all capture groups and their positions
+        pattern_str.gsub(/^\^|\$$/, "") # Remove anchors
+
+        # Replace each capture group with a placeholder
+        # We need to track which capture group corresponds to which component
+        # Since @component_definitions might not be set yet, we defer to a simpler approach
+
+        # For now, just store the pattern and use raw_string for rendering
+        # Users can provide explicit format_template if they want custom rendering
+        nil
+      end
+
+      def extract_components(match)
+        @component_definitions.each_with_index.map do |comp_def, index|
+          raw_value = match[index + 1] # Skip full match
+
+          # Handle optional components
+          if raw_value.nil?
+            next nil if comp_def.optional
+
+            # Skip optional components that didn't match
+
+            raise Errors::ParseError, "Required component '#{comp_def.name}' is missing"
+
+          end
+
+          type = ComponentTypes.resolve(comp_def.type)
+          parsed_value = type.parse(raw_value, comp_def)
+
+          VersionComponent.new(
+            name: comp_def.name,
+            type: comp_def.type,
+            value: parsed_value,
+            weight: comp_def.weight || 1,
+            values: comp_def.values,
+            order: comp_def.order || [],
+            definition: comp_def
+          )
+        end.compact # Remove nils from optional components
+      end
+
+      def build_comparable_array(components)
+        components.map do |component|
+          next if component.definition&.ignore_in_comparison
+
+          type = ComponentTypes.resolve(component.type)
+          type.to_comparable(component.value, component)
+        end.compact
+      end
+
+      def validate_component_count(capture_count)
+        # For patterns with optional components, we validate during extraction
+        # The capture_count here is total groups, but optional ones may be nil
+        # This is validated in extract_components where we check required components
+      end
+
+      def validate_version_string(version_string)
+        return unless version_string.nil? || version_string.strip.empty?
+
+        raise Errors::InvalidVersionError,
+              "Version string cannot be empty"
+      end
+    end
+  end
+end

data/lib/versionian/schemes/semantic.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "rubygems/version"
+
+module Versionian
+  module Schemes
+    # Autoload all scheme classes
+    autoload :Pattern, "versionian/schemes/pattern"
+    autoload :Declarative, "versionian/schemes/declarative"
+    autoload :CalVer, "versionian/schemes/calver"
+    autoload :Composite, "versionian/schemes/composite"
+    autoload :SoloVer, "versionian/schemes/solover"
+    autoload :WendtVer, "versionian/schemes/wendtver"
+
+    class Semantic < VersionScheme
+      # SemVer pattern: MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]
+      # Must be exactly X.Y or X.Y.Z format where X, Y, Z are non-negative integers
+      # CalVer formats like YYYY.MM.DD should not match (year is 4 digits)
+      SEMVER_PATTERN = /\A\d{1,5}\.\d{1,5}(?:\.\d{1,5})?(?:-[\w.]+)?(?:\+[\w.]+)?\z/
+
+      def initialize(name: :semantic, description: "Semantic versioning (semver.org)")
+        component_definitions = [
+          { name: :major, type: :integer },
+          { name: :minor, type: :integer },
+          { name: :patch, type: :integer, optional: true }
+        ].map { |d| d.is_a?(Hash) ? ComponentDefinition.from_hash(d) : ComponentDefinition.new(**d) }
+
+        super(
+          name: name,
+          description: description,
+          component_definitions: component_definitions
+        )
+      end
+
+      def parse(version_string)
+        validate_version_string(version_string)
+
+        # Strip build metadata for Gem::Version compatibility
+        version_without_build = version_string.gsub(/\+.*$/, "")
+        gem_version = ::Gem::Version.new(version_without_build)
+        components = build_components(version_string, gem_version)
+        comparable_array = [gem_version] # Gem::Version is directly comparable
+
+        VersionIdentifier.new(
+          raw_string: version_string,
+          scheme: self,
+          components: components,
+          comparable_array: comparable_array
+        )
+      rescue ArgumentError => e
+        raise Errors::InvalidVersionError, "Invalid semantic version '#{version_string}': #{e.message}"
+      end
+
+      def compare_arrays(a, b)
+        # Gem::Version handles comparison
+        a <=> b
+      end
+
+      def matches_range?(version_string, range)
+        version = parse(version_string)
+        gem_version = version.comparable_array.first
+
+        case range.type
+        when :equals
+          gem_version == ::Gem::Version.new(range.boundary.gsub(/\+.*$/, ""))
+        when :before
+          gem_version < ::Gem::Version.new(range.boundary.gsub(/\+.*$/, ""))
+        when :after
+          gem_version >= ::Gem::Version.new(range.boundary.gsub(/\+.*$/, ""))
+        when :between
+          gem_version >= ::Gem::Version.new(range.from.gsub(/\+.*$/, "")) &&
+            gem_version <= ::Gem::Version.new(range.to.gsub(/\+.*$/, ""))
+        end
+      end
+
+      def valid?(version_string)
+        return false if version_string.nil? || version_string.strip.empty?
+        return false unless version_string =~ SEMVER_PATTERN
+
+        # Check if this looks like a CalVer date (first component is a 4-digit year)
+        # Exclude versions like 2024.01.15 that look like dates
+        first_component = version_string.split(/[-.+]/).first
+        if first_component =~ /^\d{4}$/ && first_component.to_i.between?(1900, 2100)
+          # This looks like a year, not a semantic version
+          return false
+        end
+
+        # Try to parse it
+        super
+      end
+
+      private
+
+      def build_components(version_string, gem_version)
+        # Extract components from version string
+        parts = version_string.split(/[+-]/).first.split(".")
+        components = []
+
+        components << VersionComponent.new(
+          name: :major,
+          type: :integer,
+          value: gem_version.segments[0] || 0,
+          weight: 1,
+          definition: @component_definitions[0]
+        )
+
+        components << VersionComponent.new(
+          name: :minor,
+          type: :integer,
+          value: gem_version.segments[1] || 0,
+          weight: 1,
+          definition: @component_definitions[1]
+        )
+
+        if gem_version.segments.length >= 3
+          components << VersionComponent.new(
+            name: :patch,
+            type: :integer,
+            value: gem_version.segments[2],
+            weight: 1,
+            definition: @component_definitions[2]
+          )
+        end
+
+        components
+      end
+
+      def validate_version_string(version_string)
+        return unless version_string.nil? || version_string.strip.empty?
+
+        raise Errors::InvalidVersionError,
+              "Version string cannot be empty"
+      end
+    end
+  end
+end

data/lib/versionian/schemes/solover.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Versionian
+  module Schemes
+    class SoloVer < VersionScheme
+      SOLO_PATTERN = /^(\d+)(([+-])([a-zA-Z0-9]+))?$/
+
+      def initialize(name: :solover, description: "SoloVer single number with optional postfix")
+        super
+      end
+
+      def parse(version_string)
+        validate_version_string(version_string)
+
+        match = version_string.match(SOLO_PATTERN)
+        raise Errors::ParseError, "Invalid SoloVer format '#{version_string}'" unless match
+
+        number = match[1].to_i
+        postfix = match[2]
+        prefix = match[3]
+        identifier = match[4]
+
+        components = [
+          VersionComponent.new(
+            name: :number,
+            type: :integer,
+            value: number,
+            weight: 1
+          )
+        ]
+
+        comparable_array = [number]
+
+        if postfix
+          components << VersionComponent.new(
+            name: :postfix,
+            type: :postfix,
+            value: { prefix: prefix, identifier: identifier },
+            weight: 1
+          )
+
+          # Store prefix order and identifier for comparison
+          prefix_order = case prefix
+                         when "+" then 1
+                         when "-" then 2
+                         else 0
+                         end
+          comparable_array << prefix_order
+          comparable_array << identifier
+        end
+
+        VersionIdentifier.new(
+          raw_string: version_string,
+          scheme: self,
+          components: components,
+          comparable_array: comparable_array
+        )
+      end
+
+      def compare_arrays(a, b)
+        # Compare number first
+        number_cmp = a[0] <=> b[0]
+        return number_cmp if number_cmp != 0
+
+        # Check if both have postfixes or both don't
+        a_has_postfix = a.length > 1
+        b_has_postfix = b.length > 1
+
+        if !a_has_postfix && !b_has_postfix
+          return 0
+        elsif !a_has_postfix
+          return -1 # No postfix < +postfix
+        elsif !b_has_postfix
+          return 1
+        end
+
+        # Both have postfixes, compare by prefix
+        prefix_cmp = a[1] <=> b[1]
+        return prefix_cmp if prefix_cmp != 0
+
+        # Same prefix, compare identifier lexicographically
+        a[2] <=> b[2]
+      end
+
+      def matches_range?(version_string, range)
+        version_a = parse(version_string)
+        version_b = parse(range.boundary) if range.boundary
+        version_from = parse(range.from) if range.from
+        version_to = parse(range.to) if range.to
+
+        case range.type
+        when :equals
+          compare_arrays(version_a.comparable_array, version_b.comparable_array).zero?
+        when :before
+          compare_arrays(version_a.comparable_array, version_b.comparable_array).negative?
+        when :after
+          compare_arrays(version_a.comparable_array, version_b.comparable_array) >= 0
+        when :between
+          compare_arrays(version_a.comparable_array, version_from.comparable_array) >= 0 &&
+            compare_arrays(version_a.comparable_array, version_to.comparable_array) <= 0
+        end
+      end
+
+      def render(version)
+        postfix_component = version.component(:postfix)
+        if postfix_component&.value
+          "#{version.component(:number).value}#{postfix_component.value[:prefix]}#{postfix_component.value[:identifier]}"
+        else
+          version.component(:number).value.to_s
+        end
+      end
+
+      private
+
+      def validate_version_string(version_string)
+        raise Errors::InvalidVersionError, "Version string cannot be nil" if version_string.nil?
+        raise Errors::InvalidVersionError, "Version string cannot be empty" if version_string.strip.empty?
+      end
+    end
+  end
+end

data/lib/versionian/schemes/wendtver.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Versionian
+  module Schemes
+    class WendtVer < VersionScheme
+      WENDT_PATTERN = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/
+
+      # WendtVer uses auto-incrementing components with carryover
+      # Format: major.minor.patch.build
+      # When build reaches 999, it resets to 0 and increments patch
+      # When patch reaches 99, it resets to 0 and increments minor
+      # When minor reaches 99, it resets to 0 and increments major
+
+      MAX_VALUES = { build: 999, patch: 99, minor: 99, major: Float::INFINITY }.freeze
+
+      def initialize(name: :wendtver, description: "WendtVer auto-incrementing with carryover")
+        super
+      end
+
+      def parse(version_string)
+        validate_version_string(version_string)
+
+        match = version_string.match(WENDT_PATTERN)
+        raise Errors::ParseError, "Invalid WendtVer format '#{version_string}'" unless match
+
+        major = match[1].to_i
+        minor = match[2].to_i
+        patch = match[3].to_i
+        build = match[4].to_i
+
+        validate_ranges(major, minor, patch, build)
+
+        components = [
+          VersionComponent.new(name: :major, type: :integer, value: major, weight: 1),
+          VersionComponent.new(name: :minor, type: :integer, value: minor, weight: 1),
+          VersionComponent.new(name: :patch, type: :integer, value: patch, weight: 1),
+          VersionComponent.new(name: :build, type: :integer, value: build, weight: 1)
+        ]
+
+        comparable_array = [major, minor, patch, build]
+
+        VersionIdentifier.new(
+          raw_string: version_string,
+          scheme: self,
+          components: components,
+          comparable_array: comparable_array
+        )
+      end
+
+      def compare_arrays(a, b)
+        # Standard lexicographic comparison
+        a <=> b
+      end
+
+      def matches_range?(version_string, range)
+        version_a = parse(version_string)
+        version_b = parse(range.boundary) if range.boundary
+        version_from = parse(range.from) if range.from
+        version_to = parse(range.to) if range.to
+
+        case range.type
+        when :equals
+          compare_arrays(version_a.comparable_array, version_b.comparable_array).zero?
+        when :before
+          compare_arrays(version_a.comparable_array, version_b.comparable_array).negative?
+        when :after
+          compare_arrays(version_a.comparable_array, version_b.comparable_array) >= 0
+        when :between
+          compare_arrays(version_a.comparable_array, version_from.comparable_array) >= 0 &&
+            compare_arrays(version_a.comparable_array, version_to.comparable_array) <= 0
+        end
+      end
+
+      def render(version)
+        [version.component(:major).value,
+         version.component(:minor).value,
+         version.component(:patch).value,
+         version.component(:build).value].join(".")
+      end
+
+      # Increment a version by one position
+      def increment(version_string, position = :build)
+        version = parse(version_string)
+        major = version.component(:major).value
+        minor = version.component(:minor).value
+        patch = version.component(:patch).value
+        build = version.component(:build).value
+
+        case position
+        when :build
+          build += 1
+          if build > MAX_VALUES[:build]
+            build = 0
+            patch += 1
+            if patch > MAX_VALUES[:patch]
+              patch = 0
+              minor += 1
+              if minor > MAX_VALUES[:minor]
+                minor = 0
+                major += 1
+              end
+            end
+          end
+        when :patch
+          patch += 1
+          if patch > MAX_VALUES[:patch]
+            patch = 0
+            minor += 1
+            if minor > MAX_VALUES[:minor]
+              minor = 0
+              major += 1
+            end
+          end
+        when :minor
+          minor += 1
+          if minor > MAX_VALUES[:minor]
+            minor = 0
+            major += 1
+          end
+        when :major
+          major += 1
+        end
+
+        "#{major}.#{minor}.#{patch}.#{build}"
+      end
+
+      private
+
+      def validate_version_string(version_string)
+        raise Errors::InvalidVersionError, "Version string cannot be nil" if version_string.nil?
+        raise Errors::InvalidVersionError, "Version string cannot be empty" if version_string.strip.empty?
+      end
+
+      def validate_ranges(_major, minor, patch, build)
+        raise Errors::ParseError, "Minor must be 0-99" unless minor.between?(0, 99)
+        raise Errors::ParseError, "Patch must be 0-99" unless patch.between?(0, 99)
+        raise Errors::ParseError, "Build must be 0-999" unless build.between?(0, 999)
+      end
+    end
+  end
+end

data/lib/versionian/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Versionian
+  VERSION_NUMBER = "0.1.0"
+  VERSION = VERSION_NUMBER
+end

data/lib/versionian/version_component.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Versionian
+  class VersionComponent
+    attr_reader :name, :type, :value, :weight, :values, :order, :definition
+
+    def initialize(name:, type:, value:, weight: 1, values: [], order: [], definition: nil)
+      @name = name
+      @type = type
+      @value = value
+      @weight = weight
+      @values = values
+      @order = order
+      @definition = definition
+      freeze
+    end
+
+    def to_comparable
+      type_class = ComponentTypes.resolve(@type)
+      type_class.to_comparable(@value, self)
+    end
+
+    def to_s
+      type_class = ComponentTypes.resolve(@type)
+      type_class.format(@value)
+    end
+  end
+end