danger-periphery 0.2.0 → 0.2.2

data/Rakefile

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rubocop/rake_task"
-
-RSpec::Core::RakeTask.new(:specs)
-
-task default: :specs
-
-task spec: %i(specs rubocop spec_docs)
-
-desc "Run RuboCop on the lib/specs directory"
-RuboCop::RakeTask.new(:rubocop)
-
-desc "Ensure that the plugin passes `danger plugins lint`"
-task :spec_docs do
-  sh "danger plugins lint"
-end

data/bin/download_periphery

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-cd "$(dirname "$0")"
-version="2.9.0"
-curl -Lo periphery.zip "https://github.com/peripheryapp/periphery/releases/download/$version/periphery-v$version.zip"
-unzip periphery.zip
-rm periphery.zip LICENSE.md

data/danger-periphery.gemspec

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path("lib", __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "version"
-
-Gem::Specification.new do |spec|
-  spec.name = "danger-periphery"
-  spec.version = DangerPeriphery::VERSION
-  spec.authors = ["Ryosuke Ito"]
-  spec.email = ["rito.0305@gmail.com"]
-  spec.description = "A Danger plugin to detect unused codes."
-  spec.summary = spec.description
-  spec.homepage = "https://github.com/manicmaniac/danger-periphery"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  spec.files = `git ls-files`.split($/)
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "danger-plugin-api", "~> 1.0"
-end

data/spec/danger_plugin_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-describe Danger::DangerPeriphery do
-  include DangerPluginHelper
-
-  let(:periphery_options) do
-    {
-      project: fixture("test.xcodeproj"),
-      targets: "test",
-      schemes: "test"
-    }
-  end
-
-  it "should be a plugin" do
-    expect(Danger::DangerPeriphery.new(nil)).to be_a Danger::Plugin
-  end
-
-  context "with Dangerfile" do
-    let(:dangerfile) { testing_dangerfile }
-    let(:periphery) { dangerfile.periphery }
-
-    before do
-      periphery.binary_path = fixture("mock-periphery")
-      # example json: `curl -o github_pr.json https://api.github.com/repos/danger/danger-plugin-template/pulls/18
-      json = File.read(fixture("github_pr.json"))
-      allow(periphery.github).to receive(:pr_json).and_return json
-      allow(Pathname).to receive(:getwd).and_return fixtures_path
-    end
-
-    context "when periphery is not installed" do
-      before { periphery.binary_path = "not_installed" }
-
-      it "fails with error" do
-        expect { periphery.scan }.to raise_error Errno::ENOENT
-      end
-    end
-
-    context "with a real periphery executable", :slow do
-      before { periphery.binary_path = binary("periphery") }
-
-      context "when .swift files not in diff" do
-        before do
-          allow(periphery.git).to receive(:renamed_files).and_return []
-          allow(periphery.git).to receive(:modified_files).and_return []
-          allow(periphery.git).to receive(:deleted_files).and_return []
-          allow(periphery.git).to receive(:added_files).and_return []
-        end
-
-        it "reports nothing" do
-          periphery.scan(periphery_options)
-
-          expect(dangerfile.status_report[:warnings]).to be_empty
-        end
-      end
-
-      context "when .swift files were added" do
-        before do
-          allow(periphery.git).to receive(:renamed_files).and_return []
-          allow(periphery.git).to receive(:modified_files).and_return []
-          allow(periphery.git).to receive(:deleted_files).and_return []
-          allow(periphery.git).to receive(:added_files).and_return ["test/main.swift"]
-        end
-
-        it "reports unused code" do
-          periphery.scan(periphery_options)
-
-          expect(dangerfile.status_report[:warnings]).to include "Function 'unusedMethod()' is unused"
-        end
-      end
-
-      context "when .swift files were modified" do
-        before do
-          allow(periphery.git).to receive(:renamed_files).and_return []
-          allow(periphery.git).to receive(:modified_files).and_return ["test/main.swift"]
-          allow(periphery.git).to receive(:deleted_files).and_return []
-          allow(periphery.git).to receive(:added_files).and_return []
-        end
-
-        it "reports unused code" do
-          periphery.scan(periphery_options)
-
-          expect(dangerfile.status_report[:warnings]).to include "Function 'unusedMethod()' is unused"
-        end
-      end
-    end
-
-    context "with block" do
-      subject { dangerfile.status_report[:warnings] }
-
-      before do
-        allow(periphery.git).to receive(:renamed_files).and_return []
-        allow(periphery.git).to receive(:modified_files).and_return ["test/main.swift"]
-        allow(periphery.git).to receive(:deleted_files).and_return []
-        allow(periphery.git).to receive(:added_files).and_return []
-        periphery.scan(periphery_options, &block)
-      end
-
-      context "that returns nil" do
-        let(:block) { ->(violation) {} }
-
-        it "filters out all warnings" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "that returns false" do
-        let(:block) { ->(violation) { false } }
-
-        it "filters out all warnings" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "that returns true" do
-        let(:block) { ->(violation) { true } }
-
-        it "reports warnings without filtering anything" do
-          expect(subject).to include "Function 'unusedMethod()' is unused"
-        end
-      end
-
-      context "that returns truthy value" do
-        let(:block) { ->(violation) { 0 } }
-
-        it "reports warnings without filtering anything" do
-          expect(subject).to include "Function 'unusedMethod()' is unused"
-        end
-      end
-
-      context "that modifies the given violation" do
-        let(:block) { ->(violation) { violation.message.gsub!(/Function/, "Foobar") } }
-
-        it "reports modified warnings" do
-          expect(subject).to include "Foobar 'unusedMethod()' is unused"
-        end
-      end
-    end
-
-    describe "#postprocessor" do
-      subject { dangerfile.status_report[:warnings] }
-
-      before do
-        allow(periphery.git).to receive(:renamed_files).and_return []
-        allow(periphery.git).to receive(:modified_files).and_return ["test/main.swift"]
-        allow(periphery.git).to receive(:deleted_files).and_return []
-        allow(periphery.git).to receive(:added_files).and_return []
-        periphery.postprocessor = postprocessor
-        periphery.scan(periphery_options)
-      end
-
-      context "when returns nil" do
-        let(:postprocessor) { ->(path, line, column, message) {} }
-
-        it "does not report warnings" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "when returns false" do
-        let(:postprocessor) { ->(path, line, column, message) { false } }
-
-        it "does not report warnings" do
-          expect(subject).to be_empty
-        end
-      end
-
-      context "when returns true" do
-        let(:postprocessor) { ->(path, line, column, message) { true } }
-
-        it "reports warnings" do
-          expect(subject).to include "Function 'unusedMethod()' is unused"
-        end
-      end
-
-      context "when returns a modified array" do
-        let(:postprocessor) do
-          ->(path, line, column, message) { [path, line, column, message.gsub(/Function/, "Foobar")] }
-        end
-
-        it "reports modified warnings" do
-          expect(subject).to include "Foobar 'unusedMethod()' is unused"
-        end
-      end
-    end
-
-    describe "#process_warnings" do
-      it "sets postprocessor" do
-        periphery.process_warnings do |path, line, column, message|
-          nil
-        end
-        expect { periphery.process_warnings { |*args| nil } }.to(change { periphery.postprocessor })
-      end
-    end
-  end
-end

data/spec/periphery/checkstyle_parser_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-describe Periphery::CheckstyleParser do
-  subject(:parser) { described_class.new }
-
-  describe "#parse" do
-    subject { parser.parse(string) }
-
-    context "with vaild checkstyle xml" do
-      let(:string) do
-        <<~LOG
-        <?xml version="1.0" encoding="utf-8"?>
-        <checkstyle version="4.3">
-          <file name="/Users/manicmaniac/danger-periphery/main.swift">
-              <error line="1" column="1" severity="warning" message="Typealias &apos;UnusedTypeAlias&apos; is unused"/>
-              <error line="2" column="1" severity="warning" message="Class &apos;UnusedClass&apos; is unused"/>
-              <error line="3" column="1" severity="warning" message="Protocol &apos;UnusedProtocol&apos; is unused"/>
-          </file>
-        </checkstyle>
-        LOG
-      end
-
-      before { allow(Pathname).to receive(:getwd).and_return Pathname.new("/Users/manicmaniac/danger-periphery") }
-
-      it "parses all warnings" do
-        expect(subject).to eq [
-          Periphery::ScanResult.new("main.swift", 1, 1, "Typealias 'UnusedTypeAlias' is unused"),
-          Periphery::ScanResult.new("main.swift", 2, 1, "Class 'UnusedClass' is unused"),
-          Periphery::ScanResult.new("main.swift", 3, 1, "Protocol 'UnusedProtocol' is unused")
-        ]
-      end
-    end
-  end
-end

data/spec/periphery/runner_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-describe Periphery::Runner do
-  subject(:runner) { described_class.new(binary_path) }
-
-  let(:binary_path) { binary("periphery") }
-
-  describe "#scan" do
-    subject { runner.scan(options) }
-
-    context "with valid args" do
-      let(:options) do
-        {
-          project: fixture("test.xcodeproj"),
-          targets: "test",
-          "schemes" => "test"
-        }
-      end
-
-      let(:command) do
-        [
-          binary_path,
-          "scan",
-          "--project",
-          fixture("test.xcodeproj"),
-          "--targets",
-          "test",
-          "--schemes",
-          "test"
-        ]
-      end
-
-      it "runs scan without args" do
-        status = double(Process::Status, success?: true)
-        expect(Open3).to receive(:capture3).once.with(*command).and_return ["warning:", "", status]
-        expect(subject).to include "warning:"
-      end
-    end
-  end
-
-  describe "#scan_arguments" do
-    subject { runner.scan_arguments(options) }
-
-    context "with empty options" do
-      let(:options) { {} }
-
-      it { is_expected.to be_empty }
-    end
-
-    context "with options that takes no argument" do
-      let(:options) do
-        {
-          clean_build: true,
-          skip_build: true
-        }
-      end
-
-      it "returns correct arguments" do
-        expect(subject).to eq %w(--clean-build --skip-build)
-      end
-    end
-
-    context "with options that takes an argument" do
-      let(:options) do
-        {
-          project: "test.xcodeproj",
-          targets: "test1,test2"
-        }
-      end
-
-      it "returns correct arguments" do
-        expect(subject).to eq %w(--project test.xcodeproj --targets test1,test2)
-      end
-    end
-
-    context "with options that takes an array as argument" do
-      let(:options) do
-        {
-          project: "test.xcodeproj",
-          targets: %w(test1 test2)
-        }
-      end
-
-      it "returns correct arguments" do
-        expect(subject).to eq %w(--project test.xcodeproj --targets test1,test2)
-      end
-    end
-
-    context "with options passed as symbol" do
-      let(:options) do
-        {
-          project: "test.xcodeproj",
-          targets: :test
-        }
-      end
-
-      it "returns correct arguments" do
-        expect(subject).to eq %w(--project test.xcodeproj --targets test)
-      end
-    end
-
-    context "with options passed as boolean" do
-      let(:options) do
-        {
-          project: "test.xcodeproj",
-          targets: "test",
-          clean_build: true
-        }
-      end
-
-      it "returns correct arguments" do
-        expect(subject).to eq %w(--project test.xcodeproj --targets test --clean-build)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-ROOT = Pathname.new(File.expand_path("..", __dir__))
-$:.unshift("#{ROOT}lib".to_s, "#{ROOT}spec".to_s)
-
-require "bundler/setup"
-require "danger"
-require "danger_plugin"
-require "pry"
-require "rspec"
-
-module FixtureHelper
-  def fixtures_path
-    Pathname.new("support/fixtures").expand_path(__dir__)
-  end
-
-  def fixture(filename)
-    fixtures_path.join(filename).to_s
-  end
-
-  def binaries_path
-    Pathname.new("../bin").expand_path(__dir__)
-  end
-
-  def binary(filename)
-    binaries_path.join(filename).to_s
-  end
-end
-
-module DangerPluginHelper
-  def self.included(_module)
-    if `git remote -v` == ""
-      puts "You cannot run tests without setting a local git remote on this repo"
-      puts "It's a weird side-effect of Danger's internals."
-      exit(0)
-    end
-  end
-
-  # These functions are a subset of https://github.com/danger/danger/blob/master/spec/spec_helper.rb
-  # If you are expanding these files, see if it's already been done ^.
-
-  # A silent version of the user interface,
-  # it comes with an extra function `.string` which will
-  # strip all ANSI colours from the string.
-
-  # rubocop:disable Lint/NestedMethodDefinition
-  def testing_ui
-    @output = StringIO.new
-    def @output.winsize
-      [20, 9999]
-    end
-
-    cork = Cork::Board.new(out: @output)
-    def cork.string
-      out.string.gsub(/\e\[([;\d]+)?m/, "")
-    end
-    cork
-  end
-  # rubocop:enable Lint/NestedMethodDefinition
-
-  # Example environment (ENV) that would come from
-  # running a PR on TravisCI
-  def testing_env
-    {
-      "HAS_JOSH_K_SEAL_OF_APPROVAL" => "true",
-      "TRAVIS_PULL_REQUEST" => "800",
-      "TRAVIS_REPO_SLUG" => "artsy/eigen",
-      "TRAVIS_COMMIT_RANGE" => "759adcbd0d8f...13c4dc8bb61d",
-      "DANGER_GITHUB_API_TOKEN" => "123sbdq54erfsd3422gdfio"
-    }
-  end
-
-  # A stubbed out Dangerfile for use in tests
-  def testing_dangerfile
-    env = Danger::EnvironmentManager.new(testing_env)
-    Danger::Dangerfile.new(env, testing_ui)
-  end
-end
-
-RSpec.configure do |config|
-  config.filter_gems_from_backtrace "bundler"
-  config.include FixtureHelper
-end