license_finder 0.9.5.1 → 1.0.0.0

data/lib/license_finder/dependency_manager.rb

@@ -15,7 +15,7 @@ module LicenseFinder
 
       modifying {
         dependency = Dependency.new(manual: true, name: name, version: version)
-        dependency.license = LicenseAlias.create(name: license)
+        dependency.license = LicenseAlias.named(license)
         dependency.save
       }
     end
@@ -33,16 +33,15 @@ module LicenseFinder
     end
 
     def self.modifying
-      checksum_before_modifying = if File.exists? LicenseFinder.config.database_uri
-                                    Digest::SHA2.file(LicenseFinder.config.database_uri).hexdigest
-                                  end
+      database_file = LicenseFinder.config.artifacts.database_file
+      checksum_before_modifying = checksum(database_file)
       result = yield
-      checksum_after_modifying = Digest::SHA2.file(LicenseFinder.config.database_uri).hexdigest
+      checksum_after_modifying = checksum(database_file)
 
       unless checksum_after_modifying == checksum_before_modifying
         Reporter.write_reports
       end
-      unless File.exists? LicenseFinder.config.dependencies_html
+      unless LicenseFinder.config.artifacts.html_file.exist?
         Reporter.write_reports
       end
 
@@ -56,7 +55,7 @@ module LicenseFinder
     end
 
     def self.package_managers
-      [Bundler, NPM, Pip, Bower]
+      [Bundler, NPM, Pip, Bower, Maven, Gradle]
     end
 
     def self.find_by_name(name, scope = Dependency)
@@ -64,6 +63,12 @@ module LicenseFinder
       raise Error.new("could not find dependency named #{name}") unless dep
       dep
     end
+
+    def self.checksum(database_file)
+      if database_file.exist?
+        Digest::SHA2.file(database_file).hexdigest
+      end
+    end
   end
 end
 

data/lib/license_finder/license.rb

@@ -1,90 +1,64 @@
 module LicenseFinder
-  module License
+  class License
     class << self
       def all
         @all ||= []
       end
 
-      def find_by_name(license_name)
-        all.detect { |l| l.names.map(&:downcase).include? license_name.to_s.downcase }
-      end
-    end
-
-    class Text
-      def initialize(text)
-        @text = normalized(text)
-      end
-
-      def to_s
-        @text
+      def find_by_name(name)
+        all.detect { |l| l.matches_name? name } || UnknownLicense.new(name)
       end
 
-      private
-
-      def normalized(text)
-        text.gsub(/\s+/, ' ').gsub(/['`"]{1,2}/, "\"")
+      def find_by_text(text)
+        all.detect { |l| l.matches_text? text } || UnknownLicense.new
       end
     end
 
-    class Base
-      class << self
-        attr_accessor :license_url, :alternative_names
-
-        def inherited(descendant)
-          License.all << descendant
-        end
-
-        def names
-          ([demodulized_name, pretty_name] + self.alternative_names).uniq
-        end
+    autoload :Text,          "license_finder/license/text"
+    autoload :Template,      "license_finder/license/template"
+    autoload :Matcher,       "license_finder/license/matcher"
+    autoload :HeaderMatcher, "license_finder/license/header_matcher"
+    autoload :AnyMatcher,    "license_finder/license/any_matcher"
 
-        def alternative_names
-          @alternative_names ||= []
-        end
+    attr_reader :url, :pretty_name
 
-        def demodulized_name
-          name.gsub(/^.*::/, '')
-        end
-
-        def slug
-          demodulized_name.downcase
-        end
+    def initialize(settings)
+      @short_name  = settings.fetch(:short_name)
+      @pretty_name = settings.fetch(:pretty_name, short_name)
+      @other_names = settings.fetch(:other_names, [])
+      @url         = settings.fetch(:url)
+      @matcher     = settings.fetch(:matcher) { Matcher.from_template(Template.named(short_name)) }
+    end
 
-        def pretty_name
-          demodulized_name
-        end
+    def matches_name?(name)
+      names.map(&:downcase).include? name.to_s.downcase
+    end
 
-        def license_text
-          unless defined?(@license_text)
-            template = ROOT_PATH.join("data", "licenses", "#{demodulized_name}.txt")
+    def matches_text?(text)
+      matcher.matches_text?(text)
+    end
 
-            @license_text = Text.new(template.read).to_s if template.exist?
-          end
-          @license_text
-        end
+    private
 
-        def license_regex
-          /#{Regexp.escape(license_text).gsub(/<[^<>]+>/, '(.*)')}/ if license_text
-        end
-      end
+    attr_reader :short_name, :other_names, :matcher
 
-      def initialize(text)
-        self.text = text
-      end
+    def names
+      ([short_name, pretty_name] + other_names).uniq
+    end
+  end
 
-      attr_reader :text
+  class UnknownLicense
+    attr_reader :pretty_name
 
-      def text=(text)
-        @text = Text.new(text).to_s
-      end
+    def initialize(name = nil)
+      @pretty_name = name
+    end
+    def url; end
 
-      def matches?
-        !!(text =~ self.class.license_regex if self.class.license_regex)
-      end
+    def ==(other)
+      pretty_name.eql?(other.pretty_name)
     end
   end
 end
 
-Pathname.glob(LicenseFinder::ROOT_PATH.join('license_finder', 'license', "*.rb")) do |license|
-  require license
-end
+require LicenseFinder::ROOT_PATH.join("license_finder", "license", "definitions.rb")

data/lib/license_finder/license/any_matcher.rb

@@ -0,0 +1,13 @@
+module LicenseFinder
+  class License
+    class AnyMatcher
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+
+      def matches_text?(text)
+        @matchers.any? { |m| m.matches_text? text }
+      end
+    end
+  end
+end

data/lib/license_finder/license/definitions.rb

@@ -0,0 +1,106 @@
+class LicenseFinder::License
+  def self.mit_matcher
+    url_regexp = %r{MIT Licen[sc]e.*http://(?:www\.)?opensource\.org/licenses/mit-license}
+    header_regexp = /The MIT Licen[sc]e/
+    one_liner_regexp = /is released under the MIT licen[sc]e/
+
+    AnyMatcher.new(
+      Matcher.from_template(Template.named("MIT")),
+      Matcher.new(url_regexp),
+      HeaderMatcher.new(Matcher.new(header_regexp)),
+      Matcher.new(one_liner_regexp)
+    )
+  end
+
+  def self.new_bsd_matcher
+    template = Template.named("NewBSD")
+    alternate_content = template.content.gsub(
+      "Neither the name of <organization> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.",
+      "The names of its contributors may not be used to endorse or promote products derived from this software without specific prior written permission."
+    )
+
+    AnyMatcher.new(
+      Matcher.from_template(template),
+      Matcher.from_text(alternate_content)
+    )
+  end
+
+  def self.ruby_license_url
+    "http://www.ruby-lang.org/en/LICENSE.txt"
+  end
+
+  def self.ruby_matcher
+    url_regex = Regexp.new(Regexp.escape(ruby_license_url))
+
+    AnyMatcher.new(
+      Matcher.from_template(Template.named("Ruby")),
+      Matcher.new(url_regex)
+    )
+  end
+
+  all << new(
+    short_name:  "Apache2",
+    pretty_name: "Apache 2.0",
+    other_names: ["Apache-2.0", "Apache Software License", "Apache License 2.0", "Apache License Version 2.0", "Apache Public License 2.0"],
+    url:         "http://www.apache.org/licenses/LICENSE-2.0.txt"
+  )
+
+  all << new(
+    short_name:  "BSD",
+    other_names: ["BSD4", "bsd-old", "4-clause BSD", "BSD-4-Clause", "BSD License"],
+    url:         "http://en.wikipedia.org/wiki/BSD_licenses#4-clause_license_.28original_.22BSD_License.22.29"
+  )
+
+  all << new(
+    short_name:  "GPLv2",
+    other_names: ["GPL V2", "gpl-v2", "GNU GENERAL PUBLIC LICENSE Version 2"],
+    url:         "http://www.gnu.org/licenses/gpl-2.0.txt"
+  )
+
+  all << new(
+    short_name: "ISC",
+    url:        "http://en.wikipedia.org/wiki/ISC_license"
+  )
+
+  all << new(
+    short_name:  "LGPL",
+    other_names: ["LGPL-3", "LGPLv3", "LGPL-3.0"],
+    url:         "http://www.gnu.org/licenses/lgpl.txt"
+  )
+
+  all << new(
+    short_name:  "MIT",
+    other_names: ["Expat", "MIT license", "MIT License"],
+    url:         "http://opensource.org/licenses/mit-license",
+    matcher:     mit_matcher
+  )
+
+  all << new(
+    short_name:  "NewBSD",
+    pretty_name: "New BSD",
+    other_names: ["Modified BSD", "BSD3", "BSD-3", "3-clause BSD", "BSD-3-Clause"],
+    url:         "http://opensource.org/licenses/BSD-3-Clause",
+    matcher:     new_bsd_matcher
+  )
+
+  all << new(
+    short_name:  "Python",
+    pretty_name: "Python Software Foundation License",
+    other_names: ["PSF"],
+    url:         "http://hg.python.org/cpython/raw-file/89ce323357db/LICENSE"
+  )
+
+  all << new(
+    short_name:  "Ruby",
+    pretty_name: "ruby",
+    url:         ruby_license_url,
+    matcher:     ruby_matcher
+  )
+
+  all << new(
+    short_name:  "SimplifiedBSD",
+    pretty_name: "Simplified BSD",
+    other_names: ["FreeBSD", "2-clause BSD", "BSD-2-Clause"],
+    url:         "http://opensource.org/licenses/bsd-license"
+  )
+end

data/lib/license_finder/license/header_matcher.rb

@@ -0,0 +1,10 @@
+module LicenseFinder
+  class License
+    HeaderMatcher = Struct.new(:base_matcher) do
+      def matches_text?(text)
+        header = text.split("\n").first || ''
+        base_matcher.matches_text?(header)
+      end
+    end
+  end
+end

data/lib/license_finder/license/matcher.rb

@@ -0,0 +1,17 @@
+module LicenseFinder
+  class License
+    Matcher = Struct.new(:regexp) do
+      def self.from_template(template)
+        from_text(template.content)
+      end
+
+      def self.from_text(text)
+        new(Text.compile_to_regex(text))
+      end
+
+      def matches_text?(text)
+        !!(Text.normalize_punctuation(text) =~ regexp)
+      end
+    end
+  end
+end

data/lib/license_finder/license/template.rb

@@ -0,0 +1,16 @@
+module LicenseFinder
+  class License
+    class Template
+      def self.named(name)
+        path = ROOT_PATH.join("data", "licenses", "#{name}.txt")
+        new(path.read)
+      end
+
+      attr_reader :content
+
+      def initialize(raw_content)
+        @content = Text.normalize_punctuation(raw_content)
+      end
+    end
+  end
+end

data/lib/license_finder/license/text.rb

@@ -0,0 +1,19 @@
+module LicenseFinder
+  class License
+    module Text
+      SPACES = /\s+/
+      QUOTES = /['`"]{1,2}/
+      PLACEHOLDERS = /<[^<>]+>/
+
+      def self.normalize_punctuation(text)
+        text.gsub(SPACES, ' ')
+            .gsub(QUOTES, '"')
+      end
+
+      def self.compile_to_regex(text)
+        Regexp.new(Regexp.escape(text).gsub(PLACEHOLDERS, '(.*)'))
+      end
+    end
+  end
+end
+

data/lib/license_finder/license_url.rb

@@ -3,10 +3,7 @@ module LicenseFinder
     extend self
 
     def find_by_name(name)
-      name = name.to_s
-
-      license = License.find_by_name(name)
-      license.license_url if license
+      License.find_by_name(name.to_s).url
     end
   end
 end

data/lib/license_finder/package.rb

@@ -6,6 +6,17 @@ module LicenseFinder
   #     it_behaves_like "it conforms to interface required by PackageSaver"
   # and see BundlerPackage, PipPackage and NpmPackage
   class Package
+    def self.extract_licenses_from_standard_spec(spec)
+      licenses = spec["licenses"] || [spec["license"]].compact
+      licenses.map do |license|
+        if license.is_a? Hash
+          license["type"]
+        else
+          license
+        end
+      end
+    end
+
     def license
       @license ||= determine_license
     end
@@ -13,11 +24,16 @@ module LicenseFinder
     private
 
     def determine_license
-      license_from_spec || license_from_files || default_license
+      licenses = (licenses_from_spec + license_from_files).uniq
+      if licenses.length == 1
+        licenses.first
+      else
+        default_license
+      end
     end
 
     def license_from_files
-      license_files.map(&:license).compact.first
+      license_files.map(&:license).compact
     end
 
     def license_files

data/lib/license_finder/package_managers/bower_package.rb

@@ -39,25 +39,11 @@ module LicenseFinder
     attr_reader :module_metadata
 
     def install_path
-      bower_module.fetch("canonicalDir", nil)
+      bower_module["canonicalDir"]
     end
 
-    def license_from_spec
-      license = module_metadata.fetch("licenses", []).first
-
-      if license.is_a? Hash
-        license = license.fetch("type", nil)
-      end
-
-      if license.nil?
-        license = module_metadata.fetch("license", nil)
-
-        if license.is_a? Hash
-          license = license.fetch("type", nil)
-        end
-      end
-
-      license
+    def licenses_from_spec
+      Package.extract_licenses_from_standard_spec(module_metadata)
     end
   end
 end