puppetfile-resolver 0.1.0

data/lib/puppetfile-resolver/puppetfile/forge_module.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/base_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class ForgeModule < BaseModule
+      def initialize(title)
+        super
+        @module_type = FORGE_MODULE
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/git_module.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/base_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class GitModule < BaseModule
+      attr_accessor :remote
+      attr_accessor :ref
+      attr_accessor :commit
+      attr_accessor :tag
+
+      def initialize(title)
+        super
+        @module_type = GIT_MODULE
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/invalid_module.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/base_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class InvalidModule < BaseModule
+      attr_accessor :reason
+
+      def initialize(title)
+        super
+        @module_type = INVALID_MODULE
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/local_module.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/base_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class LocalModule < BaseModule
+      def initialize(title)
+        super
+        @module_type = LOCAL_MODULE
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      class ParserError < RuntimeError
+        attr_accessor :location
+
+        def initialize(error_message)
+          @error_message = error_message
+        end
+
+        def to_s
+          @error_message
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile'
+require 'puppetfile-resolver/puppetfile/parser/errors'
+require 'puppetfile-resolver/puppetfile/document'
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/dsl'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      # Parses a Puppetfile using the instance_eval method from R10K
+      module R10KEval
+        PUPPETFILE_MONIKER ||= 'Puppetfile'
+
+        def self.parse(puppetfile_contents)
+          document = ::PuppetfileResolver::Puppetfile::Document.new(puppetfile_contents)
+
+          puppetfile_dsl = DSL.new(document)
+          begin
+            puppetfile_dsl.instance_eval(puppetfile_contents, PUPPETFILE_MONIKER)
+          rescue StandardError, LoadError => e
+            # Find the originating error from within the puppetfile
+            loc = e.backtrace_locations
+                   .select { |item| item.absolute_path == PUPPETFILE_MONIKER }
+                   .first
+            start_line_number = loc.nil? ? 0 : loc.lineno - 1 # Line numbers from ruby are base 1
+            end_line_number = loc.nil? ? puppetfile_contents.lines.count - 1 : loc.lineno - 1 # Line numbers from ruby are base 1
+            # Note - Ruby doesn't give a character position so just highlight the entire line
+
+            err = PuppetfileResolver::Puppetfile::Parser::ParserError.new(e.to_s)
+            err.location = PuppetfileResolver::Puppetfile::DocumentLocation.new.tap do |doc_loc|
+              doc_loc.start_line = start_line_number
+              doc_loc.end_line = end_line_number
+            end
+            raise err, e.backtrace
+          rescue SyntaxError => e
+            # Syntax Errrors are special as they don't appear in the backtrace :-(
+            # Sytnax Errors are _really_ horrible as they don't give you the line or character position
+            # as methods on the error. Instead we have to use janky regexes to get the information
+            matches = /^#{PUPPETFILE_MONIKER}:(\d+):/.match(e.message)
+            line_num = matches.nil? ? 0 : matches[1].to_i - 1 # Line numbers from ruby are base 1
+            # If we get a string that can't be cast to integer properly to_i returns 0, which we then take 1 from
+            # which results in a negative number. As a simple precaution, anything that's negative, just assume line zero
+            line_num = 0 if line_num < 0
+
+            err = PuppetfileResolver::Puppetfile::Parser::ParserError.new(e.to_s)
+            err.location = PuppetfileResolver::Puppetfile::DocumentLocation.new.tap do |doc_loc|
+              doc_loc.start_line = line_num
+              doc_loc.end_line = line_num
+              # We can't get character position reliably
+            end
+            raise err, e.backtrace
+          end
+
+          # Post process magic comments
+          post_process_flags!(document)
+
+          # Freeze the flags so they can't be modified
+          document.modules.each { |mod| mod.resolver_flags.freeze }
+
+          document
+        end
+
+        # Parses a Puppetfile and applies the "magic comments"
+        def self.post_process_flags!(document)
+          flag_ranges = {}
+          document.content.lines.each_with_index do |line, index|
+            if (matches = line.match(%r{^\s*# resolver:disable ([A-Za-z\/,]+)(?:\s|$)}))
+              flags_from_line(matches[1]).each do |flag|
+                # Start a flag range if there isn't already one going
+                next unless flag_ranges[flag].nil?
+                flag_ranges[flag] = index
+              end
+            elsif (matches = line.match(%r{# resolver:disable ([A-Za-z\/,]+)(?:\s|$)}))
+              flags_from_line(matches[1]).each do |flag|
+                # Assert the flag if we're not already within a range
+                next unless flag_ranges[flag].nil?
+                assert_resolver_flag(document, flag, index, index)
+              end
+            elsif (matches = line.match(%r{^\s*# resolver:enable ([A-Za-z\/,]+)(?:\s|$)}))
+              flags_from_line(matches[1]).each do |flag|
+                # End a flag range if there isn't already one going
+                next if flag_ranges[flag].nil?
+                assert_resolver_flag(document, flag, flag_ranges[flag], index)
+                flag_ranges.delete(flag)
+              end
+            end
+          end
+
+          return if flag_ranges.empty?
+          # Any remaining flag ranges will be at the document end
+          end_line = document.content.lines.count
+          flag_ranges.each do |flag, start_line|
+            assert_resolver_flag(document, flag, start_line, end_line)
+          end
+        end
+        private_class_method :post_process_flags!
+
+        # Extracts the flags from the text based definitions
+        # @return [Array[Symbol]]
+        def self.flags_from_line(line)
+          line.split(',').map do |flag_name|
+            case flag_name.downcase
+            when 'dependency/puppet'
+              PuppetfileResolver::Puppetfile::DISABLE_PUPPET_DEPENDENCY_FLAG
+            when 'dependency/all'
+              PuppetfileResolver::Puppetfile::DISABLE_ALL_DEPENDENCIES_FLAG
+            else # rubocop:disable Style/EmptyElse We will be adding something here later
+              # TODO: Should we log a warning/info here?
+              nil
+            end
+          end.compact
+        end
+        private_class_method :flags_from_line
+
+        # Sets the specified flag on modules which are between from_line to to_line
+        def self.assert_resolver_flag(document, flag, from_line, to_line)
+          document.modules.each do |mod|
+            # If we don't know where the module is (?) then ignore it
+            next if mod.location.start_line.nil? || mod.location.end_line.nil?
+
+            # If the module doesn't span the range we're looking for (from_line --> to_line) ignore it
+            next unless mod.location.start_line >= from_line && mod.location.start_line <= to_line ||
+                        mod.location.end_line >= from_line && mod.location.end_line <= to_line
+            mod.resolver_flags << flag unless mod.resolver_flags.include?(flag)
+          end
+          nil
+        end
+        private_class_method :assert_resolver_flag
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/dsl.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/puppet_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        class DSL
+          def initialize(puppetfile_document)
+            @document = puppetfile_document
+          end
+
+          # @param [String] name
+          # @param [*Object] args
+          def mod(name, args = nil)
+            # Get the module object
+            mod = PuppetModule.from_puppetfile(name, args)
+            # Inject the file location
+            line_num = find_load_line_number
+            mod.location.start_line = line_num
+            mod.location.end_line = line_num
+            # Append to the list of modules
+            @document.add_module(mod)
+          end
+
+          # @param [String] forge
+          def forge(location)
+            @document.forge_uri = location
+          end
+
+          # @param [String] moduledir
+          def moduledir(_location)
+          end
+
+          def method_missing(method_name, *_args) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+            raise NoMethodError, "Unknown method #{method_name}"
+          end
+
+          private
+
+          def find_load_line_number
+            loc = Kernel.caller_locations
+                        .find { |call_loc| call_loc.absolute_path == ::PuppetfileResolver::Puppetfile::Parser::R10KEval::PUPPETFILE_MONIKER }
+            loc.nil? ? 0 : loc.lineno - 1 # Line numbers from ruby are base 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/module/forge.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/forge_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module Module
+          class Forge
+            def self.implements?(name, args)
+              !name.match(/\A(\w+)[-\/](\w+)\Z/).nil? && valid_version?(args)
+            end
+
+            def self.to_document_module(title, args)
+              mod = ::PuppetfileResolver::Puppetfile::ForgeModule.new(title)
+              mod.version = args if valid_version?(args)
+              mod
+            end
+
+            def self.valid_version?(value)
+              return false unless value.is_a?(String) || value.is_a?(Symbol)
+              value == :latest || value.nil? || valid_version_string?(value)
+            end
+            private_class_method :valid_version?
+
+            # Version string matching regexes
+            # From Semantic Puppet gem
+            REGEX_NUMERIC = '(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)' # Major . Minor . Patch
+            REGEX_PRE     = '(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?' # Prerelease
+            REGEX_BUILD   = '(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?' # Build
+            REGEX_FULL    = REGEX_NUMERIC + REGEX_PRE + REGEX_BUILD.freeze
+            REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/.freeze
+
+            def self.valid_version_string?(value)
+              match = value.match(REGEX_FULL_RX)
+              if match.nil?
+                false
+              else
+                prerelease = match[4]
+                prerelease.nil? || prerelease.split('.').all? { |x| x !~ /^0\d+$/ }
+              end
+            end
+            private_class_method :valid_version_string?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/module/git.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/git_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module Module
+          module Git
+            def self.implements?(_name, args)
+              args.is_a?(Hash) && args.key?(:git)
+            rescue StandardError
+              false
+            end
+
+            def self.to_document_module(title, args)
+              mod = ::PuppetfileResolver::Puppetfile::GitModule.new(title)
+              mod.remote = args[:git]
+              mod.ref = args[:ref] || args[:branch]
+              mod.commit = args[:commit]
+              mod.tag = args[:tag]
+              mod
+            end
+
+            # TODO: https://github.com/puppetlabs/r10k/blob/master/doc/puppetfile.mkd#git
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/module/invalid.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# This is a special module definition.  It's the catchall when no other module type can handle it
+
+require 'puppetfile-resolver/puppetfile/invalid_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module Module
+          module Invalid
+            def self.implements?(_name, _args)
+              true
+            end
+
+            def self.to_document_module(title, args)
+              mod = ::PuppetfileResolver::Puppetfile::InvalidModule.new(title)
+              mod.reason = format("Module %<title>s with args %<args>s doesn't have an implementation. (Are you using the right arguments?)", title: title, args: args.inspect)
+              mod
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/module/local.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/local_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module Module
+          class Local
+            def self.implements?(_name, args)
+              args.is_a?(Hash) && args.key?(:local)
+            rescue StandardError
+              false
+            end
+
+            def self.to_document_module(title, _args)
+              mod = ::PuppetfileResolver::Puppetfile::LocalModule.new(title)
+              mod
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/module/svn.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/svn_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module Module
+          module Svn
+            def self.implements?(_name, args)
+              args.is_a?(Hash) && args.key?(:svn)
+            rescue StandardError
+              false
+            end
+
+            def self.to_document_module(title, args)
+              mod = ::PuppetfileResolver::Puppetfile::SvnModule.new(title)
+              mod.remote = args[:svn]
+              mod
+            end
+
+            # TODO: What about rev, revision, username, password?
+            # https://github.com/puppetlabs/r10k/blob/master/doc/puppetfile.mkd#svn
+          end
+        end
+      end
+    end
+  end
+end