license_finder 1.2 → 2.0.0.rc2

data/lib/license_finder/decision_applier.rb

@@ -0,0 +1,46 @@
+module LicenseFinder
+  class DecisionApplier
+    def initialize(options)
+      @decisions = options.fetch(:decisions)
+      @packages = options.fetch(:packages)
+    end
+
+    def unapproved
+      acknowledged.reject(&:approved?)
+    end
+
+    def acknowledged
+      base_packages = decisions.packages + packages
+      base_packages.
+        reject { |package| ignored?(package) }.
+        map    { |package| with_decided_licenses(package) }.
+        map    { |package| with_approval(package) }
+    end
+
+    private
+
+    attr_reader :packages, :decisions
+
+    def ignored?(package)
+      decisions.ignored?(package.name) ||
+        package.groups.any? { |group| decisions.ignored_group?(group) }
+    end
+
+    def with_decided_licenses(package)
+      decisions.licenses_of(package.name).each do |license|
+        package.decide_on_license license
+      end
+      package
+    end
+
+    def with_approval(package)
+      if decisions.approved?(package.name)
+        package.approved_manually!(decisions.approval_of(package.name))
+      elsif package.licenses.any? { |license| decisions.whitelisted?(license) }
+        package.whitelisted!
+      end
+      package
+    end
+  end
+end
+

data/lib/license_finder/decisions.rb

@@ -0,0 +1,174 @@
+module LicenseFinder
+  class Decisions
+    ######
+    # READ
+    ######
+
+    attr_reader :packages, :whitelisted, :ignored, :ignored_groups, :project_name
+
+    def licenses_of(name)
+      @licenses[name]
+    end
+
+    def approval_of(name)
+      @approvals[name]
+    end
+
+    def approved?(name)
+      @approvals.has_key?(name)
+    end
+
+    def whitelisted?(lic)
+      @whitelisted.include?(lic)
+    end
+
+    def ignored?(name)
+      @ignored.include?(name)
+    end
+
+    def ignored_group?(name)
+      @ignored_groups.include?(name)
+    end
+
+    #######
+    # WRITE
+    #######
+
+    TXN = Struct.new(:who, :why, :safe_when) do
+      def self.from_hash(txn)
+        new(txn[:who], txn[:why], txn[:when])
+      end
+    end
+
+    def initialize
+      @decisions = []
+      @packages = Set.new
+      @licenses = Hash.new { |h, k| h[k] = Set.new }
+      @approvals = {}
+      @whitelisted = Set.new
+      @ignored = Set.new
+      @ignored_groups = Set.new
+    end
+
+    def add_package(name, version, txn = {})
+      @decisions << [:add_package, name, version, txn]
+      @packages << ManualPackage.new(name, version)
+      self
+    end
+
+    def remove_package(name, txn = {})
+      @decisions << [:remove_package, name, txn]
+      @packages.delete(ManualPackage.new(name))
+      self
+    end
+
+    def license(name, lic, txn = {})
+      @decisions << [:license, name, lic, txn]
+      @licenses[name] << License.find_by_name(lic)
+      self
+    end
+
+    def unlicense(name, lic, txn= {})
+      @decisions << [:unlicense, name, lic, txn]
+      @licenses[name].delete(License.find_by_name(lic))
+      self
+    end
+
+    def approve(name, txn = {})
+      @decisions << [:approve, name, txn]
+      @approvals[name] = TXN.from_hash(txn)
+      self
+    end
+
+    def unapprove(name, txn = {})
+      @decisions << [:unapprove, name, txn]
+      @approvals.delete(name)
+      self
+    end
+
+    def whitelist(lic, txn = {})
+      @decisions << [:whitelist, lic, txn]
+      @whitelisted << License.find_by_name(lic)
+      self
+    end
+
+    def unwhitelist(lic, txn = {})
+      @decisions << [:unwhitelist, lic, txn]
+      @whitelisted.delete(License.find_by_name(lic))
+      self
+    end
+
+    def ignore(name, txn = {})
+      @decisions << [:ignore, name, txn]
+      @ignored << name
+      self
+    end
+
+    def heed(name, txn = {})
+      @decisions << [:heed, name, txn]
+      @ignored.delete(name)
+      self
+    end
+
+    def ignore_group(name, txn = {})
+      @decisions << [:ignore_group, name, txn]
+      @ignored_groups << name
+      self
+    end
+
+    def heed_group(name, txn = {})
+      @decisions << [:heed_group, name, txn]
+      @ignored_groups.delete(name)
+      self
+    end
+
+    def name_project(name, txn = {})
+      @decisions << [:name_project, name, txn]
+      @project_name = name
+      self
+    end
+
+    def unname_project(txn = {})
+      @decisions << [:unname_project, txn]
+      @project_name = nil
+      self
+    end
+
+    #########
+    # PERSIST
+    #########
+
+    def self.saved!(file)
+      restore(read!(file))
+    end
+
+    def save!(file)
+      write!(persist, file)
+    end
+
+    def self.restore(persisted)
+      result = new
+      if persisted
+        YAML.load(persisted).each do |action, *args|
+          result.send(action, *args)
+        end
+      end
+      result
+    end
+
+    def persist
+      YAML.dump(@decisions)
+    end
+
+    def self.read!(file)
+      file.read if file.exist?
+    end
+
+    def write!(value, file)
+      file.dirname.mkpath
+      file.open('w+') do |f|
+        f.print value
+      end
+    end
+  end
+end

data/lib/license_finder/license.rb

@@ -2,12 +2,12 @@ module LicenseFinder
   class License
     class << self
       def all
-        @all ||= Definitions.all(LicenseFinder.config.whitelist)
+        @all ||= Definitions.all
       end
 
       def find_by_name(name)
-        name ||= "other"
-        all.detect { |l| l.matches_name? name } || Definitions.build_unrecognized(name, LicenseFinder.config.whitelist)
+        name ||= "unknown"
+        all.detect { |l| l.matches_name? name } || Definitions.build_unrecognized(name)
       end
 
       def find_by_text(text)
@@ -15,20 +15,11 @@ module LicenseFinder
       end
     end
 
-    autoload :Definitions,   "license_finder/license/definitions"
-    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"
-    autoload :NoneMatcher,   "license_finder/license/none_matcher"
-
     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)
-      @whitelisted = settings.fetch(:whitelisted, false)
       @matcher     = settings.fetch(:matcher) { Matcher.from_template(Template.named(short_name)) }
     end
 
@@ -46,14 +37,6 @@ module LicenseFinder
       matcher.matches_text?(text)
     end
 
-    def whitelisted?
-      @whitelisted
-    end
-
-    def whitelist
-      copy(whitelisted: true)
-    end
-
     def eql?(other)
       name == other.name
     end
@@ -70,17 +53,15 @@ module LicenseFinder
     def names
       ([short_name, pretty_name] + other_names).uniq
     end
-
-    def copy(overrides)
-      settings = {
-        short_name:  short_name,
-        pretty_name: pretty_name,
-        other_names: other_names,
-        url:         url,
-        whitelisted: whitelisted?,
-        matcher:     matcher
-      }
-      self.class.new(settings.merge(overrides))
-    end
   end
 end
+
+require "license_finder/license/text"
+require "license_finder/license/template"
+
+require "license_finder/license/matcher"
+require "license_finder/license/header_matcher"
+require "license_finder/license/any_matcher"
+require "license_finder/license/none_matcher"
+
+require "license_finder/license/definitions"

data/lib/license_finder/license/definitions.rb

@@ -3,7 +3,7 @@ module LicenseFinder
     module Definitions
       extend self
 
-      def all(whitelist)
+      def all
         [
           apache2,
           bsd,
@@ -15,32 +15,34 @@ module LicenseFinder
           python,
           ruby,
           simplifiedbsd
-        ].map { |license|
-          whitelist_if_necessary(license, whitelist)
-        }
+        ]
       end
 
-      def build_unrecognized(name, whitelist)
-        result = License.new(
+      def build_unrecognized(name)
+        License.new(
           short_name: name,
           url: nil,
           matcher: NoneMatcher.new
         )
-        whitelist_if_necessary(result, whitelist)
       end
 
       private
 
-      def whitelist_if_necessary(license, whitelist)
-        whitelisted = whitelist.any? { |name| license.matches_name? name }
-        whitelisted ? license.whitelist : license
-      end
-
       def apache2
         License.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"],
+          other_names: [
+            "Apache-2.0",
+            "Apache Software License",
+            "Apache License 2.0",
+            "Apache License Version 2.0",
+            "Apache Public License 2.0",
+            "The Apache Software License, Version 2.0",
+            "Apache 2",
+            "Apache License",
+            "Apache License, Version 2.0"
+          ],
           url:         "http://www.apache.org/licenses/LICENSE-2.0.txt"
         )
       end

data/lib/license_finder/license/template.rb

@@ -2,7 +2,7 @@ module LicenseFinder
   class License
     class Template
       def self.named(name)
-        path = ROOT_PATH.join("data", "licenses", "#{name}.txt")
+        path = ROOT_PATH.join("license", "templates", "#{name}.txt")
         new(path.read)
       end
 

data/lib/license_finder/package.rb

@@ -9,8 +9,10 @@ module LicenseFinder
   # Additional guidelines are:
   #
   # - if you're going to use Package#licenses ...
-  #   - implement #licenses_names_from_spec
-  #   - implement #install_path
+  #   - and the package spec will report licenses,
+  #     pass :spec_licenses in the constructor options
+  #   - and the package's files can be searched for licenses
+  #     pass :install_path in the constructor options
   # - else
   #   - implement #licenses
   #
@@ -29,15 +31,70 @@ module LicenseFinder
       end
     end
 
-    def initialize options={}
+    def initialize(name, version = nil, options={})
       @logger = options[:logger] || LicenseFinder::Logger::Default.new
+
+      @name = name
+      @version = version
+      @summary = options[:summary] || ""
+      @description = options[:description] || ""
+      @homepage = options[:homepage] || ""
+      @children = options[:children] || []
+      @parents = Set.new # will be figured out later by package manager
+      @groups = options[:groups] || []
+
+      ## APPROVAL
+      @whitelisted = false
+      @manual_approval = nil
+
+      ## LICENSING
+      @license_names_from_spec = options[:spec_licenses] || []
+      @install_path = options[:install_path]
+      @missing = options[:missing] || false
+      @decided_licenses = Set.new
+    end
+
+    attr_reader :name, :version,
+                :summary, :description, :homepage,
+                :children, :parents, :groups
+
+    ## APPROVAL
+
+    def approved_manually!(approval)
+      @manual_approval = approval
+    end
+
+    def whitelisted!
+      @whitelisted = true
+    end
+
+    def approved?
+      approved_manually? || whitelisted?
     end
 
+    def approved_manually?
+      !@manual_approval.nil?
+    end
+
+    def whitelisted?
+      @whitelisted
+    end
+
+    attr_reader :manual_approval
+
+    ## LICENSING
+
+    attr_reader :license_names_from_spec # stubbed in tests, otherwise private
+    attr_reader :install_path # checked in tests, otherwise private
+
     def licenses
-      @licenses ||= determine_license.to_set
+      @licenses ||= determine_licenses.to_set
     end
 
-    def determine_license
+    def determine_licenses
+      dl = @decided_licenses
+      return dl if dl.any?
+
       lfs = licenses_from_spec
       return lfs if lfs.any?
 
@@ -47,6 +104,10 @@ module LicenseFinder
       [default_license].to_set
     end
 
+    def decide_on_license(license)
+      @decided_licenses << license
+    end
+
     def licenses_from_spec
       license_names_from_spec.map do |name|
         License.find_by_name(name).tap do |license|
@@ -71,8 +132,17 @@ module LicenseFinder
       License.find_by_name nil
     end
 
-    def install_path
-      nil
+    def missing?
+      @missing
     end
   end
 end
+
+require 'license_finder/package_managers/manual_package'
+require 'license_finder/package_managers/bower_package'
+require 'license_finder/package_managers/bundler_package'
+require 'license_finder/package_managers/pip_package'
+require 'license_finder/package_managers/npm_package'
+require 'license_finder/package_managers/maven_package'
+require 'license_finder/package_managers/gradle_package'
+require 'license_finder/package_managers/cocoa_pods_package'