licensed 2.15.2 → 3.2.0

data/lib/licensed/reporters/list_reporter.rb

@@ -3,84 +3,71 @@
 module Licensed
   module Reporters
     class ListReporter < Reporter
-      # Reports on an application configuration in a list command run
+      # Reports the start of application configuration in a list command run
       #
       # app - An application configuration
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_app(app)
-        super do |report|
-          shell.info "Listing dependencies for #{app["name"]}"
-          yield report
-        end
+      # report - A report object containing information about the app evaluation
+      def begin_report_app(app, report)
+        shell.info "Listing dependencies for #{app["name"]}"
       end
 
-      # Reports on a dependency source enumerator in a list command run.
-      # Shows the type and count of dependencies found by the source.
+      # Reports the start of a source evaluation
       #
       # source - A dependency source enumerator
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_source(source)
-        super do |report|
-          shell.info "  #{source.class.type}"
-          result = yield report
+      # report - A report object containing information about the source evaluation
+      def begin_report_source(source, report)
+        shell.info "  #{source.class.type}"
+      end
 
-          warning_reports = report.all_reports.select { |r| r.warnings.any? }.to_a
-          if warning_reports.any?
-            shell.newline
-            shell.warn "  * Warnings:"
-            warning_reports.each do |r|
-              display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
+      # Report the type and count of dependencies found by the source,
+      # along with any warnings and errors
+      #
+      # source - A dependency source enumerator
+      # report - A report object containing information about the source evaluation
+      def end_report_source(source, report)
+        warning_reports = report.all_reports.select { |r| r.warnings.any? }.to_a
+        if warning_reports.any?
+          shell.newline
+          shell.warn "  * Warnings:"
+          warning_reports.each do |r|
+            display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-              shell.warn "    * #{r.name}"
-              shell.warn "    #{display_metadata}" unless display_metadata.empty?
-              r.warnings.each do |warning|
-                shell.warn "      - #{warning}"
-              end
-              shell.newline
+            shell.warn "    * #{r.name}"
+            shell.warn "    #{display_metadata}" unless display_metadata.empty?
+            r.warnings.each do |warning|
+              shell.warn "      - #{warning}"
             end
+            shell.newline
           end
+        end
 
-          errored_reports = report.all_reports.select { |r| r.errors.any? }.to_a
-          if errored_reports.any?
-            shell.newline
-            shell.error "  * Errors:"
-            errored_reports.each do |r|
-              display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
+        errored_reports = report.all_reports.select { |r| r.errors.any? }.to_a
+        if errored_reports.any?
+          shell.newline
+          shell.error "  * Errors:"
+          errored_reports.each do |r|
+            display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-              shell.error "    * #{r.name}"
-              shell.error "    #{display_metadata}" unless display_metadata.empty?
-              r.errors.each do |error|
-                shell.error "      - #{error}"
-              end
-              shell.newline
+            shell.error "    * #{r.name}"
+            shell.error "    #{display_metadata}" unless display_metadata.empty?
+            r.errors.each do |error|
+              shell.error "      - #{error}"
             end
-          else
-            shell.confirm "  * #{report.reports.size} #{source.class.type} dependencies"
+            shell.newline
           end
-
-          result
+        else
+          shell.confirm "  * #{report.reports.size} #{source.class.type} dependencies"
         end
       end
 
       # Reports on a dependency in a list command run.
       #
       # dependency - An application dependency
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_dependency(dependency)
-        super do |report|
-          result = yield report
-          info = "#{dependency.name} (#{dependency.version})"
-          info = "#{info}: #{report["license"]}" if report["license"]
-          shell.info "    #{info}"
-
-          result
-        end
+      # report - A report object containing information about the dependency evaluation
+      def end_report_dependency(dependency, report)
+        info = "#{dependency.name} (#{dependency.version})"
+        info = "#{info}: #{report["license"]}" if report["license"]
+        shell.info "    #{info}"
       end
     end
   end

data/lib/licensed/reporters/notices_reporter.rb

@@ -6,66 +6,47 @@ module Licensed
       TEXT_SEPARATOR = "\n\n#{("-" * 5)}\n\n".freeze
       LICENSE_SEPARATOR = "\n#{("*" * 5)}\n".freeze
 
-      # Reports on an application configuration in a notices command run
+      # Reports the start of an application evaluation in a notices command run
       #
       # app - An application configuration
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_app(app)
-        super do |report|
-          filename = app["shared_cache"] ? "NOTICE.#{app["name"]}" : "NOTICE"
-          path = app.cache_path.join(filename)
-          shell.info "Writing notices for #{app["name"]} to #{path}"
-
-          result = yield report
-
-          File.open(path, "w") do |file|
-            file << "THIRD PARTY NOTICES\n"
-            file << LICENSE_SEPARATOR
-            file << report.all_reports
-                          .map { |r| notices(r) }
-                          .compact
-                          .join(LICENSE_SEPARATOR)
-          end
+      # report - A report object containing information about the app evaluation
+      def begin_report_app(app, report)
+        shell.info "Writing notices for #{app["name"]} to #{app_notices_path(app)}"
+      end
 
-          result
+      # Writes the licensing information gathered during the application evaluation
+      # to a notices file
+      #
+      # app - An application configuration
+      # report - A report object containing information about the app evaluation
+      def end_report_app(app, report)
+        File.open(app_notices_path(app), "w") do |file|
+          file << "THIRD PARTY NOTICES\n"
+          file << LICENSE_SEPARATOR
+          file << report.all_reports
+                        .map { |r| notices(r) }
+                        .compact
+                        .join(LICENSE_SEPARATOR)
         end
       end
 
-
-      # Reports on a dependency source enumerator in a notices command run.
-      # Shows warnings encountered during the run.
+      # Reports any warnings encountered during the run.
       #
       # source - A dependency source enumerator
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_source(source)
-        super do |report|
-          result = yield report
-
-          report.warnings.each do |warning|
-            shell.warn "* #{report.name}: #{warning}"
-          end
-
-          result
+      # report - A report object containing information about the source evaluation
+      def end_report_source(source, report)
+        report.warnings.each do |warning|
+          shell.warn "* #{report.name}: #{warning}"
         end
       end
 
       # Reports on a dependency in a notices command run.
       #
       # dependency - An application dependency
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_dependency(dependency)
-        super do |report|
-          result = yield report
-          report.warnings.each do |warning|
-            shell.warn "* #{report.name}: #{warning}"
-          end
-          result
+      # report - A report object containing information about the dependency evaluation
+      def end_report_dependency(dependency, report)
+        report.warnings.each do |warning|
+          shell.warn "* #{report.name}: #{warning}"
         end
       end
 
@@ -94,6 +75,12 @@ module Licensed
           #{texts.map(&:strip).reject(&:empty?).compact.join(TEXT_SEPARATOR)}
         NOTICE
       end
+
+      # Returns the path to an applications notices file
+      def app_notices_path(app)
+        filename = app["shared_cache"] ? "NOTICE.#{app["name"]}" : "NOTICE"
+        app.cache_path.join(filename)
+      end
     end
   end
 end

data/lib/licensed/reporters/reporter.rb

@@ -2,133 +2,66 @@
 module Licensed
   module Reporters
     class Reporter
-      class Report < Hash
-        attr_reader :name
-        attr_reader :target
-        def initialize(name:, target:)
-          super()
-          @name = name
-          @target = target
-        end
-
-        def reports
-          @reports ||= []
-        end
-
-        def errors
-          @errors ||= []
-        end
-
-        def warnings
-          @warnings ||= []
-        end
-
-        def all_reports
-          result = []
-          result << self
-          result.push(*reports.flat_map(&:all_reports))
-        end
-
-        # Returns the data from the report as a hash
-        def to_h
-          # add name, errors and warnings if they have real data
-          output = {}
-          output["name"] = name unless name.to_s.empty?
-          output["errors"] = errors.dup if errors.any?
-          output["warnings"] = warnings.dup if warnings.any?
-
-          # merge the hash data from the report.  command-specified data always
-          # overwrites local data
-          output.merge(super)
-        end
-      end
-
       class ReportingError < StandardError; end;
 
       def initialize(shell = Licensed::UI::Shell.new)
         @shell = shell
-        @run_report = nil
-        @app_report = nil
-        @source_report = nil
       end
 
-      # Generate a report for a licensed command execution
-      # Yields a report object which can be used to view or add
-      # data generated for this run
+      # Report the beginning of a command evaluation
       #
-      # Returns the result of the yielded method
-      def report_run(command)
-        result = nil
-        @run_report = Report.new(name: nil, target: command)
-        begin
-          result = yield @run_report
-        ensure
-          @run_report = nil
-        end
+      # command - The command being run
+      # report - A report object containing information about the command run
+      def begin_report_command(command, report)
+      end
 
-        result
+      # Report the end of a command evaluation
+      #
+      # command - The command being run
+      # report - A report object containing information about the command run
+      def end_report_command(command, report)
       end
 
-      # Generate a report for a licensed app configuration
-      # Yields a report object which can be used to view or add
-      # data generated for this app
+      # Report the beginning of an app evaluation
       #
       # app - An application configuration
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_app(app)
-        raise ReportingError.new("Cannot call report_app with active app context") unless @app_report.nil?
-        raise ReportingError.new("Call report_run before report_app") if @run_report.nil?
-        result = nil
-        @app_report = Report.new(name: app["name"], target: app)
-        begin
-          result = yield @app_report
-        ensure
-          @run_report.reports << @app_report
-          @app_report = nil
-        end
+      # report - A report object containing information about the app evaluation
+      def begin_report_app(app, report)
+      end
 
-        result
+      # Report the end of an app evaluation
+      #
+      # app - An application configuration
+      # report - A report object containing information about the app evaluation
+      def end_report_app(app, report)
       end
 
-      # Generate a report for a licensed dependency source enumerator
-      # Yields a report object which can be used to view or add
-      # data generated for this dependency source
+      # Report the beginning of a source evaluation
       #
       # source - A dependency source enumerator
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_app` scope
-      def report_source(source)
-        raise ReportingError.new("Cannot call report_source with active source context") unless @source_report.nil?
-        raise ReportingError.new("Call report_app before report_source") if @app_report.nil?
-        result = nil
-        @source_report = Report.new(name: [@app_report.name, source.class.type].join("."), target: source)
-        begin
-          result = yield @source_report
-        ensure
-          @app_report.reports << @source_report
-          @source_report = nil
-        end
+      # report - A report object containing information about the source evaluation
+      def begin_report_source(source, report)
+      end
 
-        result
+      # Report the end of a source evaluation
+      #
+      # source - A dependency source enumerator
+      # report - A report object containing information about the source evaluation
+      def end_report_source(source, report)
       end
 
-      # Generate a report for a licensed dependency
-      # Yields a report object which can be used to view or add
-      # data generated for this dependency
+      # Report the beginning of a dependency evaluation
       #
       # dependency - An application dependency
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_source` scope
-      def report_dependency(dependency)
-        raise ReportingError.new("Call report_source before report_dependency") if @source_report.nil?
+      # source - A report object containing information about the dependency evaluation
+      def begin_report_dependency(dependency, report)
+      end
 
-        dependency_report = Report.new(name: [@source_report.name, dependency.name].join("."), target: dependency)
-        @source_report.reports << dependency_report
-        yield dependency_report
+      # Report the end of a dependency evaluation
+      #
+      # dependency - An application dependency
+      # source - A report object containing information about the dependency evaluation
+      def end_report_dependency(dependency, report)
       end
 
       protected

data/lib/licensed/reporters/status_reporter.rb

@@ -3,80 +3,82 @@
 module Licensed
   module Reporters
     class StatusReporter < Reporter
-      # Generate a report for a licensed status command run
-      # Shows the errors found when checking status, as well as
-      # overall number of dependencies checked
+      # Reports any errors encountered at the command level
       #
-      # Returns the result of the yielded method
-      def report_app(app)
-        super do |report|
-          shell.info "Checking cached dependency records for #{app["name"]}"
+      # command - The command being run
+      # report - A report object containing information about the command run
+      def end_report_command(command, report)
+        if report.errors.any?
+          shell.newline
+          report.errors.each { |e| shell.error e }
+        end
+      end
 
-          result = yield report
+      # Reports the start of checking records for an app
+      #
+      # app - An application configuration
+      # report - A report containing information about the app evaluation
+      def begin_report_app(app, report)
+          shell.info "Checking cached dependency records for #{app["name"]}"
+      end
 
-          all_reports = report.all_reports
+      # Reports any errors found when checking status, as well as
+      # overall number of dependencies checked
+      #
+      # app - An application configuration
+      # report - A report containing information about the app evaluation
+      def end_report_app(app, report)
+        all_reports = report.all_reports
 
-          warning_reports = all_reports.select { |r| r.warnings.any? }.to_a
-          if warning_reports.any?
-            shell.newline
-            shell.warn "Warnings:"
-            warning_reports.each do |r|
-              display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
+        warning_reports = all_reports.select { |r| r.warnings.any? }.to_a
+        if warning_reports.any?
+          shell.newline
+          shell.warn "Warnings:"
+          warning_reports.each do |r|
+            display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-              shell.warn "* #{r.name}"
-              shell.warn "  #{display_metadata}" unless display_metadata.empty?
-              r.warnings.each do |warning|
-                shell.warn "    - #{warning}"
-              end
-              shell.newline
+            shell.warn "* #{r.name}"
+            shell.warn "  #{display_metadata}" unless display_metadata.empty?
+            r.warnings.each do |warning|
+              shell.warn "    - #{warning}"
             end
+            shell.newline
           end
+        end
 
-          errored_reports = all_reports.select { |r| r.errors.any? }.to_a
+        errored_reports = all_reports.select { |r| r.errors.any? }.to_a
 
-          dependency_count = all_reports.select { |r| r.target.is_a?(Licensed::Dependency) }.size
-          error_count = errored_reports.sum { |r| r.errors.size }
+        dependency_count = all_reports.select { |r| r.target.is_a?(Licensed::Dependency) }.size
+        error_count = errored_reports.sum { |r| r.errors.size }
 
-          if error_count > 0
-            shell.newline
-            shell.error "Errors:"
-            errored_reports.each do |r|
-              display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
+        if error_count > 0
+          shell.newline
+          shell.error "Errors:"
+          errored_reports.each do |r|
+            display_metadata = r.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-              shell.error "* #{r.name}"
-              shell.error "  #{display_metadata}" unless display_metadata.empty?
-              r.errors.each do |error|
-                shell.error "    - #{error}"
-              end
-              shell.newline
+            shell.error "* #{r.name}"
+            shell.error "  #{display_metadata}" unless display_metadata.empty?
+            r.errors.each do |error|
+              shell.error "    - #{error}"
             end
+            shell.newline
           end
-
-          shell.newline
-          shell.info "#{dependency_count} dependencies checked, #{error_count} errors found."
-
-          result
         end
+
+        shell.newline
+        shell.info "#{dependency_count} dependencies checked, #{error_count} errors found."
       end
 
-      # Reports on a dependency in a status command run.
-      # Shows whether the dependency's status is valid in dot format
+      # Reports whether the dependency's status is valid in dot format
       #
       # dependency - An application dependency
-      #
-      # Returns the result of the yielded method
-      # Note - must be called from inside the `report_run` scope
-      def report_dependency(dependency)
-        super do |report|
-          result = yield report
-
-          if report.errors.empty?
-            shell.confirm(".", false)
-          else
-            shell.error("F", false)
-          end
-
-          result
+      # report - A report containing information about the dependency evaluation
+      def end_report_dependency(dependency, report)
+        if report.errors.empty?
+          shell.confirm(".", false)
+        else
+          shell.error("F", false)
         end
       end
     end