cease 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cdd44d4a984dd4c0f68b3e3708dcf8e1e7d5ab85fda130a67a41fa5942473231
+  data.tar.gz: 0ca8399c3a97ad5de4c278c9d318556074a23ab5576b652d4d312f2197a4a008
+SHA512:
+  metadata.gz: 87d2e9b44d400ec3696ccd509dfd7a55c6c4a47b6b1fb7635e9eedc6e76888aa62e51a6644324e686f920a16a7b454edc814fa3db6fca4676bb1a698ebc7c9e3
+  data.tar.gz: 325ce0face6fd0751041e911ec7e3d12ce8a5960a461cc85b5d55fe1463926141e252274cf99349b045c3d2d04641b9d1111f3906991f715c50cb830ed1df783

data/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby: [2.6, 2.7, "3.0", "3.1", jruby-9.3]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run specs
+        run: bundle exec rspec

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock
+Gemfile.gpg

data/.rspec

@@ -0,0 +1 @@
+--color

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sung@dustybit.software. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "rake", "~> 12.0"
+  gem "minitest", "~> 5.0"
+  gem "rspec", "~> 3.5.0"
+end
+
+group :development, :test do
+  gem 'pry', '~> 0.13.1'
+end

data/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright (c) 2021 Dusty Bit Software, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Solidus nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,134 @@
+# Cease
+
+![GitHub Actions](https://github.com/DustyBitSoftware/cease/actions/workflows/ci.yml/badge.svg)
+
+`cease` is a tool that scans for Ruby code marked as EOL.
+
+## Installation
+
+Install via rubygems:
+```sh
+gem install cease
+```
+
+## Usage
+
+Run it:
+```sh
+cease [directory_or_source_file]*
+```
+
+## Example
+### Basic usage
+Given a source file called `example.rb` that contains the following code:
+
+```ruby
+# [cease] at 12pm on 1/1/1999
+class RemoveMeLater
+  def foo
+    puts 'bar'
+  end
+end
+# [/cease]
+```
+
+You should see the output:
+```sh
+$ cease example.rb
+Scanning 1 source(s)...
+
+(example.rb)
+
+  [3, 9]: Overdue by roughly 23 years
+    class RemoveMeLater
+      def foo
+        puts 'bar'
+      end
+    end
+
+
+Total of 1 evictions(s) found.
+```
+
+### Options
+Cease supports both 12 and 24 hour clocks:
+```ruby
+# [cease] at 13:00 on 1/1/1999
+class RemoveMeLater
+...
+# [/cease]
+```
+
+Multiple commands per source:
+```ruby
+# [cease] at 12pm on 1/1/1999
+class RemoveMeLater
+  def foo
+    puts 'bar'
+  end
+end
+# [/cease]
+
+# [cease] at 1pm on 3/3/3333
+class RemoveMeWayLater
+  def foo
+    puts 'bar'
+  end
+end
+# [/cease]
+```
+
+If a date isn't provided, Cease attempts to guess the date based on the git commit:
+```ruby
+# [cease] at 13:00 # The date will be based on the commit timestamp of this comment.
+class RemoveMeLater
+...
+# [/cease]
+```
+
+You can provide an optional timezone (defaults to UTC):
+```ruby
+# [cease] at 1pm on 1/1/1999 { timezone: 'PST' }
+class RemoveMeLater
+...
+# [/cease]
+```
+
+**NOTE: Do not nest commands! This will not work:**
+```ruby
+# [cease] at 1pm
+  class RemoveMe
+    # [cease] at 3pm
+    def initialize
+    end
+    # [/cease]
+  end
+# [/cease]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/DustyBitSoftware/cease. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to
+the [code of
+conduct](https://github.com/nohmar/cease/blob/master/CODE_OF_CONDUCT.md).
+
+
+## Code of Conduct
+
+Everyone interacting in the Cease project's codebases, issue trackers, chat
+rooms and mailing lists is expected to follow the [code of
+conduct](https://github.com/nohmar/cease/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/cease

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/cease'
+
+exit Cease::CLI.new(argv: ARGV).execute

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cease"
+require "pry"
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cease.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/cease/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cease"
+  spec.version       = Cease::VERSION
+  spec.authors       = ["Sung Noh"]
+  spec.email         = ["sung@dustybit.software"]
+
+  spec.summary       = 'Evict unused code at some time in the future'
+  spec.description   = 'Cease is a tool that detects blocks of code ' \
+    'to be removed at a specified time.'
+  spec.homepage      = 'https://github.com/DustyBitSoftware/cease'
+  spec.license       = 'BSD-3-Clause'
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}).map { |path| File.basename(path) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'parser', '~> 3.0.0'
+  spec.add_runtime_dependency 'git', '~> 1.10.0'
+  spec.add_runtime_dependency 'rainbow', '~> 3.0.0'
+  spec.add_runtime_dependency 'dotiw', '~> 5.3.2'
+  spec.add_runtime_dependency 'tzinfo', '~> 2.0.4'
+end

data/lib/cease/cli.rb

@@ -0,0 +1,53 @@
+require 'pathname'
+
+require_relative 'report'
+
+module Cease
+  class CLI
+    def initialize(argv: ARGV)
+      @argv = argv
+    end
+
+    def execute
+      report.execute
+    end
+
+    private
+
+    attr_reader :argv
+
+    def report
+      Report.new(sources: sources)
+    end
+
+    def sources
+      entries.each_with_object([]) do |given_path, paths|
+        next unless given_path.exist?
+        next if hidden_entry?(given_path)
+
+        relevant_paths = []
+
+        # Peform a depth-first search for a given Pathname.
+        given_path.find do |path|
+          relevant_paths << path if ruby_file?(path)
+        end
+
+        paths.concat(relevant_paths)
+      end
+    end
+
+    def entries
+      return Pathname.new('.').entries if argv.empty?
+      argv.map { |arg| Pathname.new(arg) }
+    end
+
+
+    def hidden_entry?(path)
+      path.basename.to_s.start_with? '.'
+    end
+
+    def ruby_file?(path)
+      path.extname == '.rb'
+    end
+  end
+end

data/lib/cease/eviction/chunk.rb

@@ -0,0 +1,81 @@
+require 'forwardable'
+
+module Cease
+  module Eviction
+    class Chunk
+      extend Forwardable
+
+      # @params ast [Parser::AST::Node]
+      # @params statement [Cease::Eviction::Statement]
+      def initialize(ast:, statement:)
+        @ast = ast
+        @statement = statement
+        @closest_parent = nil
+        @children = []
+      end
+
+      # @return [Array<Parser::AST::Node>] 
+      def extract
+        return ast if only_child?
+
+        find_closest_parent(ast)
+        find_children(closest_parent)
+        children
+      end
+
+      private
+
+      attr_reader :ast, :closest_parent, :statement, :children
+
+      delegate [:open_comment, :close_comment] => :statement
+
+      # @note A depth-first search to find the closest non-comment parent to
+      #   the open comment. The closest parent is found outside the boundaries
+      #   of the Eviction statement.
+      def find_closest_parent(ast)
+        @closest_parent = ast
+
+        return unless open_comment > ast
+
+        filter_children(ast) do |child|
+          # Skip the child if it begins past the closing comment.
+          next if close_comment < child
+
+          # Skip the child if the expression begins and ends on the same line
+          # e.g. send, array, symbol
+          next if open_comment > child && close_comment > child
+
+          find_closest_parent(child)
+        end
+      end
+
+      def find_children(ast)
+        return children unless ast
+
+        filter_children(ast) do |child|
+          if open_comment > child && !close_comment.nested_in?(child)
+            @children << child
+            next # We got what we need. Don't go digging for other children.
+          end
+
+          find_children(child)
+        end
+      end
+
+      def filter_children(ast)
+        return unless block_given?
+
+        ast.children.grep(Parser::AST::Node).each do |child|
+          next unless child.respond_to? :loc
+          next unless child.loc.expression
+
+          yield(child)
+        end
+      end
+
+      def only_child?
+        ast.children.count < 2
+      end
+    end
+  end
+end

data/lib/cease/eviction/command/date_time.rb

@@ -0,0 +1,136 @@
+require 'forwardable'
+require 'yaml'
+
+require_relative '../../git'
+
+module Cease
+  module Eviction
+    module Command
+      class DateTime
+        extend Forwardable
+
+        class BadOptionsError < StandardError; end
+
+        DEFAULT_TIMEZONE = 'UTC'.freeze
+        TIMEZONE_NAME_MAPPING = {
+          "UTC" => "Etc/UTC",
+          "PST" => "America/Los_Angeles",
+          "MTZ" => "America/Denver",
+          "CST" => "America/Chicago",
+          "EST" => "America/New_York"
+        }.freeze
+        TIMEZONE_KEY = "timezone".freeze
+
+        # @params comment [Cease::Eviction::Comment]
+        # @params date_time [String]
+        # @params options [String]
+        def initialize(comment, date_time, options)
+          @comment = comment
+          @time, @date = parse(date_time)
+          @options = options
+        end
+
+        # @return [TZ::DateTimeWithOffset, nil]
+        def parsed_in_timezone
+          return unless valid?
+          tz.local_datetime(*local_datetime_args)
+        end
+
+        def valid?
+          return false unless valid_time?
+          return false if date && !valid_date?
+          return false if timezone_name && !valid_timezone?
+          true
+        rescue
+          false
+        end
+
+        def guess?
+          return true unless parsed_date
+          !!parsed_date
+        rescue
+          true
+        end
+
+        def tz
+          ::TZInfo::Timezone.get(
+            TIMEZONE_NAME_MAPPING[timezone_name] ||
+            TIMEZONE_NAME_MAPPING[DEFAULT_TIMEZONE]
+          )
+        end
+
+        private
+
+        delegate [:year, :month, :day, :hour, :minute] => :best_guess_date
+
+        attr_reader :comment, :options, :time, :date
+        
+        def parse(date_time)
+          split = date_time.split(' ')
+          results = []
+
+          loop do
+            break if split.length == 0
+            results << split.shift(2)
+          end
+
+          results
+            .partition { |result| result.include?("at") }
+            .map { |result| _identifer, value = result.flatten; value }
+        end
+
+        def parsed_options
+          @parsed_options ||= YAML.safe_load(options || '')
+        rescue Psych::SyntaxError
+          raise BadOptionsError
+        end
+
+        def timezone_name
+          return unless parsed_options
+          parsed_options[TIMEZONE_KEY]
+        end
+
+        def valid_time?
+          return false unless time
+          parsed_time
+        end
+
+        def valid_date?
+          return false unless date
+          parsed_date
+        end
+
+        def valid_timezone?
+          return true if TIMEZONE_NAME_MAPPING.keys.include?(timezone_name)
+          false
+        end
+
+        def best_guess_date
+          @best_guess_date ||= begin
+            parsed_date ||
+            (comment.last_commit_date &&
+              ::DateTime.parse(comment.last_commit_date.to_s)) ||
+            ::DateTime.now
+          end
+        end
+
+        def local_datetime_args
+          [year, month, day, hour, minute]
+        end
+
+        def parsed_date
+          return unless date
+
+          ::DateTime.strptime(
+            "#{date} #{parsed_time.hour}:#{parsed_time.minute}",
+            "%m/%d/%Y %H:%M"
+          )
+        end
+
+        def parsed_time
+          @parsed_time ||= ::DateTime.parse(time)
+        end
+      end
+    end
+  end
+end

data/lib/cease/eviction/comment.rb

@@ -0,0 +1,107 @@
+require 'forwardable'
+require 'dotiw'
+
+require_relative 'command/date_time'
+
+module Cease
+  module Eviction
+    class Comment
+      extend Forwardable
+
+      include Comparable
+      include DOTIW::Methods
+
+      # @examples
+      #   [cease] at 14:00
+      #   [cease] at 1pm on 01/01/2044
+      #   [cease] at 2:30pm on 12/01/2021 {timezone: 'PST'}
+      OPEN_COMMENT_REGEX = /
+        \[cease\]\s # prefix
+        (.+?) # non-greedy date and time
+        (:?\s*) # optional seperator
+        (\{.*?\})? # optional options
+        $ # extend non-greedy matchers to end of line
+      /x.freeze
+      CLOSE_COMMENT_REGEX = /\[\/cease\]/.freeze
+
+      def self.close_comment?(comment)
+        return false unless comment
+        !!(comment.text =~ CLOSE_COMMENT_REGEX)
+      end
+
+      # @params comment [Parser::Source::Comment]
+      # @params source [Pathname]
+      def initialize(comment:, source: nil)
+        @comment = comment
+        @date_time, @seperator, @options = scanned_comment
+        @source = source
+      end
+
+      def parse
+        scanned_comment
+      end
+
+      def date_time
+         Command::DateTime.new(self, @date_time, @options)
+      end
+
+      def close_comment?
+        self.class.close_comment?(comment)
+      end
+
+      def last_commit_date
+        return unless source
+
+        line = loc.line
+        search = "-L #{line},#{line}:#{source.to_s}"
+        Git.log.object(search)&.first&.date
+      end
+
+      def past_due_description
+        return unless overdue?
+
+        dotiw = distance_of_time_in_words(
+          date_time.tz.to_local(DateTime.now),
+          date_time.parsed_in_timezone,
+          highest_measures: 1
+        )
+
+        "Overdue by roughly #{dotiw}"
+      end
+
+      def overdue?
+        return false if close_comment?
+        return false unless date_time.valid?
+
+        date_time.tz.to_local(DateTime.now) >= date_time.parsed_in_timezone
+      end
+
+      def <=>(other)
+        other.loc.expression.begin_pos <=> loc.expression.begin_pos
+      end
+
+      def nested_in?(other)
+        other.loc.expression.end_pos > loc.expression.begin_pos
+      end
+
+      def valid?
+        return false unless comment
+        return true if close_comment?
+        parse.any?
+      end
+
+      attr_reader :comment, :options, :source
+
+      private
+
+      delegate loc: :comment
+
+      def scanned_comment
+        return [] unless comment
+
+        @scanned_comment ||=
+          comment.text.scan(OPEN_COMMENT_REGEX).flatten
+      end
+    end
+  end
+end

data/lib/cease/eviction/context.rb

@@ -0,0 +1,100 @@
+require 'parser/current'
+
+require_relative 'chunk'
+require_relative 'comment'
+require_relative 'scope'
+require_relative 'statement'
+
+module Cease
+  module Eviction
+    class Context
+      class << self
+        # @params source [Pathname]
+        #
+        # @return [Array<Cease::Eviction>]
+        def from_source(source:)
+          source_to_chunks(source) do |chunk, statement, comments|
+            new(comments: comments, statement: statement, chunk: chunk)
+          end.compact
+        end
+
+        private
+
+        def parsed_source(source)
+          buffer = Parser::Source::Buffer.new(source.to_s, 1)
+          buffer.read
+
+          Parser::CurrentRuby.new.parse_with_comments(buffer)
+        end
+
+        def closest_close_comment(comments, index)
+          # Find the next closest close command.
+          # Nested evictions break things.
+          comments[index..-1].find do |comment|
+            Comment.close_comment?(comment)
+          end
+        end
+
+        def source_to_chunks(source)
+          ast, comments = parsed_source(source)
+
+          comments.each_with_index.map do |comment, index|
+            next if Comment.close_comment?(comment)
+
+            statement = Statement.from_comments(
+              comment,
+              closest_close_comment(comments, index + 1),
+              source
+            )
+
+            next unless statement.valid?
+
+            chunk = Chunk.new(ast: ast, statement: statement)
+            yield(chunk, statement, comments) if block_given?
+          end
+        end
+      end
+
+      def initialize(chunk:, comments:, statement:)
+        @chunk = chunk 
+        @comments = comments
+        @statement = statement
+      end
+
+      def description
+        indent = ' ' * 2
+        lines_output = lines.inspect
+        alignment = ' ' * (lines_output.length - indent.length)
+        result = '' 
+
+        header = "#{indent}#{Rainbow(lines_output).blue}: "\
+          "#{Rainbow(statement.open_comment.past_due_description).indianred}\n"
+
+        scope.format.each do |line|
+          result << "#{alignment}#{line}\n"
+        end
+
+        "#{header}#{Rainbow(result).wheat}\n"
+      end
+
+      def lines
+        return [] unless statement.valid?
+        statement.lines
+      end
+
+      def overdue?
+        return false unless statement.valid?
+        statement.open_comment.overdue?
+      end
+
+      attr_reader :comments, :statement, :chunk
+
+      private
+
+      def scope
+        @scope ||=
+          Scope.new(chunk: chunk, comments: comments, statement: statement)
+      end
+    end
+  end
+end

data/lib/cease/eviction/scope.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+
+require 'rainbow'
+
+module Cease
+  module Eviction
+    class Scope
+      extend Forwardable
+
+      # @params chunk [Cease::Eviction::Chunk]
+      # @params comments [Array<Parser::Source::Comment>]
+      # @params statement [Cease::Statement>]
+      def initialize(chunk:, comments:, statement:)
+        @chunk = chunk
+        @comments = comments
+        @statement = statement
+      end
+
+      # @return [Array<String>]
+      def format
+        length = formatted_lines.length
+
+        case length
+        when (0..25) then formatted_lines
+        else
+          [
+            formatted_lines[0..10],
+            formatted_lines[11] << "\n",
+            Rainbow("...#{line_count - 12} line(s) truncated.").yellow
+          ].flatten
+        end
+      end
+
+      private
+
+      attr_reader :chunk, :comments, :statement
+
+      delegate [:open_comment, :close_comment] => :statement
+
+      # @return [Array<Parser::AST::Node, Parser::Source::Comment>]
+      def chunk_with_comments
+        extracted_chunk = chunk.extract
+        sorted_comments = comments.sort_by { |comment| comment.loc.line }
+
+        sorted_scope = extracted_chunk.each_with_object([]) do |ast, results|
+          until sorted_comments.first.loc.line > ast.loc.line do
+            comment = sorted_comments.shift
+
+            results << comment if comment.loc.line > open_comment.comment.loc.line
+          end
+
+          results << ast
+        end
+
+        # Concatenate any leftover comments outside AST nodes.
+        sorted_comments.each do |comment|
+          sorted_scope << comment if comment.loc.line < close_comment.comment.loc.line
+        end
+
+        sorted_scope
+      end
+
+      # @note Align indented lines relative to the expression's column.
+      def formatted_lines
+        @formatted_lines ||= chunk_with_comments.map do |content|
+          column = content.loc.column
+
+          # TODO: Find single line breaks between lines.
+          content.loc.expression.source
+            .split("\n")
+            .map do |result|
+              next result[column...] if result.start_with?(' ')
+              result
+            end
+        end.flatten
+      end
+
+      def line_count
+        statement.lines.inject(&:-).abs
+      end
+    end
+  end
+end

data/lib/cease/eviction/statement.rb

@@ -0,0 +1,39 @@
+require_relative 'comment'
+
+module Cease
+  module Eviction
+    class Statement
+      def self.from_comments(*comments)
+        open_comment, close_comment, source = comments
+
+        new(
+          open_comment: open_comment,
+          close_comment: close_comment,
+          source: source
+        )
+      end
+
+      # @param open_comment [Parser::Source::Comment]
+      # @param close_comment [Parser::Source::Comment]
+      # @params source [Pathname]
+      def initialize(open_comment:, close_comment:, source:)
+        @open_comment = Comment.new(comment: open_comment, source: source)
+        @close_comment = Comment.new(comment: close_comment, source: source)
+      end
+
+      def lines
+        return [] unless valid?
+
+        [open_comment, close_comment].map do |eviction_comment|
+          eviction_comment.loc&.line
+        end
+      end
+
+      def valid?
+        [open_comment, close_comment].all?(&:valid?)
+      end
+
+      attr_reader :open_comment, :close_comment
+    end
+  end
+end

data/lib/cease/examiner.rb

@@ -0,0 +1,30 @@
+require_relative 'summary'
+require_relative 'eviction/context'
+
+module Cease
+  class Examiner
+    # @param source [Pathname]
+    def initialize(source:)
+      @source = source
+    end
+
+    def evictions
+      @evictions ||= Eviction::Context.from_source(source: source)
+    end
+
+    def summarize
+      return unless summarizable?
+      Summary.new(examiner: self).summarize
+    end
+
+    def summarizable?
+      overdue_evictions.any?
+    end
+
+    def overdue_evictions
+      evictions.select(&:overdue?)
+    end
+
+    attr_reader :source
+  end
+end

data/lib/cease/git.rb

@@ -0,0 +1,21 @@
+require 'git'
+
+module Cease
+  class Git
+    def self.log
+      new.log
+    end
+
+    def initialize(pwd: Pathname.pwd.to_s)
+      @pwd = pwd
+    end
+
+    def log
+      @log ||= ::Git.open(pwd).log
+    end
+
+    private
+
+    attr_reader :pwd
+  end
+end

data/lib/cease/report.rb

@@ -0,0 +1,68 @@
+require_relative 'examiner'
+
+module Cease
+  class Report
+    SUCCESS_EXIT_CODE = 0
+    ERROR_EXIT_CODE = 1
+
+    def initialize(sources:)
+      @sources = sources
+      @examiners = []
+      @total_eviction_count = 0
+    end
+
+    def execute
+      print_header
+
+      sources.each do |source|
+        add_examiner(Examiner.new(source: source))
+      end
+
+      print_results
+      print_footer if reportable?
+
+      result_code
+    end
+
+    attr_accessor :total_eviction_count
+
+    private
+
+    attr_reader :examiners, :sources
+
+    def add_examiner(examiner)
+      self.total_eviction_count += examiner.overdue_evictions.length
+      examiners << examiner
+    end
+
+    def print_results
+      summarizable_examiners.each(&:summarize)
+    end
+
+    def print_header
+      puts "\nScanning #{sources.length} source(s)...\n\n"
+    end
+
+    def print_footer
+      puts Rainbow(
+        Rainbow"\nTotal of #{total_eviction_count} evictions(s) found.\n"
+      ).green
+    end
+
+    def result_code
+      if reportable?
+        ERROR_EXIT_CODE
+      else
+        SUCCESS_EXIT_CODE
+      end
+    end
+
+    def reportable?
+      summarizable_examiners.any?
+    end
+
+    def summarizable_examiners
+      examiners.select(&:summarizable?)
+    end
+  end
+end

data/lib/cease/summary.rb

@@ -0,0 +1,33 @@
+require 'forwardable'
+
+require 'rainbow'
+
+module Cease
+  class Summary
+    extend Forwardable
+
+    delegate [
+      :source,
+      :overdue_evictions
+    ] => :examiner
+
+    def initialize(examiner:)
+      @examiner = examiner
+    end
+
+    def summarize
+      return if overdue_evictions.none?
+
+      puts Rainbow("(#{source_name})").underline.bright
+      puts "\n#{overdue_evictions.map(&:description).join}"
+    end
+
+    private
+
+    attr_reader :examiner
+
+    def source_name
+      source.to_s
+    end
+  end
+end

data/lib/cease/version.rb

@@ -0,0 +1,3 @@
+module Cease
+  VERSION = "0.1.1"
+end

data/lib/cease.rb

@@ -0,0 +1,11 @@
+require 'tzinfo'
+
+require "cease/cli"
+require "cease/examiner"
+require "cease/git"
+require "cease/report"
+require "cease/summary"
+require "cease/version"
+
+module Cease
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: cease
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Sung Noh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: dotiw
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.2
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+description: Cease is a tool that detects blocks of code to be removed at a specified
+  time.
+email:
+- sung@dustybit.software
+executables:
+- cease
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cease
+- bin/console
+- bin/setup
+- cease.gemspec
+- lib/cease.rb
+- lib/cease/cli.rb
+- lib/cease/eviction/chunk.rb
+- lib/cease/eviction/command/date_time.rb
+- lib/cease/eviction/comment.rb
+- lib/cease/eviction/context.rb
+- lib/cease/eviction/scope.rb
+- lib/cease/eviction/statement.rb
+- lib/cease/examiner.rb
+- lib/cease/git.rb
+- lib/cease/report.rb
+- lib/cease/summary.rb
+- lib/cease/version.rb
+homepage: https://github.com/DustyBitSoftware/cease
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/DustyBitSoftware/cease
+  source_code_uri: https://github.com/DustyBitSoftware/cease
+  changelog_uri: https://github.com/DustyBitSoftware/cease/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Evict unused code at some time in the future
+test_files: []