danger-periphery 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8478fb86f4d5952f88ee7772f352049288bbc5c21f2f5d452ab7b37389b561ec
-  data.tar.gz: 63c976e46da5ad41bd5797adb3f1ddc83edd5c09f8d607c043757924b3b32cad
+  metadata.gz: 151988044c8bd6c18f36c5c44952bea6cba9443defbdbab19b309058b37c50fd
+  data.tar.gz: f67a5ec28410926edbd3efd022730fb0f8db0d1a07e77f8319a6c3cfdc241e4c
 SHA512:
-  metadata.gz: aeae221bc8e42918a500eb3050b3bd44451a4fa4af5e2e42a77e252a64cfc17ca7213b455af830d26c1c001a0250a2af4e532303b1bce8c5e45dd2b02c817dfb
-  data.tar.gz: d07fd15ea7105b6fbb875d628771a70c557bbd4066246712e26e5f1599d80d6d42e078d61b22e3c0c30c677105c0da317596a2d3a60595b3f16355193a8bed48
+  metadata.gz: 5804a836bd9ea4ac4564fba40e207440b62fd135eb0474d54c9a5c539719e3e9cc1a1e119e1c096c6a08f49a9af59c4aec70bdcfaba4982f54a2e853a413cafa
+  data.tar.gz: e22a91d942805d7abc7d4228b27c1caf0926f8a0ce8a5b16048c30c1bae1e42141522b7a13cd63af7598f3c499ed973b608f4a68b6d40193429f2ead4da0c11c

data/.gitignore

@@ -2,7 +2,6 @@
 .idea/
 .yardoc
 /tmp
-Gemfile.lock
 bin/lib_InternalSwiftSyntaxParser.dylib
 bin/periphery
 pkg

data/Dangerfile

@@ -3,6 +3,10 @@
 rubocop.lint inline_comment: true
 
 periphery.binary_path = "bin/periphery"
+periphery.process_warnings do |path, line, column, message|
+  !message.match(/unused/i)
+end
+
 periphery.scan(
   project: "spec/support/fixtures/test.xcodeproj",
   schemes: "test",

data/Gemfile

@@ -2,17 +2,16 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in danger-periphery.gemspec
 gemspec
 
 gem "bundler", "~> 2.0"
 gem "danger"
 gem "danger-rubocop"
-gem "guard", "~> 2.14"
-gem "guard-rspec", "~> 4.7"
-gem "listen", "3.0.7"
+gem "guard"
+gem "guard-rspec"
+gem "listen"
 gem "pry"
-gem "rake", "~> 10.0"
-gem "rspec", "~> 3.4"
+gem "rake"
+gem "rspec"
 gem "rubocop"
 gem "yard"

data/Gemfile.lock

@@ -0,0 +1,170 @@
+PATH
+  remote: .
+  specs:
+    danger-periphery (0.1.0)
+      danger-plugin-api (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.2)
+    claide (1.0.3)
+    claide-plugins (0.9.2)
+      cork
+      nap
+      open4 (~> 1.3)
+    coderay (1.1.3)
+    colored2 (3.1.2)
+    cork (0.3.0)
+      colored2 (~> 3.1)
+    danger (8.4.0)
+      claide (~> 1.0)
+      claide-plugins (>= 0.9.2)
+      colored2 (~> 3.1)
+      cork (~> 0.1)
+      faraday (>= 0.9.0, < 2.0)
+      faraday-http-cache (~> 2.0)
+      git (~> 1.7)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.0)
+      no_proxy_fix
+      octokit (~> 4.7)
+      terminal-table (>= 1, < 4)
+    danger-plugin-api (1.0.0)
+      danger (> 2.0)
+    danger-rubocop (0.9.5)
+      danger
+      rubocop (~> 1.0)
+    diff-lcs (1.5.0)
+    faraday (1.8.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0.1)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      multipart-post (>= 1.2, < 3)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-http-cache (2.2.0)
+      faraday (>= 0.8)
+    faraday-httpclient (1.0.1)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    ffi (1.15.5)
+    formatador (1.1.0)
+    git (1.9.1)
+      rchardet (~> 1.8)
+    guard (2.18.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    kramdown (2.3.1)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    multipart-post (2.1.1)
+    nap (1.1.0)
+    nenv (0.3.0)
+    no_proxy_fix (0.1.2)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    octokit (4.21.0)
+      faraday (>= 0.9)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    open4 (1.3.4)
+    parallel (1.21.0)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    public_suffix (4.0.6)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    rb-fsevent (0.11.0)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rchardet (1.8.0)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.2)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rubocop (1.22.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.12.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.12.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    sawyer (0.8.2)
+      addressable (>= 2.3.5)
+      faraday (> 0.8, < 2.0)
+    shellany (0.0.1)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    thor (1.2.1)
+    unicode-display_width (2.1.0)
+    yard (0.9.26)
+
+PLATFORMS
+  ruby
+  universal-darwin-20
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  danger
+  danger-periphery!
+  danger-rubocop
+  guard
+  guard-rspec
+  listen
+  pry
+  rake
+  rspec
+  rubocop
+  yard
+
+BUNDLED WITH
+   2.3.6

data/Guardfile

@@ -1,21 +1,42 @@
 # frozen_string_literal: true
 
-# A guardfile for making Danger Plugins
-# For more info see https://github.com/guard/guard#readme
+module ::Guard
+  class Periphery < Plugin
+    def initialize(options = {})
+      opts = options.dup
+      @project = opts.delete(:project)
+      @targets = opts.delete(:targets)
+      @schemes = opts.delete(:schemes)
+      super(opts)
+    end
 
-# To run, use `bundle exec guard`.
+    def run_on_modifications(_paths)
+      command = %W(
+        bin/periphery scan
+        --project '#{@project}'
+        --targets '#{@targets}'
+        --schemes '#{@schemes}'
+        --format checkstyle
+      ).join(" ")
+      puts(command)
+      system(command)
+    end
+  end
+end
 
 guard :rspec, cmd: "bundle exec rspec" do
   require "guard/rspec/dsl"
   dsl = Guard::RSpec::Dsl.new(self)
 
-  # RSpec files
   rspec = dsl.rspec
   watch(rspec.spec_helper) { rspec.spec_dir }
   watch(rspec.spec_support) { rspec.spec_dir }
   watch(rspec.spec_files)
 
-  # Ruby files
   ruby = dsl.ruby
   dsl.watch_spec_files_for(ruby.lib_files)
 end
+
+guard :periphery, project: "spec/support/fixtures/test.xcodeproj", targets: "test", schemes: "test" do
+  watch("spec/support/fixtures/test/main.swift")
+end

data/README.md

@@ -1,36 +1,75 @@
 # danger-periphery
 
+[![Test](https://github.com/manicmaniac/danger-periphery/actions/workflows/test.yml/badge.svg)](https://github.com/manicmaniac/danger-periphery/actions/workflows/test.yml)
+
 A Danger plugin to detect unused codes.
 
 ## Installation
 
 You need to install [Periphery](https://github.com/peripheryapp/periphery) beforehand.
 
-Currently `danger-periphery` is in early development stage so it's not published to rubygems.org yet.
-
 Write the following code in your Gemfile.
 
-    gem "danger-periphery", git: "https://github.com/manicmaniac/danger-periphery.git"
+```ruby
+gem "danger-periphery"
+```
 
 ## Usage
 
 If you already have `.periphery.yml`, the easiest way to use is just add this to your Dangerfile.
 
-    periphery.scan
+```ruby
+periphery.scan
+```
 
 You can specify the path to executable in this way.
 
-    periphery.binary_path = "bin/periphery"
+```ruby
+periphery.binary_path = "bin/periphery"
+```
 
 You can pass command line options to `periphery.scan` like the following.
 See `periphery scan -h` for available options.
 
-    periphery.scan(
-      project: "Foo.xcodeproj",
-      schemes: ["foo", "bar"],
-      targets: "foo",
-      clean_build: true
-    )
+```ruby
+periphery.scan(
+  project: "Foo.xcodeproj",
+  schemes: ["foo", "bar"],
+  targets: "foo",
+  clean_build: true
+)
+```
+
+## Advanced Usage
+
+You can modify warnings as you like by passing a block to `process_warnings`.
+`process_warnings` takes a block that receives `[path, line, column, message]` as arguments and returns one of the following types.
+
+- `Array` that exactly contains `[path, line, column, message]`
+- `true`
+- `false`
+- `nil`
+
+If an `Array` is returned, danger-periphery uses the values in an array instead of the raw result produced by Periphery.
+`true` has the same meaning as `[path, line, column, message]`, the argument array as-is.
+
+If it returns `false` or `nil`, the processing warning will be suppressed.
+
+For example, if you want your team members to be careful with warnings, the following code may work.
+
+```ruby
+periphery.process_warnings do |path, line, column, message|
+  [path, line, column, "Pay attention please! #{message}"]
+end
+```
+
+Or if you want to suppress all `unused` warnings, to return `nil` or `false` in the block works.
+
+```ruby
+periphery.process_warnings do |path, line, column, message|
+    !message.match(/unused/i)
+end
+```
 
 ## Development
 

data/Rakefile

@@ -8,16 +8,10 @@ RSpec::Core::RakeTask.new(:specs)
 
 task default: :specs
 
-task :spec do
-  Rake::Task["specs"].invoke
-  Rake::Task["rubocop"].invoke
-  Rake::Task["spec_docs"].invoke
-end
+task spec: %i(specs rubocop spec_docs)
 
 desc "Run RuboCop on the lib/specs directory"
-RuboCop::RakeTask.new(:rubocop) do |task|
-  task.patterns = ["lib/**/*.rb", "spec/**/*.rb"]
-end
+RuboCop::RakeTask.new(:rubocop)
 
 desc "Ensure that the plugin passes `danger plugins lint`"
 task :spec_docs do

data/danger-periphery.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.summary = spec.description
   spec.homepage = "https://github.com/manicmaniac/danger-periphery"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.3.0"
+  spec.required_ruby_version = ">= 2.6.0"
 
   spec.files = `git ls-files`.split($/)
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/lib/danger_plugin.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require "periphery/runner"
-require "periphery/scan_log_parser"
+require "periphery"
 
 module Danger
   # Analyze Swift files and detect unused codes in your project.
@@ -24,6 +23,32 @@ module Danger
     # @return [String]
     attr_accessor :binary_path
 
+    # Proc object to process each warnings just before showing them.
+    # The Proc must receive 4 arguments: path, line, column, message
+    # and return one of:
+    #   - an array that contains 4 elements [path, line, column, message]
+    #   - true
+    #   - false
+    #   - nil
+    # If Proc returns an array, the warning will be raised based on returned elements.
+    # If Proc returns true, the warning will not be modified.
+    # If Proc returns false or nil, the warning will be ignored.
+    #
+    # By default the Proc returns true.
+    # @return [Proc]
+    attr_accessor :postprocessor
+
+    OPTION_OVERRIDES = {
+      disable_update_check: true,
+      format: "checkstyle",
+      quiet: true
+    }.freeze
+
+    def initialize(dangerfile)
+      super(dangerfile)
+      @postprocessor = ->(path, line, column, message) { true }
+    end
+
     # Scans Swift files.
     # Raises an error when Periphery executable is not found.
     #
@@ -35,12 +60,27 @@ module Danger
     #                       5. Override some options like --disable-update-check, --format, --quiet and so.
     # @return [void]
     def scan(**options)
-      output = Periphery::Runner.new(binary_path).scan(options.merge(disable_update_check: true, format: "xcode", quiet: true))
-      entries = Periphery::ScanLogParser.new.parse(output)
+      output = Periphery::Runner.new(binary_path).scan(options.merge(OPTION_OVERRIDES))
       files = files_in_diff
-      entries.
+      Periphery::CheckstyleParser.new.parse(output).
+        lazy.
         select { |entry| files.include?(entry.path) }.
-        each { |entry| warn(entry.message, file: entry.path, line: entry.line) }
+        map { |entry| postprocess(entry) }.
+        force.
+        compact.
+        each { |path, line, column, message| warn(message, file: path, line: line) }
+    end
+
+    # Convenience method to set `postprocessor` with block.
+    #
+    # @return [Proc]
+    #
+    # @example Ignore all warnings from files matching regular expression
+    #   periphery.process_warnings do |path, line, column, message|
+    #     !path.match(/.*\/generated\.swift/)
+    #   end
+    def process_warnings(&block)
+      @postprocessor = block
     end
 
     private
@@ -51,5 +91,18 @@ module Danger
       post_rename_modified_files = git.modified_files.map { |modified_file| renamed_files_hash[modified_file] || modified_file }
       (post_rename_modified_files - git.deleted_files) + git.added_files
     end
+
+    def postprocess(entry)
+      result = @postprocessor.call(entry.path, entry.line, entry.column, entry.message)
+      if !result
+        nil
+      elsif result.kind_of?(TrueClass)
+        [entry.path, entry.line, entry.column, entry.message]
+      elsif result.kind_of?(Array) && result.size == 4
+        result
+      else
+        raise "Proc passed to postprocessor must return one of nil, true, false and Array that includes 4 elements."
+      end
+    end
   end
 end

data/lib/periphery/checkstyle_parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "periphery/scan_result"
+require "rexml/parsers/baseparser"
+require "rexml/parsers/streamparser"
+require "rexml/streamlistener"
+
+module Periphery
+  class CheckstyleParser
+    class Listener
+      include REXML::StreamListener
+
+      attr_reader :results
+
+      def initialize
+        @current_file = nil
+        @results = []
+      end
+
+      def tag_start(name, attrs)
+        case name
+        when "file"
+          @current_file = relative_path(attrs["name"])
+        when "error"
+          if @current_file
+            @results << ScanResult.new(
+              @current_file,
+              attrs["line"].to_i,
+              attrs["column"].to_i,
+              attrs["message"]
+            )
+          end
+        end
+      end
+
+      def tag_end(name)
+        @current_file = nil if name == "file"
+      end
+
+      private
+
+      def relative_path(path, base = Pathname.getwd)
+        Pathname.new(path).relative_path_from(base).to_s
+      end
+    end
+
+    def parse(string)
+      listener = Listener.new
+      REXML::Parsers::StreamParser.new(string, listener).parse
+      listener.results
+    end
+  end
+end

data/lib/periphery/runner.rb

@@ -13,17 +13,21 @@ module Periphery
     def scan(options)
       arguments = [binary_path, "scan"] + scan_arguments(options)
       stdout, stderr, status = Open3.capture3(*arguments)
-      raise "error: #{arguments} exited with status code #{status.exitstatus}. #{stderr}" unless status.success?
-
-      stdout
+      if status.success?
+        stdout
+      else
+        raise "error: #{arguments} exited with status code #{status.exitstatus}. #{stderr}" unless status.success?
+      end
     end
 
     def scan_arguments(options)
       options.
+        lazy.
         select { |_key, value| value }.
         map { |key, value| value.kind_of?(TrueClass) ? [key, nil] : [key, value] }.
         map { |key, value| value.kind_of?(Array) ? [key, value.join(",")] : [key, value] }.
-        map { |key, value| ["--#{key.to_s.tr('_', '-')}", value] }.
+        map { |key, value| ["--#{key.to_s.tr('_', '-')}", value&.to_s] }.
+        force.
         flatten.
         compact
     end

data/lib/periphery/scan_result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Periphery
+  ScanResult = Struct.new(:path, :line, :column, :message)
+end

data/lib/periphery.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "periphery/runner"
+require "periphery/checkstyle_parser"

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DangerPeriphery
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/danger_plugin_spec.rb

@@ -1,87 +1,145 @@
 # frozen_string_literal: true
 
-require File.expand_path("spec_helper", __dir__)
+describe Danger::DangerPeriphery do
+  include DangerPluginHelper
 
-module Danger
-  describe Danger::DangerPeriphery do
-    it "should be a plugin" do
-      expect(Danger::DangerPeriphery.new(nil)).to be_a Danger::Plugin
+  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 = binary("periphery")
+      json = File.read("#{File.dirname(__FILE__)}/support/fixtures/github_pr.json") # example json: `curl https://api.github.com/repos/danger/danger-plugin-template/pulls/18 > github_pr.json`
+      allow(periphery.github).to receive(:pr_json).and_return(json)
+      allow(Pathname).to receive(:getwd).and_return fixtures_path
     end
 
-    context "with Dangerfile" do
-      let(:dangerfile) { testing_dangerfile }
-      let(:periphery) { dangerfile.periphery }
+    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 "when .swift files not in diff" do
       before do
-        periphery.binary_path = binary("periphery")
-        json = File.read("#{File.dirname(__FILE__)}/support/fixtures/github_pr.json") # example json: `curl https://api.github.com/repos/danger/danger-plugin-template/pulls/18 > github_pr.json`
-        allow(periphery.github).to receive(:pr_json).and_return(json)
-        allow(Pathname).to receive(:getwd).and_return fixtures_path
+        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
 
-      context "when periphery is not installed" do
-        before { periphery.binary_path = "not_installed" }
+      it "reports nothing" do
+        periphery.scan(
+          project: fixture("test.xcodeproj"),
+          targets: "test",
+          schemes: "test"
+        )
 
-        it "fails with error" do
-          expect { periphery.scan }.to raise_error Errno::ENOENT
-        end
+        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
 
-      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 unused code" do
+        periphery.scan(
+          project: fixture("test.xcodeproj"),
+          targets: "test",
+          schemes: "test"
+        )
 
-        it "reports nothing" do
-          periphery.scan(
-            project: fixture("test.xcodeproj"),
-            targets: "test",
-            schemes: "test"
-          )
+        expect(dangerfile.status_report[:warnings]).to include "Function 'unusedMethod()' is unused"
+      end
+    end
 
-          expect(dangerfile.status_report[:warnings]).to be_empty
+    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(
+          project: fixture("test.xcodeproj"),
+          targets: "test",
+          schemes: "test"
+        )
+
+        expect(dangerfile.status_report[:warnings]).to include "Function 'unusedMethod()' is unused"
+      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(
+          project: fixture("test.xcodeproj"),
+          targets: "test",
+          schemes: "test"
+        )
+      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 .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"]
+      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
 
-        it "reports unused code" do
-          periphery.scan(
-            project: fixture("test.xcodeproj"),
-            targets: "test",
-            schemes: "test"
-          )
+      context "when returns true" do
+        let(:postprocessor) { ->(path, line, column, message) { true } }
 
-          expect(dangerfile.status_report[:warnings]).to eq(["Enum 'UnusedEnum' is unused"])
+        it "reports warnings" do
+          expect(subject).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 []
+      context "when returns a modified array" do
+        let(:postprocessor) do
+          ->(path, line, column, message) { [path, line, column, message.gsub(/Function/, "Foobar")] }
         end
 
-        it "reports unused code" do
-          periphery.scan(
-            project: fixture("test.xcodeproj"),
-            targets: "test",
-            schemes: "test"
-          )
+        it "reports modified warnings" do
+          expect(subject).to include "Foobar 'unusedMethod()' is unused"
+        end
+      end
+    end
 
-          expect(dangerfile.status_report[:warnings]).to eq(["Enum 'UnusedEnum' is unused"])
+    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

data/spec/periphery/checkstyle_parser_spec.rb

@@ -0,0 +1,34 @@
+# 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,77 +1,115 @@
 # frozen_string_literal: true
 
-require "periphery/runner"
+describe Periphery::Runner do
+  subject(:runner) { described_class.new(binary_path) }
 
-module Periphery
-  describe Runner do
-    subject(:runner) { described_class.new(binary_path) }
+  let(:binary_path) { binary("periphery") }
 
-    let(:binary_path) { binary("periphery") }
+  describe "#scan" do
+    subject { runner.scan(options) }
 
-    describe "#scan" do
-      subject { runner.scan(options) }
+    context "with valid args" do
+      let(:options) do
+        {
+          project: fixture("test.xcodeproj"),
+          targets: "test",
+          "schemes" => "test"
+        }
+      end
 
-      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
-          expect(subject).to include "warning:"
-        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) }
+  describe "#scan_arguments" do
+    subject { runner.scan_arguments(options) }
 
-      context "with empty options" do
-        let(:options) { {} }
+    context "with empty options" do
+      let(:options) { {} }
 
-        it { is_expected.to be_empty }
+      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
 
-      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
+      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 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
+    context "with options passed as boolean" do
+      let(:options) do
+        {
+          project: "test.xcodeproj",
+          targets: "test",
+          clean_build: true
+        }
       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
+      it "returns correct arguments" do
+        expect(subject).to eq %w(--project test.xcodeproj --targets test --clean-build)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,83 +1,83 @@
 # frozen_string_literal: true
 
-require "pathname"
 ROOT = Pathname.new(File.expand_path("..", __dir__))
-$:.unshift("#{ROOT}lib".to_s)
-$:.unshift("#{ROOT}spec".to_s)
+$:.unshift("#{ROOT}lib".to_s, "#{ROOT}spec".to_s)
 
 require "bundler/setup"
-require "pry"
-
-require "rspec"
 require "danger"
-
-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
-
-# Use coloured output, it's the best.
-RSpec.configure do |config|
-  config.filter_gems_from_backtrace "bundler"
-  config.color = true
-  config.tty = true
-end
-
 require "danger_plugin"
+require "pry"
+require "rspec"
 
-# 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]
+module FixtureHelper
+  def fixtures_path
+    Pathname.new("../support/fixtures").expand_path(__FILE__)
   end
 
-  cork = Cork::Board.new(out: @output)
-  def cork.string
-    out.string.gsub(/\e\[([;\d]+)?m/, "")
+  def fixture(filename)
+    fixtures_path.join(filename).to_s
   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
+  def binaries_path
+    Pathname.new("../../bin").expand_path(__FILE__)
+  end
 
-# A stubbed out Dangerfile for use in tests
-def testing_dangerfile
-  env = Danger::EnvironmentManager.new(testing_env)
-  Danger::Dangerfile.new(env, testing_ui)
+  def binary(filename)
+    binaries_path.join(filename).to_s
+  end
 end
 
-def fixtures_path
-  Pathname.new("../support/fixtures").expand_path(__FILE__)
-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
 
-def fixture(filename)
-  fixtures_path.join(filename).to_s
-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
 
-def binaries_path
-  Pathname.new("../../bin").expand_path(__FILE__)
+  # 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
 
-def binary(filename)
-  binaries_path.join(filename).to_s
+RSpec.configure do |config|
+  config.filter_gems_from_backtrace "bundler"
+  config.include FixtureHelper
 end

data/spec/support/fixtures/test/main.swift

@@ -1,3 +1,23 @@
-enum UnusedEnum {
-    case unused
+protocol RedundantProtocol {
 }
+
+class SomeClass: RedundantProtocol {
+    enum SomeEnum {
+        case usedCase
+        case unusedCase
+    }
+
+    var unusedProperty = 0
+    private var assignOnlyProperty = 0
+
+
+    public func methodWithRedundantPublicAccessibility(_ unusedParameter: Int) {
+        assignOnlyProperty = 0
+        _ = SomeEnum.usedCase
+    }
+
+    func unusedMethod() {
+    }
+}
+
+SomeClass().methodWithRedundantPublicAccessibility(0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danger-periphery
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryosuke Ito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-24 00:00:00.000000000 Z
+date: 2022-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: danger-plugin-api
@@ -39,6 +39,7 @@ files:
 - ".rubocop.yml"
 - Dangerfile
 - Gemfile
+- Gemfile.lock
 - Guardfile
 - LICENSE.txt
 - README.md
@@ -46,12 +47,14 @@ files:
 - bin/download_periphery
 - danger-periphery.gemspec
 - lib/danger_plugin.rb
+- lib/periphery.rb
+- lib/periphery/checkstyle_parser.rb
 - lib/periphery/runner.rb
-- lib/periphery/scan_log_parser.rb
+- lib/periphery/scan_result.rb
 - lib/version.rb
 - spec/danger_plugin_spec.rb
+- spec/periphery/checkstyle_parser_spec.rb
 - spec/periphery/runner_spec.rb
-- spec/periphery/scan_log_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixtures/github_pr.json
 - spec/support/fixtures/test.xcodeproj/project.pbxproj
@@ -68,21 +71,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A Danger plugin to detect unused codes.
 test_files:
 - spec/danger_plugin_spec.rb
+- spec/periphery/checkstyle_parser_spec.rb
 - spec/periphery/runner_spec.rb
-- spec/periphery/scan_log_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixtures/github_pr.json
 - spec/support/fixtures/test.xcodeproj/project.pbxproj

data/lib/periphery/scan_log_parser.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Periphery
-  class ScanLogParser
-    def parse(string)
-      string.lines.map do |line|
-        match = line.match(/^(?<path>.+):(?<line>\d+):(?<column>\d+): warning: (?<message>.*)\n?$/)
-        ScanLogEntry.new(relative_path(match[:path]), match[:line].to_i, match[:column].to_i, match[:message]) if match
-      end.compact
-    end
-
-    private
-
-    def relative_path(path, base = Pathname.getwd)
-      Pathname.new(path).relative_path_from(base).to_s
-    end
-  end
-
-  ScanLogEntry = Struct.new(:path, :line, :column, :message)
-end

data/spec/periphery/scan_log_parser_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "periphery/scan_log_parser"
-
-module Periphery
-  describe ScanLogParser do
-    describe "#parse" do
-      subject { described_class.new.parse(string) }
-
-      context "with empty string" do
-        let(:string) { "" }
-
-        it { is_expected.to be_empty }
-      end
-
-      context "with a valid string" do
-        let(:string) do
-          <<~LOG
-          * Inspecting project...
-          * Building danger-periphery...
-          * Indexing...
-          * Analyzing...
-
-          /Users/manicmaniac/danger-periphery/main.swift:1:1: warning: Typealias 'UnusedTypeAlias' is unused
-          /Users/manicmaniac/danger-periphery/main.swift:2:1: warning: Class 'UnusedClass' is unused
-          /Users/manicmaniac/danger-periphery/main.swift:3:1: warning: Protocol 'UnusedProtocol' is unused
-
-          * Seeing false positives?
-          - Periphery only analyzes files that are members of the targets you specify.
-            References to declarations identified as unused may reside in files that are members of other targets, e.g test targets.
-          - By default, Periphery does not assume that all public declarations are in use.
-            You can instruct it to do so with the --retain-public option.
-          - Periphery is a very precise tool, false positives often turn out to be correct after further investigation.
-          - If it really is a false positive, please report it - https://github.com/peripheryapp/periphery/issues.
-          LOG
-        end
-
-        before { allow(Pathname).to receive(:getwd).and_return Pathname.new("/Users/manicmaniac/danger-periphery") }
-
-        it "parses all warnings without garbages" do
-          expect(subject).to eq [
-            ScanLogEntry.new("main.swift", 1, 1, "Typealias 'UnusedTypeAlias' is unused"),
-            ScanLogEntry.new("main.swift", 2, 1, "Class 'UnusedClass' is unused"),
-            ScanLogEntry.new("main.swift", 3, 1, "Protocol 'UnusedProtocol' is unused")
-          ]
-        end
-      end
-    end
-  end
-end