rudder 0.1.0

data/lib/rudder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+require_relative 'rudder/dsl.rb'
+require_relative 'rudder/version.rb'
+
+##
+# Methods to compile Rudder definitions
+# to Concourse Pipeline definitions
+#
+module Rudder
+  ##
+  # Compiles a {Rudder::DSL::Pipeline} definition from +path+
+  # to a {Hash}
+  #
+  # @param path [String] the path to the +Rudder+ definition
+  # @return [Hash] Concourse YAML friendly hash
+  #
+  def self.compile(path)
+    Rudder::DSL.eval_from_file(path).to_h
+  end
+
+  ##
+  # Dumps a {Rudder::DSL::Pipeline} or Pipeline {Hash}
+  # to the provided file handle +output+
+  #
+  # @param pipeline {Rudder::DSL::Pipeline} definition. Assumed to be evaluated.
+  # @param output [File] handle to dump YAML to
+  # @return [nil]
+  #
+  def self.dump(pipeline, output)
+    output.puts(YAML.dump(pipeline.to_h))
+  end
+end

data/lib/rudder/dsl.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'dsl/pipeline.rb'
+
+module Rudder
+  ##
+  # DSL for configuring and manipulating Concourse Pipelines
+  #
+  # The building blocks of the DSL are:
+  # - {Rudder::DSL::Pipeline}, the top level definition containg all other definitions.
+  #   See {https://concourse-ci.org/pipelines.html Concourse Pipeline}
+  # - {Rudder::DSL::Resource}, representing inputs and outputs of jobs.
+  #   See {https://concourse-ci.org/resources.html Concourse Resource}
+  # - {Rudder::DSL::Job}, units of work.
+  #   See {https://concourse-ci.org/jobs.html Concourse Job}
+  # - {Rudder::DSL::ResourceType}, defines how a {Rudder::DSL::Resource} operates.
+  #   See {https://concourse-ci.org/resource-types.html Concourse Resource Type}
+  # - {Rudder::DSL::Group}, logically groups together Concourse Jobs in the UI.
+  #   See {https://concourse-ci.org/pipeline-groups.html Concourse Grouping Jobs}
+  #
+  module DSL
+    ##
+    # Entry to the DSL. Creates a new pipeline
+    # instance to evaluate user defined pipelines
+    #
+    # @return [Rudder::DSL::Pipeline] new, and unevaluated
+    #
+    def self.pipeline(*args, **kwargs)
+      Rudder::DSL::Pipeline.new(*args, **kwargs)
+    end
+
+    ##
+    # Load a pipeline from a definition file
+    # at the +path+
+    #
+    # @param path [String] to the {Rudder::DSL::Pipeline} definition
+    # @return [Rudder::DSL::Pipeline] from +path+, unevaluated
+    #
+    def self.from_file(path)
+      Rudder::DSL::Pipeline.new path
+    end
+
+    ##
+    # Load and evaluate a pipeline from a definition file
+    # at the +path+
+    #
+    # @param path [String] to the {Rudder::DSL::Pipeline} definition
+    # @return [Rudder::DSL::Pipeline] from +path+, fully evaluated
+    #
+    def self.eval_from_file(path)
+      Rudder::DSL::Pipeline.new(path).eval
+    end
+  end
+end

data/lib/rudder/dsl/component.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'util'
+
+module Rudder
+  module DSL
+    ##
+    # Base class for other pipeline sub components to extend
+    #
+    # Not intended for public usage and subject to change.
+    #
+    class Component
+      include Rudder::DSL::Util
+
+      ##
+      # Required method for all subclasses to implement.
+      #
+      # @raise [RuntimeError] if not implemented
+      def _inner_hash
+        raise 'Implement this in a subclass'
+      end
+
+      def to_h
+        _deep_to_h(_inner_hash)
+      end
+
+      ##
+      # Populates the inner hash with missing method names and
+      # their arguments
+      #
+      # @param method [Symbol] top level key of this {Rudder::DSL::Component}
+      #                Corresponds to the highest level key in a concourse
+      #                component.
+      #
+      # @param *args entire arg collection is assigned to the value of the key
+      #              +method+. Note: if only 1 argument is provided it is
+      #              unwrapped from the +args+ {Array}.
+      # @param **kwargs treated as the last value of +args+ if provided
+      # @return the value related to +method+ if no arguments or keyword
+      #                arguments are provided. Otherwise, +nil+.
+      #
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method, *args, **kwargs)
+        # Accessing inner hash as attribute
+        return _inner_hash[method] if args.empty? && kwargs.empty?
+
+        # Ruby treats dictionaries passed as the last argument as keyword dicts
+        # (specifically when they use symbols as keys). Just smashing
+        # these into args so we don't miss anything
+        args << kwargs unless kwargs.empty?
+        raise "Argument list missing from [#{method}]" if args.empty?
+
+        # If a single arg is given then assume this field is scalar,
+        # otherwise assume its a list that needs all args
+        formatted_args = args.size == 1 ? args[0] : args
+        _inner_hash[method] = formatted_args
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      ##
+      # Components respond to everything by default
+      #
+      # @return true
+      #
+      def respond_to?(_name, _include_all = true)
+        true
+      end
+
+      ##
+      # Components respond to missing by default
+      #
+      # @return true
+      #
+      def respond_to_missing?(*_)
+        true
+      end
+    end
+  end
+end

data/lib/rudder/dsl/group.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Rudder
+  module DSL
+    ##
+    # Concourse group. Logically groups together Concourse
+    # jobs in the UI.
+    #
+    # == DSL Usage:
+    #
+    # {Rudder::DSL::Group}'s are the simplest element of any
+    # Concourse Pipeline, defined by only a name and a non-empty
+    # list of jobs.
+    #
+    #
+    # @example
+    #   # Name's are typically set during initialization
+    #   group :my_awesome_group do # => Name is set to :my_awesome_group
+    #
+    #   # but the name may be changed post construction as well
+    #   group :not_the_best_name do # => Name initialized to :not_the_best_name
+    #     name :the_best_name
+    #   end # => but is set to :the_best_name after the block is executed
+    #
+    # @example
+    #   # Job's are always set post construction. They can be added
+    #   # individually:
+    #   group :my_awesome_group do
+    #     job :some_prereq
+    #     job :my_awesome_work
+    #   end # => group.jobs = [:some_prereq, :my_awesome_work]
+    #
+    #   # and they can be added in collections
+    #   group :my_awesome_group do
+    #     jobs :a_job, :and_another, :and_one_more
+    #   end # => group.jobs = [:a_job, :and_another, :and_one_more]
+    #
+    #
+    class Group
+      ##
+      # All {Rudder::DSL::Group}'s require
+      #
+      # - Name of the group
+      # - A list of jobs in the group
+      #
+      # Jobs are added after initilization.
+      #
+      # @param [String, Symbol] the non-+nil+ name of this group
+      # @raise [ArgumentError] if +name+ is +nil
+      #
+      def initialize(name)
+        raise super.ArgumentError 'Name cannot be nil' if name.nil?
+
+        @name = name
+        @jobs = Set.new
+      end
+
+      ##
+      # Replace's this {Rudder::DSL::Group}'s name unless
+      # +name+ is nil.
+      #
+      # @param name [String, Symbol] the new name to use. Ignored if +nil+.
+      # @return [String, Symbol] the latest component name.
+      #
+      def name(name = nil)
+        @name = name unless name.nil?
+        @name
+      end
+
+      ##
+      # Add a single job to the jobs list
+      #
+      # @param job_name [String, Symbol] to add to the jobs list
+      # @return [Set<String, Symbol>] the latest list of jobs
+      #
+      def job(job_name)
+        jobs job_name
+      end
+
+      ##
+      # Adds all the jobs to the jobs list
+      #
+      # @param *args [*String, *Symbol] collection of jobs to add to this
+      #        {Rudder::DSL::Group}
+      # @return [Set<String, Symbol>] the latest list of jobs
+      #
+      def jobs(*args)
+        args.each { |arg| @jobs << arg }
+        @jobs
+      end
+
+      ##
+      # @return [Hash] YAML friendly +Hash+ representation of this resource
+      #
+      # @raise [RuntimeError] if +name+ is +nil+ or +jobs+ is empty
+      #
+      def to_h
+        raise 'Groups require a name'         if @name.nil?
+        raise 'Groups require at least 1 job' if @jobs.empty?
+
+        {
+          'name' => @name.to_s,
+          'jobs' => @jobs.to_a.map(&:to_s)
+        }
+      end
+    end
+  end
+end

data/lib/rudder/dsl/job.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+
+module Rudder
+  module DSL
+    ##
+    # Concourse job
+    #
+    # Defines a plan of work that may share state
+    # in an explicit manner.
+    #
+    # == DSL Usage:
+    #
+    # {Rudder::DSL::Job} are defined by a +name+ and a +plan+ of work.
+    #
+    # @example
+    #   # Name's are set during initializtion, and may not be nil
+    #   job :awesome_job # => job.name = :awesome_job
+    #
+    #   job nil # => Raises ArgumentError
+    #
+    # @example
+    #   # The plan is set after construction
+    #   job :awesome_job do
+    #     plan << { get: :some_resource   }
+    #     plan << { get: :another_resource }
+    #   end # => plan.source = [{get: :some_resource}, {get: :another_resource}]
+    #
+    class Job < Rudder::DSL::Component
+      ##
+      # All Jobs require:
+      #
+      # - A name
+      # - A plan of work
+      #
+      # Plans are defined after initialization
+      #
+      # @param name [String, Symbol] name of this Concourse job. Must not be +nil+
+      # @raise [ArgumentError] when +name+ is nil
+      #
+      def initialize(name)
+        raise super.ArgumentError 'Name cannot be nil' if name.nil?
+
+        @job = { name: name, plan: [] }
+      end
+
+      def _inner_hash
+        @job
+      end
+
+      ##
+      # @return [Hash] YAML friendly +Hash+ representation of this resource
+      #
+      # @raise [RuntimeError] if +name+ is +nil+ or +plan+ is empty
+      #
+      def to_h
+        raise 'Name must be set for Concourse Jobs' if @job[:name].nil?
+        raise 'Plan must be set for Concourse Jobs' if @job[:plan].empty?
+
+        super.to_h
+      end
+    end
+  end
+end

data/lib/rudder/dsl/pipeline.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+require_relative 'group'
+require_relative 'job'
+require_relative 'resource'
+require_relative 'resource_type'
+require_relative 'util'
+
+module Rudder
+  module DSL
+    ##
+    # Concourse Pipeline. Main entry of the DSL. Evaluates
+    # user defined pipelines.
+    #
+    # == DSL Usage:
+    #
+    # {Rudder::DSL::Pipeline}'s are composed of various components:
+    #
+    # - {Rudder::DSL::Resource}: basic inputs and output of jobs.
+    # - {Rudder::DSL::Job}: basic computation unit of a pipeline
+    # - {Rudder::DSL::ResourceType}: custom resource definitions
+    # - {Rudder::DSL::Group}: logical grouping of jobs in the UI.
+    #   Either every job is in a Group or no job is (hard Concourse
+    #   requirement)
+    #
+    # === Adding Components
+    #
+    # Components are added to the Pipeline by component type, followed
+    # by name, optional arguments, then typically a block.
+    #
+    # @example Adding Components to Pipelines
+    #   #
+    #   # my_pipeline_definition.rb
+    #   #
+    #   resource :my_git_repo, :git do
+    #     source[:uri]    = 'https://github.com/my/repo.git'
+    #     source[:branch] = :master
+    #   end
+    #
+    #   resource :daily, :time do
+    #     source[:interval] = '24h'
+    #
+    #   job :build_project do
+    #     plan << [in_parallel: [{ get: :my_git_repo }, { get: :daily, trigger: true}]]
+    #     build = { task: 'build my project', config: {
+    #       platform: :linux,
+    #       image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+    #       run: { path: 'my_git_repo/build.sh' }
+    #     }}
+    #     plan << build
+    #   end
+    #
+    #
+    # === Loading Other Pipelines
+    #
+    # {Rudder::DSL::Pipeline}'s can load other pipeline definitions
+    # using {Rudder::DSL::Pipeline#load}. This is a useful mechanism
+    # for abstracting out common subsections of pipelines, then
+    # merging them into larger pipelines.
+    #
+    # @example Loading / Importing Pipelines
+    #   #
+    #   # load_neighbor.rb
+    #   #
+    #   neighbor = load 'neighbor_pipeline.rb'
+    #
+    #   # merge all the neighboring resources and jobs into this pipeline
+    #   resources.merge! neighbor.resources
+    #   jobs.merge! neighbor.jobs
+    #
+    #   resource_type :slack_notification, 'docker-image' do
+    #     source[:repository] = 'some/slack-docker-repo'
+    #   end
+    #
+    #   resource :our_slack_channel, :slack_notification do
+    #     source[:url] = '((slack-team-webhook))'
+    #   end
+    #
+    #   # Add a slack notification task to the end
+    #   # of every job
+    #   jobs.values.each do |job|
+    #     job.plan << {
+    #       put: :our_slack_channel,
+    #       params: { text: "Job #{job.name} complete!" }
+    #     }
+    #   end
+    #
+    # === Loading Individual Components
+    # Individual pipeline components can also be defined on a per-file
+    # basis and then loaded into a {Rudder::DSL::Pipeline} using
+    # {Rudder::DSL::Pipeline#load_component}. This is useful for factoring
+    # out common resources for multiple pipeline's to use.
+    #
+    # @example Loading / Importing Individual Components
+    #   #
+    #   # operations_scripts_resource.rb
+    #   #
+    #   type :git
+    #   source[:uri]    = 'https://github.com/<our org>/operations_scripts.git'
+    #   source[:branch] = 'master'
+    #
+    #
+    #   #
+    #   # some_operations_pipeline.rb
+    #   #
+    #
+    #   # load the resource into the pipeline. Automatically includes
+    #   # the resource into the resources list with the name :scripts
+    #   load_component 'operations_scripts_resource.rb', :resource, :scripts
+    #
+    #   job :audit do |pipeline|
+    #     plan << {
+    #       task: 'run the audit script', config: {
+    #         platform: :linux,
+    #         image_resource: {
+    #           type: 'docker-image',
+    #           source: { repository: 'alpine/git' }
+    #         },
+    #         run: {
+    #           path: pipeline.scripts.sub_path('audit.rb')
+    #         }
+    #       }
+    #     }
+    #   end
+    class Pipeline
+      include Rudder::DSL::Util
+      # {Hash} of names to {Rudder::DSL::Resource}
+      # @return [Hash<(String, Symbol), Rudder::DSL::Resource>]
+      attr_accessor :resources
+      # {Hash} of names to {Rudder::DSL::Job}
+      # @return [Hash<(String, Symbol), Rudder::DSL::Job>]
+      attr_accessor :jobs
+      # {Hash} of names to {Rudder::DSL::ResourceType}
+      # @return [Hash<(String, Symbol), Rudder::DSL::ResourceType>]
+      attr_accessor :resource_types
+      # {Hash} of names to {Rudder::DSL::Group}
+      # @return [Hash<(String, Symbol), Rudder::DSL::Group>]
+      attr_accessor :groups
+
+      ##
+      # All pipelines require:
+      # - Jobs
+      # - Resources
+      #
+      # Concourse Pipelines may optionally provide:
+      # - Resource Types
+      # - Groups
+      #
+      # +Rudder+ Pipelines may optionally include a +file_path+. This
+      # is required when loading resources from neighboring files.
+      #
+      # All pipeline requirements are only needed at the Pipeline
+      # render time (after evaluation), and need not be specified
+      # for initialization.
+      #
+      # @param file_path [String] path to this {Rudder::DSL::Pipeline} definition.
+      # @param resources [Hash<(String, Symbol), Rudder::DSL::Resource]
+      #                  map of Resource names to their definitions.
+      # @param jobs      [Hash<(String, Symbol), Rudder::DSL::Job]
+      #                  map of Job names to their definitions.
+      # @param groups    [Hash<(String, Symbol), Rudder::DSL::Group]
+      #                  map of Group names to their definitions.
+      # @param resources_types [Hash<(String, Symbol), Rudder::DSL::ResourceType]
+      #                  map of Resource Type names to their definitions.
+      #
+      def initialize(file_path = nil, resources: {}, jobs: {},
+                     groups: {}, resource_types: {})
+        @resources      = resources
+        @jobs           = jobs
+        @groups         = groups
+        @resource_types = resource_types
+        # rubocop:disable Layout/AlignHash, Layout/SpaceBeforeComma
+        @known_classes  = {
+          resource:      { clazz: Resource    , pipeline_group: @resources      },
+          job:           { clazz: Job         , pipeline_group: @jobs           },
+          group:         { clazz: Group       , pipeline_group: @groups         },
+          resource_type: { clazz: ResourceType, pipeline_group: @resource_types }
+        }
+        # rubocop:enable Layout/AlignHash, Layout/SpaceBeforeComma
+        @pipelines = {}
+        @file_path = file_path
+      end
+
+      ##
+      # Renders all of this pipeline's components to their +Hash+
+      # representations.
+      #
+      # @return [Hash] YAML friendly +Hash+ representation of this +Pipeline+
+      #         if either +groups+ or +resource_types+ is empty they will
+      #         not be included in the rendering at all.
+      #
+      def to_h
+        h = {
+          'resources' => _convert_h_val(@resources.values),
+          'jobs' => _convert_h_val(@jobs.values)
+        }
+        h['groups'] = _convert_h_val(@groups.values) unless @groups.empty?
+        h['resource_types'] = _convert_h_val(@resource_types.values) unless @resource_types.empty?
+        h
+      end
+
+      ##
+      # Populates this {Rudder::DSL::Pipeline} with components
+      # and optionally fetches defined components.
+      #
+      # Fetching
+      # --------------------------------------------------------------------
+      # When +method+ is called with no arguments it is treated
+      # as a {Rudder::DSL::Pipeline} getter method. +method+ is translated
+      # to the name of a {Rudder::DSL::Component} and the +Component+
+      # is returned if defined, otherwise nil is returned.
+      # --------------------------------------------------------------------
+      #
+      # Setting
+      # --------------------------------------------------------------------
+      # When +method+ is passed _any_ arguments (positional, placement, or block)
+      # then +method+ is treated as a setter.
+      #
+      # When setting, +method+ must be the name of a known {Rudder::DSL::Component}.
+      # The first argument is a required _name_ for the component. _All_ arguments
+      # and keyword arguments are then delegated to the {Rudder::DSL::Component}'s
+      # specific initializer.
+      #
+      # Finally, when a block is provided it is evaluated within the context
+      # of the newly constructed {Rudder::DSL::Component} with full priveleges
+      # to operate on it.
+      # --------------------------------------------------------------------
+      #
+      # @return [Rudder::DSL::Component, nil] when +method+ is called with no
+      #         arguments, returns the {Rudder::DSL::Component} with name
+      #         +method+, if any exists. Otherwise returns +nil+.
+      # @raise [RuntimeError] when attempting to define an unknown
+      #         {Rudder::DSL::Component}
+      # @internal_todo
+      #   TODO: Clean this up so these can be reenabled
+      #   rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def method_missing(method, *args, &component_block)
+        local_component = _get_local_component(method)
+        if !@known_classes.include?(method) && !local_component
+          return super.send(method, args, component_block)
+        end
+
+        # Look up a previously defined component from the pipeline
+        return local_component if local_component && args.empty? && !block_given?
+
+        component_group = @known_classes[method][:pipeline_group]
+        name = args[0]
+        raise "Overlapping component name: #{method}" if component_group.include? name
+
+        component = @known_classes[method][:clazz].new(*args)
+
+        component.instance_exec self, &component_block if block_given?
+        component_group[name] = component
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      ##
+      # {Rudder::DSL::Pipeline}'s respond to missing
+      #
+      # @return true
+      def respond_to_missing?(*_)
+        true
+      end
+
+      def respond_to?(name, _include_all = true)
+        @known_classes.key? name
+      end
+
+      ##
+      # Evaluates the given file path.
+      # If file_path nil, defaults to the one provided at construction time
+      # If both are nil, raises an exception
+      #
+      # @param file_path [String, nil] path to {Rudder::DSL::Pipeline} definition
+      #                  to evaluate. Uses the current +file_path+ if +nil+
+      # @raise [RuntimeError] if +file_path+ and {Rudder::DSL::Pipeline#file_path}
+      #                       are both +nil+
+      # @return [Rudder::DSL::Pipeline] the evaluated pipeline
+      def eval(file_path = nil)
+        @file_path = file_path || @file_path
+        if @file_path.nil?
+          raise 'File path must be provided at Pipeline initialization or eval call'
+        end
+
+        File.open(@file_path) do |f|
+          instance_eval f.read, @file_path
+        end
+        self
+      end
+
+      ##
+      # Given a path relative to this pipeline, loads another
+      # pipeline and returns it
+      #
+      # Note that this includes _nothing_ from the relative pipeline in this
+      # one, instead just returning the pipeline to be manipulated
+      #
+      # May also optionally provides hashes for
+      # - resources
+      # - resource_types
+      # - jobs
+      # - groups
+      #
+      # @param other_pipeline_path [String] relative path to {Rudder::DSL::Pipeline}
+      #        definition to load and evaluate.
+      # @param resources [Hash<(String, Symbol), Rudder::DSL::Resource]
+      #        resources to initialize the other {Rudder::DSL::Pipeline} with
+      # @param resources_types [Hash<(String, Symbol), Rudder::DSL::ResourceType]
+      #        resources_types to initialize the other {Rudder::DSL::Pipeline} with
+      # @param jobs [Hash<(String, Symbol), Rudder::DSL::Job]
+      #        jobs to initialize the other {Rudder::DSL::Pipeline} with
+      # @param groups [Hash<(String, Symbol), Rudder::DSL::Group]
+      #        groups to initialize the other {Rudder::DSL::Pipeline} with
+      def load(other_pipeline_path, resources: {}, resource_types: {},
+               jobs: {}, groups: {})
+        if @pipelines.key? other_pipeline_path
+          @pipelines[other_pipeline_path]
+        else
+          dir = File.dirname(@file_path)
+          full_path = File.join(dir, other_pipeline_path)
+          pipeline = Rudder::DSL::Pipeline.new(
+            full_path, resources: resources, resource_types: resource_types,
+                       jobs: jobs, groups: groups
+          ).eval
+          @pipelines[other_pipeline_path] = pipeline
+          pipeline
+        end
+      end
+
+      ##
+      # Given a path to a component, its class, and
+      # any args required to construct it, creates
+      # a new component
+      #
+      # Note that this automatically includes the component into this pipeline
+      #
+      # @param component_path [String] path, relative to this pipeline, containing
+      #        a {Rudder::DSL::Component} to load
+      # @param class_sym [Symbol] symbol of a {Rudder::DSL::Component}. May be one of:
+      #        (+:job+, +:resource+, +:resource_type+, +:group+)
+      # @param name [String, Symbol] name to use for the loaded
+      #             {Rudder::DSL::Component}. Must not be +nil+.
+      # @param *args any additional arguments to pass to the {Rudder::DSL::Component}
+      #             constructor.
+      # @raise RuntimeError if +name+ is +nil+ or an uknown +class_sym+ is provided.
+      #
+      def load_component(component_path, class_sym, name, *args)
+        raise "Unable to load #{class_sym}" unless @known_classes.keys.include? class_sym
+        raise 'Name must not be nil' if name.nil?
+
+        full_path = File.join(File.dirname(@file_path), component_path)
+        component = @known_classes[class_sym][:clazz].new(name, *args)
+        component.instance_eval File.read(full_path), full_path
+        @known_classes[class_sym][:pipeline_group][name] = component
+        component
+      end
+
+      # Yikes! Seems like a bad idea - if someone uses the same name twice (say, 1 resource
+      # and 1 job), then this will return one pretty much at random.
+      # TODO: Make this not bad
+      # Oh well..
+      # TODO: This may be returning a non-nil/non-falsey type that causes some issues
+      def _get_local_component(component)
+        component = component.to_sym
+        locals = @known_classes.values.map do |m|
+          m[:pipeline_group][component]
+        end.compact
+        # TODO: Add a logger here..
+        puts "Found multiple bindings for: #{p}. Getting first found" unless locals.size <= 1
+        locals[0]
+      end
+    end
+  end
+end