license_finder 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+.rvmrc
+.idea/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in license_finder.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Jacob Maine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.markdown

@@ -0,0 +1,84 @@
+Goal
+====
+
+With bundler it's easy for your project to depend on many gems.  This decomposition is nice, but managing licenses becomes difficult.  This tool gathers info about the licenses of the gems in your project.
+
+Usage
+=====
+
+For a Rails project add license_finder to your Gemfile:
+    gem 'license_finder', :git => "https://github.com/pivotal/LicenseFinder.git"
+
+Run 'rake license:init'
+This will create a config/license_finder.yml file that lets you configure license finder.
+
+Run 'rake license:generate_dependencies'
+This will write out a dependencies.yml and dependencies.txt file in the root of your project. 
+It will also merge in an existing dependencies.yml file, if one exists.
+
+Run 'rake license:action_items'
+This will output a list of unapproved dependencies to the console
+
+As a standalone script:
+    cd ~
+    git clone http://github.com/pivotal/LicenseFinder.git license_finder
+    cd your/project
+    ~/license_finder/bin/license_finder
+
+Optionally add `--with-licenses` to include the full text of the licenses in the output.
+
+Sample Output
+=============
+
+dependencies.yml:
+
+    ---
+    - name: "json_pure"
+      version: "1.5.1"
+      license: "other"
+      approved: false
+
+    - name: "rake"
+      version: "0.8.7"
+      license: "MIT"
+      approved: true
+
+dependencies.txt:
+
+    json_pure 1.5.1, other
+    rake 0.8.7, MIT
+
+bin/license_finder:
+
+    ---
+    json_pure 1.5.1:
+      dependency_name: json_pure
+      dependency_version: 1.5.1
+      install_path: /some/path/.rvm/gems/ruby-1.9.2-p180/gems/json_pure-1.5.1
+      license_files:
+      - file_name: COPYING
+        header_type: other
+        body_type: other
+        disclaimer_of_liability: other
+      - file_name: COPYING-json-jruby
+        header_type: other
+        body_type: other
+        disclaimer_of_liability: other
+      readme_files:
+      - file_name: README
+        mentions_license: true
+      - file_name: README-json-jruby.markdown
+        mentions_license: false
+    ---
+    rake 0.8.7:
+      dependency_name: rake
+      dependency_version: 0.8.7
+      install_path: /some/path/.rvm/gems/ruby-1.9.2-p180/gems/rake-0.8.7
+      license_files:
+      - file_name: MIT-LICENSE
+        header_type: other
+        body_type: mit
+        disclaimer_of_liability: "mit: THE AUTHORS OR COPYRIGHT HOLDERS"
+      readme_files:
+      - file_name: README
+        mentions_license: true

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec/"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.fail_on_error = true
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rspec_opts = %w[--color]
+end
+

data/bin/license_finder

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+$LOAD_PATH.unshift Pathname.new(__FILE__).dirname + ".." + "lib"
+require "license_finder"
+
+LicenseFinder::Finder.new.from_bundler.each { |lf| puts lf.to_s(ARGV.first == "--with-licenses") }

data/files/license_finder.yml

@@ -0,0 +1,7 @@
+--- 
+whitelist: 
+#- MIT
+#- Apache 2.0
+ignore_groups:
+#- test
+#- development

data/lib/license_finder.rb

@@ -0,0 +1,15 @@
+require 'pathname'
+require 'yaml'
+
+module LicenseFinder
+  ROOT_PATH = Pathname.new(__FILE__).dirname
+end
+
+require 'license_finder/railtie' if defined?(Rails)
+require 'license_finder/finder'
+require 'license_finder/gem_spec_details'
+require 'license_finder/file_parser'
+require 'license_finder/license_file'
+
+require 'license_finder/dependency'
+require 'license_finder/dependency_list'

data/lib/license_finder/dependency.rb

@@ -0,0 +1,63 @@
+module LicenseFinder
+  class Dependency
+
+    attr_reader :name, :version, :license, :approved, :license_url, :notes, :license_files, :readme_files
+
+    def self.from_hash(attrs)
+      lfs = attrs['license_files'] ? attrs['license_files'].map { |lf| lf['path'] } : []
+      rfs = attrs['readme_files'] ? attrs['readme_files'].map { |rf| rf['path'] } : []
+      new(attrs['name'], attrs['version'], attrs['license'], attrs['approved'], attrs['license_url'], attrs['notes'], lfs, rfs)
+    end
+
+    def initialize(name, version, license, approved, license_url = '', notes = '', license_files = [], readme_files = [])
+      @name = name
+      @version = version
+      @license = license
+      @approved = approved
+      @license_url = license_url
+      @notes = notes
+      @license_files = license_files
+      @readme_files = readme_files
+    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"
+        end
+      end
+      attrs << "  readme_files:\n"
+      if !self.readme_files.empty?
+        self.readme_files.each do |rf|
+          attrs << "  - path: \"#{rf}\"\n"
+        end
+      end
+      attrs
+    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
+
+      str
+    end
+
+  end
+end
+

data/lib/license_finder/dependency_list.rb

@@ -0,0 +1,55 @@
+module LicenseFinder
+  class DependencyList
+
+    attr_reader :dependencies
+
+    def self.from_bundler(whitelist = [], ignore_groups = [])
+      gemfile = Pathname.new("Gemfile").expand_path
+      root = gemfile.dirname
+      lockfile = root.join('Gemfile.lock')
+      definition = Bundler::Definition.build(gemfile, lockfile, nil)
+
+      groups = definition.groups - ignore_groups
+
+      new(definition.specs_for(groups).map { |spec| GemSpecDetails.new(spec, whitelist).dependency })
+    end
+
+    def initialize(dependencies)
+      @dependencies = dependencies
+    end
+
+    def self.from_yaml(yml)
+      deps = YAML.load(yml)
+      new(deps.map { |dhash| Dependency.from_hash(dhash) })
+    end
+
+    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(new_dep.name, new_dep.version, new_dep.license, old_dep.approved || new_dep.approved, old_dep.license_url, old_dep.notes, new_dep.license_files, new_dep.readme_files)
+        elsif old_dep && new_dep.license == 'other'
+          Dependency.new(new_dep.name, new_dep.version, old_dep.license, old_dep.approved, old_dep.license_url, old_dep.notes, new_dep.license_files, new_dep.readme_files)
+        else
+          new_dep
+        end
+      end
+
+      self.class.new(deps)
+    end
+
+    def to_yaml
+      result = "--- \n"
+      dependencies.sort_by(&:name).inject(result) { |r, d| r << d.to_yaml_entry; r }
+    end
+
+    def to_s
+      dependencies.sort_by(&:name).map(&:to_s).join("\n")
+    end
+
+    def action_items
+      dependencies.sort_by(&:name).reject(&:approved).map(&:to_s).join("\n")
+    end
+  end
+end
+

data/lib/license_finder/file_parser.rb

@@ -0,0 +1,32 @@
+module LicenseFinder
+  class FileParser
+    def initialize(install_path, file_path)
+      @install_path = Pathname.new(install_path)
+      @file_path = Pathname.new(file_path)
+    end
+
+    def file_path
+      @file_path.relative_path_from(@install_path).to_s
+    end
+
+    def full_file_path
+      @file_path.realpath.to_s
+    end
+
+    def file_name
+      @file_path.basename.to_s
+    end
+
+    def text
+      @text ||= @file_path.send((@file_path.respond_to? :binread) ? :binread : :read)
+    end
+    
+    private
+    
+    def on_single_line(text)
+      text.gsub(/\s+/, ' ').gsub("'", "\"")
+    rescue
+      ''
+    end
+  end
+end

data/lib/license_finder/finder.rb

@@ -0,0 +1,48 @@
+module LicenseFinder
+  class Finder
+
+    attr_reader :whitelist, :ignore_groups
+    def initialize
+      if File.exists?('./config/license_finder.yml')
+        config = YAML.load(File.open('./config/license_finder.yml').readlines.join)
+        @whitelist = config['whitelist'] || []
+        @ignore_groups = config['ignore_groups'] ? config['ignore_groups'].map{|g| g.to_sym} : []
+      end
+    end
+
+    def from_bundler
+      require 'bundler'
+      Bundler.load.specs.map { |spec| GemSpecDetails.new(spec) }.sort_by &:sort_order
+    end
+
+    def write_files
+      new_list = generate_list
+
+      File.open('./dependencies.yml', 'w+') do |f|
+        f.puts new_list.to_yaml
+      end
+      File.open('./dependencies.txt', 'w+') do |f|
+        f.puts new_list.to_s
+      end
+
+    end
+
+    def action_items
+      new_list = generate_list
+      new_list.action_items
+    end
+
+    private
+    def generate_list
+      bundler_list = DependencyList.from_bundler(whitelist, ignore_groups)
+
+      if (File.exists?('./dependencies.yml'))
+        yml = File.open('./dependencies.yml').readlines.join
+        existing_list = DependencyList.from_yaml(yml)
+        existing_list.merge(bundler_list)
+      else
+        bundler_list
+      end
+    end
+  end
+end

data/lib/license_finder/gem_spec_details.rb

@@ -0,0 +1,101 @@
+module LicenseFinder
+  class GemSpecDetails
+    LICENSE_FILE_NAMES = '*{LICENSE,License,COPYING,README,Readme,ReadMe}*' # follows Dir.glob format
+    README_FILE_NAMES = '*{README,Readme,ReadMe}*' # follows Dir.glob format
+
+    def initialize(spec, whitelist = [])
+      @spec = spec
+      @whitelist = whitelist
+    end
+
+    attr_reader :spec
+
+    def name
+      "#{dependency_name} #{dependency_version}"
+    end
+
+    def dependency_name
+      spec.name
+    end
+
+    def dependency_version
+      spec.version.to_s
+    end
+
+    def dependency
+      license = determine_license
+      @dependency ||= Dependency.new(@spec.name, @spec.version, license, @whitelist.include?(license), '', '', license_files.map(&:full_file_path), readme_files.map(&:full_file_path))
+    end
+
+    def determine_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?)
+      'other'
+    end
+
+    def license_files
+      paths_with_license_names = Dir.glob(File.join(install_path, '**', LICENSE_FILE_NAMES))
+      paths_for_license_files = paths_with_license_names.map do |path|
+        File.directory?(path) ? paths_for_files_in_license_directory(path) : path
+      end.flatten.uniq
+      get_files_for_paths(paths_for_license_files)
+    end
+
+    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
+      end
+    end
+
+    def install_path
+      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
+    end
+
+    def paths_for_files_in_license_directory(path)
+      entries_in_directory = Dir::entries(path).reject { |p| p.match(/^(\.){1,2}$/) }
+      entries_in_directory.map { |entry_name| File.join(path, entry_name) }
+    end
+
+    def get_files_for_paths(paths_for_license_files)
+      paths_for_license_files.map do |path|
+        get_file_for_path(path)
+      end
+    end
+  end
+end