highway 0.0.1 → 1.0.1

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

@@ -0,0 +1,48 @@
+#
+# stage.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+
+        # This class represents a stage note in the semantic tree. It contains
+        # information about stage order and execution policy.
+        class Stage
+
+          public
+
+          # Initialize an instance.
+          #
+          # @param index [Integer] Index of the stage.
+          # @param name [String] Name of the stage.
+          # @param policy [Symbol] Execution policy of the stage.
+          def initialize(index:, name:, policy:)
+            @index = index
+            @name = name
+            @policy = policy
+          end
+
+          # Index of the stage.
+          #
+          # @return [Integer]
+          attr_reader :index
+
+          # Name of the stage.
+          #
+          # @return [String]
+          attr_reader :name
+
+          # Execution policy of the stage.
+          #
+          # @return [Symbol]
+          attr_reader :policy
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+#
+# step.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+
+        # This class represents a step node in a parse tree. It contains
+        # information about a single step and its parameters.
+        class Step
+
+          public
+
+          # Initialize an instance.
+          #
+          # @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.
+          def initialize(index:, name:, step_class:, parameters:, preset:, stage:)
+            @index = index
+            @name = name
+            @step_class = step_class
+            @parameters = parameters
+            @preset = preset
+            @stage = stage
+          end
+
+          # Index of step in its scope.
+          #
+          # @return [Integer]
+          attr_reader :index
+
+          # Name of the step.
+          #
+          # @return [String]
+          attr_reader :name
+
+          # Definition class of the step.
+          #
+          # @return [Class]
+          attr_reader :step_class
+
+          # The hash value of step parameters.
+          #
+          # @return [Highway::Compiler::Analyze::Tree::Values::Hash]
+          attr_reader :parameters
+
+          # Parent preset of the step.
+          #
+          # @return [String]
+          attr_reader :preset
+
+          # Parent stage of the step.
+          #
+          # @return [String]
+          attr_reader :stage
+
+        end
+
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/values/array.rb

@@ -0,0 +1,45 @@
+#
+# array.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/values/base"
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Values
+
+          # This class represents an array value in the semantic tree. It
+          # consists of an array of child values.
+          class Array < Values::Base
+
+            public
+
+            # Initialize an instance.
+            #
+            # @param children [Array<Highway::Compiler::Analyze::Tree::Values::*>] The array of child values.
+            def initialize(children)
+              @children = children
+            end
+
+            # The array of child values.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Values::*>]
+            attr_reader :children
+
+            # The flat array of all segments.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            def flatten_segments
+              @children.flat_map(&:flatten_segments)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/values/base.rb

@@ -0,0 +1,67 @@
+#
+# base.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Values
+
+          # This class is a base abstract class for other classes in this
+          # module. You should not use it directly.
+          class Base
+
+            public
+
+            # Initialize an instance.
+            def initialize()
+              raise NotImplementedError.new("You must not call `#{__method__.to_s}` on `#{self.class.to_s}`.")
+            end
+
+            # A flat array of all segments.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            def flatten_segments
+              raise NotImplementedError.new("You must override `#{__method__.to_s}` in `#{self.class.to_s}`.")
+            end
+
+            # A flat array of all segments which satisty the given block.
+            #
+            # @param &block [Block] The selection block.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            def select_segments(&block)
+              flatten_segments.select(&block)
+            end
+
+            # The flat array of variable segments which satisfy the given block.
+            #
+            # @param &block [Block] The selection block.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::Variable>]
+            def select_variable_segments(&block)
+              if block_given?
+                select_segments { |s| s.is_a?(Segments::Variable) && block.call(s) }
+              else
+                select_segments { |s| s.is_a?(Segments::Variable) }
+              end
+            end
+
+            # The flat array of variable segments with the given scope.
+            #
+            # @param &block [Symbol] The lookup scope.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::Variable>]
+            def select_variable_segments_with_scope(scope)
+              select_variable_segments { |s| s.scope == scope }
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/values/hash.rb

@@ -0,0 +1,45 @@
+#
+# hash.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/values/base"
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Values
+
+          # This class represents a hash value in the semantic tree. It
+          # consists of an array of child values.
+          class Hash < Values::Base
+
+            public
+
+            # Initialize an instance.
+            #
+            # @param children [Hash<String, Highway::Compiler::Analyze::Tree::Values::*>] The array of child values.
+            def initialize(children)
+              @children = children
+            end
+
+            # The array of child values.
+            #
+            # @return [Hash<String, Highway::Compiler::Analyze::Tree::Values::*>]
+            attr_reader :children
+
+            # The flat array of all segments.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            def flatten_segments
+              @children.values.flat_map(&:flatten_segments)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/highway/compiler/analyze/tree/values/primitive.rb

@@ -0,0 +1,43 @@
+#
+# primitive.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/values/base"
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+        module Values
+
+          # This class represents a primitive value in the semantic tree. It
+          # consists of an array of segments.
+          class Primitive < Values::Base
+
+            public
+
+            # Initialize an instance.
+            #
+            # @param segments [Array<Highway::Compiler::Analyze::Tree::Segments::*>] The array of segments.
+            def initialize(segments)
+              @segments = segments
+            end
+
+            # The array of segments.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            attr_reader :segments
+
+            # The flat array of all segments.
+            #
+            # @return [Array<Highway::Compiler::Analyze::Tree::Segments::*>]
+            alias :flatten_segments :segments
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+#
+# variable.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+  module Compiler
+    module Analyze
+      module Tree
+
+        # This class represents a variable node in a semantic tree. It contains
+        # information about a single variable.
+        class Variable
+
+          public
+
+          # Initialize an instance.
+          #
+          # @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.
+          def initialize(name:, value:, preset:)
+            @name = name
+            @value = value
+            @preset = preset
+          end
+
+          # Name of the variable.
+          #
+          # @return [String]
+          attr_reader :name
+
+          # Value of the variable.
+          #
+          # @return [Highway::Compiler::Analyze::Tree::Values::*]
+          attr_reader :value
+
+          # Parent preset of the variable.
+          #
+          # @return [String]
+          attr_reader :preset
+
+        end
+
+      end
+    end
+  end
+end

data/lib/highway/compiler/build/builder.rb

@@ -0,0 +1,154 @@
+#
+# builder.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/compiler/analyze/tree/root"
+require "highway/compiler/build/output/manifest"
+require "highway/utilities"
+
+module Highway
+  module Compiler
+    module Build
+
+      # This class is responsible for manifest generation based on the semantic
+      # tree. This is the third and final phase of the compiler.
+      class Builder
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param interface [Highway::Interface] The interface.
+        def initialize(interface:)
+          @interface = interface
+        end
+
+        # Build the manifst.
+        #
+        # The builder resolves variables and steps in the semantic tree for
+        # given preset and builds concrete invocations.
+        #
+        # The builder produces a manifest that is later executed by runner.
+        #
+        # @param sema_tree [Highway::Compiler::Analyze::Tree::Root] The semantic tree.
+        #
+        # return [Highway::Compiler::Build::Output::Manifest]
+        def build(sema_tree:, preset:)
+
+          manifest = Build::Output::Manifest.new()
+
+          manifest.preset = preset
+
+          variables = resolve_variables(sema_tree: sema_tree, preset: preset)
+          steps = resolve_steps(sema_tree: sema_tree, preset: preset)
+
+          build_invocations(stages: sema_tree.stages, variables: variables, steps: steps, manifest: manifest)
+
+          manifest
+
+        end
+
+        private
+
+        def resolve_variables(sema_tree:, preset:)
+
+          exact_variables = sema_tree.variables.select { |variable|
+            variable.preset == preset
+          }
+
+          default_variables = sema_tree.variables.select { |variable|
+            variable.preset == sema_tree.default_preset && !exact_variables.any? { |exact_variable| exact_variable.name == variable.name }
+          }
+
+          default_variables + exact_variables
+
+        end
+
+        def resolve_steps(sema_tree:, preset:)
+
+          stages = sema_tree.stages.sort_by { |stage| stage.index }
+
+          stages.flat_map { |stage|
+
+            exact_steps = sema_tree.steps.select { |step|
+              step.preset == preset && step.stage == stage.name
+            }
+
+            default_steps = sema_tree.steps.select { |step|
+              step.preset == sema_tree.default_preset && step.stage == stage.name
+            }
+
+            exact_steps = exact_steps.sort_by { |step| step.index }
+            default_steps = default_steps.sort_by { |step| step.index }
+
+            exact_steps = nil if exact_steps.empty?
+            default_steps = nil if default_steps.empty?
+
+            exact_steps || default_steps || Array.new()
+
+          }
+
+        end
+
+        def build_invocations(stages:, variables:, steps:, manifest:)
+          steps.each_with_index do |step, index|
+            stage = stages.find { |stage| stage.name == step.stage }
+            parameters = build_value(value: step.parameters, variables: variables)
+            keypath = [step.stage, step.preset, step.name]
+            manifest.add_invocation(index: index + 1, step_class: step.step_class, parameters: parameters, policy: stage.policy, keypath: keypath)
+          end
+        end
+
+        def build_value(value:, variables:)
+          if value.is_a?(Analyze::Tree::Values::Primitive)
+            Analyze::Tree::Values::Primitive.new(
+              build_value_segments(segments: value.segments, variables: variables)
+            )
+          elsif value.is_a?(Analyze::Tree::Values::Array)
+            Analyze::Tree::Values::Array.new(
+              value.children.map { |value|
+                build_value(value: value, variables: variables)
+              }
+            )
+          elsif value.is_a?(Analyze::Tree::Values::Hash)
+            Analyze::Tree::Values::Hash.new(
+              Utilities::hash_map(value.children) { |key, value|
+                [key, build_value(value: value, variables: variables)]
+              }
+            )
+          end
+        end
+
+        def build_value_segments(segments:, variables:)
+
+          resolved = segments.flat_map { |segment|
+            if segment.is_a?(Analyze::Tree::Segments::Variable) && segment.scope == :static
+              variable = variables.find { |variable| variable.name == segment.name }
+              build_value_segments(segments: variable.value.segments, variables: variables)
+            else
+              [segment]
+            end
+          }
+
+          reduced = resolved.reduce([]) { |memo, segment|
+            if last = memo.pop()
+              if last.is_a?(Analyze::Tree::Segments::Text) && segment.is_a?(Analyze::Tree::Segments::Text)
+                memo + [Analyze::Tree::Segments::Text.new(last.value + segment.value)]
+              else
+                memo + [last, segment]
+              end
+            else
+              [segment]
+            end
+          }
+
+          reduced
+
+        end
+
+      end
+
+    end
+  end
+end