highway 0.0.1 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e7516548771a99c73bea486d466a28a3019e93729955a359a6cc004d2336b6f
+  data.tar.gz: '083baad25067f0dd1c23194c04fec6ec53e7478a6aca9e79d40661d5e99c9447'
+SHA512:
+  metadata.gz: db98b371c18cb00198ff871ee8730373d90544bf880a2ccbccb361f1e9603363e6a48372882f1c966f5e413942841d9a53a6472da204338a04e5ad1a4d51e701
+  data.tar.gz: 37d1df04101159db5b871ef8144f857fd79f1499f8795fb42135dd0f141fefa2c60eceb3d59780c091fc1eea74085fdd1b0ddae8eb26e63b74e849342f9d82a4

data/lib/highway.rb

@@ -1,5 +1,9 @@
-require "highway/version"
+#
+# highway.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/fastlane/action"
 
-module Highway
-  # Your code goes here...
-end
+require "highway/main"
+require "highway/version"

data/lib/highway/compiler/analyze/analyzer.rb

@@ -0,0 +1,249 @@
+#
+# analyzer.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/root"
+require "highway/utilities"
+
+module Highway
+  module Compiler
+    module Analyze
+
+      # This class is responsible for semantic analysis of a parse tree. This is
+      # the second phase of the compiler.
+      class Analyzer
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param registry [Highway::Steps::Registry] The steps registry.
+        # @param reporter [Highway::Interface] The interface.
+        def initialize(registry:, interface:)
+          @registry = registry
+          @interface = interface
+        end
+
+        # Analyze the parse tree.
+        #
+        # The semantic analyzer validates the parse tree in terms of content,
+        # performs segmentation of values and resolves steps against the
+        # registry.
+        #
+        # The semantic analyzer produces a semantic tree which is then used by
+        # build phase to generate a manifest.
+        #
+        # @param parse_tree [Highway::Compiler::Parse::Tree::Root] The parse tree.
+        #
+        # @return [Highway::Compiler::Analyze::Tree::Root]
+        def analyze(parse_tree:)
+
+          sema_tree = Analyze::Tree::Root.new()
+
+          sema_tree.add_stage(index: 0, name: "bootstrap", policy: :normal, )
+          sema_tree.add_stage(index: 1, name: "test", policy: :normal)
+          sema_tree.add_stage(index: 2, name: "deploy", policy: :normal)
+          sema_tree.add_stage(index: 3, name: "report", policy: :always)
+
+          sema_tree.default_preset = "default"
+
+          validate_preset_names(parse_tree: parse_tree)
+          validate_variable_names(parse_tree: parse_tree)
+          validate_variable_values(parse_tree: parse_tree)
+          validate_step_names(parse_tree: parse_tree)
+          validate_step_parameter_values(parse_tree: parse_tree)
+
+          resolve_variables(parse_tree: parse_tree, sema_tree: sema_tree)
+          resolve_steps(parse_tree: parse_tree, sema_tree: sema_tree)
+
+          validate_variable_references(sema_tree: sema_tree)
+
+          sema_tree
+
+        end
+
+        private
+
+        def validate_preset_names(parse_tree:)
+          parse_tree.variables.each do |variable|
+            assert_preset_name_valid(variable.preset, keypath: ["variables"])
+          end
+          parse_tree.steps.each do |step|
+            assert_preset_name_valid(step.preset, keypath: [step.stage])
+          end
+        end
+
+        def validate_variable_names(parse_tree:)
+          parse_tree.variables.each do |variable|
+            assert_variable_name_valid(variable.name, keypath: ["variables", variable.preset])
+          end
+        end
+
+        def validate_variable_values(parse_tree:)
+          parse_tree.variables.each do |variable|
+            assert_variable_value_valid(variable.value, keypath: ["variables", variable.preset, variable.name])
+          end
+        end
+
+        def validate_step_names(parse_tree:)
+          parse_tree.steps.each do |step|
+            assert_step_exists(step.name, keypath: [step.stage, step.preset])
+          end
+        end
+
+        def validate_step_parameter_values(parse_tree:)
+          parse_tree.steps.each do |step|
+            step.parameters.each_pair do |param_name, param_value|
+              assert_step_parameter_value_valid(param_value, keypath: [step.stage, step.preset, step.name, param_name])
+            end
+          end
+        end
+
+        def validate_variable_references(sema_tree:)
+          sema_tree.variables.each do |variable|
+            variable.value.select_variable_segments_with_scope(:static).each do |segment|
+              unless (ref_variable = find_referenced_variable(sema_tree: sema_tree, name: segment.name, preset: variable.preset))
+                @interface.fatal!("Unknown variable: '#{segment.name}' referenced from: '#{Utilities::keypath_to_s(["variables", variable.preset, variable.name])}'.")
+              end
+              if ref_variable.value.select_variable_segments_with_scope(:static).any? { |other| other.name == variable.name }
+                @interface.fatal!("Detected a reference cycle between: '#{Utilities::keypath_to_s(["variables", variable.preset, variable.name])}' and '#{Utilities::keypath_to_s(["variables", ref_variable.preset, ref_variable.name])}'.")
+              end
+            end
+          end
+          sema_tree.steps.each do |step|
+            step.parameters.children.each_pair do |name, value|
+              value.select_variable_segments_with_scope(:static).each do |segment|
+                unless find_referenced_variable(sema_tree: sema_tree, name: segment.name, preset: step.preset)
+                  @interface.fatal!("Unknown variable: '#{segment.name}' referenced from: '#{Utilities::keypath_to_s([step.stage, step.preset, step.name, name])}'.")
+                end
+              end
+            end
+          end
+        end
+
+        def resolve_variables(parse_tree:, sema_tree:)
+          parse_tree.variables.each do |variable|
+            value = segmentize_value(variable.value)
+            sema_tree.add_variable(name: variable.name, value: value, preset: variable.preset)
+          end
+        end
+
+        def resolve_steps(parse_tree:, sema_tree:)
+          parse_tree.steps.each do |step|
+            klass = @registry.get_by_name(step.name)
+            parameters = segmentize_value(step.parameters)
+            sema_tree.add_step(index: step.index, name: step.name, step_class: klass, parameters: parameters, stage: step.stage, preset: step.preset)
+          end
+        end
+
+        def segmentize_value(value)
+          if value.is_a?(String)
+            Analyze::Tree::Values::Primitive.new(
+              value.to_enum(:scan, %r((?<!\\)\$\(([A-Z0-9:_]+)\)|((?:[^\\\$]|\\\$)+))).map { Regexp.last_match }.map { |match|
+                if match[1]
+                  if match[1][0, 4] == "ENV:"
+                    Analyze::Tree::Segments::Variable.new(match[1][4..-1], scope: :env)
+                  else
+                    Analyze::Tree::Segments::Variable.new(match[1], scope: :static)
+                  end
+                elsif match[2]
+                  Analyze::Tree::Segments::Text.new(match[2])
+                end
+              }
+            )
+          elsif value.is_a?(Array)
+            Analyze::Tree::Values::Array.new(
+              value.map { |element|
+                segmentize_value(element)
+              }
+            )
+          elsif value.is_a?(Hash)
+            Analyze::Tree::Values::Hash.new(
+              Utilities::hash_map(value) { |name, element|
+                [name, segmentize_value(element)]
+              }
+            )
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric) || value.is_a?(NilClass)
+            Analyze::Tree::Values::Primitive.new(
+              [Analyze::Tree::Segments::Text.new(value.to_s)]
+            )
+          end
+        end
+
+        def find_referenced_variable(sema_tree:, name:, preset:)
+          sema_tree.variables.find do |variable|
+            variable.name == name && [preset, sema_tree.default_preset].include?(variable.preset)
+          end
+        end
+
+        def assert_preset_name_valid(value, keypath:)
+          unless %r(^[a-z_]*$) =~ value
+            @interface.fatal!("Invalid preset name: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+          end
+        end
+
+        def assert_variable_name_valid(value, keypath:)
+          unless %r(^[A-Z_][A-Z0-9_]*$) =~ value
+            @interface.fatal!("Invalid variable name: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+          end
+        end
+
+        def assert_variable_value_valid(value, keypath:)
+          if value.is_a?(String)
+            unless %r(^((?:[^\$]*(?:(?:\\\$)|(?<!\\)\$\((?:ENV:)?[A-Z_][A-Z0-9_]*\))*)*)$) =~ value
+              @interface.fatal!("Invalid variable value: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+            end
+          elsif value.is_a?(Array) || value.is_a?(Hash)
+            @interface.fatal!("Invalid variable value: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+          else
+            unless value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric) || value.is_a?(NilClass)
+              @interface.fatal!("Invalid variable value: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+            end
+          end
+        end
+
+        def assert_step_exists(value, keypath:)
+          unless @registry.get_by_name(value)
+            @interface.fatal!("Unknown step: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+          end
+        end
+
+        def assert_step_parameter_name_valid(value, expected:, keypath:)
+          unless expected.include?(value)
+            expected_names = expected.map { |name| "'#{name}'" }.join(", ")
+            @interface.fatal!("Unknown step parameter: '#{value}' at '#{Utilities::keypath_to_s(keypath)}'. Expected one of: [#{expected_names}].")
+          end
+        end
+
+        def assert_step_parameter_value_valid(value, keypath:)
+          if value.is_a?(String)
+            unless %r(^((?:[^\$]*(?:(?:\\\$)|(?<!\\)\$\((?:ENV:)?[A-Z_]+\))*)*)$) =~ value
+              @interface.fatal!("Invalid step parameter value: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+            end
+          elsif value.is_a?(Array)
+            value.each_with_index do |single_value, index|
+              assert_step_parameter_value_valid(single_value, keypath: keypath + [index])
+            end
+          elsif value.is_a?(Hash)
+            value.each_pair do |key, single_value|
+              assert_step_parameter_value_valid(single_value, keypath: keypath + [key])
+            end
+          else
+            unless value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric) || value.is_a?(NilClass)
+              @interface.fatal!("Invalid step parameter value: '#{value}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+            end
+          end
+        end
+
+        def assert_step_parameter_exists(value, expected:, keypath:)
+          unless value.include?(expected)
+            @interface.fatal!("Missing value for required step parameter: '#{expected}' at: '#{Utilities::keypath_to_s(keypath)}'.")
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/root.rb

@@ -0,0 +1,95 @@
+#
+# root.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/segments/text"
+require "highway/compiler/analyze/tree/segments/variable"
+require "highway/compiler/analyze/tree/stage"
+require "highway/compiler/analyze/tree/step"
+require "highway/compiler/analyze/tree/values/array"
+require "highway/compiler/analyze/tree/values/hash"
+require "highway/compiler/analyze/tree/values/primitive"
+require "highway/compiler/analyze/tree/variable"
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+
+        # This class represents a root node of a semantic tree. It contains
+        # other nodes, such as variables and steps.
+        class Root
+
+          public
+
+          # Initialize an instance.
+          def initialize()
+            @variables = Array.new()
+            @steps = Array.new()
+            @stages = Array.new()
+          end
+
+          # Name of the default preset.
+          #
+          # @return [String]
+          attr_accessor :default_preset
+
+          # Variables in the tree.
+          #
+          # @return [Array<Highway::Compiler::Analyze::Tree::Variable>]
+          attr_reader :variables
+
+          # Steps in the tree.
+          #
+          # @return [Array<Highway::Compiler::Analyze::Tree::Step>]
+          attr_reader :steps
+
+          # Stages in the tree.
+          #
+          # @return [Array<Highway::Compiler::Analyze::Tree::Stage>]
+          attr_reader :stages
+
+          # Add a variable to the tree.
+          #
+          # @param name [String] Name of the variable.
+          # @param value [Highway::Compiler::Analyze::Tree::Values::*] Value of the variable.
+          # @param preset [String] Parent preset of the variable.
+          #
+          # @return [Void]
+          def add_variable(name:, value:, preset:)
+            @variables << Variable.new(name: name, value: value, preset: preset)
+          end
+
+          # Add a step to the tree.
+          #
+          # @param index [Integer] Index of step in its scope.
+          # @param name [String] Name of the step.
+          # @param step_class [Class] Definition class of the step.
+          # @param parameters [Highway::Compiler::Analyze::Tree::Values::Hash] The hash value of step parameters.
+          # @param preset [String] Parent preset of the step.
+          # @param stage [String] Parent stage of the step.
+          #
+          # @return [Void]
+          def add_step(index:, name:, step_class:, parameters:, preset:, stage:)
+            @steps << Step.new(index: index, name: name, step_class: step_class, parameters: parameters, preset: preset, stage: stage)
+          end
+
+
+          # Add a stage to the tree.
+          #
+          # @param index [Integer] Index of the stage.
+          # @param name [String] Name of the stage.
+          # @param policy [Symbol] Execution policy of the stage.
+          #
+          # @return [Void]
+          def add_stage(index:, name:, policy:)
+            @stages << Stage.new(index: index, name: name, policy: policy)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/segments/text.rb

@@ -0,0 +1,36 @@
+#
+# text.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Segments
+
+          # This class represents a text value segment in the semantic tree. It
+          # consists of a raw text value.
+          class Text
+
+            public
+
+            # Initialize an instance.
+            #
+            # @param value [String] The raw text value.
+            def initialize(value)
+              @value = value
+            end
+
+            # The raw text value.
+            #
+            # @return [String]
+            attr_reader :value
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/segments/variable.rb

@@ -0,0 +1,43 @@
+#
+# variable.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Segments
+
+          # This class represents a variable value segment in the semantic
+          # tree. It consists of a variable name and its lookup scope.
+          class Variable
+
+            public
+
+            # Initialize an instance.
+            #
+            # @param name [String] The variable name.
+            # @param scope [Symbol] The lookup scope of variable.
+            def initialize(name, scope:)
+              @name = name
+              @scope = scope
+            end
+
+            # The variable name.
+            #
+            # @return [String]
+            attr_reader :name
+
+            # The lookup scope of the variable.
+            #
+            # @return [Symbol]
+            attr_reader :scope
+
+          end
+
+        end
+      end
+    end
+  end
+end