todoloo 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee1e4b7b084c80e186f67664ee9b885e6d6c4f87030b4afd9b6be1e526166c7c
-  data.tar.gz: 0277403f2d2a3d9950134dc6d95b5342d34c6fd0f080d20e54080ba0ffc1ffbb
+  metadata.gz: 3e10a05abef8c425b5e2e9347d1bccc9e592f5e7a03a5608f84aa5495cfdf45e
+  data.tar.gz: 3e0febaa61ee4a872d045d8df00f9b49e17716ae3384b52a1aad8e0efbd4ec68
 SHA512:
-  metadata.gz: e672a59673b228e6cb71c2bf82fdff2c1de91ff6fbc070ae82c02b9e607e28e2a5d8ba0d053ed83d579c8bb2ae83f6cb86d3c1495ca5f822a9659d43081d969d
-  data.tar.gz: eb1c5f51d59b62e9a90956f6bf0cea66545937da04edb9b2d79a544b391d0de4d376978e581f7076ee1310b023640e0f3539a450a682c5f7799a4134c7e98a0a
+  metadata.gz: aefc739a86f6120a9383f3edec5b84433498cdcfe747fa40fd72654fc61ab4925137be92402c2303e37db9ead9b632837171a58d9c1142fdc80fa664deb43387
+  data.tar.gz: b0862355aa8fdb6bbfc4c405f8b0f83fd84a489f930c9aca3728bbae1b9888481bde8f34c1d3ed9632934068c685d84302e3f9df995dfea209b3573ddcef3033

data/CHANGELOG

@@ -0,0 +1,3 @@
+0.0.2 - 19 July 2024
+- Add regression for `Todoloo::TaskList` on writing tasks with blank topics
+

data/exe/todoloo

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "todoloo"
+
+Todoloo::CLI.start

data/lib/todoloo/cli.rb

@@ -0,0 +1,27 @@
+require "thor"
+
+class Todoloo::CLI < Thor
+  package_name "Todoloo"
+
+  desc "scan", "Scans all files that match the given globs and outputs a tasks.yml"
+  method_option :exclude, type: :array, aliases: "-e", desc: "List of path globs to exclude"
+  def scan
+    Todoloo::FileScanner
+      .new("**/*.rb", excludes: options[:exclude] || [], trace: true)
+      .scan
+      .write("tasks.yml")
+  end
+
+  desc "io", "Reads input from stdio and writes to stdout"
+  def io
+    Todoloo::TaskList.new.add(
+      Todoloo::Parser
+        .new
+        .parse_and_transform($stdin.read)
+    ).write($stdout)
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+end

data/lib/todoloo/error_handler.rb

@@ -0,0 +1,40 @@
+module Todoloo
+  class ErrorHandler
+    def initialize(kind)
+      @handler = new_handler_proc(kind)
+    end
+
+    def call(error, original_exception: nil)
+      # TODO(errors): Handle `original_exception`
+      @handler.call(error)
+    end
+
+    private
+
+    def new_handler_proc(kind)
+      case kind
+      when :raise
+        proc { |e| raise e }
+      when :stderr, :log, :trace
+        new_handler($stderr)
+      when String
+        File.open(kind, "w")
+      else
+        if kind.respond_to?(:write)
+          proc do |e|
+            if e.is_a?(Error)
+              kind.puts(e.message)
+              kind.puts(e.backtrace) if e.backtrace && !e.backtrace.empty?
+            else
+              kind.puts(e)
+            end
+          end
+        elsif kind.respond_to?(:call)
+          kind
+        else
+          raise ArgumentError, "Unsupported type for ErrorHandler: #{kind}"
+        end
+      end
+    end
+  end
+end

data/lib/todoloo/file_scanner.rb

@@ -0,0 +1,50 @@
+require "concurrent-ruby"
+require "parallel"
+
+# File scanner for finding todos
+class Todoloo::FileScanner
+  def initialize(pattern, excludes: [], trace: nil)
+    @parsers = Concurrent::Hash.new
+
+    @pattern = pattern
+
+    @excludes = excludes
+
+    @trace_output = case trace
+    when nil, false
+      nil
+    when true
+      $stderr
+    when String
+      File.open(trace, "w")
+    else
+      raise ArgumentError, "Invalid value #{trace} for argument trace"
+    end
+  end
+
+  # @return [Todoloo::TaskList]
+  def scan
+    Todoloo::TaskList.new.add(scan_files)
+  end
+
+  private
+
+  def parser
+    (@parsers[Parallel.worker_number] ||= Todoloo::Parser.new)
+  end
+
+  # @return [Array<Array<Task>>]
+  def scan_files
+    Parallel.map(Todoloo::Helpers.glob_paths(@pattern, excludes: @excludes)) do |path|
+      trace { "* Scan #{path}" }
+
+      parser.parse_and_transform(File.read(path), path: path)
+    end
+  end
+
+  def trace(&block)
+    return unless @trace_output
+
+    @trace_output.puts(block.call)
+  end
+end

data/lib/todoloo/helpers.rb

@@ -0,0 +1,24 @@
+module Todoloo
+  module Helpers
+    extend self
+    # Returns an `Enumerator` over the paths that match `pattern`
+    #
+    # TODO We need to optimize how we traverse the file-system so that we can short-circuit the excludes instead
+    #      of only filtering after finding them.
+    #
+    # @pattern [String]
+    #   The file paths to glob
+    #
+    # @excludes [Array<String>]
+    #   Optional list of file globs to exclude from the enumeration
+    #
+    # @return [Enumerator<String>]
+    def glob_paths(pattern, excludes: [])
+      Enumerator.new do |y|
+        Dir[pattern].lazy.each do |path|
+          y << path unless excludes.any? { |e| File.fnmatch(e, path) }
+        end
+      end
+    end
+  end
+end

data/lib/todoloo/parser.rb

@@ -0,0 +1,159 @@
+module Todoloo
+  # Read https://kschiess.github.io/parslet/get-started.html
+  class Parser < Parslet::Parser
+    TASK_TYPES = %w[TODO NOTE FIXME HBD HACK XXX]
+    root :file
+
+    # Returns a list of tasks
+    def parse_and_transform(text, path: "")
+      tree = parse(text)
+
+      pp tree if Todoloo.debug?
+
+      Transformer.new.apply(tree).map do |hash|
+        line, column = hash.fetch(:type).line_and_column
+
+        Task.from_hash(hash.merge(path: path, line: line, column: column))
+      end
+    end
+
+    def safe_parse(text)
+      parse(text)
+    rescue Parslet::ParseFailed => e
+      puts e.parse_failure_cause.ascii_tree
+      nil
+    end
+
+    # Extension to automatically define `?` predicate rules
+    def self.rule(name, *args, **kwargs, &block)
+      if name.to_s.end_with?("?")
+        super
+      else
+        super # Define the original rule
+        super("#{name}?") { public_send(name).maybe }
+      end
+    end
+
+    # Single char rules
+    rule(:lparen) { str("(") }
+    rule(:rparen) { str(")") }
+
+    rule(:eof) { any.absent? }
+
+    rule(:eol) { str("\n") }
+
+    rule(:space) { match(/[ \t]/) }
+
+    rule(:code_text) { match(/[^#\n]/) }
+
+    # FIXME: Cannot handle JS comments yet
+    rule(:comment_char) { str("#") } # || str("//") }
+
+    # Can read all the way without honoring anything special,
+    # since its use will only be when the comment has already started
+    rule(:comment_text) { match(/[^\n]/) }
+
+    # Parts
+    rule(:spacing) { space.repeat(1) }
+
+    rule(:code) { code_text.repeat(1).as(:code) }
+
+    rule(:line) { (comment | code >> comment | code).as(:line) }
+
+    rule(:file) { (line >> eol | eol | line >> eof).repeat.as(:file) }
+
+    rule(:comment) { (comment_start >> (task.as(:task) | line).maybe).as(:comment) }
+
+    rule(:comment_start) do
+      comment_char.capture(:comment_start) >> spacing?
+    end
+
+    # examples
+    #  TODO(topic): My task
+    #  TODO: My task
+    #  TODO: My task
+    rule(:task) { task_type.as(:type).capture(:type) >> topics.repeat(0, 1).as(:topics) >> task_separator? >> spacing? >> description.repeat(0, 1).as(:description) }
+
+    rule(:description) { multiline_description | single_line_description }
+
+    rule(:description_text) { comment_text.repeat(1) }
+
+    rule(:single_line_description) { description_text.as(:text) }
+
+    rule(:multiline_description) do
+      (description_text >> comment_continuation.repeat(1)).as(:text)
+    end
+
+    MIN_INDENTATION_BEYOND_TYPE_START = 1
+    def comment_continuation
+      dynamic do |_source, context|
+        parser = match('[\n]')
+
+        comment_start = column_offset_of_capture(:comment_start, context)
+
+        # Match any non comment content before the comment starts
+        parser = ignore_code_text(parser, comment_start)
+
+        # Consume the characther that the comment opened with, like a `#` or `//`
+        parser >>= str(context.captures[:comment_start]).ignore
+
+        parser >>= (spacing? >> task_type).absent?
+
+        required_indentation = column_offset_of_capture(:type, context) - comment_start - context.captures[:comment_start].length + MIN_INDENTATION_BEYOND_TYPE_START
+
+        parser = indentation(parser, required_indentation)
+
+        # parser >>= task_type.absent?
+
+        parser >>= description_text
+        parser
+      end
+    end
+
+    # Calculates zero-based column offset for the given capture.
+    # Use only within dynamic blocks
+    def column_offset_of_capture(name, context)
+      case name
+      when :type
+        # FIXME: Not sure yet why this is even necessary...
+        _, col_index = context.captures[:type][:type].line_and_column
+      else
+        _, col_index = context.captures[name].line_and_column
+      end
+
+      col_index - 1
+    end
+
+    def ignore_code_text(parser, count)
+      if count.positive?
+        parser >> code_text.repeat(count, count).ignore
+      else
+        parser
+      end
+    end
+
+    def indentation(parser, count)
+      return parser unless count.positive?
+
+      parser >> space.repeat(count, count)
+    end
+
+    rule(:task_type) do
+      TASK_TYPES
+        .map { |t| str(t) }
+        .reduce do |result, partial_matcher|
+        result | partial_matcher
+      end
+    end
+
+    rule(:topic) { match(/[^),]/).repeat(1).as(:topic) }
+
+    rule(:topic_rest) { (str(",") >> spacing.maybe >> topic).repeat(0, 1) }
+
+    # (topic1, topic2)
+    rule(:topics) { lparen >> topic >> topic_rest >> rparen }
+
+    rule(:task_separator) { str(":") }
+    rule(:task_separator?) { task_separator.maybe }
+  end
+end

data/lib/todoloo/task.rb

@@ -0,0 +1,14 @@
+module Todoloo
+  class Task < Struct.new(:type, :topics, :description, :path, :line, :column)
+    def self.from_hash(hash)
+      new(
+        hash.fetch(:type),
+        hash.fetch(:topics),
+        hash.fetch(:description),
+        hash.fetch(:path),
+        hash.fetch(:line),
+        hash.fetch(:column)
+      )
+    end
+  end
+end

data/lib/todoloo/task_list/folded_string.rb

@@ -0,0 +1,13 @@
+require "psych"
+# A string that is written to YAML as a folded string by default
+class Todoloo::TaskList::FoldedString
+  def initialize(string)
+    @string = string
+  end
+
+  def encode_with(coder)
+    coder.style = Psych::Nodes::Scalar::LITERAL
+    coder.scalar = @string
+    coder.tag = nil
+  end
+end

data/lib/todoloo/task_list.rb

@@ -0,0 +1,74 @@
+require "yaml"
+
+module Todoloo
+  class TaskList
+    def initialize
+      @tasks = []
+    end
+
+    def add(task)
+      if task.is_a?(Array)
+        task.each { |t| add(t) }
+      else
+        raise ArgumentError, "Task type must be Todoloo::Task: #{task.inspect}" unless task.is_a?(Todoloo::Task)
+        @tasks << task
+      end
+
+      self
+    end
+
+    # Structure:
+    #   TOPIC:
+    #     TYPE:
+    #       - description:
+    #         path:
+    def write(path, error: :raise)
+      output = YAML.dump(
+        converted_tasks(
+          error_handler: ErrorHandler.new(error)
+        )
+      )
+
+      if path.is_a?(String)
+        File.write(path, output)
+      else
+        path.write(output)
+      end
+    end
+
+    private
+
+    def topics_for_task(task)
+      if task.topics.empty?
+        [""]
+      else
+        task.topics
+      end
+    end
+
+    def converted_tasks(error_handler)
+      output = {}
+
+      @tasks.each do |task|
+        output_task = {
+          "description" => FoldedString.new(task.description.to_s),
+          "path" => "#{task.path}:#{task.line}:#{task.column}"
+        }
+
+        topics_for_task(task).each do |topic|
+          by_type = output[topic.to_s] ||= {}
+          tasks = by_type[task.type.to_s.downcase] ||= []
+          tasks << output_task.dup
+        end
+      rescue Error => e
+        if task.respond_to?(:line) && task.respond_to?(:column)
+          error_handler.call("#{path}:#{task.line}:#{task.column}: Error: #{e}", original_exception: e)
+        else
+          error_handler.call("#{path}:??:??:Error: #{e}", original_exception: e)
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/todoloo/transformer.rb

@@ -0,0 +1,28 @@
+module Todoloo
+  class Transformer < Parslet::Transform
+    rule(file: subtree(:x)) { x.compact }
+
+    rule(lines: subtree(:x)) { x }
+
+    rule(line: {code: subtree(:x)}) { nil }
+
+    rule(line: {code: subtree(:x), comment: subtree(:y)}) { y }
+
+    # Discard lines with only code and comments without tasks
+    rule(line: {code: subtree(:x), comment: simple(:y)}) { nil }
+
+    rule(line: {comment: subtree(:x)}) { x }
+
+    rule(line: {comment: simple(:x)}) { nil }
+
+    rule(type: simple(:type), topics: sequence(:topics), description: sequence(:description)) do
+      {type: type, topics: topics, description: description.empty? ? "" : (raise "must be empty")}
+    end
+
+    rule(topic: simple(:x)) { x }
+
+    rule(task: subtree(:task)) { task }
+
+    rule([{text: simple(:x)}]) { x }
+  end
+end

data/lib/todoloo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Todoloo
-  VERSION = "0.0.0"
+  VERSION = "0.0.2"
 end

data/lib/todoloo.rb

@@ -1,7 +1,28 @@
 # frozen_string_literal: true
 
 require_relative "todoloo/version"
+
+require "parslet"
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+
+loader.inflector.inflect "cli" => "CLI"
+
+loader.setup # ready!
+
 module Todoloo
   class Error < StandardError; end
   # Your code goes here...
+
+  class << self
+    attr_accessor :debug
+
+    def debug?
+      @debug
+    end
+  end
 end
+
+Todoloo.debug = false

metadata

@@ -1,31 +1,124 @@
 --- !ruby/object:Gem::Specification
 name: todoloo
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.2
 platform: ruby
 authors:
 - Chris Coetzee
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
-dependencies: []
+date: 2024-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A tool for managing and saying bye to todos
 email:
 - chriscz93@gmail.com
-executables: []
+executables:
+- todoloo
 extensions: []
 extra_rdoc_files: []
 files:
-- ".ruby-version"
+- CHANGELOG
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
-- Makefile
 - README.md
 - Rakefile
+- exe/todoloo
 - lib/todoloo.rb
+- lib/todoloo/cli.rb
+- lib/todoloo/error_handler.rb
+- lib/todoloo/file_scanner.rb
+- lib/todoloo/helpers.rb
+- lib/todoloo/parser.rb
+- lib/todoloo/task.rb
+- lib/todoloo/task_list.rb
+- lib/todoloo/task_list/folded_string.rb
+- lib/todoloo/transformer.rb
 - lib/todoloo/version.rb
-- sig/todoloo.rbs
 homepage: https://github.com/chriscz/todoloo
 licenses:
 - MIT

data/.ruby-version

@@ -1 +0,0 @@
-3.2.2

data/Makefile

@@ -1,8 +0,0 @@
-test:
-	bundle exec ruby test.rb
-
-format:
-	rubocop -a *.rb
-
-scan:
-	bundle exec ruby main.rb scan

data/sig/todoloo.rbs

@@ -1,4 +0,0 @@
-module Todoloo
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end