igniter 0.2.0 → 0.3.0

data/lib/igniter/compiler/validator.rb

@@ -9,196 +9,10 @@ module Igniter
 
       def initialize(graph)
         @graph = graph
-        @runtime_nodes_by_name = {}
       end
 
       def call
-        validate_unique_ids!
-        index_runtime_nodes!
-        validate_outputs!
-        validate_unique_paths!
-        validate_dependencies!
-        validate_callable_signatures!
-
-        self
-      end
-
-      def runtime_nodes
-        @runtime_nodes ||= @graph.nodes.reject { |node| node.kind == :output }
-      end
-
-      def outputs
-        @outputs ||= @graph.nodes.select { |node| node.kind == :output }
-      end
-
-      def runtime_nodes_by_name
-        @runtime_nodes_by_name
-      end
-
-      private
-
-      def validate_unique_ids!
-        seen = {}
-
-        @graph.nodes.each do |node|
-          if seen.key?(node.id)
-            raise validation_error(node, "Duplicate node id: #{node.id}")
-          end
-
-          seen[node.id] = true
-        end
-      end
-
-      def validate_unique_paths!
-        seen = {}
-
-        runtime_nodes.each do |node|
-          if seen.key?(node.path)
-            raise validation_error(node, "Duplicate node path: #{node.path}")
-          end
-
-          seen[node.path] = true
-        end
-
-        outputs.each do |output|
-          if seen.key?(output.path)
-            raise validation_error(output, "Duplicate node path: #{output.path}")
-          end
-
-          seen[output.path] = true
-        end
-      end
-
-      def index_runtime_nodes!
-        runtime_nodes.each do |node|
-          raise validation_error(node, "Duplicate node name: #{node.name}") if @runtime_nodes_by_name.key?(node.name)
-
-          @runtime_nodes_by_name[node.name] = node
-        end
-      end
-
-      def validate_outputs!
-        raise ValidationError, "Graph must define at least one output" if outputs.empty?
-
-        seen = {}
-        outputs.each do |output|
-          raise validation_error(output, "Duplicate output name: #{output.name}") if seen.key?(output.name)
-          raise validation_error(output, "Unknown output source '#{output.source}' for output '#{output.name}'") unless @runtime_nodes_by_name.key?(output.source)
-
-          seen[output.name] = true
-        end
-      end
-
-      def validate_dependencies!
-        runtime_nodes.each do |node|
-          validate_composition_node!(node) if node.kind == :composition
-
-          node.dependencies.each do |dependency_name|
-            next if @runtime_nodes_by_name.key?(dependency_name)
-
-            raise validation_error(node, "Unknown dependency '#{dependency_name}' for node '#{node.name}'")
-          end
-        end
-      end
-
-      def validate_composition_node!(node)
-        contract_class = node.contract_class
-
-        unless contract_class.is_a?(Class) && contract_class <= Igniter::Contract
-          raise validation_error(node, "Composition '#{node.name}' must reference an Igniter::Contract subclass")
-        end
-
-        unless contract_class.compiled_graph
-          raise validation_error(node, "Composition '#{node.name}' references an uncompiled contract")
-        end
-
-        validate_composition_input_mapping!(node, contract_class.compiled_graph)
-      end
-
-      def validate_composition_input_mapping!(node, child_graph)
-        child_input_nodes = child_graph.nodes.select { |child_node| child_node.kind == :input }
-        child_input_names = child_input_nodes.map(&:name)
-
-        unknown_inputs = node.input_mapping.keys - child_input_names
-        unless unknown_inputs.empty?
-          raise validation_error(
-            node,
-            "Composition '#{node.name}' maps unknown child inputs: #{unknown_inputs.sort.join(', ')}"
-          )
-        end
-
-        missing_required_inputs = child_input_nodes
-          .select(&:required?)
-          .reject { |child_input| node.input_mapping.key?(child_input.name) }
-          .map(&:name)
-
-        return if missing_required_inputs.empty?
-
-        raise validation_error(
-          node,
-          "Composition '#{node.name}' is missing mappings for required child inputs: #{missing_required_inputs.sort.join(', ')}"
-        )
-      end
-
-      def validate_callable_signatures!
-        runtime_nodes.each do |node|
-          next unless node.kind == :compute
-          next unless node.callable.is_a?(Proc)
-
-          validate_proc_signature!(node)
-        end
-      end
-
-      def validate_proc_signature!(node)
-        parameters = node.callable.parameters
-        positional_kinds = %i[req opt rest]
-        positional = parameters.select { |kind, _name| positional_kinds.include?(kind) }
-
-        unless positional.empty?
-          raise validation_error(
-            node,
-            "Compute '#{node.name}' proc must use keyword arguments for dependencies, got positional parameters"
-          )
-        end
-
-        accepts_any_keywords = parameters.any? { |kind, _name| kind == :keyrest }
-        accepted_keywords = parameters
-          .select { |kind, _name| %i[key keyreq].include?(kind) }
-          .map(&:last)
-        required_keywords = parameters
-          .select { |kind, _name| kind == :keyreq }
-          .map(&:last)
-
-        missing_dependencies = required_keywords - node.dependencies
-        unless missing_dependencies.empty?
-          raise validation_error(
-            node,
-            "Compute '#{node.name}' requires undeclared dependencies: #{missing_dependencies.sort.join(', ')}"
-          )
-        end
-
-        return if accepts_any_keywords
-
-        unknown_dependencies = node.dependencies - accepted_keywords
-        return if unknown_dependencies.empty?
-
-        raise validation_error(
-          node,
-          "Compute '#{node.name}' declares unsupported dependencies for its proc: #{unknown_dependencies.sort.join(', ')}"
-        )
-      end
-
-      def validation_error(node, message)
-        ValidationError.new(
-          message,
-          context: {
-            graph: @graph.name,
-            node_id: node.id,
-            node_name: node.name,
-            node_path: node.path,
-            source_location: node.source_location
-          }
-        )
+        ValidationPipeline.call(ValidationContext.new(@graph))
       end
     end
   end

data/lib/igniter/compiler/validators/callable_validator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    module Validators
+      class CallableValidator
+        def self.call(context)
+          new(context).call
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        def call
+          @context.runtime_nodes.each do |node|
+            next unless node.kind == :compute
+
+            validate_callable_signature!(node)
+          end
+        end
+
+        private
+
+        def validate_callable_signature!(node)
+          callable = node.callable
+
+          case callable
+          when Proc
+            validate_parameters_signature!(node, callable.parameters, "proc")
+          when Class
+            validate_class_callable_signature!(node, callable)
+          when Symbol, String
+            nil
+          else
+            validate_object_callable_signature!(node, callable)
+          end
+        end
+
+        def validate_class_callable_signature!(node, callable)
+          if callable <= Igniter::Executor
+            validate_executor_inputs!(node, callable)
+            validate_parameters_signature!(node, callable.instance_method(:call).parameters, callable.name || "executor")
+          elsif callable.respond_to?(:call)
+            validate_parameters_signature!(node, callable.method(:call).parameters, callable.name || "callable class")
+          else
+            raise @context.validation_error(node, "Compute '#{node.name}' class callable must respond to `.call`")
+          end
+        end
+
+        def validate_object_callable_signature!(node, callable)
+          unless callable.respond_to?(:call)
+            raise @context.validation_error(node, "Compute '#{node.name}' callable object must respond to `call`")
+          end
+
+          validate_parameters_signature!(node, callable.method(:call).parameters, callable.class.name || "callable object")
+        end
+
+        def validate_executor_inputs!(node, executor_class)
+          declared_inputs = executor_class.executor_inputs
+          required_inputs = declared_inputs.select { |_name, config| config[:required] }.keys
+          missing_dependencies = required_inputs - node.dependencies
+
+          return if missing_dependencies.empty?
+
+          raise @context.validation_error(
+            node,
+            "Compute '#{node.name}' executor requires undeclared dependencies: #{missing_dependencies.sort.join(', ')}"
+          )
+        end
+
+        def validate_parameters_signature!(node, parameters, callable_label)
+          positional_kinds = %i[req opt rest]
+          positional = parameters.select { |kind, _name| positional_kinds.include?(kind) }
+          unless positional.empty?
+            raise @context.validation_error(
+              node,
+              "Compute '#{node.name}' #{callable_label} must use keyword arguments for dependencies, got positional parameters"
+            )
+          end
+
+          accepts_any_keywords = parameters.any? { |kind, _name| kind == :keyrest }
+          accepted_keywords = parameters.select { |kind, _name| %i[key keyreq].include?(kind) }.map(&:last)
+          required_keywords = parameters.select { |kind, _name| kind == :keyreq }.map(&:last)
+
+          missing_dependencies = required_keywords - node.dependencies
+          unless missing_dependencies.empty?
+            raise @context.validation_error(
+              node,
+              "Compute '#{node.name}' #{callable_label} requires undeclared dependencies: #{missing_dependencies.sort.join(', ')}"
+            )
+          end
+
+          return if accepts_any_keywords
+
+          unknown_dependencies = node.dependencies - accepted_keywords
+          return if unknown_dependencies.empty?
+
+          raise @context.validation_error(
+            node,
+            "Compute '#{node.name}' declares unsupported dependencies for its #{callable_label}: #{unknown_dependencies.sort.join(', ')}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler/validators/dependencies_validator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    module Validators
+      class DependenciesValidator
+        def self.call(context)
+          new(context).call
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        def call
+          @context.runtime_nodes.each do |node|
+            validate_composition_node!(node) if node.kind == :composition
+            validate_branch_node!(node) if node.kind == :branch
+            validate_collection_node!(node) if node.kind == :collection
+
+            node.dependencies.each do |dependency_name|
+              next if @context.dependency_resolvable?(dependency_name)
+
+              raise @context.validation_error(node, "Unknown dependency '#{dependency_name}' for node '#{node.name}'")
+            end
+          end
+        end
+
+        private
+
+        def validate_composition_node!(node)
+          contract_class = node.contract_class
+
+          unless contract_class.is_a?(Class) && contract_class <= Igniter::Contract
+            raise @context.validation_error(node, "Composition '#{node.name}' must reference an Igniter::Contract subclass")
+          end
+
+          unless contract_class.compiled_graph
+            raise @context.validation_error(node, "Composition '#{node.name}' references an uncompiled contract")
+          end
+
+          validate_composition_input_mapping!(node, contract_class.compiled_graph)
+        end
+
+        def validate_composition_input_mapping!(node, child_graph)
+          child_input_nodes = child_graph.nodes.select { |child_node| child_node.kind == :input }
+          child_input_names = child_input_nodes.map(&:name)
+
+          unknown_inputs = node.input_mapping.keys - child_input_names
+          unless unknown_inputs.empty?
+            raise @context.validation_error(
+              node,
+              "Composition '#{node.name}' maps unknown child inputs: #{unknown_inputs.sort.join(', ')}"
+            )
+          end
+
+          missing_required_inputs = child_input_nodes
+            .select(&:required?)
+            .reject { |child_input| node.input_mapping.key?(child_input.name) }
+            .map(&:name)
+
+          return if missing_required_inputs.empty?
+
+          raise @context.validation_error(
+            node,
+            "Composition '#{node.name}' is missing mappings for required child inputs: #{missing_required_inputs.sort.join(', ')}"
+          )
+        end
+
+        def validate_branch_node!(node)
+          validate_branch_structure!(node)
+
+          node.possible_contracts.each do |contract_class|
+            validate_branch_contract!(node, contract_class)
+            validate_branch_input_mapping!(node, contract_class.compiled_graph)
+          end
+        end
+
+        def validate_branch_structure!(node)
+          raise @context.validation_error(node, "Branch '#{node.name}' must define at least one `on` case") if node.cases.empty?
+          raise @context.validation_error(node, "Branch '#{node.name}' must define a `default` contract") unless node.default_contract
+
+          duplicate_matches = node.cases.group_by { |entry| entry[:match] }.select { |_match, entries| entries.size > 1 }.keys
+          return if duplicate_matches.empty?
+
+          raise @context.validation_error(
+            node,
+            "Branch '#{node.name}' has duplicate case values: #{duplicate_matches.map(&:inspect).join(', ')}"
+          )
+        end
+
+        def validate_branch_contract!(node, contract_class)
+          unless contract_class.is_a?(Class) && contract_class <= Igniter::Contract
+            raise @context.validation_error(node, "Branch '#{node.name}' must reference Igniter::Contract subclasses")
+          end
+
+          unless contract_class.compiled_graph
+            raise @context.validation_error(node, "Branch '#{node.name}' references an uncompiled contract")
+          end
+        end
+
+        def validate_branch_input_mapping!(node, child_graph)
+          child_input_nodes = child_graph.nodes.select { |child_node| child_node.kind == :input }
+          child_input_names = child_input_nodes.map(&:name)
+
+          unknown_inputs = node.input_mapping.keys - child_input_names
+          unless unknown_inputs.empty?
+            raise @context.validation_error(
+              node,
+              "Branch '#{node.name}' maps unknown child inputs: #{unknown_inputs.sort.join(', ')}"
+            )
+          end
+
+          missing_required_inputs = child_input_nodes
+            .select(&:required?)
+            .reject { |child_input| node.input_mapping.key?(child_input.name) }
+            .map(&:name)
+
+          return if missing_required_inputs.empty?
+
+          raise @context.validation_error(
+            node,
+            "Branch '#{node.name}' is missing mappings for required child inputs: #{missing_required_inputs.sort.join(', ')}"
+          )
+        end
+
+        def validate_collection_node!(node)
+          unless node.contract_class.is_a?(Class) && node.contract_class <= Igniter::Contract
+            raise @context.validation_error(node, "Collection '#{node.name}' must reference an Igniter::Contract subclass")
+          end
+
+          unless node.contract_class.compiled_graph
+            raise @context.validation_error(node, "Collection '#{node.name}' references an uncompiled contract")
+          end
+
+          unless %i[collect fail_fast].include?(node.mode)
+            raise @context.validation_error(node, "Collection '#{node.name}' mode must be `:collect` or `:fail_fast`")
+          end
+
+          child_input_names = node.contract_class.compiled_graph.nodes.select { |child_node| child_node.kind == :input }.map(&:name)
+          return if child_input_names.include?(node.key_name)
+
+          raise @context.validation_error(
+            node,
+            "Collection '#{node.name}' key '#{node.key_name}' must be a child contract input"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler/validators/outputs_validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    module Validators
+      class OutputsValidator
+        def self.call(context)
+          new(context).call
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        def call
+          raise ValidationError, "Graph must define at least one output" if @context.outputs.empty?
+
+          @context.outputs.each { |output| validate_output_source!(output) }
+        end
+
+        private
+
+        def validate_output_source!(output)
+          if output.composition_output?
+            validate_nested_output_source!(output)
+          else
+            return if @context.runtime_nodes_by_name.key?(output.source)
+
+            raise @context.validation_error(output, "Unknown output source '#{output.source}' for output '#{output.name}'")
+          end
+        end
+
+        def validate_nested_output_source!(output)
+          parent_node = @context.runtime_nodes_by_name[output.source_root]
+          unless %i[composition branch].include?(parent_node&.kind)
+            raise @context.validation_error(
+              output,
+              "Output '#{output.name}' references unknown nested source '#{output.source}'"
+            )
+          end
+
+          validate_nested_output_presence!(output, parent_node)
+        end
+
+        def validate_nested_output_presence!(output, parent_node)
+          child_graphs =
+            case parent_node.kind
+            when :composition
+              [parent_node.contract_class.compiled_graph]
+            when :branch
+              parent_node.possible_contracts.map(&:compiled_graph)
+            else
+              []
+            end
+
+          return if child_graphs.all? { |graph| graph.outputs_by_name.key?(output.child_output_name) }
+
+          raise @context.validation_error(
+            output,
+            "Output '#{output.name}' references unknown child output '#{output.child_output_name}' on nested source '#{parent_node.name}'"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler/validators/type_compatibility_validator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    module Validators
+      class TypeCompatibilityValidator
+        def self.call(context)
+          new(context).call
+        end
+
+        def initialize(context)
+          @context = context
+          @resolver = TypeResolver.new(context)
+        end
+
+        def call
+          validate_executor_dependency_types!
+          validate_composition_input_types!
+        end
+
+        private
+
+        def validate_executor_dependency_types!
+          @context.runtime_nodes.each do |node|
+            next unless node.kind == :compute
+            next unless node.callable.is_a?(Class) && node.callable <= Igniter::Executor
+
+            node.callable.executor_inputs.each do |dependency_name, config|
+              next unless node.dependencies.include?(dependency_name)
+
+              validate_edge_type!(
+                node: node,
+                dependency_name: dependency_name,
+                target_type: config[:type],
+                label: "executor input '#{dependency_name}'"
+              )
+            end
+          end
+        end
+
+        def validate_composition_input_types!
+          @context.runtime_nodes.each do |node|
+            next unless node.kind == :composition
+
+            child_inputs = node.contract_class.compiled_graph.nodes.select { |child_node| child_node.kind == :input }
+            child_inputs.each do |child_input|
+              dependency_name = node.input_mapping[child_input.name]
+              next unless dependency_name
+
+              validate_edge_type!(
+                node: node,
+                dependency_name: dependency_name,
+                target_type: child_input.type,
+                label: "composition input '#{child_input.name}'"
+              )
+            end
+          end
+        end
+
+        def validate_edge_type!(node:, dependency_name:, target_type:, label:)
+          return unless target_type
+
+          unless TypeSystem.supported?(target_type)
+            raise @context.validation_error(node, "Unsupported target type '#{target_type}' for #{label}")
+          end
+
+          source_type = @resolver.call(dependency_name)
+          return if source_type.nil?
+
+          unless TypeSystem.supported?(source_type)
+            raise @context.validation_error(node, "Unsupported source type '#{source_type}' for dependency '#{dependency_name}'")
+          end
+
+          return if TypeSystem.compatible?(source_type, target_type)
+
+          raise @context.validation_error(
+            node,
+            "Type mismatch for #{label}: dependency '#{dependency_name}' is #{source_type}, expected #{target_type}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler/validators/uniqueness_validator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    module Validators
+      class UniquenessValidator
+        def self.call(context)
+          new(context).call
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        def call
+          validate_unique_ids!
+          validate_unique_names!
+          validate_unique_paths!
+        end
+
+        private
+
+        def validate_unique_ids!
+          seen = {}
+          @context.graph.nodes.each do |node|
+            raise @context.validation_error(node, "Duplicate node id: #{node.id}") if seen.key?(node.id)
+
+            seen[node.id] = true
+          end
+        end
+
+        def validate_unique_names!
+          seen_runtime = {}
+          @context.runtime_nodes.each do |node|
+            raise @context.validation_error(node, "Duplicate node name: #{node.name}") if seen_runtime.key?(node.name)
+
+            seen_runtime[node.name] = true
+          end
+
+          seen_outputs = {}
+          @context.outputs.each do |output|
+            raise @context.validation_error(output, "Duplicate output name: #{output.name}") if seen_outputs.key?(output.name)
+
+            seen_outputs[output.name] = true
+          end
+        end
+
+        def validate_unique_paths!
+          seen = {}
+
+          (@context.runtime_nodes + @context.outputs).each do |node|
+            raise @context.validation_error(node, "Duplicate node path: #{node.path}") if seen.key?(node.path)
+
+            seen[node.path] = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "compiler/compiled_graph"
+require_relative "compiler/validation_context"
+require_relative "compiler/type_resolver"
+require_relative "compiler/validators/uniqueness_validator"
+require_relative "compiler/validators/outputs_validator"
+require_relative "compiler/validators/dependencies_validator"
+require_relative "compiler/validators/callable_validator"
+require_relative "compiler/validators/type_compatibility_validator"
+require_relative "compiler/validation_pipeline"
 require_relative "compiler/validator"
 require_relative "compiler/graph_compiler"