versionian 0.1.0

data/lib/versionian/version_identifier.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Versionian
+  class VersionIdentifier
+    include Comparable
+
+    attr_reader :raw_string, :scheme, :components, :comparable_array
+
+    def initialize(raw_string:, scheme:, components:, comparable_array:)
+      @raw_string = raw_string
+      @scheme = scheme
+      @components = components.freeze
+      @comparable_array = comparable_array.freeze
+      freeze
+    end
+
+    def <=>(other)
+      raise ArgumentError, "Cannot compare versions from different schemes" unless @scheme == other.scheme
+
+      @scheme.compare_arrays(@comparable_array, other.comparable_array)
+    end
+
+    def component(name)
+      @components.find { |c| c.name == name }
+    end
+
+    def matches_range?(range)
+      @scheme.matches_range?(@raw_string, range)
+    end
+
+    def to_s
+      @scheme.render(self)
+    end
+
+    def inspect
+      "#<Versionian::VersionIdentifier #{@raw_string} scheme=#{@scheme.name}>"
+    end
+
+    # Build a version programmatically from component values
+    #
+    # @param scheme [VersionScheme] The scheme to use for this version
+    # @param components [Hash] Hash of component_name => value pairs
+    # @return [VersionIdentifier] A new version identifier object
+    #
+    # @example
+    #   scheme = Versionian.get_scheme(:semantic)
+    #   version = Versionian::VersionIdentifier.build(
+    #     scheme: scheme,
+    #     components: { major: 1, minor: 2, patch: 3 }
+    #   )
+    def self.build(scheme:, components:)
+      # Build raw_string from components using format_template if available
+      raw_string = if scheme.format_template
+                    render_from_template(scheme.format_template, scheme.component_definitions, components)
+                  else
+                    # Fallback: join components with dots
+                    components.map { |name, value| value.to_s }.join(".")
+                  end
+
+      # Build component objects
+      component_objects = components.map do |name, value|
+        comp_def = scheme.component_definitions.find { |cd| cd.name == name.to_sym }
+
+        VersionComponent.new(
+          name: name.to_sym,
+          type: comp_def&.type || :string,
+          value: value,
+          weight: comp_def&.weight || 1,
+          values: comp_def&.values || [],
+          order: comp_def&.order || [],
+          definition: comp_def
+        )
+      end
+
+      # Build comparable_array
+      # Special handling for Semantic scheme: use Gem::Version for comparison
+      comparable_array = if scheme.is_a?(Schemes::Semantic)
+                          require "rubygems/version"
+                          version_str = components.map { |name, value| value.to_s }.join(".")
+                          [::Gem::Version.new(version_str)]
+                        else
+                          component_objects.map do |comp|
+                            type = ComponentTypes.resolve(comp.type)
+                            type.to_comparable(comp.value, comp)
+                          end
+                        end
+
+      new(
+        raw_string: raw_string,
+        scheme: scheme,
+        components: component_objects,
+        comparable_array: comparable_array
+      )
+    end
+
+    private
+
+    def self.render_from_template(format_template, component_definitions, components)
+      result = format_template.dup
+
+      # Process optional segments []
+      loop do
+        match = result.match(/\[([^\[\]]+)\]/)
+        break unless match
+
+        segment_content = match[1]
+        has_value = segment_content.scan(/\{(\w+)\}/).any? { |name| components.key?(name.first.to_sym) }
+
+        result = result.sub(match[0], has_value ? segment_content : "")
+      end
+
+      # Replace component placeholders
+      components.each do |name, value|
+        placeholder = "{#{name}}"
+        result = result.gsub(placeholder, value.to_s)
+      end
+
+      result
+    end
+  end
+end

data/lib/versionian/version_range.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Versionian
+  class VersionRange
+    attr_reader :type, :scheme
+
+    def initialize(type, scheme, **boundaries)
+      @type = type
+      @scheme = scheme
+      @boundaries = boundaries.freeze
+      validate!
+      freeze
+    end
+
+    def boundary
+      @boundaries[:version]
+    end
+
+    def from
+      @boundaries[:from]
+    end
+
+    def to
+      @boundaries[:to]
+    end
+
+    def matches?(version_string)
+      @scheme.matches_range?(version_string, self)
+    end
+
+    def includes?(version)
+      if version.is_a?(Version)
+        matches?(version.raw_string)
+      else
+        matches?(version)
+      end
+    end
+
+    def to_s
+      case @type
+      when :equals then "== #{@boundaries[:version]}"
+      when :before then "< #{@boundaries[:version]}"
+      when :after then ">= #{@boundaries[:version]}"
+      when :between then "#{@boundaries[:from]} - #{@boundaries[:to]}"
+      end
+    end
+
+    private
+
+    def validate!
+      case @type
+      when :equals, :before, :after
+        raise ArgumentError, "#{@type} range requires :version" unless @boundaries[:version]
+      when :between
+        raise ArgumentError, "between range requires :from and :to" unless @boundaries[:from] && @boundaries[:to]
+      else
+        raise ArgumentError, "Unknown range type: #{@type}"
+      end
+    end
+  end
+end

data/lib/versionian/version_scheme.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Versionian
+  class VersionScheme
+    attr_reader :name, :description, :format_template, :component_definitions
+
+    def initialize(name:, description: nil, format_template: nil, component_definitions: [])
+      @name = name
+      @description = description
+      @format_template = format_template
+      @component_definitions = component_definitions
+    end
+
+    # Abstract methods
+    def parse(version_string)
+      raise NotImplementedError, "#{self.class} must implement #parse"
+    end
+
+    def render(version)
+      version.raw_string
+    end
+
+    # Default comparison (can be overridden)
+    def compare_arrays(a, b)
+      a <=> b
+    end
+
+    def compare(a, b)
+      version_a = parse(a)
+      version_b = parse(b)
+      version_a <=> version_b
+    end
+
+    def matches_range?(version_string, range)
+      version = parse(version_string)
+      version.matches_range?(range)
+    end
+
+    def valid?(version_string)
+      parse(version_string)
+      true
+    rescue Errors::InvalidVersionError, Errors::ParseError
+      false
+    end
+
+    # Alias for valid? - check if this scheme supports a version string
+    def supports?(version_string)
+      valid?(version_string)
+    end
+
+    # Build a version programmatically from component values
+    #
+    # @param components [Hash] Hash of component_name => value pairs
+    # @return [VersionIdentifier] A new version identifier object
+    #
+    # @example
+    #   scheme.build(major: 1, minor: 2, patch: 3)
+    def build(**components)
+      VersionIdentifier.build(scheme: self, components: components)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(VersionScheme)
+
+      @name == other.name
+    end
+  end
+end

data/lib/versionian.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "versionian/version"
+
+# Require error classes (they have interdependent module definitions)
+require_relative "versionian/errors/invalid_version_error"
+require_relative "versionian/errors/invalid_scheme_error"
+require_relative "versionian/errors/parse_error"
+
+# Autoload models at the Versionian module level
+module Versionian
+  # Autoload models
+  autoload :VersionComponent, "versionian/version_component"
+  autoload :VersionIdentifier, "versionian/version_identifier"
+  autoload :VersionScheme, "versionian/version_scheme"
+  autoload :VersionRange, "versionian/version_range"
+  autoload :ComponentDefinition, "versionian/component_definition"
+
+  # Autoload component types module
+  autoload :ComponentTypes, "versionian/component_types/registry"
+  autoload :Parsers, "versionian/parsers/declarative"
+
+  # Autoload schemes module
+  autoload :Schemes, "versionian/schemes/semantic"
+
+  # Autoload utilities
+  autoload :SchemeRegistry, "versionian/scheme_registry"
+  autoload :SchemeLoader, "versionian/scheme_loader"
+  autoload :PrimitiveLibrary, "versionian/primitive_library"
+
+  # Register built-in component types
+  ComponentTypes.register(:integer, ComponentTypes::Integer)
+  ComponentTypes.register(:float, ComponentTypes::Float)
+  ComponentTypes.register(:enum, ComponentTypes::Enum)
+  ComponentTypes.register(:string, ComponentTypes::String)
+  ComponentTypes.register(:date_part, ComponentTypes::DatePart)
+  ComponentTypes.register(:prerelease, ComponentTypes::Prerelease)
+  ComponentTypes.register(:postfix, ComponentTypes::Postfix)
+  ComponentTypes.register(:hash, ComponentTypes::Hash)
+
+  class << self
+    def scheme_registry
+      @scheme_registry ||= SchemeRegistry.instance.tap do |registry|
+        # Register built-in schemes
+        registry.register(:semantic, Schemes::Semantic.new)
+        registry.register(:calver, Schemes::CalVer.new)
+        registry.register(:solover, Schemes::SoloVer.new)
+        registry.register(:wendtver, Schemes::WendtVer.new)
+      end
+    end
+
+    def register_scheme(name, scheme)
+      scheme_registry.register(name, scheme)
+    end
+
+    def get_scheme(name)
+      scheme_registry.get(name)
+    end
+
+    def detect_scheme(version_string)
+      scheme_registry.detect_from(version_string)
+    end
+  end
+end

data/lib/versius.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Versius
+  # Your code goes here...
+end

data/sig/versius.rbs

@@ -0,0 +1,4 @@
+module Versius
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: versionian
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: singleton
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Versionian is a Ruby library for declaring, parsing, comparing, and rendering
+  version schemes. It provides model-driven primitives for defining how versions work,
+  supporting Semantic Versioning, Calendar Versioning, and unlimited custom schemes
+  through YAML configuration or Ruby inheritance.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- README.adoc
+- Rakefile
+- docs/Gemfile
+- docs/_guides/custom-schemes.adoc
+- docs/_guides/index.adoc
+- docs/_pages/component-types.adoc
+- docs/_pages/declarative-schemes.adoc
+- docs/_pages/index.adoc
+- docs/_pages/range-matching.adoc
+- docs/_pages/schemes.adoc
+- docs/_references/api.adoc
+- docs/_references/index.adoc
+- docs/_references/schemes.adoc
+- docs/_tutorials/getting-started.adoc
+- docs/_tutorials/index.adoc
+- docs/index.adoc
+- lib/versionian.rb
+- lib/versionian/component_definition.rb
+- lib/versionian/component_types/base.rb
+- lib/versionian/component_types/date_part.rb
+- lib/versionian/component_types/enum.rb
+- lib/versionian/component_types/float.rb
+- lib/versionian/component_types/hash.rb
+- lib/versionian/component_types/integer.rb
+- lib/versionian/component_types/postfix.rb
+- lib/versionian/component_types/prerelease.rb
+- lib/versionian/component_types/registry.rb
+- lib/versionian/component_types/string.rb
+- lib/versionian/errors/invalid_scheme_error.rb
+- lib/versionian/errors/invalid_version_error.rb
+- lib/versionian/errors/parse_error.rb
+- lib/versionian/parsers/declarative.rb
+- lib/versionian/scheme_loader.rb
+- lib/versionian/scheme_registry.rb
+- lib/versionian/schemes/calver.rb
+- lib/versionian/schemes/composite.rb
+- lib/versionian/schemes/declarative.rb
+- lib/versionian/schemes/pattern.rb
+- lib/versionian/schemes/semantic.rb
+- lib/versionian/schemes/solover.rb
+- lib/versionian/schemes/wendtver.rb
+- lib/versionian/version.rb
+- lib/versionian/version_component.rb
+- lib/versionian/version_identifier.rb
+- lib/versionian/version_range.rb
+- lib/versionian/version_scheme.rb
+- lib/versius.rb
+- sig/versius.rbs
+homepage: https://github.com/lutaml/versionian
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/lutaml/versionian
+  source_code_uri: https://github.com/lutaml/versionian
+  changelog_uri: https://github.com/lutaml/versionian/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Version scheme declaration and comparison library supporting 20+ versioning
+  patterns
+test_files: []