licensee 9.8.0 → 9.9.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6da17475ba74d0aea6d92013e6d141cc88f0d400af3aa9d0be99947c551f3ad6
-  data.tar.gz: 654876f0d889688a13752497759d2856be48a8714667a167e9781f80b9f1eef1
+  metadata.gz: 07cb2f24a84e1c09c9e8b18b8d884fe167075294883c7bdc38a41d96ac43e7cd
+  data.tar.gz: 0a5884c9abec6b33e3883cde81533a4b2d9c4b2e6f196dc93a3f8148500f91d0
 SHA512:
-  metadata.gz: 208fea169fb835f863d85ec6ac2bbcb87878c10e312938380fd262cfc3b3b7fe0e55b65d74cdd166a1c361d47d071ec5bfc785e4a7854031aa0855fc96105c54
-  data.tar.gz: 1c23cf247b226d85326ac7c9d388b22e228f07a13388d0e21cac091f6ca8fefd1c4b726448c13e44c429e83c828ef99b56cfaea5c39ae30ef22fc13655027d29
+  metadata.gz: 1413f1609224bcc6c0220c9838a9959af8b008231ece109f2d4cf58042c64f6be9df66618b7d15c46ff08b67f90cdb9260693baa189c91a9aa49150731d178b9
+  data.tar.gz: f143548da667914c309269e54da37cf449efdf51baa05b1a8bb24a91d82c80def6b01f3d2b804db3be914045f03048a3e111a1145f7674cce0a3086df5eff280

data/bin/licensee

@@ -1,64 +1,37 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/licensee'
-
-path = ARGV[0] || Dir.pwd
-
-# Given a string or object, prepares it for output and human consumption
-def humanize(value, type = nil)
-  case type
-  when :license
-    value.name
-  when :matcher
-    value.class
-  when :confidence
-    Licensee::ContentHelper.format_percent(value)
-  when :method
-    value.to_s.tr('_', ' ').capitalize
-  else
-    value
-  end
-end
-
-# Methods to call when displaying information about ProjectFiles
-MATCHED_FILE_METHODS = %i[
-  content_hash attribution confidence matcher license
-].freeze
+require 'dotenv/load'
+require 'thor'
+require 'json'
 
-project = Licensee.project(path, detect_packages: true, detect_readme: true)
-
-if project.license
-  puts "License: #{project.license.name}"
-elsif project.licenses
-  puts "Licenses: #{project.licenses.map(&:name)}"
-else
-  puts 'License: Not detected'
-end
+require_relative '../lib/licensee'
 
-puts "Matched files: #{project.matched_files.map(&:filename)}"
+class LicenseeCLI < Thor
+  package_name 'Licensee'
+  class_option :remote, type: :boolean, desc: 'Assume PATH is a GitHub owner/repo path'
+  default_task :detect
 
-project.matched_files.each do |matched_file|
-  puts "#{matched_file.filename}:"
+  private
 
-  MATCHED_FILE_METHODS.each do |method|
-    next unless matched_file.respond_to? method
-    value = matched_file.public_send method
-    next if value.nil?
-    puts "  #{humanize(method, :method)}: #{humanize(value, method)}"
+  def path
+    @path ||= if !options[:remote] || args.first =~ %r{^https://}
+      args.first || Dir.pwd
+    else
+      "https://github.com/#{args.first}"
+    end
   end
 
-  next unless matched_file.is_a? Licensee::ProjectFiles::LicenseFile
-  next unless matched_file.confidence != 100
+  def project
+    @project ||= Licensee.project(path,
+                                  detect_packages: options[:packages], detect_readme: options[:readme])
+  end
 
-  matcher = Licensee::Matchers::Dice.new(matched_file)
-  licenses = matcher.licenses_by_similiarity
-  next if licenses.empty?
-  puts '  Closest licenses:'
-  licenses[0...3].each do |license, similarity|
-    spdx_id = license.meta['spdx-id']
-    percent = Licensee::ContentHelper.format_percent(similarity)
-    puts "    * #{spdx_id} similarity: #{percent}"
+  def remote?
+    path =~ %r{^https://}
   end
 end
 
-exit !project.licenses.empty?
+commands_dir = File.expand_path 'lib/licensee/commands/'
+Dir["#{commands_dir}/*.rb"].each { |c| require(c) }
+
+LicenseeCLI.start(ARGV)

data/lib/licensee/commands/detect.rb

@@ -0,0 +1,103 @@
+class LicenseeCLI < Thor
+  # Methods to call when displaying information about ProjectFiles
+  MATCHED_FILE_METHODS = %i[
+    content_hash attribution confidence matcher license
+  ].freeze
+
+  desc 'detect [PATH]', 'Detect the license of the given project'
+  option :json, type: :boolean, desc: 'Return output as JSON'
+  option :packages, type: :boolean, default: true, desc: 'Detect licenses in package manager files'
+  option :readme, type: :boolean, default: true, desc: 'Detect licenses in README files'
+  option :confidence, type: :numeric, default: Licensee.confidence_threshold, desc: 'Confidence threshold'
+  option :license, type: :string, desc: 'The SPDX ID or key of the license to compare (implies --diff)'
+  option :diff, type: :boolean, desc: 'Compare the license to the closest match'
+  def detect(_path = nil)
+    Licensee.confidence_threshold = options[:confidence]
+
+    if options[:json]
+      say project.to_h.to_json
+      exit !project.licenses.empty?
+    end
+
+    rows = []
+    rows << if project.license
+              ['License:', project.license.name]
+            elsif !project.licenses.empty?
+              ['Licenses:', project.licenses.map(&:name)]
+            else
+              ['License:', set_color('None', :red)]
+            end
+
+    unless project.matched_files.empty?
+      rows << ['Matched files:', project.matched_files.map(&:filename).join(', ')]
+    end
+
+    print_table rows
+
+    project.matched_files.each do |matched_file|
+      rows = []
+      say "#{matched_file.filename}:"
+
+      MATCHED_FILE_METHODS.each do |method|
+        next unless matched_file.respond_to? method
+        value = matched_file.public_send method
+        next if value.nil?
+        rows << [humanize(method, :method), humanize(value, method)]
+      end
+      print_table rows, indent: 2
+
+      next unless matched_file.is_a? Licensee::ProjectFiles::LicenseFile
+      next if matched_file.confidence == 100
+
+      licenses = licenses_by_similiarity(matched_file)
+      next if licenses.empty?
+      say '  Closest licenses:'
+      rows = licenses[0...3].map do |license, similarity|
+        spdx_id = license.meta['spdx-id']
+        percent = Licensee::ContentHelper.format_percent(similarity)
+        ["#{spdx_id} similarity:", percent]
+      end
+      print_table rows, indent: 4
+    end
+
+    if project.license_file && (options[:license] || options[:diff])
+      license = options[:license] || closest_license_key(project.license_file)
+      if license
+        invoke(:diff, nil,
+               license: license, license_to_diff: project.license_file)
+      end
+    end
+
+    exit !project.licenses.empty?
+  end
+
+  private
+
+  # Given a string or object, prepares it for output and human consumption
+  def humanize(value, type = nil)
+    case type
+    when :license
+      value.name
+    when :matcher
+      value.class
+    when :confidence
+      Licensee::ContentHelper.format_percent(value)
+    when :method
+      value.to_s.tr('_', ' ').capitalize + ':'
+    else
+      value
+    end
+  end
+
+  def licenses_by_similiarity(matched_file)
+    matcher = Licensee::Matchers::Dice.new(matched_file)
+    potential_licenses = Licensee.licenses(hidden: true).select(&:wordset)
+    matcher.instance_variable_set('@potential_licenses', potential_licenses)
+    matcher.licenses_by_similiarity
+  end
+
+  def closest_license_key(matched_file)
+    licenses = licenses_by_similiarity(matched_file)
+    licenses.first.first.key unless licenses.empty?
+  end
+end

data/lib/licensee/commands/diff.rb

@@ -0,0 +1,67 @@
+require 'tmpdir'
+
+class LicenseeCLI < Thor
+  desc 'diff [PATH]', 'Compare the given license text to a known license'
+  option :license, type: :string, desc: 'The SPDX ID or key of the license to compare'
+  def diff(_path = nil)
+    say "Comparing to #{expected_license.name}:"
+    rows = []
+
+    left = expected_license.content_normalized(wrap: 80)
+    right = license_to_diff.content_normalized(wrap: 80)
+    similarity = expected_license.similarity(license_to_diff)
+    similarity = Licensee::ContentHelper.format_percent(similarity)
+
+    rows << ['Input Length:', license_to_diff.length]
+    rows << ['License length:', expected_license.length]
+    rows << ['Similarity:', similarity]
+    print_table rows
+
+    if left == right
+      say 'Exact match!', :green
+      exit
+    end
+
+    Dir.mktmpdir do |dir|
+      path = File.expand_path 'LICENSE', dir
+      Dir.chdir(dir) do
+        `git init`
+        File.write(path, left)
+        `git add LICENSE`
+        `git commit -m 'left'`
+        File.write(path, right)
+        say `git diff --word-diff`
+      end
+    end
+  end
+
+  private
+
+  def license_to_diff
+    return options[:license_to_diff] if options[:license_to_diff]
+    return project.license_file if remote?
+
+    @license_via_stdin ||= begin
+      if STDIN.tty?
+        error 'You must pipe license contents to the command via STDIN'
+        exit 1
+      end
+
+      Licensee::ProjectFiles::LicenseFile.new(STDIN.read, 'LICENSE')
+    end
+  end
+
+  def expected_license
+    @expected_license ||= Licensee::License.find options[:license] if options[:license]
+    return @expected_license if @expected_license
+
+    if options[:license]
+      error "#{options[:license]} is not a valid license"
+    else
+      error 'You must provide an expected license'
+    end
+
+    error "Valid licenses: #{Licensee::License.all(hidden: true).map(&:key).join(', ')}"
+    exit 1
+  end
+end

data/lib/licensee/commands/license_path.rb

@@ -0,0 +1,14 @@
+class LicenseeCLI < Thor
+  desc 'license-path [PATH]', "Returns the path to the given project's license file"
+  def license_path(_path)
+    if project.license_file
+      if remote?
+        say project.license_file.path
+      else
+        say File.expand_path project.license_file.path
+      end
+    else
+      exit 1
+    end
+  end
+end

data/lib/licensee/commands/version.rb

@@ -0,0 +1,6 @@
+class LicenseeCLI < Thor
+  desc 'version', 'Return the Licensee version'
+  def version
+    say Licensee::VERSION
+  end
+end

data/lib/licensee/content_helper.rb

@@ -12,6 +12,7 @@ module Licensee
     MARKDOWN_HEADING_REGEX = /\A\s*#+/
     VERSION_REGEX = /\Aversion.*$/i
     MARKUP_REGEX = /[#_*=~\[\]()`|>]+/
+    DEVELOPED_BY_REGEX = /\Adeveloped by:.*?\n\n/im
 
     # A set of each word in the license, without duplicates
     def wordset
@@ -77,6 +78,7 @@ module Licensee
           string = strip_copyright(string)
         end
         string = strip_all_rights_reserved(string)
+        string = strip_developed_by(string)
         string, _partition, _instructions = string.partition(END_OF_TERMS_REGEX)
         string = strip_markup(string)
         string = normalize_quotes(string)
@@ -162,6 +164,10 @@ module Licensee
       strip(string, MARKUP_REGEX)
     end
 
+    def strip_developed_by(string)
+      strip(string, DEVELOPED_BY_REGEX)
+    end
+
     def strip(string, regex)
       string.gsub(regex, ' ').squeeze(' ').strip
     end

data/lib/licensee/hash_helper.rb

@@ -0,0 +1,20 @@
+module Licensee
+  module HashHelper
+    def to_h
+      hash = {}
+      self.class::HASH_METHODS.each do |method|
+        key = method.to_s.delete('?').to_sym
+        value = public_send(method)
+        hash[key] = if value.is_a?(Array)
+          value.map { |v| v.respond_to?(:to_h) ? v.to_h : v }
+        elsif value.respond_to?(:to_h) && !value.nil?
+          value.to_h
+        else
+          value
+        end
+      end
+
+      hash
+    end
+  end
+end

data/lib/licensee/license.rb

@@ -92,9 +92,14 @@ module Licensee
     }.freeze
 
     SOURCE_PREFIX = %r{https?://(?:www\.)?}i
-    SOURCE_SUFFIX = %r{(?:\.html?|\.txt|\/)}i
+    SOURCE_SUFFIX = %r{(?:\.html?|\.txt|\/)(?:\?[^\s]*)?}i
+
+    HASH_METHODS = %i[
+      key spdx_id meta url rules fields other? gpl? lgpl? cc?
+    ].freeze
 
     include Licensee::ContentHelper
+    include Licensee::HashHelper
     extend Forwardable
     def_delegators :meta, *LicenseMeta.helper_methods
 

data/lib/licensee/license_meta.rb

@@ -12,6 +12,9 @@ module Licensee
 
     PREDICATE_FIELDS = %i[featured hidden].freeze
 
+    include Licensee::HashHelper
+    HASH_METHODS = members - %i[conditions permissions limitations spdx_id]
+
     class << self
       # Create a new LicenseMeta from YAML
       #

data/lib/licensee/license_rules.rb

@@ -1,6 +1,9 @@
 module Licensee
   # Exposes #conditions, #permissions, and #limitation arrays of LicenseRules
   class LicenseRules < Struct.new(:conditions, :permissions, :limitations)
+    include Licensee::HashHelper
+    HASH_METHODS = Rule.groups
+
     class << self
       def from_license(license)
         from_meta(license.meta)
@@ -9,7 +12,7 @@ module Licensee
       def from_meta(meta)
         rules = {}
         Rule.groups.each do |group|
-          rules[group] = meta[group].map do |tag|
+          rules[group] = (meta[group] || []).map do |tag|
             Rule.find_by_tag_and_group(tag, group)
           end
         end

data/lib/licensee/matchers/exact.rb

@@ -1,12 +1,6 @@
 module Licensee
   module Matchers
-    class Exact
-      attr_reader :file
-
-      def initialize(file)
-        @file = file
-      end
-
+    class Exact < Licensee::Matchers::Matcher
       def match
         return @match if defined? @match
         @match = Licensee.licenses(hidden: true).find do |license|

data/lib/licensee/matchers/matcher.rb

@@ -3,10 +3,17 @@ module Licensee
     class Matcher
       attr_reader :file
 
+      include Licensee::HashHelper
+      HASH_METHODS = %i[name confidence].freeze
+
       def initialize(file)
         @file = file
       end
 
+      def name
+        @name ||= self.class.to_s.split('::').last.downcase.to_sym
+      end
+
       def match
         raise 'Not implemented'
       end

data/lib/licensee/project_files/project_file.rb

@@ -10,6 +10,11 @@ module Licensee
 
       attr_reader :content
 
+      include Licensee::HashHelper
+      HASH_METHODS = %i[
+        filename content content_hash content_normalized matcher matched_license
+      ].freeze
+
       ENCODING = Encoding::UTF_8
       ENCODING_OPTIONS = {
         invalid: :replace,
@@ -61,6 +66,10 @@ module Licensee
       alias match license
       alias path filename
 
+      def matched_license
+        license.key if license
+      end
+
       # Is this file a COPYRIGHT file with only a copyright statement?
       # If so, it can be excluded from determining if a project has >1 license
       def copyright?
@@ -68,6 +77,14 @@ module Licensee
         return false unless matcher.is_a?(Matchers::Copyright)
         filename =~ /\Acopyright(?:#{LicenseFile::OTHER_EXT_REGEX})?\z/i
       end
+
+      def content_hash
+        nil
+      end
+
+      def content_normalized
+        nil
+      end
     end
   end
 end

data/lib/licensee/projects/project.rb

@@ -10,6 +10,9 @@ module Licensee
       alias detect_readme? detect_readme
       alias detect_packages? detect_packages
 
+      include Licensee::HashHelper
+      HASH_METHODS = %i[licenses matched_files].freeze
+
       def initialize(detect_packages: false, detect_readme: false)
         @detect_packages = detect_packages
         @detect_readme = detect_readme

data/lib/licensee/rule.rb

@@ -2,6 +2,9 @@ module Licensee
   class Rule
     attr_reader :tag, :label, :description, :group
 
+    include Licensee::HashHelper
+    HASH_METHODS = %i[tag label description].freeze
+
     def initialize(tag: nil, label: nil, description: nil, group: nil)
       @tag = tag
       @label = label

data/lib/licensee/version.rb

@@ -1,3 +1,3 @@
 module Licensee
-  VERSION = '9.8.0'.freeze
+  VERSION = '9.9.0.beta.2'.freeze
 end

data/lib/licensee.rb

@@ -6,6 +6,7 @@ require 'yaml'
 
 module Licensee
   autoload :ContentHelper, 'licensee/content_helper'
+  autoload :HashHelper, 'licensee/hash_helper'
   autoload :License, 'licensee/license'
   autoload :LicenseField, 'licensee/license_field'
   autoload :LicenseMeta, 'licensee/license_meta'

data/spec/bin_spec.rb

@@ -1,64 +1,21 @@
 RSpec.describe 'command line invocation' do
-  let(:command) { ['ruby', 'bin/licensee'] }
+  let(:command) { ['bundle', 'exec', 'bin/licensee', 'help'] }
+  let(:arguments) { [] }
   let(:output) do
     Dir.chdir project_root do
       Open3.capture3(*[command, arguments].flatten)
     end
   end
+  let(:parsed_output) { YAML.safe_load(stdout) }
   let(:stdout) { output[0] }
   let(:stderr) { output[1] }
   let(:status) { output[2] }
-  let(:hash) { '46cdc03462b9af57968df67b450cc4372ac41f53' }
 
-  context 'without any arguments' do
-    let(:arguments) { [] }
-
-    it 'Returns a zero exit code' do
-      expect(status.exitstatus).to eql(0)
-    end
-
-    it "detects the folder's license" do
-      expect(stdout).to match('License: MIT License')
-    end
-
-    it 'outputs the hash' do
-      expect(stdout).to match(hash)
-    end
-
-    it 'outputs the attribution' do
-      expect(stdout).to match('2014-2017 Ben Balter')
-    end
-
-    it 'outputs the confidence' do
-      expect(stdout).to match('Confidence: 100.00%')
-      expect(stdout).to match('Confidence: 90.00%')
-    end
-
-    it 'outputs the method' do
-      expect(stdout).to match('Matcher: Licensee::Matchers::Exact')
-      expect(stdout).to match('Matcher: Licensee::Matchers::Gemspec')
-    end
-
-    it 'outputs the matched files' do
-      matched_files = 'Matched files: ["LICENSE.md", "licensee.gemspec"]'
-      expect(stdout).to include(matched_files)
-    end
-  end
-
-  context 'when given a folder path' do
-    let(:arguments) { [project_root] }
-
-    it "detects the folder's license" do
-      expect(stdout).to match('License: MIT License')
-    end
+  it 'Returns a zero exit code' do
+    expect(status.exitstatus).to eql(0)
   end
 
-  context 'when given a license path' do
-    let(:license_path) { File.expand_path 'LICENSE.md', project_root }
-    let(:arguments) { [license_path] }
-
-    it "detects the file's license" do
-      expect(stdout).to match('License: MIT License')
-    end
+  it 'returns the help text' do
+    expect(stdout).to include('Licensee commands:')
   end
 end