license_finder 1.2 → 2.0.0.rc2

data/features/step_definitions/shared_steps.rb

@@ -1,307 +0,0 @@
-require 'fileutils'
-require 'pathname'
-require 'bundler'
-require 'capybara'
-require 'open3'
-
-########## COMMON STEPS ##########
-
-Given(/^I have an app$/) do
-  @user = ::DSL::User.new
-  @user.create_ruby_app
-end
-
-When(/^I run license_finder$/) do
-  @user.execute_command "license_finder --quiet"
-end
-
-When(/^I whitelist everything I can think of$/) do
-  @user.configure_license_finder_whitelist ["MIT","other","New BSD","Apache 2.0","Ruby"]
-  @user.execute_command "license_finder --quiet"
-end
-
-Then(/^I should see the project name (\w+) in the html$/) do |project_name|
-  @user.in_html do |page|
-    title = page.find("h1")
-
-    expect(title).to have_content project_name
-  end
-end
-
-
-module DSL
-  class User
-    def create_python_app
-      reset_projects!
-
-      app_path.mkpath
-      shell_out("cd #{app_path} && touch requirements.txt")
-
-      add_pip_dependency('argparse==1.2.1')
-
-      pip_install
-    end
-
-    def create_node_app
-      reset_projects!
-
-      app_path.mkpath
-      shell_out("cd #{app_path} && touch package.json")
-
-      add_npm_dependency('http-server', '0.6.1')
-
-      npm_install
-    end
-
-    def create_maven_app
-      reset_projects!
-
-      app_path.mkpath
-
-      add_maven_dependency
-
-      mvn_install
-    end
-
-    def create_gradle_app
-      reset_projects!
-
-      app_path.mkpath
-
-      add_gradle_dependency
-    end
-
-    def create_ruby_app
-      reset_projects!
-
-      shell_out("cd #{projects_path} && bundle gem #{app_name}")
-
-      add_gem_dependency('license_finder', path: root_path.to_s)
-
-      bundle_install
-    end
-
-    def create_cocoapods_app
-      reset_projects!
-
-      app_path.mkpath
-
-      add_pod_dependency
-
-      pod_install
-    end
-
-    def create_and_depend_on_gem(gem_name, options)
-      create_gem(gem_name, options)
-      depend_on_local_gem(gem_name)
-    end
-
-    def create_gem(gem_name, options)
-      gem_dir = projects_path.join(gem_name)
-
-      gem_dir.mkpath
-      gem_dir.join("#{gem_name}.gemspec").open('w') do |file|
-        file.write gemspec_string(gem_name, options)
-      end
-    end
-
-    def depend_on_local_gem(gem_name, options={})
-      gem_dir = projects_path.join(gem_name)
-      options[:path] = gem_dir.to_s
-
-      add_gem_dependency(gem_name, options)
-
-      bundle_install
-    end
-
-    def configure_license_finder_whitelist(whitelisted_licenses=[])
-      config_path.mkpath
-      config_file.open("w") do |f|
-        f.write({'whitelist' => whitelisted_licenses}.to_yaml)
-      end
-    end
-
-    def execute_command(command)
-      ::Bundler.with_clean_env do
-        @output = shell_out("cd #{app_path} && bundle exec #{command}", true)
-      end
-    end
-
-    def seeing?(content)
-      @output.include? content
-    end
-
-    def seeing_line?(content)
-      seeing_something_like? /^#{Regexp.escape content}$/
-    end
-
-    def seeing_something_like?(regex)
-      @output =~ regex
-    end
-
-    def app_path(sub_directory = nil)
-      path = base_path = projects_path.join(app_name).cleanpath
-
-      if sub_directory
-        path = base_path.join(sub_directory).cleanpath
-
-        raise "#{sub_directory} is outside of the app" unless path.to_s =~ %r{^#{base_path}/}
-      end
-
-      path
-    end
-
-    def config_path
-      app_path('config')
-    end
-
-    def config_file
-      config_path.join("license_finder.yml")
-    end
-
-    def in_html
-      yield Capybara.string(app_path('doc/dependencies.html').read)
-    end
-
-    def in_gem_html(gem_name)
-      in_html do |page|
-        yield page.find("##{gem_name}")
-      end
-    end
-
-    private
-
-    def gemspec_string(gem_name, options)
-      if options.has_key?(:license) && options.has_key?(:licenses)
-        raise "Can't specify both `license` and `licenses`"
-      end
-
-      license_key = ([:license, :licenses] & options.keys).first
-      license_value = options.fetch(license_key)
-      summary = options.fetch(:summary, "")
-      description = options.fetch(:description, "")
-      version = options[:version] || "0.0.0"
-      homepage = options[:homepage]
-
-      <<-GEMSPEC
-      Gem::Specification.new do |s|
-        s.name = "#{gem_name}"
-        s.version = "#{version}"
-        s.author = "Cucumber"
-        s.summary = "#{summary}"
-        s.#{license_key} = #{license_value.inspect}
-        s.description = "#{description}"
-        s.homepage = "#{homepage}"
-      end
-      GEMSPEC
-    end
-
-    def add_gem_dependency(name, options = {})
-      line = "gem #{name.inspect}"
-      line << ", " + options.inspect unless options.empty?
-
-      add_to_gemfile(line)
-    end
-
-    def add_pip_dependency(dependency)
-      add_to_requirements(dependency)
-    end
-
-    def add_npm_dependency(dependency, version)
-      line = "{\"dependencies\" : {\"#{dependency}\": \"#{version}\"}}"
-
-      add_to_package(line)
-    end
-
-    def add_maven_dependency
-      path = fixtures_path.join("pom.xml")
-      shell_out("cp #{path} #{app_path}")
-    end
-
-    def add_gradle_dependency
-      path = fixtures_path.join("build.gradle")
-      shell_out("cd #{app_path} && cp #{path} .")
-    end
-
-    def add_pod_dependency
-      path = fixtures_path.join("Podfile")
-      shell_out("cp #{path} #{app_path}")
-    end
-
-    def bundle_install
-      ::Bundler.with_clean_env do
-        shell_out("cd #{app_path} && bundle check || bundle install")
-      end
-    end
-
-    def pip_install
-      shell_out("cd #{app_path} && pip install -r requirements.txt")
-    end
-
-    def npm_install
-      shell_out("cd #{app_path} && npm install 2>/dev/null")
-    end
-
-    def mvn_install
-      shell_out("cd #{app_path} && mvn install")
-    end
-
-    def pod_install
-      shell_out("cd #{app_path} && pod install --no-integrate")
-    end
-
-    def add_to_gemfile(line)
-      shell_out("echo #{line.inspect} >> #{app_path.join("Gemfile")}")
-    end
-
-    def add_to_requirements(line)
-      shell_out("echo #{line.inspect} >> #{app_path.join("requirements.txt")}")
-    end
-
-    def add_to_package(line)
-      shell_out("echo #{line.inspect} >> #{app_path.join("package.json")}")
-    end
-
-    def app_name
-      "my_app"
-    end
-
-    def sandbox_path
-      root_path.join("tmp")
-    end
-
-    def projects_path
-      sandbox_path.join("projects")
-    end
-
-    def fixtures_path
-      root_path.join("spec", "fixtures")
-    end
-
-    def reset_projects!
-      shell_out("rm -rf #{projects_path}")
-      projects_path.mkpath
-    end
-
-    def root_path
-      Pathname.new(__FILE__).dirname.join("..", "..").realpath
-    end
-
-    def shell_out(command, allow_failures = false)
-      output = `#{command} 2>&1`
-      status = $?
-      unless status.success? || allow_failures
-        message_format = <<EOM
-Command failed: `%s`
-output: %s
-exit: %d
-EOM
-        message = sprintf message_format, command, output.chomp, status.exitstatus
-        raise RuntimeError.new(message)
-      end
-
-      $last_command_exit_status = status
-      output
-    end
-  end
-end

data/lib/data/license_finder.example.yml

@@ -1,12 +0,0 @@
----
-whitelist:
-#- MIT
-#- Apache 2.0
-ignore_groups:
-#- test
-#- development
-ignore_dependencies:
-#- bundler
-dependencies_file_dir: './doc/'
-project_name: # project name
-gradle_command: # only meaningful if used with a Java/gradle project. Defaults to "gradle".

data/lib/license_finder/dependency_manager.rb

@@ -1,92 +0,0 @@
-require 'digest'
-
-module LicenseFinder
-  class DependencyManager
-    attr_reader :logger
-
-    def initialize options={}
-      @logger = options[:logger] || LicenseFinder::Logger::Default.new
-    end
-
-    def sync_with_package_managers options={}
-      modifying {
-        current_dependencies = PackageSaver.save_all(current_packages)
-
-        Dependency.added_automatically.obsolete(current_dependencies).each(&:destroy)
-      }
-    end
-
-    def manually_add(license, name, version)
-      raise Error.new("#{name} dependency already exists") unless Dependency.where(name: name).empty?
-
-      modifying {
-        dependency = Dependency.new(added_manually: true, name: name, version: version)
-        dependency.licenses = [License.find_by_name(license)].to_set
-        dependency.save
-      }
-    end
-
-    def manually_remove(name)
-      modifying { find_by_name(name, Dependency.added_manually).destroy }
-    end
-
-    def license!(name, license_name)
-      license = License.find_by_name(license_name)
-      modifying { find_by_name(name).set_license_manually!(license) }
-    end
-
-    def approve!(name, approver = nil, notes = nil)
-      modifying { find_by_name(name).approve!(approver, notes)  }
-    end
-
-    def modifying
-      checksum_before = checksum
-      result = DB.transaction { yield }
-      checksum_after = checksum
-
-      database_changed = checksum_before != checksum_after
-
-      if database_changed || reports_do_not_exist || reports_are_stale
-        Reporter.write_reports
-      end
-
-      result
-    end
-
-    private # not really private, but it looks like it is!
-
-    def reports_do_not_exist
-      !(LicenseFinder.config.artifacts.html_file.exist?)
-    end
-
-    def reports_are_stale
-      LicenseFinder.config.last_modified > LicenseFinder.config.artifacts.last_refreshed
-    end
-
-    def current_packages
-      package_managers.
-        map { |pm| pm.new(logger: logger) }.
-        select(&:active?).
-        map(&:current_packages).
-        flatten
-    end
-
-    def package_managers
-      [Bundler, NPM, Pip, Bower, Maven, Gradle, CocoaPods]
-    end
-
-    def find_by_name(name, scope = Dependency)
-      dep = scope.first(name: name)
-      raise Error.new("could not find dependency named #{name}") unless dep
-      dep
-    end
-
-    def checksum
-      database_file = LicenseFinder.config.artifacts.database_file
-      if database_file.exist?
-        Digest::SHA2.file(database_file).hexdigest
-      end
-    end
-  end
-end
-

data/lib/license_finder/package_saver.rb

@@ -1,44 +0,0 @@
-require 'forwardable'
-
-module LicenseFinder
-  class PackageSaver
-    extend Forwardable
-    def_delegators :package, :licenses, :children, :groups, :summary, :description, :version, :homepage
-
-    attr_reader :dependency, :package
-
-    def self.save_all(packages)
-      packages.map do |package|
-        find_or_create_by_name(package).save
-      end
-    end
-
-    def initialize(dependency, package)
-      @dependency = dependency
-      @package = package
-    end
-
-    def save
-      dependency.version = version.to_s
-      dependency.summary = summary
-      dependency.description = description
-      dependency.homepage = homepage
-      dependency.bundler_group_names = groups.map(&:to_s)
-      dependency.children_names = children
-      dependency.set_licenses licenses
-
-      # Only save *changed* dependencies. This ensures re-running
-      # `license_finder` won't always update the DB, and therefore won't always
-      # update the HTML/markdown reports with a new timestamp.
-      dependency.save_changes
-      dependency
-    end
-
-    private
-
-    def self.find_or_create_by_name(package)
-      dependency = Dependency.named(package.name)
-      new(dependency, package)
-    end
-  end
-end