licensed 1.5.2 → 2.0.0

data/lib/licensed/dependency_record.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require "fileutils"
+require "forwardable"
+require "licensee"
+
+module Licensed
+  class DependencyRecord
+    include Licensee::ContentHelper
+    extend Forwardable
+
+    EXTENSION = "dep.yml".freeze
+
+    # Read an existing record file
+    #
+    # filename - A String path to the file
+    #
+    # Returns a Licensed::DependencyRecord
+    def self.read(filename)
+      return unless File.exist?(filename)
+      data = YAML.load_file(filename)
+      return if data.nil? || data.empty?
+      new(
+        licenses: data.delete("licenses"),
+        notices: data.delete("notices"),
+        metadata: data
+      )
+    end
+
+    def_delegators :@metadata, :[], :[]=
+    attr_reader :licenses
+    attr_reader :notices
+
+    # Construct a new record
+    #
+    # licenses - a string, or array of strings, representing the content of each license
+    # notices - a string, or array of strings, representing the content of each legal notice
+    # metadata - a Hash of the metadata for the package
+    def initialize(licenses: [], notices: [], metadata: {})
+      @licenses = [licenses].flatten.compact
+      @notices = [notices].flatten.compact
+      @metadata = metadata
+    end
+
+    # Save the metadata and text to a file
+    #
+    # filename - The destination file to save record contents at
+    def save(filename)
+      data_to_save = @metadata.merge({
+        "licenses" => licenses,
+        "notices" => notices
+      })
+
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.write(filename, data_to_save.to_yaml)
+    end
+
+    # Returns the content used to compare two licenses using normalization from
+    # `Licensee::CotentHelper`
+    def content
+      return if licenses.nil? || licenses.empty?
+      licenses.map do |license|
+        if license.is_a?(String)
+          license
+        elsif license.respond_to?(:[])
+          license["text"]
+        end
+      end.join
+    end
+
+    # Returns whether two records match based on their contents
+    def matches?(other)
+      return false unless other.is_a?(DependencyRecord)
+      self.content_normalized == other.content_normalized
+    end
+  end
+end

data/lib/licensed/migrations.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Licensed
+  module Migrations
+    require "licensed/migrations/v2"
+  end
+end

data/lib/licensed/migrations/v2.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require "licensed/shell"
+
+module Licensed
+  module Migrations
+    class V2
+      YAML_FRONTMATTER_PATTERN = /\A---\s*\n(.*?\n?)^---\s*$\n?(.*)\z/m
+      TEXT_SEPARATOR = ("-" * 80).freeze
+      LICENSE_SEPARATOR = ("*" * 80).freeze
+
+      def self.migrate(config_path, shell = Licensed::UI::Shell.new)
+        shell.info "updating to v2"
+
+        shell.info "updating bundler configuration keys"
+        # replace all "rubygem" and "rubygems" configuration keys with "bundler"
+        # to account for the bundler source's `type` change from `rubygem` to `bundler`
+        File.write(config_path, File.read(config_path).gsub(/("?)rubygems?("?):/, "\\1bundler\\2:"))
+
+        shell.info "updating cached records"
+        # load the configuration to find and update cached contents
+        configuration = Licensed::Configuration.load_from(config_path)
+        configuration.apps.each do |app|
+
+          # move any bundler records from the `rubygem` folder to the `bundler` folder
+          rubygem_cache = app.cache_path.join("rubygem")
+          if rubygem_cache.exist?
+            File.rename rubygem_cache, app.cache_path.join("bundler")
+          end
+
+          app.sources.each do |source|
+            Dir.chdir app.cache_path.join(source.class.type) do
+              # licensed v1 cached records were stored as .txt files with YAML frontmatter
+              Dir["**/*.txt"].each do |file|
+                yaml, licenses, notices = parse_file(file)
+
+                # rename the rubygem type to bundler
+                yaml["type"] = "bundler" if yaml["type"] == "rubygem"
+
+                # set licenses and notices as yaml properties
+                yaml["licenses"] = licenses.map { |text| { "text" => text } }
+                yaml["notices"] = notices.map { |text| { "text" => text } }
+
+                # v2 records are stored in `.dep.yml` files
+                # write the new yaml contents to the new file and delete old file
+                new_file = file.gsub(".txt", ".dep.yml")
+                File.write(new_file, yaml.to_yaml)
+                File.delete(file)
+              end
+            end
+          end
+        end
+      end
+
+      # find the yaml and non-yaml data according to parsing logic from v1
+      def self.parse_file(filename)
+        match = File.read(filename).scrub.match(YAML_FRONTMATTER_PATTERN)
+        yaml = YAML.load(match[1])
+        # in v1, licenses and notices are separated by special text dividers
+        licenses, *notices = match[2].split(TEXT_SEPARATOR).map(&:strip)
+        licenses = licenses.split(LICENSE_SEPARATOR).map(&:strip)
+        [yaml, licenses, notices]
+      end
+    end
+  end
+end

data/lib/licensed/reporters.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Licensed
+  module Reporters
+    require "licensed/reporters/reporter"
+    require "licensed/reporters/cache_reporter"
+    require "licensed/reporters/status_reporter"
+    require "licensed/reporters/list_reporter"
+  end
+end

data/lib/licensed/reporters/cache_reporter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module Licensed
+  module Reporters
+    class CacheReporter < Reporter
+      # Reports on an application configuration in a cache 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 "Caching dependency records for #{app["name"]}"
+          yield report
+        end
+      end
+
+      # Reports on a dependency source enumerator in a cache command run.
+      # Shows the type and count of dependencies found by the source.
+      #
+      # 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
+
+          errored_reports = report.all_reports.select { |report| report.errors.any? }.to_a
+          if errored_reports.any?
+            shell.newline
+            shell.error "  * Errors:"
+            errored_reports.each do |report|
+              display_metadata = report.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+              shell.error "    * #{report.name}"
+              shell.error "    #{display_metadata}" unless display_metadata.empty?
+              report.errors.each do |error|
+                shell.error "      - #{error}"
+              end
+              shell.newline
+            end
+          else
+            shell.confirm "  * #{report.reports.size} #{source.class.type} dependencies"
+          end
+
+          result
+        end
+      end
+
+      # Reports on a dependency in a cache command run.
+      # Shows whether the dependency's record was cached or reused.
+      #
+      # 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.any?
+            shell.error "    Error #{dependency.name} (#{dependency.version})"
+          elsif report["cached"]
+            shell.info "    Caching #{dependency.name} (#{dependency.version})"
+          else
+            shell.info "    Using #{dependency.name} (#{dependency.version})"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/licensed/reporters/list_reporter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Licensed
+  module Reporters
+    class ListReporter < Reporter
+      # Reports on an 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
+      end
+
+      # Reports on a dependency source enumerator in a list command run.
+      # Shows the type and count of dependencies found by the source.
+      #
+      # 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
+
+          errored_reports = report.all_reports.select { |report| report.errors.any? }.to_a
+          if errored_reports.any?
+            shell.newline
+            shell.error "  * Errors:"
+            errored_reports.each do |report|
+              display_metadata = report.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+              shell.error "    * #{report.name}"
+              shell.error "    #{display_metadata}" unless display_metadata.empty?
+              report.errors.each do |error|
+                shell.error "      - #{error}"
+              end
+              shell.newline
+            end
+          else
+            shell.confirm "  * #{report.reports.size} #{source.class.type} dependencies"
+          end
+
+          result
+        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
+          shell.info "    #{dependency.name} (#{dependency.version})"
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/licensed/reporters/reporter.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+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 all_reports
+          result = []
+          result << self
+          result.push(*reports.flat_map(&:all_reports))
+        end
+      end
+
+      class ReportingError < StandardError; end;
+
+      def initialize(shell = Licensed::UI::Shell.new)
+        @shell = shell
+      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
+      #
+      # 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
+
+        result
+      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
+      #
+      # 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
+
+        result
+      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
+      #
+      # 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
+
+        result
+      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
+      #
+      # 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?
+
+        dependency_report = Report.new(name: [@source_report.name, dependency.name].join("."), target: dependency)
+        @source_report.reports << dependency_report
+        yield dependency_report
+      end
+
+      protected
+
+      attr_reader :shell
+    end
+  end
+end

data/lib/licensed/reporters/status_reporter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+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
+      #
+      # Returns the result of the yielded method
+      def report_app(app)
+        super do |report|
+          shell.info "Checking cached dependency records for #{app["name"]}"
+
+          result = yield report
+
+          all_reports = report.all_reports
+          errored_reports = all_reports.select { |report| report.errors.any? }.to_a
+
+          dependency_count = all_reports.select { |report| report.target.is_a?(Licensed::Dependency) }.size
+          error_count = errored_reports.sum { |report| report.errors.size }
+
+          if error_count > 0
+            shell.newline
+            shell.error "Errors:"
+            errored_reports.each do |report|
+              display_metadata = report.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+              shell.error "* #{report.name}"
+              shell.error "  #{display_metadata}" unless display_metadata.empty?
+              report.errors.each do |error|
+                shell.error "    - #{error}"
+              end
+              shell.newline
+            end
+          end
+
+          shell.newline
+          shell.info "#{dependency_count} dependencies checked, #{error_count} errors found."
+
+          result
+        end
+      end
+
+      # Reports on a dependency in a status command run.
+      # Shows 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
+        end
+      end
+    end
+  end
+end