shivers 0.6.0.pre.2 → 0.6.0.pre.3

data/lib/shivers/parts/static.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module Shivers
+  module Parts
+    class Static
+      include ValueEquality
+
+      def initialize(data)
+        @value = data[:value]
+      end
+
+      def matcher
+        /#{Regexp.quote(@value)}/
+      end
+
+      def convert(value)
+        value
+      end
+
+      def merge(_, second)
+        second
+      end
+
+      def capturable?
+        false
+      end
+
+      def multivalued?
+        false
+      end
+
+      def state
+        [@value]
+      end
+    end
+  end
+end

data/lib/shivers/parts.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'parts/numeric'
+require_relative 'parts/alphanumeric'
+require_relative 'parts/alphanumeric_or_hyphen'
+require_relative 'parts/static'
+
+module Shivers
+  module Parts
+  end
+end

data/lib/shivers/value_equality.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Shivers
+  module ValueEquality
+    def ==(other)
+      other.class == self.class && other.state == state
+    end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ state.hash
+    end
+  end
+end

data/lib/shivers/version.rb

@@ -1,3 +1,31 @@
+# frozen_string_literal: true
+
 module Shivers
-  VERSION = '0.6.0.pre.2'
+  class Version
+    def self.from_file(path)
+      git_sha = ENV['GIT_SHA'] || 'LOCAL'
+      metadata = git_sha.to_s
+
+      base_version =
+        if File.exist?(path)
+          File.open(path) { |file| file.read.strip }
+        else
+          '0.0.0'
+        end
+
+      Version.new("#{base_version}+#{metadata}")
+    end
+
+    def initialize(version_string)
+      @version = Semantic::Version.new(version_string)
+    end
+
+    def to_docker_tag
+      to_s.gsub(/\+/, '_').downcase
+    end
+
+    def to_s
+      @version.to_s
+    end
+  end
 end

data/lib/shivers/version2.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'value_equality'
+
+module Shivers
+  class Version2
+    include ValueEquality
+
+    def initialize(data)
+      @data = data
+    end
+
+    def state
+      [@data]
+    end
+  end
+end

data/lib/shivers/version_definition.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative 'parts'
+require_relative 'format'
+require_relative 'visitors'
+require_relative 'value_equality'
+
+module Shivers
+  class VersionDefinition
+    PART_TYPES = {
+      numeric: Parts::Numeric,
+      alphanumeric: Parts::Alphanumeric,
+      alphanumeric_or_hyphen: Parts::AlphanumericOrHyphen,
+      static: Parts::Static
+    }.freeze
+
+    include ValueEquality
+
+    attr_reader :parts, :format
+
+    def initialize(definition)
+      @parts =
+        definition[:parts]
+        .transform_values { |part| PART_TYPES[part[:type]].new(part) }
+      @format = Format.new(definition[:formatter])
+    end
+
+    def parse(value)
+      extract_visitor = Visitors::ExtractVisitor.new(@parts, value)
+
+      @format.visit(extract_visitor)
+
+      Version2.new(
+        parts: @parts, format: @format,
+        values: extract_visitor.result
+      )
+    end
+
+    def state
+      [@parts, @format]
+    end
+  end
+end

data/lib/shivers/visitors/extract_visitor.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Shivers
+  module Visitors
+    class ExtractVisitor
+      def initialize(parts, value, _options = {})
+        @parts = parts
+        @value = value
+        @delegate = MatcherVisitor.new(parts)
+      end
+
+      def optionally(&block)
+        @delegate.optionally(&block)
+      end
+
+      def recursively(name, &block)
+        @delegate.recursively(name, &block)
+      end
+
+      def method_missing(symbol, *args, &block)
+        @delegate.send(symbol, *args, &block)
+      end
+
+      def respond_to_missing?(symbol, include_private = false)
+        @delegate.respond_to_missing?(symbol, include_private) || super
+      end
+
+      def result
+        matchers = @delegate.result
+
+        parent_captures = match_parent(matchers)
+        total_captures = match_children(matchers, parent_captures)
+
+        convert_values(total_captures)
+      end
+
+      private
+
+      def match_parent(matchers)
+        standard_captures(/\A#{matchers.capturer.source}\z/, @value)
+      end
+
+      def match_children(matchers, captures)
+        matchers.children.reduce(captures) do |caps, child|
+          value = caps[child.capture_group]
+          first_captures = standard_captures(child.first, value)
+
+          next caps unless first_captures
+
+          rest_captures = recursive_captures(first_captures[:rest], child.rest)
+
+          caps = merge_captures(caps, first_captures)
+          caps = merge_captures(caps, rest_captures)
+
+          caps
+        end
+      end
+
+      def recursive_captures(value, matcher)
+        match_recursively(value, matcher)
+          .reduce({}) do |all_rest_captures, rest_captures|
+          all_rest_captures.merge(rest_captures) do |name, existing, new|
+            merge_capture_value(name, existing, new)
+          end
+        end
+      end
+
+      def match_recursively(value, matcher)
+        rest_matches = value.scan(matcher)
+        rest_capture_names = matcher.names.map(&:to_sym)
+        rest_matches.map do |rest_match|
+          rest_capture_names.zip(rest_match).to_h
+        end
+      end
+
+      def merge_captures(existing, new)
+        new.reduce(existing) do |captures, capture|
+          name, value = capture
+          captures.merge(
+            name =>
+              merge_capture_value(name, captures[name], value)
+          )
+        end
+      end
+
+      def merge_capture_value(name, existing, new)
+        @parts[name]&.merge(existing, new)
+      end
+
+      def standard_captures(matcher, value)
+        return unless value
+
+        ensure_match(matcher.match(value))
+          .named_captures
+          .transform_keys(&:to_sym)
+      end
+
+      def convert_values(captures)
+        capturable_parts
+          .to_h { |name, part| [name, part&.convert(captures[name])] }
+      end
+
+      def ensure_match(match)
+        unless match
+          raise(
+            ArgumentError,
+            "Version string: '#{@value}' does not satisfy expected format."
+          )
+        end
+
+        match
+      end
+
+      def capturable_parts
+        @parts.select { |_, part| part.capturable? }
+      end
+    end
+  end
+end

data/lib/shivers/visitors/matcher_visitor.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative '../matchers'
+require_relative '../value_equality'
+
+module Shivers
+  module Visitors
+    class MatcherVisitor
+      class RecursiveMatcherVisitor
+        def initialize(name, parts)
+          @name = name
+          @parts = parts
+        end
+
+        def first(&block)
+          @first_block = block
+        end
+
+        def rest(&block)
+          @rest_block = block
+        end
+
+        def result
+          first = visit(@first_block, MatcherVisitor.new(@parts))
+          rest = visit(@rest_block, MatcherVisitor.new(@parts))
+
+          Matchers::Child.new(
+            parent_matcher(first, rest), parent_capturer(first, rest),
+            Matchers::Recursive.new(
+              @name, first_capturer(first, rest), rest_capturer(first, rest)
+            )
+          )
+        end
+
+        private
+
+        def visit(block, visitor)
+          block.call(visitor)
+          visitor.result
+        end
+
+        def parent_matcher(first, rest)
+          /#{first.matcher.source}(?:#{rest.matcher.source})*/
+        end
+
+        def parent_capturer(first, rest)
+          /(?<#{@name}>#{first.matcher.source}(?:#{rest.matcher.source})*)/
+        end
+
+        def first_capturer(first, rest)
+          /#{first.capturer.source}(?<rest>(?:#{rest.matcher.source})*)?/
+        end
+
+        def rest_capturer(_, rest)
+          /#{rest.capturer.source}/
+        end
+      end
+
+      def initialize(parts)
+        @parts = parts
+        @matching_regexps = []
+        @capturing_regexps = []
+        @children = []
+      end
+
+      def optionally(&block)
+        sub_visitor = MatcherVisitor.new(@parts)
+        block.call(sub_visitor)
+        result = sub_visitor.result
+        @matching_regexps << /(?:#{result.matcher.source})?/
+        @capturing_regexps << /(?:#{result.capturer.source})?/
+        @children.concat(result.children)
+      end
+
+      def recursively(name, &block)
+        sub_visitor = RecursiveMatcherVisitor.new(name, @parts)
+        block.call(sub_visitor)
+        result = sub_visitor.result
+        @matching_regexps << result.matcher
+        @capturing_regexps << result.capturer
+        @children << result.child
+      end
+
+      def method_missing(symbol, *_)
+        raise no_dsl_element_error(symbol) unless respond_to_missing?(symbol)
+
+        part = @parts[symbol]
+
+        @matching_regexps << part.matcher
+        @capturing_regexps << if part.capturable?
+                                /(?<#{symbol}>#{part.matcher.source})/
+                              else
+                                part.matcher
+                              end
+      end
+
+      def respond_to_missing?(symbol, _ = false)
+        @parts.include?(symbol) || super
+      end
+
+      def result
+        Matchers::Parent.new(
+          /#{@matching_regexps.collect(&:source).join}/,
+          /#{@capturing_regexps.collect(&:source).join}/,
+          @children
+        )
+      end
+
+      private
+
+      def no_dsl_element_error(symbol)
+        NoMethodError.new(
+          "DSL does not include an element with name: '#{symbol}'. "\
+          'Check usage.',
+          symbol
+        )
+      end
+    end
+  end
+end

data/lib/shivers/visitors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'visitors/matcher_visitor'
+require_relative 'visitors/extract_visitor'
+
+module Shivers
+  module Visitors
+  end
+end

data/lib/shivers.rb

@@ -1,30 +1,10 @@
+# frozen_string_literal: true
+
+require 'shivers/library_version'
+require 'shivers/value_equality'
+require 'shivers/matchers'
 require 'shivers/version'
+require 'shivers/version2'
+require 'shivers/version_definition'
 
 require 'semantic'
-
-module Shivers
-  class Version
-    def self.from_file(path)
-      git_sha = ENV['GIT_SHA'] || 'LOCAL'
-      metadata = "#{git_sha}"
-
-      base_version = File.exist?(path) ?
-          File.open(path) { |file| file.read.strip } :
-          '0.0.0'
-
-      Version.new("#{base_version}+#{metadata}")
-    end
-
-    def initialize(version_string)
-      @version = Semantic::Version.new(version_string)
-    end
-
-    def to_docker_tag
-      to_s.gsub(/[\+]/, '_').downcase
-    end
-
-    def to_s
-      @version.to_s
-    end
-  end
-end

data/shivers.gemspec

@@ -1,7 +1,19 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'shivers/version'
+require_relative 'lib/shivers/library_version'
+
+files = %w[
+  bin
+  lib
+  CODE_OF_CONDUCT.md
+  shivers.gemspec
+  Gemfile
+  LICENSE.txt
+  Rakefile
+  README.md
+]
 
 Gem::Specification.new do |spec|
   spec.name = 'shivers'
@@ -9,31 +21,34 @@ Gem::Specification.new do |spec|
   spec.authors = ['InfraBlocks Maintainers']
   spec.email = ['maintainers@infrablocks.io']
 
-  spec.date = '2021-01-11'
   spec.summary = 'Semantic version numbers for CI pipelines.'
-  spec.description = 'Semantic version number management, by file and environment, for CI pipelines.'
+  spec.description = 'Semantic version number management, by file and '\
+                     'environment, for CI pipelines.'
   spec.homepage = 'https://github.com/infrablocks/shivers'
   spec.license = 'MIT'
 
   spec.files = `git ls-files -z`.split("\x0").select do |f|
-    f.match(%r{^(bin|lib|CODE_OF_CONDUCT\.md|shivers\.gemspec|Gemfile|LICENSE\.txt|Rakefile|README\.md)})
+    f.match(/^(#{files.map { |g| Regexp.escape(g) }.join('|')})/)
   end
   spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.6'
+  spec.required_ruby_version = '>= 2.7'
 
   spec.add_dependency 'semantic', '~> 1.6'
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rake_circle_ci', '~> 0.9'
-  spec.add_development_dependency 'rake_github', '~> 0.7'
-  spec.add_development_dependency 'rake_ssh', '~> 0.6'
-  spec.add_development_dependency 'rake_gpg', '~> 0.14'
-  spec.add_development_dependency 'rspec', '~> 3.9'
-  spec.add_development_dependency 'fakefs', '~> 0.18'
-  spec.add_development_dependency 'gem-release', '~> 2.0'
-  spec.add_development_dependency 'simplecov', '~> 0.16'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'fakefs'
+  spec.add_development_dependency 'gem-release'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake_circle_ci'
+  spec.add_development_dependency 'rake_github'
+  spec.add_development_dependency 'rake_gpg'
+  spec.add_development_dependency 'rake_ssh'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
 end