# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "versionaire/cast"
          
        
      
        

          

            
              1
            

            
              
            

            require "versionaire/error"
          
        
      
        

          

            
              1
            

            
              
            

            require "versionaire/function"
          
        
      
        

          

            
              1
            

            
              
            

            require "versionaire/version"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Versionaire
          
        
      
        

          

            
              1
            

            
              
            

              DELIMITER = "."
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              PATTERN = /
          
        
      
        

          

            

            
              
            

                          \A(                  # Start of string and OR.
          
        
      
        

          

            

            
              
            

                          \d*                  # Major only.
          
        
      
        

          

            

            
              
            

                          |                    # OR pipe.
          
        
      
        

          

            

            
              
            

                          \d+                  # Major.
          
        
      
        

          

            

            
              
            

                          #{DELIMITER}?        # Delimiter.
          
        
      
        

          

            

            
              
            

                          \d*                  # Minor.
          
        
      
        

          

            

            
              
            

                          (?:#{DELIMITER}\d+)  # Passive delimiter and patch.
          
        
      
        

          

            

            
              
            

                          )\z                  # End of OR and string.
          
        
      
        

          

            

            
              
            

                        /x
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Versionaire
          
        
      
        

          

            

            
              
            

              # Refines Kernel in order to provide a top-level Version conversion function.
          
        
      
        

          

            
              1
            

            
              
            

              module Cast
          
        
      
        

          

            
              1
            

            
              
            

                refine Kernel do
          
        
      
        

          

            
              1
            

            
              
            

                  def Version(object) = Versionaire::Version object
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Versionaire
          
        
      
        

          

            

            
              
            

              # The base error class for all gem related errors.
          
        
      
        

          

            
              1
            

            
              
            

              class Error < StandardError
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "optparse"
          
        
      
        

          

            
              1
            

            
              
            

            require "versionaire"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            OptionParser.accept Versionaire::Version do |value|
          
        
      
        

          

            
              2
            

            
              
            

              Versionaire::Version value
          
        
      
        

          

            

            
              
            

            rescue Versionaire::Error
          
        
      
        

          

            
              1
            

            
              
            

              raise OptionParser::InvalidArgument, value
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # The gem namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Versionaire
          
        
      
        

          

            
              1
            

            
              
            

              module_function
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # Conversion function (strict) for casting an object into a version.
          
        
      
        

          

            
              1
            

            
              
            

              def Version object
          
        
      
        

          

            
              82
            

            
              
            

                Converter.new(object).then do |converter|
          
        
      
        

          

            
              82
            

            
              
                
                  when: 56
                
              
            

                  case object
          
        
      
        

          

            
              56
            

            
              
                
                  when: 10
                
              
            

                    when String then converter.from_string
          
        
      
        

          

            
              10
            

            
              
                
                  when: 10
                
              
            

                    when Array then converter.from_array
          
        
      
        

          

            
              10
            

            
              
                
                  when: 2
                
              
            

                    when Hash then converter.from_hash
          
        
      
        

          

            
              2
            

            
              
                
                  else: 4
                
              
            

                    when Version then object
          
        
      
        

          

            
              4
            

            
              
            

                    else converter.from_object
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # Aids with converting objects into valid versions.
          
        
      
        

          

            
              1
            

            
              
            

              class Converter
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize object, model: Version
          
        
      
        

          

            
              82
            

            
              
            

                  @object = object
          
        
      
        

          

            
              82
            

            
              
            

                  @model = model
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def from_string
          
        
      
        

          

            
              56
            

            
              
            

                  body = "Use: <major>.<minor>.<patch>, <major>.<minor>, <major>, or empty string."
          
        
      
        

          

            
              56
            

            
              
                
                  else: 53
                
              
                
                  then: 3
                
              
            

                  fail Error, error_message(object, body) unless PATTERN.match? object
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              53
            

            
              
            

                  string_to_version
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def from_array
          
        
      
        

          

            
              10
            

            
              
            

                  body = "Use: [<major>, <minor>, <patch>], [<major>, <minor>], [<major>], or []."
          
        
      
        

          

            
              10
            

            
              
                
                  else: 8
                
              
                
                  then: 2
                
              
            

                  fail Error, error_message(object, body) unless (0..3).cover? object.size
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
            

                  model.new(**attributes_for(object.pad(0, 3)))
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def from_hash
          
        
      
        

          

            
              10
            

            
              
            

                  body = "Use: {major: <major>, minor: <minor>, patch: <patch>}, " \
          
        
      
        

          

            

            
              
            

                         "{major: <major>, minor: <minor>}, {major: <major>}, or {}."
          
        
      
        

          

            
              10
            

            
              
                
                  else: 8
                
              
                
                  then: 2
                
              
            

                  fail Error, error_message(object, body) unless required_keys?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
            

                  Version[**object]
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def from_object
          
        
      
        

          

            
              4
            

            
              
            

                  fail Error, error_message(object, "Use: String, Array, Hash, or Version.")
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :object, :model
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def string_to_version
          
        
      
        

          

            
              53
            

            
              
            

                  object.split(DELIMITER)
          
        
      
        

          

            

            
              
            

                        .map(&:to_i)
          
        
      
        

          

            
              53
            

            
              
            

                        .then { |numbers| numbers.pad 0, 3 }
          
        
      
        

          

            
              53
            

            
              
            

                        .then { |values| model.new(**attributes_for(values)) }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def attributes_for(values) = model.members.zip(values).to_h
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              15
            

            
              
            

                def required_keys? = object.keys.all? { |key| model.members.include? key }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def error_message(object, body) = "Invalid version conversion: #{object}. #{body}"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              private_constant :Converter
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Versionaire
          
        
      
        

          

            

            
              
            

              # An immutable, semantic version value object.
          
        
      
        

          

            
              1
            

            
              
            

              Version = Data.define :major, :minor, :patch do
          
        
      
        

          

            
              1
            

            
              
            

                include Comparable
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize major: 0, minor: 0, patch: 0
          
        
      
        

          

            
              176
            

            
              
            

                  super
          
        
      
        

          

            
              176
            

            
              
            

                  validate
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def +(other) = add other
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def -(other) = substract other
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def ==(other) = hash == other.hash
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias_method :eql?, :==
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def <=>(other) = to_s <=> other.to_s
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def down(key, value = 1) = substract({key => value})
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def up(key, value = 1) = add({key => value})
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def bump key
          
        
      
        

          

            
              4
            

            
              
                
                  when: 1
                
              
            

                  case key
          
        
      
        

          

            
              1
            

            
              
                
                  when: 1
                
              
            

                    when :major then bump_major
          
        
      
        

          

            
              1
            

            
              
                
                  when: 1
                
              
            

                    when :minor then bump_minor
          
        
      
        

          

            
              1
            

            
              
                
                  else: 1
                
              
            

                    when :patch then bump_patch
          
        
      
        

          

            
              1
            

            
              
            

                    else fail Error, %(Invalid key: #{key.inspect}. Use: #{members.to_sentence "or"}.)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def inspect = to_s.inspect
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def to_proc = method(:public_send).to_proc
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def to_s = to_a.join DELIMITER
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias_method :to_str, :to_s
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias_method :to_a, :deconstruct
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def validate
          
        
      
        

          

            
              176
            

            
              
                
                  else: 175
                
              
                
                  then: 1
                
              
            

                  fail Error, "Major, minor, and patch must be a number." unless to_a.all? Integer
          
        
      
        

          

            
              175
            

            
              
                
                  then: 3
                
              
                
                  else: 172
                
              
            

                  fail Error, "Major, minor, and patch must be a positive number." if to_a.any?(&:negative?)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def add other
          
        
      
        

          

            
              5
            

            
              
            

                  attributes = other.to_h
          
        
      
        

          

            
              12
            

            
              
            

                  attributes.each { |key, value| attributes[key] = public_send(key) + value }
          
        
      
        

          

            
              5
            

            
              
            

                  with(**attributes)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def substract other
          
        
      
        

          

            
              7
            

            
              
            

                  attributes = other.to_h
          
        
      
        

          

            
              18
            

            
              
            

                  attributes.each { |key, value| attributes[key] = public_send(key) - value }
          
        
      
        

          

            
              7
            

            
              
            

                  with(**attributes)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def bump_major = with major: major + 1, minor: 0, patch: 0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def bump_minor = with major:, minor: minor + 1, patch: 0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def bump_patch = with major:, minor:, patch: patch + 1
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end