mdlogbook 0.1.0

data/lib/mdlogbook/parser.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Mdlogbook
+  # Parses markdown logbook files into structured {Result} objects.
+  class Parser
+    DATE_HEADER_RE = /^# (\d{4}-\d{2}-\d{2})$/
+    JOB_HEADER_RE = /^## /
+    ENTRY_RE = /^\* ((\d\d):(\d\d)-(\d\d):(\d\d)) \((\d+\.\d+)\)/
+
+    # Immutable value object representing a single time entry.
+    #
+    # @!attribute [r] range_str
+    #   @return [String] Time range string (e.g. "09:00-12:30").
+    # @!attribute [r] time
+    #   @return [Float] Duration in hours calculated from the range.
+    # @!attribute [r] job
+    #   @return [String] Job or task description.
+    # @!attribute [r] line_number
+    #   @return [Integer, nil] 1-based line number in the source file.
+    Entry = Data.define(:range_str, :time, :job, :line_number) do
+      def initialize(range_str:, time:, job:, line_number: nil)
+        super
+      end
+
+      # Returns the start time as minutes since midnight.
+      # @return [Integer]
+      def start_minutes
+        h, m = range_str.split("-").first.split(":").map(&:to_i)
+        h * 60 + m
+      end
+
+      # Returns the end time as minutes since midnight (handles midnight crossing).
+      # @return [Integer]
+      def end_minutes
+        parts = range_str.split("-")
+        sh, sm = parts[0].split(":").map(&:to_i)
+        eh, em = parts[1].split(":").map(&:to_i)
+        start_val = sh * 60 + sm
+        end_val = eh * 60 + em
+        (end_val < start_val) ? end_val + 24 * 60 : end_val
+      end
+    end
+
+    # Accumulates parsed entries and warnings for a set of log files.
+    class Result
+      # @return [Array<String>] Warnings generated during parsing (e.g. time mismatches).
+      attr_reader :warnings
+
+      # Creates an empty result.
+      def initialize
+        @data = {}
+        @warnings = []
+      end
+
+      # Adds a time entry for the given date.
+      # @param date [Date] The date of the entry.
+      # @param entry [Entry] The entry to add.
+      # @return [void]
+      def add_entry(date, entry)
+        (@data[date] ||= []) << entry
+      end
+
+      # Records a warning message.
+      # @param message [String] Warning text.
+      # @return [void]
+      def add_warning(message)
+        @warnings << message
+      end
+
+      # @return [Array<Date>] All dates with entries, sorted ascending.
+      def dates
+        @data.keys.sort
+      end
+
+      # Returns all entries recorded on the given date.
+      # @param date [Date]
+      # @return [Array<Entry>]
+      def entries_on(date)
+        @data.fetch(date, [])
+      end
+
+      # Iterates over each date in ascending order.
+      # @yield [date] Each date that has entries.
+      # @yieldparam date [Date]
+      # @return [void]
+      def each_date(&)
+        dates.each(&)
+      end
+
+      # Merges another {Result} into this one in place.
+      # @param other [Result] The result to merge from.
+      # @return [self]
+      def merge!(other)
+        other.each_date do |date|
+          other.entries_on(date).each do |entry|
+            add_entry(date, entry)
+          end
+        end
+        @warnings.concat(other.warnings)
+        self
+      end
+    end
+
+    # @param regexp [Regexp, nil] When set, only entries whose job matches are kept.
+    def initialize(regexp: nil)
+      @regexp = regexp
+    end
+
+    # Parses the markdown logbook at the given file path.
+    # @param filename [String] Path to the logbook file.
+    # @return [Result]
+    def parse_file(filename)
+      File.open(filename, "r") { |io| parse(io) }
+    end
+
+    # Parses logbook content from an IO-like object.
+    # @param io [IO] Readable stream of logbook text.
+    # @return [Result]
+    def parse(io)
+      result = Result.new
+      date = nil
+      job = nil
+
+      io.each_line.with_index(1) do |raw_line, line_number|
+        line = raw_line.chomp
+
+        if (matched_date = parse_date_header(line))
+          date = matched_date
+          job = nil
+          next
+        end
+
+        if (matched_job = parse_job_header(line))
+          job = matched_job
+          next
+        end
+
+        parse_entry(line, date, job, line_number, result)
+      end
+
+      result
+    end
+
+    private
+
+    def parse_date_header(line)
+      match = DATE_HEADER_RE.match(line)
+      Date.parse(match[1]) if match
+    end
+
+    def parse_job_header(line)
+      match = JOB_HEADER_RE.match(line)
+      match&.post_match
+    end
+
+    def parse_entry(line, date, job, line_number, result)
+      match = ENTRY_RE.match(line)
+      return unless match && job
+      return if @regexp && !@regexp.match?(job)
+
+      range_str = match[1]
+      calculated = calculate_entry_hours(match)
+      add_overnight_notation_warning_if_needed(result, date, match)
+      add_warning_if_needed(result, date, range_str, match[6], calculated)
+      result.add_entry(date, build_entry(range_str, calculated, job, line_number))
+    end
+
+    def calculate_entry_hours(match)
+      h1, m1, h2, m2 = match.values_at(2, 3, 4, 5).map(&:to_i)
+      time_diff(h1, m1, h2, m2)
+    end
+
+    def add_warning_if_needed(result, date, range_str, recorded_hours, calculated_hours)
+      recorded = format("%.2f", recorded_hours.to_f)
+      calculated = format("%.2f", calculated_hours)
+      return if recorded == calculated
+
+      result.add_warning("#{date} #{range_str} #{recorded} != #{calculated}")
+    end
+
+    def add_overnight_notation_warning_if_needed(result, date, match)
+      start_hour = match[2].to_i
+      end_hour = match[4].to_i
+      return unless end_hour < start_hour
+      return unless end_hour < 24
+
+      normalized = normalized_overnight_range(match)
+      result.add_warning("#{date} #{match[1]} interpreted as #{normalized}; use 24:xx notation for overnight entries")
+    end
+
+    def build_entry(range_str, calculated_hours, job, line_number)
+      Entry.new(range_str: range_str, time: calculated_hours, job: job, line_number: line_number)
+    end
+
+    def normalized_overnight_range(match)
+      start_hour = match[2].to_i
+      start_minute = match[3]
+      end_hour = match[4].to_i + 24
+      end_minute = match[5]
+      format("%02d:%s-%02d:%s", start_hour, start_minute, end_hour, end_minute)
+    end
+
+    def time_diff(h1, m1, h2, m2)
+      t1 = h1 * 60 + m1
+      t2 = h2 * 60 + m2
+      t2 += 24 * 60 if t2 < t1
+      h, m = (t2 - t1).divmod(60)
+      h + m.to_f / 60
+    end
+  end
+end

data/lib/mdlogbook/period_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Mdlogbook
+  # Represents a contiguous date range to be processed.
+  #
+  # Use {.month} to construct a full-month period, or {.new} for an arbitrary range.
+  class PeriodSpec
+    # @return [Date]
+    attr_reader :start_date, :end_date
+
+    # @param start_date [Date]
+    # @param end_date [Date]
+    # @param month_unit [Boolean] true when this period represents exactly one calendar month.
+    def initialize(start_date, end_date, month_unit: false, relative: false)
+      @start_date = start_date
+      @end_date = end_date
+      @month_unit = month_unit
+      @relative = relative
+    end
+
+    # Constructs a full-month period.
+    # @param year [Integer]
+    # @param month [Integer]
+    # @return [PeriodSpec]
+    def self.month(year, month, relative: false)
+      first = Date.new(year, month, 1)
+      last = first.next_month - 1
+      new(first, last, month_unit: true, relative: relative)
+    end
+
+    # @return [Boolean] true when this period represents exactly one calendar month.
+    def month_unit?
+      @month_unit
+    end
+
+    # @return [Boolean] true when this period was derived from a relative specifier (d/w/m/q/y/D).
+    def relative?
+      @relative
+    end
+
+    # Returns all (year, month) pairs whose calendar month overlaps this period.
+    # @return [Array<Array(Integer, Integer)>]
+    def months_covered
+      result = []
+      d = Date.new(start_date.year, start_date.month, 1)
+      last = Date.new(end_date.year, end_date.month, 1)
+      while d <= last
+        result << [d.year, d.month]
+        d = d.next_month
+      end
+      result
+    end
+  end
+end

data/lib/mdlogbook/raw_extractor.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Mdlogbook
+  # Extracts raw markdown lines from logbook files, grouped by date section.
+  #
+  # Unlike {Parser}, this class preserves all lines (including free-form notes)
+  # within each date section, making it suitable for AI summarization.
+  class RawExtractor
+    # Accumulates raw lines per date for a set of log files.
+    class Result
+      # Creates an empty result.
+      def initialize
+        @sections = {}
+      end
+
+      # Returns all dates with content, sorted ascending.
+      # @return [Array<Date>]
+      def dates
+        @sections.keys.sort
+      end
+
+      # Returns raw lines for the given date.
+      # @param date [Date]
+      # @return [Array<String>]
+      def lines_on(date)
+        @sections.fetch(date, [])
+      end
+
+      # Iterates over each date in ascending order.
+      # @yield [date, lines]
+      # @yieldparam date [Date]
+      # @yieldparam lines [Array<String>]
+      # @return [void]
+      def each_date
+        dates.each { |date| yield date, lines_on(date) }
+      end
+
+      # Returns true when no dates have been added.
+      # @return [Boolean]
+      def empty?
+        @sections.empty?
+      end
+
+      # Merges another {Result} into this one in place.
+      # @param other [Result]
+      # @return [self]
+      def merge!(other)
+        other.each_date { |date, lines| @sections[date] = lines }
+        self
+      end
+
+      # @api private
+      def add_section(date, lines)
+        @sections[date] = lines
+      end
+    end
+
+    # Parses logbook content from a file path, extracting sections within +date_range+.
+    # @param filename [String]
+    # @param date_range [Range<Date>]
+    # @return [Result]
+    def extract_file(filename, date_range)
+      File.open(filename, "r") { |io| extract(io, date_range) }
+    end
+
+    # Parses logbook content from an IO object, extracting sections within +date_range+.
+    # @param io [IO]
+    # @param date_range [Range<Date>]
+    # @return [Result]
+    def extract(io, date_range)
+      result = Result.new
+      current_date = nil
+      current_lines = []
+
+      io.each_line do |line|
+        line = line.chomp
+        if (m = line.match(/^# (\d{4}-\d{2}-\d{2})$/))
+          flush_section(result, current_date, current_lines, date_range)
+          current_date = Date.parse(m[1])
+          current_lines = [line]
+        elsif current_date
+          current_lines << line
+        end
+      end
+
+      flush_section(result, current_date, current_lines, date_range)
+      result
+    end
+
+    private
+
+    def flush_section(result, date, lines, date_range)
+      return unless date && date_range.cover?(date)
+
+      result.add_section(date, lines.dup)
+    end
+  end
+end

data/lib/mdlogbook/runner/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Mdlogbook
+  module Runner
+    # Base class for all Runner subclasses.
+    #
+    # Provides shared functionality: argument parsing, spec iteration,
+    # result loading from log files, and file-not-found warnings.
+    class Base
+      # @param env [Env] Execution context.
+      # @param file_resolver [FileResolver] Resolves (year, month) to log file paths.
+      def initialize(env:, file_resolver:)
+        @env = env
+        @file_resolver = file_resolver
+        @specs = parse_args
+        @work_threshold = nil
+      end
+
+      private
+
+      def parse_args
+        ArgParser.new(today: @env.today, file_resolver: @file_resolver).parse(@env.argv)
+      end
+
+      def each_spec(&)
+        @specs.each(&)
+      end
+
+      def each_sorted_spec(&)
+        @specs.sort_by(&:start_date).each(&)
+      end
+
+      def load_result(spec)
+        parser = Parser.new(regexp: @env.opts.filter_regexp)
+        merged = Parser::Result.new
+        inject_result(spec, merged) { |path| parser.parse_file(path) }
+        DateFilter.filter(merged, spec)
+      end
+
+      def inject_result(spec, merged)
+        spec.months_covered.each do |year, month|
+          path = @file_resolver.resolve(year, month)
+          merge_file_or_warn(merged, path) { yield(path) }
+        end
+      end
+
+      def merge_file_or_warn(target, path)
+        target.merge!(yield)
+      rescue Errno::ENOENT
+        report_missing_file(path)
+      end
+
+      def report_missing_file(path)
+        @env.puts "Warning: file not found: #{path}" if @env.debug?
+      end
+
+      def spec_range
+        [@specs.map(&:start_date).min, @specs.map(&:end_date).max]
+      end
+
+      def work_threshold
+        @work_threshold ||= WorkThresholds.new(target_hours: @env.opts.target_hours)
+      end
+    end
+  end
+end

data/lib/mdlogbook/runner/editor_runner.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mdlogbook
+  module Runner
+    # Launches the user's editor for the target log file.
+    #
+    # After the editor exits successfully, parses the file and reports
+    # any parser warnings (time mismatches) and overlapping time entries.
+    class EditorRunner < Base
+      def run
+        if @specs.size > 1
+          @env.warn "Warning: --edit uses only the first period; ignoring #{@specs.size - 1} additional period(s)"
+        end
+        spec = @specs.first
+        year, month = spec.months_covered.first
+        file = @file_resolver.resolve(year, month)
+        ref_date = spec.month_unit? ? @env.today : spec.start_date
+        success = EditorLauncher.new(file: file, today: ref_date, args_template: @env.config.editor_args).launch
+
+        unless success
+          @env.warn "Warning: editor exited with an error"
+          return
+        end
+
+        validate_file(file)
+      end
+
+      private
+
+      def validate_file(file)
+        result = Parser.new.parse_file(file)
+        report_parser_warnings(result)
+        report_overlaps(result)
+      rescue Errno::ENOENT
+        # File does not exist; nothing to validate.
+      end
+
+      def report_parser_warnings(result)
+        result.warnings.each { |warning| @env.alert warning }
+      end
+
+      def report_overlaps(result)
+        checker = OverlapChecker.new
+        overlaps = checker.check(result)
+        overlaps.each { |o| @env.alert checker.format_message(o) }
+      end
+    end
+  end
+end

data/lib/mdlogbook/runner/extract_format_runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mdlogbook
+  module Runner
+    # Runs extraction modes: raw markdown output and grep-based section extraction.
+    class ExtractFormatRunner < Base
+      def run
+        if @env.raw_format?
+          run_raw
+        elsif @env.grep_format?
+          run_grep
+        end
+      end
+
+      private
+
+      def run_raw
+        extract_config = @env.config.extract_settings
+        extractor = RawExtractor.new
+        merged = RawExtractor::Result.new
+
+        each_spec do |spec|
+          inject_result(spec, merged) do |path|
+            extractor.extract_file(path, spec.start_date..spec.end_date)
+          end
+        end
+
+        range_begin, range_end = spec_range
+        Formatter::Extract.new.format_output(merged, @env.stdout,
+          extract_config: extract_config,
+          range_begin: range_begin,
+          range_end: range_end)
+      end
+
+      def run_grep
+        extractor = SectionExtractor.new
+        merged = SectionExtractor::Result.new
+
+        each_spec do |spec|
+          inject_result(spec, merged) do |path|
+            extractor.extract_file(path, spec.start_date..spec.end_date, regexp: @env.opts.regexp)
+          end
+        end
+
+        first = true
+        merged.each_section do |section|
+          @env.puts unless first
+          first = false
+          section.lines.each { |line| @env.puts line }
+        end
+      end
+    end
+  end
+end

data/lib/mdlogbook/runner/standard_format_runner.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Mdlogbook
+  module Runner
+    # Runs standard summary views: simple, calendar, anonymize, anonymize_dict.
+    #
+    # Handles merge/no-merge logic, overlap checking, and parser warning reporting.
+    class StandardFormatRunner < Base
+      def run
+        formatter = build_formatter
+        result = if should_merge?
+          run_merge(formatter)
+        else
+          run_each(formatter)
+        end
+
+        report_parser_warnings(result) if @env.warning_reporting_format?
+        report_overlaps(result) if @env.overlap_reporting_format?
+      end
+
+      private
+
+      def build_formatter
+        case @env.opts.format
+        when :simple
+          Formatter::Simple.new(color: @env.tty?)
+        when :calendar
+          Formatter::Calendar.new(color: @env.tty?)
+        when :anonymize
+          Formatter::Anonymize.new(color: false)
+        when :anonymize_dict
+          Formatter::AnonymizeDict.new(color: false)
+        else
+          raise ArgumentError, "unknown format: #{@env.opts.format}"
+        end
+      end
+
+      # Relative specifiers (d/w/m/y/D) and non-month-unit specs (week, day, duration) merge by default.
+      # Relative year (y1) expands to month_unit specs, so relative? handles that case.
+      # Explicit --merge or --no-merge overrides this.
+      def should_merge?
+        return true if @env.opts.merge
+        return false if @env.opts.no_merge
+
+        @specs.any? { |s| s.relative? || !s.month_unit? }
+      end
+
+      def run_each(formatter)
+        first = true
+        all = Parser::Result.new
+        threshold = work_threshold
+
+        each_sorted_spec do |spec|
+          result = load_result(spec)
+          next if result.dates.empty?
+
+          @env.puts unless first
+          first = false
+          output(formatter, result, threshold, range_begin: spec.start_date, range_end: spec.end_date)
+          all.merge!(result)
+        end
+
+        all
+      end
+
+      def run_merge(formatter)
+        merged = Parser::Result.new
+
+        each_spec do |spec|
+          merged.merge!(load_result(spec))
+        end
+
+        range_begin, range_end = spec_range
+        output(formatter, merged, work_threshold,
+          range_begin: range_begin,
+          range_end: range_end)
+
+        merged
+      end
+
+      def output(formatter, result, threshold, range_begin: nil, range_end: nil)
+        formatter.format_output(result, threshold, @env.stdout,
+          today: @env.today,
+          debug: @env.debug?,
+          anonymize_settings: @env.anonymize_settings,
+          range_begin: range_begin,
+          range_end: range_end)
+      end
+
+      def report_overlaps(result)
+        checker = OverlapChecker.new
+        overlaps = checker.check(result)
+        return if overlaps.empty?
+
+        overlaps.each { |o| @env.alert checker.format_message(o) }
+      end
+
+      def report_parser_warnings(result)
+        return if result.warnings.empty?
+
+        result.warnings.each { |warning| @env.alert warning }
+      end
+    end
+  end
+end