licensee 8.9.2 → 9.0.0.beta.1

data/lib/licensee/matchers/{package_matcher.rb → matcher.rb}

@@ -1,16 +1,18 @@
 module Licensee
   module Matchers
-    class Package
+    class Matcher
+      attr_reader :file
+
       def initialize(file)
         @file = file
       end
 
       def match
-        Licensee.licenses(hidden: true).find { |l| l.key == license_property }
+        raise 'Not implemented'
       end
 
       def confidence
-        90
+        raise 'Not implemented'
       end
     end
   end

data/lib/licensee/matchers/{npm_bower_matcher.rb → npm_bower.rb}

@@ -1,10 +1,10 @@
 module Licensee
   module Matchers
-    class NpmBower < Package
+    class NpmBower < Licensee::Matchers::Package
       # While we could parse the package.json or bower.json file, prefer
       # a lenient regex for speed and security. Moar parsing moar problems.
       LICENSE_REGEX = /
-        s*[\"\']license[\"\']\s*\:\s*[\'\"]([a-z\-0-9\.]+)[\'\"],?\s*
+        \s*[\"\']license[\"\']\s*\:\s*[\'\"]([a-z\-0-9\.]+)[\'\"],?\s*
       /ix
 
       private

data/lib/licensee/matchers/package.rb

@@ -0,0 +1,22 @@
+module Licensee
+  module Matchers
+    class Package < Licensee::Matchers::Matcher
+      def match
+        return @match if defined? @match
+        return if license_property.nil? || license_property.to_s.empty?
+        @match = Licensee.licenses(hidden: true).find do |license|
+          license.key == license_property
+        end
+        @match ||= License.find('other')
+      end
+
+      def confidence
+        90
+      end
+
+      def license_property
+        raise 'Not implemented'
+      end
+    end
+  end
+end

data/lib/licensee/project_files.rb

@@ -0,0 +1,8 @@
+module Licensee
+  module ProjectFiles
+    autoload :ProjectFile, 'licensee/project_files/project_file'
+    autoload :LicenseFile, 'licensee/project_files/license_file'
+    autoload :PackageManagerFile, 'licensee/project_files/package_manager_file'
+    autoload :ReadmeFile, 'licensee/project_files/readme_file'
+  end
+end

data/lib/licensee/project_files/license_file.rb

@@ -1,6 +1,6 @@
 module Licensee
-  class Project
-    class LicenseFile < Licensee::Project::File
+  module ProjectFiles
+    class LicenseFile < Licensee::ProjectFiles::ProjectFile
       include Licensee::ContentHelper
 
       # List of extensions to give preference to
@@ -27,8 +27,10 @@ module Licensee
         /\A#{COPYING_REGEX}#{PREFERRED_EXT_REGEX}\z/ => 0.7,  # COPYING.md
         /\A#{LICENSE_REGEX}#{ANY_EXT_REGEX}\z/       => 0.6,  # LICENSE.textile
         /\A#{COPYING_REGEX}#{ANY_EXT_REGEX}\z/       => 0.5,  # COPYING.textile
-        /#{LICENSE_REGEX}/                           => 0.4,  # LICENSE-MIT
-        /#{COPYING_REGEX}/                           => 0.3,  # COPYING-MIT
+        /#{LICENSE_REGEX}-/                          => 0.4,  # LICENSE-MIT
+        /#{COPYING_REGEX}-/                          => 0.35, # COPYING-MIT
+        /-#{LICENSE_REGEX}/                          => 0.3,  # MIT-LICENSE-MIT
+        /-#{COPYING_REGEX}/                          => 0.25, # MIT-COPYING
         /\A#{OFL_REGEX}#{PREFERRED_EXT_REGEX}/       => 0.2,  # OFL.md
         /\A#{OFL_REGEX}#{ANY_EXT_REGEX}/             => 0.1,  # OFL.textile
         /\A#{OFL_REGEX}\z/                           => 0.05, # OFL
@@ -58,6 +60,22 @@ module Licensee
         content.strip =~ CC_FALSE_POSITIVE_REGEX
       end
 
+      def lgpl?
+        LicenseFile.lesser_gpl_score(filename) == 1 && license && license.lgpl?
+      end
+
+      def gpl?
+        license && license.gpl?
+      end
+
+      def license
+        if matcher && matcher.match
+          matcher.match
+        else
+          License.find('other')
+        end
+      end
+
       def self.name_score(filename)
         FILENAME_REGEXES.find { |regex, _| filename =~ regex }[1]
       end

data/lib/licensee/project_files/package_manager_file.rb

@@ -0,0 +1,37 @@
+module Licensee
+  module ProjectFiles
+    class PackageManagerFile < Licensee::ProjectFiles::ProjectFile
+      # Hash of Extension => [possible matchers]
+      MATCHERS_EXTENSIONS = {
+        '.gemspec' => [Matchers::Gemspec],
+        '.json'    => [Matchers::NpmBower],
+        '.cabal'   => [Matchers::Cabal]
+      }.freeze
+
+      # Hash of Filename => [possible matchers]
+      FILENAMES_EXTENSIONS = {
+        'DESCRIPTION' => [Matchers::Cran],
+        'dist.ini'    => [Matchers::DistZilla]
+      }.freeze
+
+      def possible_matchers
+        MATCHERS_EXTENSIONS[extension] || FILENAMES_EXTENSIONS[filename] || []
+      end
+
+      def self.name_score(filename)
+        return 1.0  if ['.gemspec', '.cabal'].include?(File.extname(filename))
+        return 1.0  if filename == 'package.json'
+        return 0.8  if filename == 'dist.ini'
+        return 0.9  if filename == 'DESCRIPTION'
+        return 0.75 if filename == 'bower.json'
+        0.0
+      end
+
+      private
+
+      def extension
+        @extension ||= File.extname(filename)
+      end
+    end
+  end
+end

data/lib/licensee/project_files/project_file.rb

@@ -0,0 +1,65 @@
+# A project file is a file within a project that contains license information
+# Currently extended by LicenseFile, PackageManagerFile, and ReadmeFile
+#
+# Sublcasses should implement the possible_matchers method
+module Licensee
+  module ProjectFiles
+    class ProjectFile
+      extend Forwardable
+      def_delegator :@data, :[]
+
+      attr_reader :content
+
+      ENCODING = Encoding::UTF_8
+      ENCODING_OPTIONS = {
+        invalid: :replace,
+        undef:   :replace,
+        replace: ''
+      }.freeze
+
+      # Create a new Licensee::ProjectFile with content and metadata
+      #
+      # content - file content
+      # metadata - can be either the string filename, or a hash containing
+      #            metadata about the file content. If a hash is given, the
+      #            filename should be given using the :name key. See individual
+      #            project types for additional available metadata
+      #
+      # Returns a new Licensee::ProjectFile
+      def initialize(content, metadata = {})
+        @content = content
+        @content.force_encoding(ENCODING)
+        unless @content.valid_encoding?
+          @content.encode!(ENCODING, ENCODING_OPTIONS)
+        end
+
+        metadata = { name: metadata } if metadata.is_a? String
+        @data = metadata || {}
+      end
+
+      def filename
+        @data[:name]
+      end
+
+      def possible_matchers
+        raise 'Not implemented'
+      end
+
+      def matcher
+        @matcher ||= possible_matchers.map { |m| m.new(self) }.find(&:match)
+      end
+
+      # Returns the percent confident with the match
+      def confidence
+        matcher && matcher.confidence
+      end
+
+      def license
+        matcher && matcher.match
+      end
+
+      alias match license
+      alias path filename
+    end
+  end
+end

data/lib/licensee/project_files/{readme.rb → readme_file.rb}

@@ -1,6 +1,6 @@
 module Licensee
-  class Project
-    class Readme < LicenseFile
+  module ProjectFiles
+    class ReadmeFile < Licensee::ProjectFiles::LicenseFile
       SCORES = {
         /\AREADME\z/i                          => 1.0,
         /\AREADME\.(md|markdown|mdown|txt)\z/i => 0.9

data/lib/licensee/projects.rb

@@ -0,0 +1,7 @@
+module Licensee
+  module Projects
+    autoload :Project, 'licensee/projects/project'
+    autoload :FSProject, 'licensee/projects/fs_project'
+    autoload :GitProject, 'licensee/projects/git_project'
+  end
+end

data/lib/licensee/projects/fs_project.rb

@@ -1,41 +1,78 @@
 # Filesystem-based project
 #
 # Analyze a folder on the filesystem for license information
+#
+# Project files for this project type will contain the following keys:
+#  :name - the relative file name
+#  :dir  - the directory path containing the file
 module Licensee
-  class FSProject < Project
-    def initialize(path, **args)
-      if ::File.file?(path)
-        @pattern = ::File.basename(path)
-        @dir = ::File.dirname(path)
-      else
-        @pattern = '*'
-        @dir = path
+  module Projects
+    class FSProject < Licensee::Projects::Project
+      def initialize(path, **args)
+        if ::File.file?(path)
+          @pattern = ::File.basename(path)
+          @dir = ::File.dirname(path)
+        else
+          @pattern = '*'
+          @dir = path
+        end
+
+        @root = args.delete(:search_root) || @dir
+        unless valid_search_root?
+          raise 'Search root must be the project path directory or its ancestor'
+        end
+
+        super(**args)
       end
-      super(**args)
-    end
 
-    private
+      private
+
+      # Returns an array of hashes representing the project's files.
+      # Hashes will have the the following keys:
+      #  :name - the relative file name
+      #  :dir  - the directory path containing the file
+      def files
+        @files ||= search_directories.flat_map do |dir|
+          Dir.glob(::File.join(dir, @pattern).tr('\\', '/')).map do |file|
+            next unless ::File.file?(file)
+            { name: ::File.basename(file), dir: dir }
+          end.compact
+        end
+      end
 
-    # Returns an array of hashes representing the project's files.
-    # Hashes will have the :name key, with the relative path to the file
-    def files
-      files = []
+      # Retrieve a file's content from disk
+      #
+      # file - the file hash, with the :name key as the file's relative path
+      #
+      # Returns the file contents as a string
+      def load_file(file)
+        ::File.read(::File.join(file[:dir], file[:name]))
+      end
 
-      Dir.glob(::File.join(@dir, @pattern).tr('\\', '/')) do |file|
-        next unless ::File.file?(file)
-        files.push(name: ::File.basename(file))
+      # Returns true if @dir is @root or it's descendant
+      def valid_search_root?
+        dir = Pathname.new(@dir)
+        dir.fnmatch?(@root) || dir.fnmatch?(::File.join(@root, '**'))
       end
 
-      files
-    end
+      # Returns the set of unique paths to search for project files
+      # in order from @dir -> @root
+      def search_directories
+        search_enumerator.map(&:to_path)
+                         .push(@root) # ensure root is included in the search
+                         .uniq # don't include the root twice if @dir == @root
+      end
 
-    # Retrieve a file's content from disk
-    #
-    # file - the file hash, with the :name key as the file's relative path
-    #
-    # Returns the file contents as a string
-    def load_file(file)
-      ::File.read(::File.join(@dir, file[:name]))
+      # Enumerates all directories to search, from @dir to @root
+      def search_enumerator
+        root = Pathname.new(@root)
+        dir = Pathname.new(@dir)
+        Enumerator.new do |yielder|
+          dir.relative_path_from(root).ascend do |relative|
+            yielder.yield root.join(relative)
+          end
+        end
+      end
     end
   end
 end

data/lib/licensee/projects/git_project.rb

@@ -1,60 +1,66 @@
 # Git-based project
 #
 # Analyze a given (bare) Git repository for license information
+#
+# Project files for this project type will contain the following keys:
+#  :name - the file's path relative to the repo root
+#  :oid  - the file's OID
 module Licensee
-  class GitProject < Project
-    attr_reader :repository, :revision
+  module Projects
+    class GitProject < Licensee::Projects::Project
+      attr_reader :repository, :revision
 
-    class InvalidRepository < ArgumentError; end
+      class InvalidRepository < ArgumentError; end
 
-    def initialize(repo, revision: nil, **args)
-      @repository = if repo.is_a? Rugged::Repository
-        repo
-      else
-        Rugged::Repository.new(repo)
-      end
+      def initialize(repo, revision: nil, **args)
+        @repository = if repo.is_a? Rugged::Repository
+          repo
+        else
+          Rugged::Repository.new(repo)
+        end
 
-      @revision = revision
-      super(**args)
-    rescue Rugged::OSError, Rugged::RepositoryError
-      raise InvalidRepository
-    end
+        @revision = revision
+        super(**args)
+      rescue Rugged::OSError, Rugged::RepositoryError
+        raise InvalidRepository
+      end
 
-    def close
-      @repository.close
-    end
+      def close
+        @repository.close
+      end
 
-    private
+      private
 
-    def commit
-      @commit ||= if revision
-        repository.lookup(revision)
-      else
-        repository.last_commit
+      def commit
+        @commit ||= if revision
+          repository.lookup(revision)
+        else
+          repository.last_commit
+        end
       end
-    end
 
-    MAX_LICENSE_SIZE = 64 * 1024
+      MAX_LICENSE_SIZE = 64 * 1024
 
-    # Retrieve a file's content from the Git database
-    #
-    # file - the file hash, including the file's OID
-    #
-    # Returns a string representing the file's contents
-    def load_file(file)
-      data, = Rugged::Blob.to_buffer(repository, file[:oid], MAX_LICENSE_SIZE)
-      data
-    end
+      # Retrieve a file's content from the Git database
+      #
+      # file - the file hash, including the file's OID
+      #
+      # Returns a string representing the file's contents
+      def load_file(file)
+        data, = Rugged::Blob.to_buffer(repository, file[:oid], MAX_LICENSE_SIZE)
+        data
+      end
 
-    # Returns an array of hashes representing the project's files.
-    # Hashes will have the the following keys:
-    #  :name - the file's path relative to the repo root
-    #  :oid  - the file's OID
-    def files
-      commit.tree.map do |entry|
-        next unless entry[:type] == :blob
-        { name: entry[:name], oid: entry[:oid] }
-      end.compact
+      # Returns an array of hashes representing the project's files.
+      # Hashes will have the the following keys:
+      #  :name - the file's path relative to the repo root
+      #  :oid  - the file's OID
+      def files
+        @files ||= commit.tree.map do |entry|
+          next unless entry[:type] == :blob
+          { name: entry[:name], oid: entry[:oid] }
+        end.compact
+      end
     end
   end
 end