if_test_foo 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dafb31274e1cce6fe5443f86457ce873ae19be43d3a205f9130b194fa1dab87b
-  data.tar.gz: 73fccb790656c3fba9b8305bd15ac5bef7c2bf3bafd83a96b28b2a5230e3b8cb
+  metadata.gz: 8ffa70908fed56f8f808cd0e34fa82ea5d0dff6b7dfeb7076e6c2f940dbe8bbd
+  data.tar.gz: 300d99b7ac59c5acc020b49cc8a920c678e36bd0bc7606ee05872febc08de233
 SHA512:
-  metadata.gz: 5775a971d8468ed8ba4b37c16d5755c0f843538b4c93c44d888ed02bec0b1051c5cd681ff7626c5d2e31f03e36190794d51fe42fba3dc4ba2b29935af14c74e8
-  data.tar.gz: c22e3deeaad17152e322cb611f5591e19c3a7369f8550b433dccce6aab178bcdcad6f4aad49b243a488e81b0d95c174de6a30f0d3aa9f90b157ad468eb9d20bd
+  metadata.gz: 254f781ea32977293b1a469f74cc9cc0314187aa097dd9824419fb464665438fd5ed8471340feaa2a72cce88bba3e7a335c398f71ee4b91fb49b4afb797f7236
+  data.tar.gz: c7e5b30781f3e16b9d4ee18130328302a3019378c7d31130a9865b655950b11d8c74be8810793ac809dc056110866e859f93cfb42463603f503eb53c7c9a8c77

data/lib/semver_dialects/cli.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module SemverDialects
+  # Handle the application command line parsing
+  # and the dispatch to various command objects
+  #
+  # @api public
+  class CLI < Thor
+    # Error raised by this runner
+    Error = Class.new(StandardError)
+
+    desc 'version', 'semver_dialects version'
+    def version
+      require_relative 'version'
+      puts "v#{SemverDialects::VERSION}"
+    end
+    map %w[--version -v] => :version
+
+    desc 'check_version TYPE VERSION CONSTRAINT', 'Command description...'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def check_version(type, version, constraint)
+      if options[:help]
+        invoke :help, ['check_version']
+      else
+        require_relative 'commands/check_version'
+        ecode = SemverDialects::Commands::CheckVersion.new(type, version, constraint, options).execute
+        exit(ecode)
+      end
+    end
+  end
+end

data/lib/semver_dialects/command.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module SemverDialects
+  # A CLI command
+  class Command
+    extend Forwardable
+
+    def_delegators :command, :run
+
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # The external commands runner
+    #
+    # @see http://www.rubydoc.info/gems/tty-command
+    #
+    # @api public
+    def command(**options)
+      require 'tty-command'
+      TTY::Command.new(options)
+    end
+
+    # The cursor movement
+    #
+    # @see http://www.rubydoc.info/gems/tty-cursor
+    #
+    # @api public
+    def cursor
+      require 'tty-cursor'
+      TTY::Cursor
+    end
+
+    # Open a file or text in the user's preferred editor
+    #
+    # @see http://www.rubydoc.info/gems/tty-editor
+    #
+    # @api public
+    def editor
+      require 'tty-editor'
+      TTY::Editor
+    end
+
+    # File manipulation utility methods
+    #
+    # @see http://www.rubydoc.info/gems/tty-file
+    #
+    # @api public
+    def generator
+      require 'tty-file'
+      TTY::File
+    end
+
+    # Terminal output paging
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def pager(**options)
+      require 'tty-pager'
+      TTY::Pager.new(options)
+    end
+
+    # Terminal platform and OS properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def platform
+      require 'tty-platform'
+      TTY::Platform.new
+    end
+
+    # The interactive prompt
+    #
+    # @see http://www.rubydoc.info/gems/tty-prompt
+    #
+    # @api public
+    def prompt(**options)
+      require 'tty-prompt'
+      TTY::Prompt.new(options)
+    end
+
+    # Get terminal screen properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-screen
+    #
+    # @api public
+    def screen
+      require 'tty-screen'
+      TTY::Screen
+    end
+
+    # The unix which utility
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def which(*args)
+      require 'tty-which'
+      TTY::Which.which(*args)
+    end
+
+    # Check if executable exists
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def exec_exist?(*args)
+      require 'tty-which'
+      TTY::Which.exist?(*args)
+    end
+  end
+end

data/lib/semver_dialects/commands/check_version.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../../semver_dialects.rb'
+require_relative '../semantic_version/version_translator.rb'
+require_relative '../semantic_version/version_parser.rb'
+require_relative '../semantic_version/version_range.rb'
+
+module SemverDialects
+  module Commands
+    # The check version command implementation
+    class CheckVersion < SemverDialects::Command
+      def initialize(type, version, constraint, options)
+        @type = type
+        @version = version
+        @constraint = constraint
+        @options = options
+        @avail_types = %w[gem npm ruby pypi php maven go]
+      end
+
+      def execute(_input: $stdin, output: $stdout)
+        typ = @type.downcase
+        raise SemverDialects::Error, 'wrong package type' unless @avail_types.include?(typ)
+
+        if VersionChecker.version_sat?(typ, @version, @constraint)
+          output.puts "#{@version} matches #{@constraint} for #{@type}"
+          0
+        else
+          output.puts "#{@version} does not match #{@constraint}"
+          1
+        end
+      end
+    end
+  end
+end

data/lib/semver_dialects/semantic_version/semantic_version.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require_relative '../../utils.rb'
+
+class SemanticVersion
+  attr_reader :version_string, :prefix_delimiter, :prefix_segments, :suffix_segments, :segments
+
+  def initialize(version_string, segments = nil)
+    @version_string = version_string
+    @prefix_segments = []
+    @suffix_segments = []
+    @prefix_delimiter = 0
+    version, _ = version_string.split('+')
+    if segments.nil?
+      @segments = split_version_string!(version)
+    else
+      @prefix_segments = segments
+      @prefix_delimiter = segments.size - 1
+      @segments = segments
+    end
+  end
+
+  def split_version_string!(version_string)
+    delim_pattern = /[\.\-]/
+    split_array = version_string.split(delim_pattern).map {
+      |grp|
+      grp.split(/(\d+)/).reject { |cell| cell.nil? || cell.empty? }
+    }.flatten
+
+    # go as far to the right as possible considering numbers and placeholders
+    (0..split_array.size - 1).each do
+      |i|
+      if split_array[i].number? || split_array[i] == "X" || split_array[i] == "x"
+        @prefix_delimiter = i
+      else
+        break
+      end
+    end
+
+    # remove redundant trailing zeros
+    @prefix_delimiter.downto(0).each do
+      |i|
+      if split_array[i] == "0"
+        split_array.delete_at(i)
+        @prefix_delimiter -= 1
+      else
+        break
+      end
+    end
+
+    @prefix_segments = split_array[0..@prefix_delimiter].map { |group_string| SemanticVersionSegment.new(group_string) } unless @prefix_delimiter < 0
+    if split_array.size - 1 >= @prefix_delimiter + 1
+      @suffix_segments = split_array[@prefix_delimiter + 1, split_array.size].map { |group_string| SemanticVersionSegment.new(group_string) }
+    end
+
+    @prefix_segments.clone().concat(@suffix_segments)
+  end
+
+  def _get_equalized_arrays_for(array_a, array_b)
+    first_array = array_a.clone()
+    second_array = array_b.clone()
+    if first_array.size < second_array.size
+      (second_array.size - first_array.size).times do
+        first_array << SemanticVersionSegment.new("0")
+      end
+    elsif first_array.size > second_array.size
+      (first_array.size - second_array.size).times do
+        second_array << SemanticVersionSegment.new("0")
+      end
+    end
+    [first_array, second_array]
+  end
+
+  def get_equalized_arrays_for(semver_a, semver_b)
+    first_array_prefix = semver_a.prefix_segments.clone()
+    second_array_prefix = semver_b.prefix_segments.clone()
+    first_array_suffix = semver_a.suffix_segments.clone()
+    second_array_suffix = semver_b.suffix_segments.clone()
+    first_array_prefix, second_array_prefix = _get_equalized_arrays_for(first_array_prefix, second_array_prefix)
+    first_array_suffix, second_array_suffix = _get_equalized_arrays_for(first_array_suffix, second_array_suffix)
+    [first_array_prefix.concat(first_array_suffix), second_array_prefix.concat(second_array_suffix)]
+  end
+
+  def get_equalized_prefix_arrays_for(semver_a, semver_b)
+    first_array_prefix = semver_a.prefix_segments.clone()
+    second_array_prefix = semver_b.prefix_segments.clone()
+    first_array_prefix, second_array_prefix = _get_equalized_arrays_for(first_array_prefix, second_array_prefix)
+    [first_array_prefix, second_array_prefix]
+  end
+
+  def <(other_semver)
+    self_array, other_array = get_equalized_arrays_for(self, other_semver)
+    (0..self_array.size - 1).each {
+      |i|
+      if self_array[i] < other_array[i]
+        return true
+      elsif self_array[i] > other_array[i]
+        return false
+      end
+    }
+    false
+  end
+
+  def is_zero?
+    @prefix_segments.empty? || @prefix_segments.all? { |segment| segment.is_zero? }
+  end
+
+  def pre_release?
+    @suffix_segments.any?(&:is_pre_release)
+  end
+
+  def post_release?
+    @suffix_segments.any?(&:is_post_release)
+  end
+
+  def >(other_semver)
+    self_array, other_array = get_equalized_arrays_for(self, other_semver)
+    (0..self_array.size - 1).each {
+      |i|
+      if self_array[i] > other_array[i]
+        return true
+      elsif self_array[i] < other_array[i]
+        return false
+      end
+    }
+    false
+  end
+
+  def >=(other_semver)
+    self == other_semver || self > other_semver || self == other_semver
+  end
+
+  def <=(other_semver)
+    self == other_semver || self < other_semver
+  end
+
+  def ==(other_semver)
+    segments_a = []
+    segments_b = []
+
+    segments_a += other_semver.segments
+    segments_b += @segments
+
+    if other_semver.segments.size < @segments.size
+      (@segments.size - other_semver.segments.size).times {|_| segments_a << SemanticVersionSegment.new("0")}
+    elsif other_semver.segments.size > @segments.size
+      (other_semver.segments.size - @segments.size).times {|_| segments_b << SemanticVersionSegment.new("0") }
+    end
+
+    (0..segments_a.size - 1).each {
+      |i|
+      if segments_a[i] != segments_b[i]
+        return false
+      end
+    }
+    true
+  end
+
+  def !=(other_semver)
+    return !(self == other_semver)
+  end
+
+  def diff(other_semver, abs = true)
+    diffs = []
+
+    self_array, other_array = get_equalized_prefix_arrays_for(self, other_semver)
+    (0..self_array.size - 1).each {
+      |i|
+      # diff semantic groups
+      diffs << (self_array[i].diff(other_array[i], abs))
+    }
+    diffs
+  end
+
+  def to_normalized_s
+    @segments.map { |group| group.to_normalized_s }.join(":").to_s
+  end
+
+  def to_s
+    @segments.map { |group| group.to_s }.join(":").to_s
+  end
+
+  def minor
+    @prefix_segments.size >= 1 ? @prefix_segments[1].to_s : "0"
+  end
+
+  def major
+    @prefix_segments.size >= 2 ? @prefix_segments[0].to_s : "0"
+  end
+
+  def patch
+    @prefix_segments.size >= 3 ? @prefix_segments[2].to_s : "0"
+  end
+
+  def is_successor_of?(other_semver)
+    filtered_segments = self.diff(other_semver, false).reject { |i| i.to_i == 0 }
+    filtered_segments.size == 1 && filtered_segments.last.to_i == 1
+  end
+
+  def cross_total()
+    [self.major, self.minor, self.patch].reject { |i| i.empty? }.map { |i| i.to_i }.inject(0) { |sum, x| sum + x }
+  end
+end
+
+class SemanticVersionSegment
+  attr_accessor :normalized_group_string, :original_group_string, :is_post_release, :is_pre_release
+
+  @@group_suffixes = {
+    # pre-releases
+    "PRE" => -16,
+    "PREVIEW" => -16,
+    "DEV" => -15,
+    "A" => -14,
+    "ALPHA" => -13,
+    "B" => -12,
+    "BETA" => -12,
+    "RC" => -11,
+    "M" => -10,
+
+    "RELEASE" => 0,
+    "FINAL" => 0,
+    # PHP specific
+    "STABLE" => 0,
+
+    # post-releases
+    "SP" => 1,
+  }
+
+  def initialize(group_string)
+    @is_post_release = false
+    @is_pre_release = false
+
+    @version_string = group_string
+    @original_group_string = group_string
+    # use x as unique placeholder
+    group_string_ucase = group_string.to_s.gsub(/\*/, "x").upcase
+
+    if @@group_suffixes.key?(group_string_ucase)
+      value = @@group_suffixes[group_string_ucase]
+      @is_post_release = value > 0
+      @is_pre_release = value < 0
+      @normalized_group_string = @@group_suffixes[group_string_ucase].to_s
+    else
+      @normalized_group_string = group_string_ucase
+    end
+  end
+
+  def compare(semver_a, semver_b, ret_anr_bnonr, ret_anonr_bnr, comparator)
+    if semver_a.number? && semver_b.number?
+      semver_a.to_i.send(comparator, semver_b.to_i)
+    elsif semver_a.number? && !semver_b.number?
+      if semver_b == "X"
+        true
+      else
+        ret_anr_bnonr
+      end
+    elsif !semver_a.number? && semver_b.number?
+      if semver_a == "X"
+        true
+      else
+        ret_anonr_bnr
+      end
+    else # !semantic_version_b.group_string.is_number? && !semantic_version_agrous_string.is_number?
+      if semver_a == "X" || semver_b == "X"
+        true
+      else
+        semver_a.send(comparator, semver_b)
+      end
+    end
+  end
+
+  def <(other_semver)
+    compare(self.normalized_group_string, other_semver.normalized_group_string, true, false, :<)
+  end
+
+  def >(other_semver)
+    compare(self.normalized_group_string, other_semver.normalized_group_string, false, true, :>)
+  end
+
+  def >=(other_semver)
+    self == other_semver || compare(self.normalized_group_string, other_semver.normalized_group_string, false, true, :>)
+  end
+
+  def <=(other_semver)
+    self == other_semver || compare(self.normalized_group_string, other_semver.normalized_group_string, true, false, :<)
+  end
+
+  def ==(other_semver)
+    self.normalized_group_string == other_semver.normalized_group_string
+  end
+
+  def !=(other_semver)
+    return !(self == other_semver)
+  end
+
+  def to_normalized_s
+    @normalized_group_string
+  end
+
+  def to_s
+    @version_string
+  end
+
+  def is_number?
+    self.normalized_group_string.number?
+  end
+
+  def is_zero?
+    is_number? ? self.normalized_group_string.to_i == 0 : false
+  end
+
+  def diff(other_semver, abs = true)
+
+    if other_semver.normalized_group_string == "X" || self.normalized_group_string == "X"
+      "0"
+    elsif self.normalized_group_string.number? && other_semver.normalized_group_string.number?
+      ret = self.normalized_group_string.to_i - other_semver.normalized_group_string.to_i
+      (abs && ret < 0) ? -ret : ret
+    else
+      nil
+    end
+  end
+end

data/lib/semver_dialects/semantic_version/version_cut.rb

@@ -0,0 +1,176 @@
+require_relative "semantic_version"
+
+class VersionCut
+  attr_accessor :semver, :value
+
+  def initialize(value, segments = nil)
+    @value = value.to_s
+    if segments.nil?
+      @semver = SemanticVersion.new(@value)
+    else
+      @semver = SemanticVersion.new(@value, segments)
+    end
+  end
+
+  def to_s
+    @value.to_s
+  end
+
+  def diff(other_cut, abs = true)
+    if other_cut.instance_of?(BelowAll)
+      AboveAll.new()
+    elsif other_cut.instance_of?(AboveAll)
+      BelowAll.new()
+    else
+      diff = self.semver.diff(other_cut.semver, abs)
+      if diff.nil?
+        EmptyInterval.new()
+      else
+        VersionCut.new(diff.join("."), diff)
+      end
+    end
+  end
+
+  def is_successor_of?(other_cut)
+    return true if other_cut.instance_of?(BelowAll)
+    return false if other_cut.instance_of?(AboveAll)
+
+    self.semver.is_successor_of?(other_cut.semver)
+  end
+
+  def <(other_cut)
+    other_cut.instance_of?(BelowAll) ? false : other_cut.instance_of?(AboveAll) ? true : @semver < other_cut.semver
+  end
+
+  def >(other_cut)
+    other_cut.instance_of?(BelowAll) ? true : other_cut.instance_of?(AboveAll) ? false : @semver > other_cut.semver
+  end
+
+  def <=(other_cut)
+    self < other_cut || self == other_cut
+  end
+
+  def >=(other_cut)
+    self > other_cut || self == other_cut
+  end
+
+  def ==(other_cut)
+    # self cannot be BelowAll or AboveAll
+    if other_cut.instance_of?(BelowAll) || other_cut.instance_of?(AboveAll)
+      false
+    else
+      @semver == other_cut.semver
+    end
+  end
+
+  def !=(other_cut)
+    # self cannot be BelowAll or AboveAll
+    if other_cut.instance_of?(BelowAll) || other_cut.instance_of?(AboveAll)
+      false
+    else
+      @semver != other_cut.semver
+    end
+  end
+
+  def is_initial_version?
+    @semver.is_zero?
+  end
+
+  def major
+    @semver.major
+  end
+
+  def minor
+    @semver.minor
+  end
+
+  def patch
+    @semver.patch
+  end
+
+  def cross_total
+    [minor, major, patch].reject { |i| i.empty? }.map { |i| i.to_i }.inject(0) { |sum, x| sum + x }
+  end
+end
+
+class BelowAll < VersionCut
+  def initialize()
+  end
+
+  def to_s
+    "-inf"
+  end
+
+  def is_initial_version?
+    false
+  end
+
+  def <(other_cut)
+    other_cut.instance_of?(BelowAll) ? false : true
+  end
+
+  def >(other_cut)
+    false
+  end
+
+  def <=(other_cut)
+    self < other_cut || self == other_cut
+  end
+
+  def >=(other_cut)
+    self > other_cut || self == other_cut
+  end
+
+  def ==(other_cut)
+    (other_cut.instance_of? BelowAll) ? true : false
+  end
+
+  def !=(other_cut)
+    !(self == other_cut)
+  end
+
+  def is_successor_of?(other_cut)
+    false
+  end
+end
+
+class AboveAll < VersionCut
+  def initialize()
+  end
+
+  def to_s
+    "+inf"
+  end
+
+  def is_initial_version?
+    false
+  end
+
+  def <(other_cut)
+    false
+  end
+
+  def >(other_cut)
+    other_cut.instance_of?(AboveAll) ? false : true
+  end
+
+  def <=(other_cut)
+    self < other_cut || self == other_cut
+  end
+
+  def >=(other_cut)
+    self > other_cut || self == other_cut
+  end
+
+  def ==(other_cut)
+    (other_cut.instance_of? AboveAll) ? true : false
+  end
+
+  def !=(other_cut)
+    !(self == other_cut)
+  end
+
+  def is_successor_of?(other_cut)
+    !other_cut.instance_of?(AboveAll)
+  end
+end