license_finder 4.0.2 → 5.0.0

data/features/fixtures/single-module-gradle/build.gradle

@@ -1,16 +0,0 @@
-plugins {
-    id 'com.github.hierynomus.license' version '0.14.0'
-}
-
-apply plugin: 'java'
-
-sourceCompatibility = 1.5
-version = '1.0'
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    compile 'junit:junit:4.11'
-}

data/features/support/feature_helper.rb

@@ -1,15 +0,0 @@
-# These are integration tests, so reaching directly into LicenseFinder is forbidden
-# DO NOT:
-# require 'rubygems'
-# require 'bundler/setup'
-# require 'license_finder'
-
-require_relative 'testing_dsl'
-
-RSpec.configure do |rspec|
-  rspec.default_formatter = 'doc'
-
-  rspec.before(:each) do
-    LicenseFinder::TestingDSL::Paths.reset_projects!
-  end
-end

data/features/support/testing_dsl.rb

@@ -1,564 +0,0 @@
-require 'delegate'
-require 'English'
-
-module LicenseFinder
-  module TestingDSL
-    class User
-      def run_license_finder(path = nil, options = '')
-        if path
-          execute_command_in_path("license_finder --quiet #{options}", Paths.project("my_app/#{path}"))
-        else
-          execute_command "license_finder --quiet #{options}"
-        end
-      end
-
-      def create_empty_project(name = 'my_app')
-        EmptyProject.create(name)
-      end
-
-      def create_ruby_app(name = 'my_app')
-        BundlerProject.create(name)
-      end
-
-      def create_gem(name, options)
-        GemProject.create(name, options)
-      end
-
-      def create_gem_in_path(name, path, options)
-        GemProject.create_in_path(name, path, options)
-      end
-
-      def execute_command(command)
-        execute_command_in_path(command, Paths.project)
-      end
-
-      def execute_command_outside_project(command)
-        execute_command_in_path(command, Paths.root)
-      end
-
-      def seeing?(content)
-        @output.include? content
-      end
-
-      def seeing_once?(content)
-        @output.scan(/#{Regexp.escape content}/).size == 1
-      end
-
-      def seeing_line?(content)
-        seeing_something_like? /^#{Regexp.escape content}$/
-      end
-
-      def seeing_something_like?(regex)
-        !!(@output =~ regex)
-      end
-
-      def receiving_exit_code?(code)
-        @exit_code == code
-      end
-
-      def view_html
-        execute_command 'license_finder report --format html'
-        HtmlReport.from_string(@output)
-      end
-
-      private
-
-      def execute_command_in_path(command, path)
-        @output, @exit_code = path.shell_out(command, true)
-      end
-    end
-
-    require 'forwardable'
-    class Project
-      extend Forwardable
-      def_delegators :project_dir, :shell_out, :add_to_file, :install_fixture
-
-      attr_reader :name
-
-      def self.create(name = 'my_app')
-        project = new(name)
-        project.add_dep
-        project.install
-        project
-      end
-
-      def initialize(name = 'my_app')
-        @name = name
-        project_dir.make
-      end
-
-      def add_dep; end
-
-      def install; end
-
-      def project_dir
-        Paths.project(name)
-      end
-
-      def clone(fixture_name)
-        FileUtils.mkpath(Paths.my_app.join(fixture_name))
-        FileUtils.cp_r(Paths.fixtures.join(fixture_name), Paths.my_app)
-      end
-    end
-
-    class EmptyProject < Project
-    end
-
-    class PipProject < Project
-      def add_dep
-        add_to_file('requirements.txt', 'rsa==3.1.4')
-      end
-
-      def install
-        shell_out('pip install -r requirements.txt --user')
-      end
-    end
-
-    class NpmProject < Project
-      def add_dep
-        add_to_file('package.json', '{"dependencies" : {"http-server": "0.6.1"}}')
-      end
-
-      def install
-        shell_out('npm install 2>/dev/null')
-      end
-    end
-
-    class BowerProject < Project
-      def add_dep
-        add_to_file('bower.json', '{"name": "my_app", "dependencies" : {"gmaps": "0.2.30"}}')
-      end
-
-      def install
-        shell_out('bower install --allow-root 2>/dev/null')
-      end
-    end
-
-    class YarnProject < Project
-      def add_dep
-        add_to_file('yarn.lock', '')
-        add_to_file('package.json', '{"dependencies" : {"http-server": "0.6.1"}}')
-      end
-    end
-
-    class MavenProject < Project
-      def add_dep
-        install_fixture('pom.xml')
-      end
-
-      def install
-        shell_out('mvn install')
-      end
-    end
-
-    class BareGradleProject < Project
-      def add_dep
-        install_fixture('build.gradle')
-      end
-    end
-
-    class GradleProject < Project
-      def add_dep
-        clone('single-module-gradle')
-      end
-
-      class MultiModule < Project
-        def add_dep
-          clone('multi-module-gradle')
-        end
-      end
-
-      class FileBasedLibs < Project
-        def add_dep
-          clone('file-based-libs-gradle')
-        end
-      end
-    end
-
-    class AlternateBuildFileGradleProject < Project
-      def add_dep
-        clone('alternate-build-file-gradle')
-      end
-    end
-
-    class GoProject < Project
-      def add_dep
-        clone('gopath')
-      end
-
-      def install
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath"
-        shell_out('godep restore')
-        ENV['GOPATH'] = orig_gopath
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath', 'src', 'github.com', 'pivotal', 'foo')).shell_out(command)
-      end
-    end
-
-    class GlideProject < Project
-      def add_dep
-        clone('gopath_glide')
-      end
-
-      def install
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath_glide"
-        shell_out('glide install')
-        ENV['GOPATH'] = orig_gopath
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_glide', 'src')).shell_out(command)
-      end
-    end
-
-    class GlideProjectWithoutSrc < Project
-      def add_dep
-        clone('gopath_glide_without_src')
-      end
-
-      def install
-        src_path = File.join(project_dir, 'gopath_glide_without_src', 'src')
-        FileUtils.mkdir_p(src_path)
-
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath_glide_without_src"
-        shell_out('glide install')
-        ENV['GOPATH'] = orig_gopath
-
-        FileUtils.rmdir(src_path)
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_glide_without_src')).shell_out(command)
-      end
-    end
-
-    class GvtProject < Project
-      def add_dep
-        clone('gopath_gvt')
-      end
-
-      def install
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath_gvt"
-        shell_out('gvt restore')
-        ENV['GOPATH'] = orig_gopath
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_gvt', 'src')).shell_out(command)
-      end
-    end
-
-    class DepProject < Project
-      def add_dep
-        clone('gopath_dep')
-      end
-
-      def install
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath_dep"
-        shell_out('dep ensure')
-        ENV['GOPATH'] = orig_gopath
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_dep', 'src', 'foo-dep')).shell_out(command)
-      end
-    end
-
-    class BrokenSymLinkDepProject < Project
-      def add_dep
-        clone('gopath_dep')
-      end
-
-      def install; end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_dep', 'src', 'foo-dep')).shell_out(command)
-      end
-    end
-
-    class GovendorProject < Project
-      def add_dep
-        clone('gopath_govendor')
-      end
-
-      def install
-        orig_gopath = ENV['GOPATH']
-        ENV['GOPATH'] = "#{project_dir}/gopath_govendor"
-        shell_out('govendor sync')
-        ENV['GOPATH'] = orig_gopath
-      end
-
-      def shell_out(command)
-        ProjectDir.new(Paths.root.join('tmp', 'projects', 'my_app', 'gopath_govendor', 'src')).shell_out(command)
-      end
-    end
-
-    class CompositeProject < Project
-      def add_dep
-        clone('single-module-gradle')
-        clone('multi-module-gradle')
-      end
-    end
-
-    class CocoaPodsProject < Project
-      def add_dep
-        install_fixture('Podfile')
-      end
-
-      def install
-        shell_out('pod install --no-integrate')
-      end
-    end
-
-    class CarthageProject < Project
-      def add_dep
-        install_fixture('Cartfile')
-      end
-
-      def install
-        shell_out('carthage bootstrap')
-      end
-    end
-
-    class ConanProject < Project
-      def add_dep
-        install_fixture('conanfile.txt')
-      end
-
-      def install
-        shell_out('conan install')
-      end
-    end
-
-    class RebarProject < Project
-      def add_dep
-        install_fixture('rebar.config')
-      end
-
-      def install
-        shell_out('rebar get-deps')
-      end
-    end
-
-    class MixProject < Project
-      def add_dep
-        install_fixture('mix.exs')
-      end
-
-      def install
-        shell_out('mix local.hex --force')
-        shell_out('mix local.rebar --force')
-        shell_out('mix deps.get')
-        shell_out('mix deps.compile')
-      end
-    end
-
-    class NugetProject < Project
-      def add_dep
-        clone('nuget')
-      end
-    end
-
-    class BundlerProject < Project
-      def add_dep
-        add_to_gemfile("source 'https://rubygems.org'")
-        add_gem_to_gemfile('license_finder', path: Paths.root.to_s)
-      end
-
-      def install
-        shell_out('bundle install')
-      end
-
-      def depend_on(gem, bundler_options = {})
-        add_gem_to_gemfile(gem.name, bundler_options.merge(path: gem.project_dir.to_s))
-        install
-      end
-
-      private
-
-      def add_gem_to_gemfile(gem_name, options)
-        add_to_gemfile("gem #{gem_name.inspect}, #{options.inspect}")
-      end
-
-      def add_to_gemfile(content)
-        add_to_file('Gemfile', content)
-      end
-    end
-
-    # lives adjacent to a BundlerProject, so has a different lifecycle from other Projects and doesn't inherit
-    class GemProject
-      def self.create(name, options)
-        result = new(name)
-        result.define(options)
-        result
-      end
-
-      def self.create_in_path(name, path, options)
-        result = new(name, path)
-        result.define(options)
-        result
-      end
-
-      def initialize(name, path = nil)
-        @name = name
-        @path = path
-        project_dir.make
-      end
-
-      def define(options)
-        project_dir.write_file("#{name}.gemspec", gemspec_string(options))
-      end
-
-      attr_reader :name, :path
-
-      def project_dir
-        if path
-          Paths.project(path + '/' + name)
-        else
-          Paths.project(name)
-        end
-      end
-
-      private
-
-      def gemspec_string(options)
-        dependencies = Array(options[:dependencies]).map do |dep|
-          %(s.add_dependency "#{dep}")
-        end.join("\n")
-
-        <<-GEMSPEC
-      Gem::Specification.new do |s|
-        s.name = "#{name}"
-        s.version = "#{options[:version] || '0.0.0'}"
-        s.license = "#{options.fetch(:license)}"
-        s.author = "license_finder tests"
-        s.summary = "#{options[:summary]}"
-        s.description = "#{options[:description]}"
-        s.homepage = "#{options[:homepage]}"
-        #{dependencies}
-      end
-        GEMSPEC
-      end
-    end
-
-    require 'capybara'
-    class HtmlReport < SimpleDelegator
-      # delegates to the parsed html
-
-      def self.from_string(str)
-        new(Capybara.string(str))
-      end
-
-      def in_dep(dep_name)
-        result = find("##{dep_name}")
-        yield result if block_given?
-        result
-      end
-
-      def approved?(dep_name)
-        classes_of(dep_name).include? 'approved'
-      end
-
-      def unapproved?(dep_name)
-        classes_of(dep_name).include? 'unapproved'
-      end
-
-      def titled?(title)
-        find('h1').has_content? title
-      end
-
-      private
-
-      def classes_of(dep_name)
-        in_dep(dep_name)[:class].split(' ')
-      end
-    end
-
-    class ProjectDir < SimpleDelegator
-      # delegates to a Pathname
-
-      def shell_out(command, allow_failures = false)
-        Dir.chdir(self) { Shell.run(command, allow_failures) }
-      end
-
-      def add_to_file(filename, content)
-        join(filename).open('a') { |file| file.puts content }
-      end
-
-      def write_file(filename, content)
-        join(filename).open('w') { |file| file.write content }
-      end
-
-      def install_fixture(fixture_name)
-        if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
-          FileUtils.cp(Paths.fixtures.join(fixture_name), join(fixture_name))
-        else
-          join(fixture_name).make_symlink Paths.fixtures.join(fixture_name)
-        end
-      end
-
-      def make
-        mkpath
-      end
-    end
-
-    require 'pathname'
-    module Paths
-      extend self
-
-      def root
-        # where license_finder is installed
-        ProjectDir.new(Pathname.new(__FILE__).dirname.join('..', '..').realpath)
-      end
-
-      def fixtures
-        root.join('features', 'fixtures')
-      end
-
-      def projects
-        root.join('tmp', 'projects')
-      end
-
-      def my_app
-        root.join('tmp', 'projects', 'my_app')
-      end
-
-      def project(name = 'my_app')
-        ProjectDir.new(projects.join(name))
-      end
-
-      def reset_projects!
-        # only destroyed when a test starts, so you can poke around after a failure
-        require 'fileutils'
-        FileUtils.rmtree(projects) if projects.exist?
-        projects.mkpath
-      end
-    end
-
-    module Shell
-      ERROR_MESSAGE_FORMAT = <<ERRORFORMAT.freeze
-Command failed: `%s`
-output: %s
-exit: %d
-ERRORFORMAT
-
-      def self.run(command, allow_failures = false)
-        output = `#{command} 2>&1`
-        status = $CHILD_STATUS
-        unless status.success? || allow_failures
-          message = format ERROR_MESSAGE_FORMAT, command, output.chomp, status.exitstatus
-          raise message
-        end
-
-        [output, status.exitstatus]
-      end
-    end
-  end
-end