igniter-extensions 0.5.2

data/lib/igniter/extensions/contracts/creator/writer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "write_step"
+require_relative "write_result"
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Creator
+        class Writer
+          VALID_MODES = %i[skip_existing overwrite].freeze
+
+          attr_reader :workflow, :root, :mode
+
+          def initialize(workflow:, root:, mode: :skip_existing)
+            @workflow = workflow
+            @root = File.expand_path(root.to_s)
+            @mode = normalize_mode(mode)
+            freeze
+          end
+
+          def scaffold
+            workflow.scaffold
+          end
+
+          def plan
+            WriteResult.new(root: root, mode: mode, steps: plan_steps)
+          end
+
+          def write
+            WriteResult.new(root: root, mode: mode, steps: directory_steps + file_steps)
+          end
+
+          private
+
+          def normalize_mode(mode)
+            value = mode.to_sym
+            return value if VALID_MODES.include?(value)
+
+            raise ArgumentError, "unsupported creator writer mode #{mode.inspect}"
+          end
+
+          def plan_steps
+            planned_directories + planned_files
+          end
+
+          def planned_directories
+            directories.map do |relative_path|
+              WriteStep.new(
+                kind: :directory,
+                relative_path: relative_path,
+                absolute_path: absolute_path_for(relative_path),
+                status: File.directory?(absolute_path_for(relative_path)) ? :unchanged : :pending
+              )
+            end
+          end
+
+          def planned_files
+            scaffold.files.map do |relative_path, _content|
+              absolute_path = absolute_path_for(relative_path)
+              WriteStep.new(
+                kind: :file,
+                relative_path: relative_path,
+                absolute_path: absolute_path,
+                status: file_plan_status(absolute_path)
+              )
+            end
+          end
+
+          def directory_steps
+            directories.map do |relative_path|
+              absolute_path = absolute_path_for(relative_path)
+              existed = File.directory?(absolute_path)
+              FileUtils.mkdir_p(absolute_path)
+              WriteStep.new(
+                kind: :directory,
+                relative_path: relative_path,
+                absolute_path: absolute_path,
+                status: existed ? :unchanged : :created
+              )
+            end
+          end
+
+          def file_steps
+            scaffold.files.map do |relative_path, content|
+              absolute_path = absolute_path_for(relative_path)
+              parent = File.dirname(absolute_path)
+              FileUtils.mkdir_p(parent)
+
+              if File.exist?(absolute_path) && mode == :skip_existing
+                WriteStep.new(
+                  kind: :file,
+                  relative_path: relative_path,
+                  absolute_path: absolute_path,
+                  status: :skipped,
+                  reason: "existing file preserved"
+                )
+              else
+                status = File.exist?(absolute_path) && File.read(absolute_path) == content ? :unchanged : :written
+                File.write(absolute_path, content)
+                WriteStep.new(
+                  kind: :file,
+                  relative_path: relative_path,
+                  absolute_path: absolute_path,
+                  status: status
+                )
+              end
+            end
+          end
+
+          def file_plan_status(absolute_path)
+            return :pending unless File.exist?(absolute_path)
+            return :skipped if mode == :skip_existing
+
+            :pending
+          end
+
+          def directories
+            scaffold.files.keys.map { |path| File.dirname(path) }.uniq.sort
+          end
+
+          def absolute_path_for(relative_path)
+            File.join(root, relative_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/creator_pack.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "creator/profile"
+require_relative "creator/scaffold"
+require_relative "creator/scope"
+require_relative "creator/report"
+require_relative "creator/workflow"
+require_relative "creator/wizard"
+
+module Igniter
+  module Extensions
+    module Contracts
+      module CreatorPack
+        module_function
+
+        def manifest
+          Igniter::Contracts::PackManifest.new(
+            name: :extensions_creator,
+            requires_packs: [DebugPack],
+            metadata: { category: :developer }
+          )
+        end
+
+        def install_into(kernel)
+          kernel
+        end
+
+        def available_profiles
+          Creator::Profile.available
+        end
+
+        def available_scopes
+          Creator::Scope.available
+        end
+
+        def scaffold(name:, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                     scope: :monorepo_package)
+          authoring_profile = Creator::Profile.build(profile: profile, kind: kind, capabilities: capabilities)
+          target_scope = Creator::Scope.build(scope)
+          Creator::Scaffold.new(
+            name: name,
+            kind: authoring_profile.kind,
+            namespace: namespace,
+            profile: authoring_profile,
+            scope: target_scope
+          )
+        end
+
+        def report(name:, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                   scope: :monorepo_package, pack: nil, target_profile: nil)
+          generated = scaffold(
+            name: name,
+            kind: kind,
+            namespace: namespace,
+            profile: profile,
+            capabilities: capabilities,
+            scope: scope
+          )
+          audit = pack ? DebugPack.audit(pack, profile: target_profile) : nil
+
+          Creator::Report.new(scaffold: generated, audit: audit)
+        end
+
+        def workflow(name:, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                     scope: :monorepo_package, pack: nil, target_profile: nil)
+          Creator::Workflow.new(
+            report: report(
+              name: name,
+              kind: kind,
+              namespace: namespace,
+              profile: profile,
+              capabilities: capabilities,
+              scope: scope,
+              pack: pack,
+              target_profile: target_profile
+            )
+          )
+        end
+
+        def wizard(name: nil, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                   scope: nil, root: nil, mode: :skip_existing, pack: nil, target_profile: nil)
+          Creator::Wizard.new(
+            name: name,
+            kind: kind,
+            namespace: namespace,
+            profile: profile,
+            capabilities: capabilities,
+            scope: scope,
+            root: root,
+            mode: mode,
+            pack: pack,
+            target_profile: target_profile
+          )
+        end
+
+        def writer(name:, root:, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                   scope: :monorepo_package, pack: nil, target_profile: nil, mode: :skip_existing)
+          workflow(
+            name: name,
+            kind: kind,
+            namespace: namespace,
+            profile: profile,
+            capabilities: capabilities,
+            scope: scope,
+            pack: pack,
+            target_profile: target_profile
+          ).writer(root: root, mode: mode)
+        end
+
+        def write(name:, root:, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                  scope: :monorepo_package, pack: nil, target_profile: nil, mode: :skip_existing)
+          writer(
+            name: name,
+            kind: kind,
+            namespace: namespace,
+            profile: profile,
+            capabilities: capabilities,
+            scope: scope,
+            pack: pack,
+            target_profile: target_profile,
+            root: root,
+            mode: mode
+          ).write
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/aggregate_operators.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        module AggregateOperators
+          Operator = Struct.new(
+            :initial_fn, :project, :add, :remove, :finalize, :recompute,
+            keyword_init: true
+          ) do
+            def initial
+              initial_fn.call
+            end
+          end
+
+          module_function
+
+          def count(filter: nil)
+            Operator.new(
+              initial_fn: -> { 0 },
+              project: ->(item) { filter.nil? || filter.call(item) ? 1 : 0 },
+              add: ->(acc, value) { acc + value },
+              remove: ->(acc, value) { acc - value },
+              finalize: ->(acc, _) { acc },
+              recompute: false
+            )
+          end
+
+          def sum(projection:)
+            Operator.new(
+              initial_fn: -> { 0 },
+              project: ->(item) { project(item, projection).to_f },
+              add: ->(acc, value) { acc + value },
+              remove: ->(acc, value) { acc - value },
+              finalize: ->(acc, _) { acc },
+              recompute: false
+            )
+          end
+
+          def avg(projection:)
+            Operator.new(
+              initial_fn: -> { { sum: 0.0, count: 0 } },
+              project: ->(item) { project(item, projection).to_f },
+              add: ->(acc, value) { { sum: acc.fetch(:sum) + value, count: acc.fetch(:count) + 1 } },
+              remove: ->(acc, value) { { sum: acc.fetch(:sum) - value, count: acc.fetch(:count) - 1 } },
+              finalize: lambda { |acc, _|
+                acc.fetch(:count).zero? ? 0.0 : acc.fetch(:sum) / acc.fetch(:count)
+              },
+              recompute: false
+            )
+          end
+
+          def min(projection:)
+            recomputed_projection(projection, &:min)
+          end
+
+          def max(projection:)
+            recomputed_projection(projection, &:max)
+          end
+
+          def group_count(projection:)
+            Operator.new(
+              initial_fn: -> { {} },
+              project: ->(item) { project(item, projection) },
+              add: ->(acc, group_key) { acc.merge(group_key => (acc[group_key] || 0) + 1) },
+              remove: lambda { |acc, group_key|
+                count = (acc[group_key] || 1) - 1
+                count <= 0 ? acc.reject { |key, _| key == group_key } : acc.merge(group_key => count)
+              },
+              finalize: ->(acc, _) { acc },
+              recompute: false
+            )
+          end
+
+          def custom(initial:, add:, remove:)
+            Operator.new(
+              initial_fn: -> { duplicate(initial) },
+              project: ->(item) { item },
+              add: ->(acc, item) { add.call(acc, item) },
+              remove: ->(acc, item) { remove.call(acc, item) },
+              finalize: ->(acc, _) { acc },
+              recompute: false
+            )
+          end
+
+          def project(item, projection)
+            return item if projection.nil?
+            return projection.call(item) if projection.respond_to?(:call)
+
+            key = projection.to_sym
+            return item.output(key) if item.outputs.key?(key)
+            return item.input(key) if item.inputs.key?(key)
+
+            raise KeyError,
+                  "aggregate projection #{projection.inspect} not present on dataflow item #{item.key.inspect}"
+          end
+
+          def recomputed_projection(projection, &finalizer)
+            Operator.new(
+              initial_fn: -> { nil },
+              project: ->(item) { project(item, projection) },
+              add: nil,
+              remove: nil,
+              finalize: ->(_acc, contributions) { finalizer.call(contributions.values) },
+              recompute: true
+            )
+          end
+
+          def duplicate(value)
+            value.frozen? ? value : value.dup
+          rescue TypeError
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/aggregate_state.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        class AggregateState
+          def initialize(operator)
+            @operator = operator
+            @contributions = {}
+            @accum = operator.initial
+          end
+
+          def apply_diff!(diff, collection_result)
+            diff.changed.each do |key|
+              retract!(key)
+              contribute!(key, collection_result[key])
+            end
+
+            diff.added.each do |key|
+              contribute!(key, collection_result[key])
+            end
+
+            diff.removed.each do |key|
+              retract!(key)
+            end
+          end
+
+          def value
+            if @operator.recompute
+              @operator.finalize.call(nil, @contributions)
+            else
+              @operator.finalize.call(@accum, @contributions.size)
+            end
+          end
+
+          private
+
+          def contribute!(key, item)
+            contribution = @operator.project.call(item)
+            return if contribution.nil?
+
+            @contributions[key] = contribution
+            return if @operator.recompute
+
+            @accum = @operator.add.call(@accum, contribution)
+          end
+
+          def retract!(key)
+            old_contribution = @contributions.delete(key)
+            return unless old_contribution
+            return if @operator.recompute
+
+            @accum = @operator.remove.call(@accum, old_contribution)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        class Builder
+          attr_reader :source, :key, :window, :context
+
+          def initialize(source:, key:, window: nil, context: [])
+            @source = source.to_sym
+            @key = key.to_sym
+            @window = window
+            @context = Array(context).map(&:to_sym).freeze
+            @item_block = nil
+            @aggregate_operators = {}
+          end
+
+          def item(&block)
+            @item_block = block
+          end
+
+          def count(name, matching: nil)
+            register(name, AggregateOperators.count(filter: matching))
+          end
+
+          def sum(name, using:)
+            register(name, AggregateOperators.sum(projection: using))
+          end
+
+          def avg(name, using:)
+            register(name, AggregateOperators.avg(projection: using))
+          end
+
+          def min(name, using:)
+            register(name, AggregateOperators.min(projection: using))
+          end
+
+          def max(name, using:)
+            register(name, AggregateOperators.max(projection: using))
+          end
+
+          def group_count(name, using:)
+            register(name, AggregateOperators.group_count(projection: using))
+          end
+
+          def aggregate(name, initial:, add:, remove:)
+            register(name, AggregateOperators.custom(initial: initial, add: add, remove: remove))
+          end
+
+          def build!(environment)
+            raise Igniter::Contracts::Error, "DataflowPack requires an `item do ... end` definition" unless @item_block
+
+            [environment.compile(&@item_block), @aggregate_operators.dup.freeze]
+          end
+
+          private
+
+          def register(name, operator)
+            @aggregate_operators[name.to_sym] = operator
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/collection_result.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        class CollectionResult
+          include Enumerable
+
+          attr_reader :items, :diff
+
+          def initialize(items:, diff:)
+            @items = items.dup.freeze
+            @diff = diff
+            freeze
+          end
+
+          def [](key)
+            items[key]
+          end
+
+          def fetch(key)
+            items.fetch(key)
+          end
+
+          def each(&block)
+            items.each(&block)
+          end
+
+          def each_value(&block)
+            items.each_value(&block)
+          end
+
+          def keys
+            items.keys
+          end
+
+          def values
+            items.values
+          end
+
+          def successes
+            items
+          end
+
+          def summary
+            {
+              mode: :incremental,
+              total: items.size,
+              succeeded: items.size,
+              failed: 0,
+              status: :success,
+              added: diff.added.size,
+              removed: diff.removed.size,
+              changed: diff.changed.size,
+              unchanged: diff.unchanged.size
+            }
+          end
+
+          def to_h
+            {
+              items: items.transform_values(&:to_h),
+              diff: diff.to_h
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/diff.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        Diff = Struct.new(:added, :removed, :changed, :unchanged, keyword_init: true) do
+          def any_changes?
+            added.any? || removed.any? || changed.any?
+          end
+
+          def processed_count
+            added.size + changed.size
+          end
+
+          def explain
+            parts = []
+            parts << "added(#{added.size}): #{added.inspect}" unless added.empty?
+            parts << "removed(#{removed.size}): #{removed.inspect}" unless removed.empty?
+            parts << "changed(#{changed.size}): #{changed.inspect}" unless changed.empty?
+            parts << "unchanged(#{unchanged.size})" unless unchanged.empty?
+            parts.empty? ? "(no changes)" : parts.join(", ")
+          end
+
+          def to_h
+            {
+              added: added,
+              removed: removed,
+              changed: changed,
+              unchanged: unchanged
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/dataflow/item_result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Dataflow
+        class ItemResult
+          attr_reader :key, :inputs, :execution_result, :incremental_result
+
+          def initialize(key:, inputs:, execution_result:, incremental_result:)
+            @key = key
+            @inputs = Igniter::Contracts::NamedValues.new(inputs)
+            @execution_result = execution_result
+            @incremental_result = incremental_result
+            freeze
+          end
+
+          alias result execution_result
+
+          def input(name)
+            inputs.fetch(name)
+          end
+
+          def output(name)
+            execution_result.output(name)
+          end
+
+          def outputs
+            execution_result.outputs
+          end
+
+          def to_h
+            {
+              key: key,
+              inputs: inputs.to_h,
+              execution_result: execution_result.to_h,
+              incremental_result: incremental_result.to_h
+            }
+          end
+        end
+      end
+    end
+  end
+end