license_finder 0.4.5 → 0.5.0

data/lib/license_finder.rb

@@ -32,13 +32,18 @@ module LicenseFinder
   def self.config
     @config ||= Configuration.new
   end
+
+  def self.load_rake_tasks
+    load 'tasks/license_finder.rake'
+  end
 end
 
 require 'license_finder/railtie' if defined?(Rails)
+require 'license_finder/bundler_dependency_query'
 require 'license_finder/finder'
-require 'license_finder/gem_spec_details'
-require 'license_finder/file_parser'
-require 'license_finder/license_file'
-
+require 'license_finder/bundled_gem'
+require 'license_finder/license'
+require 'license_finder/possible_license_file'
 require 'license_finder/dependency'
 require 'license_finder/dependency_list'
+require 'license_finder/cli'

data/lib/license_finder/{gem_spec_details.rb → bundled_gem.rb}

@@ -1,6 +1,6 @@
 module LicenseFinder
-  class GemSpecDetails
-    LICENSE_FILE_NAMES = '*{LICENSE,License,COPYING,README,Readme,ReadMe}*' # follows Dir.glob format
+  class BundledGem
+    LICENSE_FILE_NAMES = '*{LICENSE,License,Licence,COPYING,README,Readme,ReadMe}*' # follows Dir.glob format
     README_FILE_NAMES = '*{README,Readme,ReadMe}*' # follows Dir.glob format
 
     def initialize(spec)
@@ -22,26 +22,22 @@ module LicenseFinder
     end
 
     def dependency
-      license = determine_license
-
       @dependency ||= Dependency.new(
         'name' => @spec.name,
-        'version' => @spec.version,
-        'license' => license,
+        'version' => @spec.version.to_s,
+        'license' => determine_license,
         'license_files' => license_files.map(&:full_file_path),
-        'readme_files' => readme_files.map(&:full_file_path)
+        'readme_files' => readme_files.map(&:full_file_path),
+        'source' => 'bundle',
+        'summary' => @spec.summary,
+        'description' => @spec.description
       )
     end
 
     def determine_license
       return @spec.license if @spec.license
-      return 'MIT' if license_files.any?{|f| f.mit_license_body? || f.mit_license_header?}
-      return 'Apache 2.0' if license_files.any?(&:apache_license_body?)
-      return 'GPLv2' if license_files.any?(&:gplv2_license_body?)
-      return 'ruby' if license_files.any?(&:ruby_license_body?)
-      return 'LGPL' if license_files.any?(&:lgpl_license_body?)
-      return 'ISC' if license_files.any?(&:isc_license_body?)
-      'other'
+
+      license_files.map(&:license).compact.first || 'other'
     end
 
     def license_files
@@ -54,9 +50,7 @@ module LicenseFinder
 
     def readme_files
       Dir.glob(File.join(install_path, '**', README_FILE_NAMES)).map do |path|
-        file = LicenseFile.new(install_path, path)
-        file.include_license_text = include_license_text?
-        file
+        get_file_for_path path
       end
     end
 
@@ -64,37 +58,14 @@ module LicenseFinder
       spec.full_gem_path
     end
 
-    def to_s(include_license_text = true)
-      self.include_license_text = include_license_text
-
-      { name => to_hash }.to_yaml
-    end
-
-    def to_hash
-      {
-        'dependency_name' => dependency_name,
-        'dependency_version' => dependency_version,
-        'install_path' => install_path,
-        'license_files' => license_files.map { |file| file.to_hash }
-      }
-    end
-
     def sort_order
       dependency_name.downcase
     end
 
     private
 
-    attr_writer :include_license_text
-
-    def include_license_text?
-      @include_license_text
-    end
-
     def get_file_for_path(path)
-      file = LicenseFile.new(install_path, path)
-      file.include_license_text = include_license_text?
-      file
+      PossibleLicenseFile.new(install_path, path)
     end
 
     def paths_for_files_in_license_directory(path)

data/lib/license_finder/bundler_dependency_query.rb

@@ -0,0 +1,51 @@
+module LicenseFinder
+  class BundlerDependencyQuery
+    def dependencies
+      bundler_definition.specs_for(requested_groups).map do |spec|
+        dependency = define_a_new_dependency_from_a_gemspec(spec)
+        add_additional_information_from_bundler_to_a_dependency(dependency)
+      end
+    end
+
+    private
+
+    def add_additional_information_from_bundler_to_a_dependency(dependency)
+      bundler_dependency = find_bundlers_representation_of_a_dependency_by_name(dependency.name)
+
+      if bundler_dependency
+        dependency.bundler_groups = bundler_dependency.groups
+      end
+
+      dependency
+    end
+
+    def define_a_new_dependency_from_a_gemspec(gemspec)
+      BundledGem.new(gemspec).dependency
+    end
+
+    def find_bundlers_representation_of_a_dependency_by_name(name)
+      bundler_dependencies.detect { |dep| dep.name == name }
+    end
+
+    def requested_groups
+      bundler_definition.groups - LicenseFinder.config.ignore_groups
+    end
+
+    def gemfile_path
+      Pathname.new("Gemfile").expand_path
+    end
+
+    def lockfile_path
+      root = gemfile_path.dirname
+      root.join('Gemfile.lock')
+    end
+
+    def bundler_dependencies
+      @bundler_dependencies ||= bundler_definition.dependencies
+    end
+
+    def bundler_definition
+      @bundler_definition ||= Bundler::Definition.build(gemfile_path, lockfile_path, nil)
+    end
+  end
+end

data/lib/license_finder/cli.rb

@@ -0,0 +1,16 @@
+module LicenseFinder
+  class CLI
+    def check_for_action_items
+      found = LicenseFinder::Finder.new.action_items
+
+      if found.size == 0
+        puts "All gems are approved for use"
+        exit 0
+      else
+        puts "Dependencies that need approval:"
+        puts found
+        exit 1
+      end
+    end
+  end
+end

data/lib/license_finder/dependency.rb

@@ -1,6 +1,12 @@
+# encoding: UTF-8
+require "erb"
+
 module LicenseFinder
   class Dependency
-    attr_reader :name, :version, :license, :approved, :license_url, :notes, :license_files, :readme_files
+    attr_accessor :name, :version, :license, :approved, :license_url, :notes, :license_files,
+      :readme_files, :source, :bundler_groups
+
+    attr_reader :summary, :description
 
     def self.from_hash(attrs)
       attrs['license_files'] = attrs['license_files'].map { |lf| lf['path'] } if attrs['license_files']
@@ -10,6 +16,7 @@ module LicenseFinder
     end
 
     def initialize(attributes = {})
+      @source = attributes['source']
       @name = attributes['name']
       @version = attributes['version']
       @license = attributes['license']
@@ -18,44 +25,89 @@ module LicenseFinder
       @notes = attributes['notes'] || ''
       @license_files = attributes['license_files'] || []
       @readme_files = attributes['readme_files'] || []
+      @bundler_groups = attributes['bundler_groups'] || []
+      @summary = attributes['summary']
+      @description = attributes['description']
     end
 
-    def to_yaml_entry
-      attrs = "- name: \"#{name}\"\n  version: \"#{version}\"\n  license: \"#{license}\"\n  approved: #{approved}\n  license_url: \"#{license_url}\"\n  notes: \"#{notes}\"\n"
-      attrs << "  license_files:\n"
-      if !self.license_files.empty?
-        self.license_files.each do |lf|
-          attrs << "  - path: \"#{lf}\"\n"
+    def merge(other)
+      raise "Cannot merge dependencies with different names. Expected #{name}, was #{other.name}." unless other.name == name
+
+      merged = self.class.new(
+        'name' => name,
+        'version' => other.version,
+        'license_files' => other.license_files,
+        'readme_files' => other.readme_files,
+        'license_url' => other.license_url,
+        'notes' => notes,
+        'source' => other.source,
+        'summary' => other.summary,
+        'description' => other.description,
+        'bundler_groups' => other.bundler_groups,
+      )
+
+      case other.license
+      when license, 'other'
+        merged.license = license
+        merged.approved = approved
+      else
+        merged.license = other.license
+        merged.approved = other.approved
+      end
+
+      merged
+    end
+
+    def as_yaml
+      attrs = {
+        'name' => name,
+        'version' => version,
+        'license' => license,
+        'approved' => approved,
+        'source' => source,
+        'license_url' => license_url,
+        'notes' => notes,
+        'license_files' => nil,
+        'readme_files' => nil
+      }
+
+      unless license_files.empty?
+        attrs['license_files'] = license_files.map do |file|
+          {'path' => file}
         end
       end
-      attrs << "  readme_files:\n"
-      if !self.readme_files.empty?
-        self.readme_files.each do |rf|
-          attrs << "  - path: \"#{rf}\"\n"
+
+      unless readme_files.empty?
+        attrs['readme_files'] = readme_files.map do |file|
+          {'path' => file}
         end
       end
+
       attrs
     end
 
+    def to_yaml
+      as_yaml.to_yaml
+    end
+
     def to_s
-      url = ", #{license_url}" if license_url != ''
-      str = "#{name} #{version}, #{license}#{url}"
-      if license == 'other'
-        str << "\n  license files:"
-        unless self.license_files.empty?
-          self.license_files.each do |lf|
-            str << "\n    #{lf}"
-          end
-        end
-        str << "\n  readme files:"
-        unless self.readme_files.empty?
-          self.readme_files.each do |lf|
-            str << "\n    #{lf}"
-          end
-        end
-      end
+      template = ERB.new <<-TEMPLATE
+<%= attributes.join(", ") %>
+<% if license == 'other' %>
+  <% unless license_files.empty? %>
+  license files:
+    <%= license_files.join("\n    ") %>
+  <% end %>
+  <% unless readme_files.empty? %>
+  readme files:
+    <%= readme_files.join("\n    ") %>
+  <% end %>
+<% end%>
+TEMPLATE
+
+      attributes = ["#{name} #{version}".strip, license, license_url, summary, description, bundler_groups].flatten.compact.reject {|a| a == ""}
 
-      str
+      template.result(binding).gsub(/(^|\n)\s*(\n|$)/, '\1')
     end
   end
 end

data/lib/license_finder/dependency_list.rb

@@ -4,14 +4,7 @@ module LicenseFinder
     attr_reader :dependencies
 
     def self.from_bundler
-      gemfile = Pathname.new("Gemfile").expand_path
-      root = gemfile.dirname
-      lockfile = root.join('Gemfile.lock')
-      definition = Bundler::Definition.build(gemfile, lockfile, nil)
-
-      groups = definition.groups - LicenseFinder.config.ignore_groups
-
-      new(definition.specs_for(groups).map { |spec| GemSpecDetails.new(spec).dependency })
+      new(BundlerDependencyQuery.new.dependencies)
     end
 
     def initialize(dependencies)
@@ -25,48 +18,40 @@ module LicenseFinder
 
     def merge(new_list)
       deps = new_list.dependencies.map do |new_dep|
-        old_dep = self.dependencies.detect { |d| d.name == new_dep.name }
-        if old_dep && old_dep.license == new_dep.license
-          Dependency.new(
-            'name' => new_dep.name,
-            'version' => new_dep.version,
-            'license' => new_dep.license,
-            'approved' => (old_dep.approved || new_dep.approved),
-            'license_url' => old_dep.license_url,
-            'notes' => old_dep.notes,
-            'license_files' => new_dep.license_files,
-            'readme_files' => new_dep.readme_files
-          )
-        elsif old_dep && new_dep.license == 'other'
-          Dependency.new(
-            'name' => new_dep.name,
-            'version' => new_dep.version,
-            'license' => old_dep.license,
-            'approved' => old_dep.approved,
-            'license_url' => old_dep.license_url,
-            'notes' => old_dep.notes,
-            'license_files' => new_dep.license_files,
-            'readme_files' => new_dep.readme_files
-          )
+        old_dep = dependencies.detect { |d| d.name == new_dep.name }
+
+        if old_dep
+          old_dep.merge(new_dep)
         else
           new_dep
         end
       end
 
+      deps += dependencies.select { |d| d.source != "bundle" }
+
       self.class.new(deps)
     end
 
+    def as_yaml
+      sorted_dependencies.map(&:as_yaml)
+    end
+
     def to_yaml
-      result = "--- \n"
-      dependencies.sort_by(&:name).inject(result) { |r, d| r << d.to_yaml_entry; r }
+      as_yaml.to_yaml
     end
 
     def to_s
-      dependencies.sort_by(&:name).map(&:to_s).join("\n")
+      sorted_dependencies.map(&:to_s).join
     end
 
     def action_items
-      dependencies.sort_by(&:name).reject(&:approved).map(&:to_s).join("\n")
+      sorted_dependencies.reject(&:approved).map(&:to_s).join
+    end
+
+    private
+
+    def sorted_dependencies
+      dependencies.sort_by(&:name)
     end
   end
 end

data/lib/license_finder/finder.rb

@@ -2,7 +2,7 @@ module LicenseFinder
   class Finder
     def from_bundler
       require 'bundler'
-      Bundler.load.specs.map { |spec| GemSpecDetails.new(spec) }.sort_by &:sort_order
+      Bundler.load.specs.map { |spec| BundledGem.new(spec) }.sort_by &:sort_order
     end
 
     def write_files
@@ -11,10 +11,10 @@ module LicenseFinder
       File.open(LicenseFinder.config.dependencies_yaml, 'w+') do |f|
         f.puts new_list.to_yaml
       end
+
       File.open(LicenseFinder.config.dependencies_text, 'w+') do |f|
         f.puts new_list.to_s
       end
-
     end
 
     def action_items

data/lib/license_finder/license.rb

@@ -0,0 +1,74 @@
+module LicenseFinder::License
+  class << self
+    def all
+      @all ||= []
+    end
+  end
+
+  class Text
+    def initialize(text)
+      @text = normalized(text)
+    end
+
+    def to_s
+      @text
+    end
+
+    private
+
+    def normalized(text)
+      text.gsub(/\s+/, ' ').gsub(/['`"]{1,2}/, "\"")
+    end
+  end
+
+  class Base
+    class << self
+      def inherited(descendant)
+        LicenseFinder::License.all << descendant
+      end
+
+      def demodulized_name
+        name.gsub(/^.*::/, '')
+      end
+
+      def slug
+        demodulized_name.downcase
+      end
+
+      def pretty_name
+        demodulized_name
+      end
+
+      def license_text
+        unless defined?(@license_text)
+          template = File.join(LicenseFinder::ROOT_PATH, "templates", "#{demodulized_name}.txt").to_s
+
+          @license_text = Text.new(File.read(template)).to_s if File.exists?(template)
+        end
+        @license_text
+      end
+
+      def license_regex
+        /#{Regexp.escape(license_text).gsub(/<[^<>]+>/, '(.*)')}/ if license_text
+      end
+    end
+
+    def initialize(text)
+      self.text = text
+    end
+
+    attr_reader :text
+
+    def text=(text)
+      @text = Text.new(text).to_s
+    end
+
+    def matches?
+      !!(text =~ self.class.license_regex if self.class.license_regex)
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'license', '*.rb')].each do |license|
+  require license
+end