licensee 9.10.0 → 9.13.1

data/spec/licensee/commands/detect_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe 'detect command' do
   let(:command) { ['bundle', 'exec', 'bin/licensee', 'detect'] }
   let(:arguments) { [] }
@@ -10,7 +12,7 @@ RSpec.describe 'detect command' do
   let(:stdout) { output[0] }
   let(:stderr) { output[1] }
   let(:status) { output[2] }
-  let(:hash) { '46cdc03462b9af57968df67b450cc4372ac41f53' }
+  let(:hash) { license_hashes['mit'] }
   let(:expected) do
     {
       'License'          => 'MIT',
@@ -39,7 +41,7 @@ RSpec.describe 'detect command' do
       let(:arguments) { args }
 
       it 'Returns a zero exit code' do
-        expect(status.exitstatus).to eql(0)
+        expect(status.exitstatus).to be(0)
       end
 
       it 'returns the exected values' do
@@ -60,15 +62,17 @@ RSpec.describe 'detect command' do
     let(:expected) { JSON.parse fixture_contents('detect.json') }
 
     it 'Returns a zero exit code' do
-      expect(status.exitstatus).to eql(0)
+      expect(status.exitstatus).to be(0)
     end
 
     it 'returns valid JSON' do
-      expect { JSON.parse(stdout) }.to_not raise_error
+      expect { JSON.parse(stdout) }.not_to raise_error
     end
 
     it 'returns the expected output' do
-      expect(JSON.parse(stdout)).to eql(expected)
+      msg = '`licensee detect --json` output did not match expectations. '.dup
+      msg << 'Run `script/dump-detect-json-fixture` and verify the output.'
+      expect(JSON.parse(stdout)).to eql(expected), msg
     end
   end
 
@@ -76,7 +80,7 @@ RSpec.describe 'detect command' do
     let(:command) { ['bundle', 'exec', 'bin/licensee'] }
 
     it 'Returns a zero exit code' do
-      expect(status.exitstatus).to eql(0)
+      expect(status.exitstatus).to be(0)
     end
 
     it 'returns the exected values' do

data/spec/licensee/commands/license_path_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe 'license-path command' do
   let(:command) { ['bundle', 'exec', 'bin/licensee', 'license-path'] }
   let(:arguments) { [project_root] }
@@ -16,6 +18,6 @@ RSpec.describe 'license-path command' do
   end
 
   it 'Returns a zero exit code' do
-    expect(status.exitstatus).to eql(0)
+    expect(status.exitstatus).to be(0)
   end
 end

data/spec/licensee/commands/version_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe 'version command' do
   let(:command) { ['bundle', 'exec', 'bin/licensee', 'version'] }
   let(:arguments) { [] }
@@ -16,6 +18,6 @@ RSpec.describe 'version command' do
   end
 
   it 'Returns a zero exit code' do
-    expect(status.exitstatus).to eql(0)
+    expect(status.exitstatus).to be(0)
   end
 end

data/spec/licensee/content_helper_spec.rb

@@ -1,15 +1,24 @@
+# frozen_string_literal: true
+
 class ContentHelperTestHelper
   include Licensee::ContentHelper
-  attr_accessor :content
+  attr_accessor :content, :data
 
-  def initialize(content = nil)
+  def initialize(content = nil, data = {})
     @content = content
+    @data = data
+  end
+
+  def filename
+    @data[:filename]
   end
 end
 
 RSpec.describe Licensee::ContentHelper do
+  subject { ContentHelperTestHelper.new(content, filename: filename) }
+
   let(:content) do
-    <<-LICENSE.freeze.gsub(/^\s*/, '')
+    <<-LICENSE.gsub(/^\s*/, '')
   # The MIT License
 	=================
 
@@ -27,8 +36,10 @@ RSpec.describe Licensee::ContentHelper do
   -----------
     LICENSE
   end
-  subject { ContentHelperTestHelper.new(content) }
+  let(:filename) { 'license.md' }
+
   let(:mit) { Licensee::License.find('mit') }
+  let(:normalized_content) { subject.content_normalized }
 
   it 'creates the wordset' do
     wordset = Set.new(
@@ -41,25 +52,25 @@ RSpec.describe Licensee::ContentHelper do
   end
 
   it 'knows the length' do
-    expect(subject.length).to eql(135)
+    expect(subject.length).to be(135)
   end
 
   context 'a very long license' do
     let(:content) { 'license' * 1000 }
 
     it 'returns the max delta' do
-      expect(subject.max_delta).to eql(140)
+      expect(subject.max_delta).to be(140)
     end
   end
 
   it 'knows the length delta' do
-    expect(subject.length_delta(mit)).to eql(884)
-    expect(subject.length_delta(subject)).to eql(0)
+    expect(subject.length_delta(mit)).to be(885)
+    expect(subject.length_delta(subject)).to be(0)
   end
 
   it 'knows the similarity' do
     expect(subject.similarity(mit)).to be_within(1).of(11)
-    expect(subject.similarity(subject)).to eql(100.0)
+    expect(subject.similarity(subject)).to be(100.0)
   end
 
   it 'calculates the hash' do
@@ -68,75 +79,102 @@ RSpec.describe Licensee::ContentHelper do
   end
 
   it 'wraps' do
-    content = Licensee::ContentHelper.wrap(mit.content, 40)
+    content = described_class.wrap(mit.content, 40)
     lines = content.split("\n")
     expect(lines.first.length).to be <= 40
   end
 
   it 'formats percents' do
-    percent = Licensee::ContentHelper.format_percent(12.3456789)
+    percent = described_class.format_percent(12.3456789)
     expect(percent).to eql('12.35%')
   end
 
-  context 'normalizing' do
-    let(:normalized_content) { subject.content_normalized }
-
-    it 'strips copyright' do
-      expect(normalized_content).to_not match 'Copyright'
-      expect(normalized_content).to_not match 'Ben Balter'
+  describe '#strip' do
+    {
+      version:             "The MIT License\nVersion 1.0\nfoo",
+      hrs:                 "The MIT License\n=====\n-----\n*******\nfoo",
+      markdown_headings:   "# The MIT License\n\nfoo",
+      whitespace:          "The MIT License\n\n   foo  ",
+      all_rights_reserved: "Copyright 2016 Ben Balter\n\nfoo",
+      urls:                "https://example.com\nfoo",
+      developed_by:        "Developed By: Ben Balter\n\nFoo",
+      borders:             '*   Foo    *',
+      title:               "The MIT License\nfoo",
+      copyright:           "The MIT License\nCopyright 2018 Ben Balter\nFoo",
+      end_of_terms:        "Foo\nend of terms and conditions\nbar",
+      block_markup:        '> Foo',
+      link_markup:         '[Foo](http://exmaple.com)',
+      comment_markup:      "/*\n* The MIT License\n* Foo\n*/",
+      copyright_title:     "Copyright 2019 Ben Balter\nMIT License\nFoo"
+    }.each do |field, fixture|
+      context "#strip_#{field}" do
+        let(:content) { fixture }
+
+        it "strips #{field}" do
+          expect(normalized_content).to eql('foo')
+        end
+      end
     end
 
-    it 'downcases' do
-      expect(normalized_content).to_not match 'The'
-      expect(normalized_content).to match 'the'
+    context 'span markup' do
+      let(:content) { '_foo_ *foo* **foo** ~foo~' }
+
+      it 'strips span markup' do
+        expect(normalized_content).to eql('foo foo foo foo')
+      end
     end
 
-    it 'strips HRs' do
-      expect(normalized_content).to_not match '---'
-      expect(normalized_content).to_not match '==='
-      expect(normalized_content).to_not include '***'
-      expect(normalized_content).to_not include '* *'
+    context 'HTML' do
+      let(:content) { '<ul><li>foo</li></ul>' }
+      let(:filename) { 'license.html' }
+
+      it 'strips HTML' do
+        expect(normalized_content).to eql('- foo')
+      end
     end
+  end
 
-    it 'strips formatting from the MPL' do
-      license = Licensee::License.find('mpl-2.0')
-      expect(license.content_normalized).to_not include('* *')
+  context 'integration fixture' do
+    it 'strips copyright' do
+      expect(normalized_content).not_to match 'Copyright'
+      expect(normalized_content).not_to match 'Ben Balter'
     end
 
-    it 'normalizes http: to https:' do
-      license = Licensee::License.find('mpl-2.0')
-      expect(license.content).to include('http:')
-      expect(license.content_normalized).to_not include('http:')
+    it 'downcases' do
+      expect(normalized_content).not_to match 'The'
+      expect(normalized_content).to match 'the'
     end
 
-    it 'wraps' do
-      lines = mit.content_normalized(wrap: 40).split("\n")
-      expect(lines.first.length).to be <= 40
+    it 'strips HRs' do
+      expect(normalized_content).not_to match '---'
+      expect(normalized_content).not_to match '==='
+      expect(normalized_content).not_to include '***'
+      expect(normalized_content).not_to include '* *'
     end
 
     it 'squeezes whitespace' do
-      expect(normalized_content).to_not match '  '
+      expect(normalized_content).not_to match '  '
     end
 
     it 'strips whitespace' do
-      expect(normalized_content).to_not match(/\n/)
-      expect(normalized_content).to_not match(/\t/)
+      expect(normalized_content).not_to match(/\n/)
+      expect(normalized_content).not_to match(/\t/)
     end
 
     it 'strips markdown headings' do
-      expect(normalized_content).to_not match('#')
+      expect(normalized_content).not_to match('#')
     end
 
     it 'strips all rights reserved' do
-      expect(normalized_content).to_not match(/all rights reserved/i)
+      expect(normalized_content).not_to match(/all rights reserved/i)
     end
 
     it 'strips markup' do
-      expect(normalized_content).to_not match(/[*=_-]+/)
+      expect(normalized_content).not_to match(/[*=_-]+/)
     end
 
     it 'normalizes quotes' do
-      expect(normalized_content).to_not match("'as is'")
+      expect(normalized_content).not_to match("'as is'")
     end
 
     it 'preserves possessives' do
@@ -148,55 +186,120 @@ RSpec.describe Licensee::ContentHelper do
       expect(normalized_content).to match('"software"')
     end
 
+    it 'strips the title' do
+      expect(normalized_content).not_to match('MIT')
+    end
+
+    it 'normalize the content' do
+      expected = 'the made up license. this license provided "as is". '.dup
+      expected << "please respect the contributors' wishes when implementing "
+      expected << "the license's \"software\"."
+      expect(normalized_content).to eql(expected)
+    end
+  end
+
+  context 'normalizing' do
+    context 'https' do
+      let(:content) { 'http://example.com' }
+
+      it 'normalized URL protocals' do
+        expect(subject.content_normalized).to eql('https://example.com')
+      end
+    end
+
+    context 'ampersands' do
+      let(:content) { 'Foo & Bar' }
+
+      it 'normalized ampersands' do
+        expect(subject.content_normalized).to eql('foo and bar')
+      end
+    end
+
+    context 'lists' do
+      let(:content) { "1. Foo\n * Bar" }
+
+      it 'normalizes lists' do
+        expect(subject.content_normalized).to eql('- foo - bar')
+      end
+    end
+
+    context 'dashes' do
+      let(:content) { 'Foo-Bar—–baz-buzz' }
+
+      it 'normalizes dashes' do
+        expect(subject.content_normalized).to eql('foo-bar-baz-buzz')
+      end
+    end
+
+    context 'quotes' do
+      let(:content) { "`a` 'b' \"c\" ‘d’ “e”" }
+
+      it 'normalizes quotes' do
+        expect(subject.content_normalized).to eql('"a" "b" "c" "d" "e"')
+      end
+    end
+
+    it 'strips formatting from the MPL' do
+      license = Licensee::License.find('mpl-2.0')
+      expect(license.content_normalized).not_to include('* *')
+    end
+
+    it 'normalizes http: to https:' do
+      license = Licensee::License.find('mpl-2.0')
+      expect(license.content).to include('http:')
+      expect(license.content_normalized).not_to include('http:')
+    end
+
+    it 'wraps' do
+      lines = mit.content_normalized(wrap: 40).split("\n")
+      expect(lines.first.length).to be <= 40
+    end
+
+    context 'spelling' do
+      let(:content) { 'licence' }
+
+      it 'normalizes' do
+        expect(subject.content_normalized).to eql('license')
+      end
+    end
+
     Licensee::License.all(hidden: true).each do |license|
       context license.name do
         let(:stripped_content) { subject.content_without_title_and_version }
 
         it 'strips the title' do
-          regex = Licensee::ContentHelper::ALT_TITLE_REGEX[license.key]
-          regex ||= /\A#{license.name_without_version}/i
-          expect(license.content_normalized).to_not match(regex)
-          expect(stripped_content).to_not match(regex)
+          regex = /\A#{license.name_without_version}/i
+          expect(stripped_content).not_to match(regex)
+          expect(license.content_normalized).not_to match(regex)
         end
 
         it 'strips the version' do
-          expect(license.content_normalized).to_not match(/\Aversion/i)
-          expect(stripped_content).to_not match(/\Aversion/i)
+          expect(license.content_normalized).not_to match(/\Aversion/i)
+          expect(stripped_content).not_to match(/\Aversion/i)
         end
 
         it 'strips all rights reserved' do
           regex = /all rights reserved/i
-          expect(license.content_normalized).to_not match(regex)
+          expect(license.content_normalized).not_to match(regex)
         end
 
         it 'strips the copyright' do
-          expect(license.content_normalized).to_not match(/\Acopyright/i)
+          expect(license.content_normalized).not_to match(/\Acopyright/i)
         end
 
         it 'strips the implementation instructions' do
           end_terms_regex = /END OF TERMS AND CONDITIONS/i
-          expect(license.content_normalized).to_not match(end_terms_regex)
-          expect(license.content_normalized).to_not match(/How to apply/i)
+          expect(license.content_normalized).not_to match(end_terms_regex)
+          expect(license.content_normalized).not_to match(/How to apply/i)
         end
       end
     end
 
-    it 'strips the title' do
-      expect(normalized_content).to_not match('MIT')
-    end
-
-    it 'normalize the content' do
-      expected = 'the made up license. this license provided "as is". '
-      expected << "please respect the contributors' wishes when implementing "
-      expected << "the license's \"software\"."
-      expect(normalized_content).to eql(expected)
-    end
-
     context 'a title in parenthesis' do
       let(:content) { "(The MIT License)\n\nfoo" }
 
       it 'strips the title' do
-        expect(normalized_content).to_not match('MIT')
+        expect(normalized_content).not_to match('MIT')
         expect(normalized_content).to eql('foo')
       end
     end
@@ -205,7 +308,7 @@ RSpec.describe Licensee::ContentHelper do
       let(:content) { "Copyright 2016 Ben Balter\nCopyright 2017 Bob\nFoo" }
 
       it 'strips multiple copyrights' do
-        expect(normalized_content).to_not match('Ben')
+        expect(normalized_content).not_to match('Ben')
         expect(normalized_content).to eql('foo')
       end
     end
@@ -259,7 +362,7 @@ RSpec.describe Licensee::ContentHelper do
           let(:text) { 'gpl-3 0' }
 
           it 'escapes' do
-            expect(text).to_not match(described_class.title_regex)
+            expect(text).not_to match(described_class.title_regex)
           end
         end
 
@@ -269,10 +372,24 @@ RSpec.describe Licensee::ContentHelper do
           end
 
           it 'matches' do
-            expect(text).to_not match(described_class.title_regex)
+            expect(text).not_to match(described_class.title_regex)
           end
         end
       end
     end
   end
+
+  context 'metaprogramming' do
+    it 'raises on invalid normalization' do
+      expect { subject.send(:normalize, :foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises on invalid strip' do
+      expect { subject.send(:strip, :foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'backwards compatibalizes regexes' do
+      expect(described_class::WHITESPACE_REGEX).to eql(/\s+/)
+    end
+  end
 end