hizuke 0.0.3 → 0.1.0

data/lib/hizuke/parser.rb

@@ -1,437 +1,109 @@
 # frozen_string_literal: true
 
-require "date"
+require_relative 'constants'
+require_relative 'date_calculator'
+require_relative 'pattern_matcher'
+require 'date'
 
 module Hizuke
-  # Result object containing the clean text and extracted date
-  class Result
-    attr_reader :text, :date
-
-    def initialize(text, date)
-      @text = text
-      @date = date
-    end
-  end
-
-  # Parser class responsible for extracting dates from text
-  class Parser
-    # Mapping of day names to their wday values (0-6, Sunday is 0)
-    DAYS_OF_WEEK = {
-      "monday" => 1,
-      "tuesday" => 2,
-      "wednesday" => 3,
-      "thursday" => 4,
-      "friday" => 5,
-      "saturday" => 6,
-      "sunday" => 0
-    }.freeze
-
-    # Date keywords mapping
-    DATE_KEYWORDS = {
-      "yesterday" => -1,
-      "today" => 0,
-      "tomorrow" => 1,
-      "dayaftertomorrow" => 2,
-      "day after tomorrow" => 2,
-      "daybeforeyesterday" => -2,
-      "day before yesterday" => -2,
-      "nextweek" => :next_week,
-      "next week" => :next_week,
-      "lastweek" => :last_week,
-      "last week" => :last_week,
-      "nextmonth" => :next_month,
-      "next month" => :next_month,
-      "lastmonth" => :last_month,
-      "last month" => :last_month,
-      "nextyear" => :next_year,
-      "next year" => :next_year,
-      "lastyear" => :last_year,
-      "last year" => :last_year,
-      "nextquarter" => :next_quarter,
-      "next quarter" => :next_quarter,
-      "lastquarter" => :last_quarter,
-      "last quarter" => :last_quarter,
-      "thisweekend" => :this_weekend,
-      "this weekend" => :this_weekend,
-      "endofweek" => :end_of_week,
-      "end of week" => :end_of_week,
-      "endofmonth" => :end_of_month,
-      "end of month" => :end_of_month,
-      "endofyear" => :end_of_year,
-      "end of year" => :end_of_year,
-      "midweek" => :mid_week,
-      "mid week" => :mid_week,
-      "midmonth" => :mid_month,
-      "mid month" => :mid_month
-    }.freeze
-
-    # Regex patterns for dynamic date references
-    IN_X_DAYS_PATTERN = /in (\d+) days?/i
-    X_DAYS_AGO_PATTERN = /(\d+) days? ago/i
-    IN_X_WEEKS_PATTERN = /in (\d+) weeks?/i
-    X_WEEKS_AGO_PATTERN = /(\d+) weeks? ago/i
-    IN_X_MONTHS_PATTERN = /in (\d+) months?/i
-    X_MONTHS_AGO_PATTERN = /(\d+) months? ago/i
-    IN_X_YEARS_PATTERN = /in (\d+) years?/i
-    X_YEARS_AGO_PATTERN = /(\d+) years? ago/i
-    
-    # Regex patterns for specific days of the week
-    THIS_DAY_PATTERN = /this (monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i
-    NEXT_DAY_PATTERN = /next (monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i
-    LAST_DAY_PATTERN = /last (monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i
-
-    # Parse text containing time references and extract both
-    # the clean text and the date.
-    #
-    # @param text [String] the text to parse
-    # @return [Hizuke::Result] the parsing result containing text and date
-    # @raise [Hizuke::ParseError] if no valid date reference is found
-    def self.parse(text)
-      new.parse(text)
+  # Time of day representation with hour, minute and second
+  class TimeOfDay
+    attr_reader :hour, :min, :sec
+
+    def initialize(hour, min, sec)
+      @hour = hour
+      @min = min
+      @sec = sec
     end
 
-    # Instance method to parse text
-    #
-    # @param text [String] the text to parse
-    # @return [Hizuke::Result] the parsing result containing text and date
-    # @raise [Hizuke::ParseError] if no valid date reference is found
-    def parse(text)
-      # Check if text is nil or empty
-      raise ParseError, "Input text cannot be nil or empty" if text.nil? || text.empty?
-
-      # Check for dynamic patterns first (in X days, X days ago)
-      result = check_dynamic_patterns(text)
-      return result if result
-
-      # Check for day of week patterns (this Monday, next Tuesday, etc.)
-      result = check_day_of_week_patterns(text)
-      return result if result
-
-      # Try to find compound date expressions (like "next week")
-      compound_matches = {}
-      
-      DATE_KEYWORDS.keys.select { |k| k.include?(" ") }.each do |compound_key|
-        if text.downcase.include?(compound_key)
-          start_idx = text.downcase.index(compound_key)
-          end_idx = start_idx + compound_key.length - 1
-          compound_matches[compound_key] = [start_idx, end_idx]
-        end
-      end
-
-      # If we found compound matches, handle them specially
-      unless compound_matches.empty?
-        # Use the first match (in case there are multiple)
-        match_key, indices = compound_matches.min_by { |_, v| v[0] }
-        
-        # Calculate date based on the keyword
-        date_value = DATE_KEYWORDS[match_key]
-        date = calculate_date(date_value)
-        
-        # Remove the date expression from the text
-        clean_text = text.dup
-        clean_text.slice!(indices[0]..indices[1])
-        clean_text = clean_text.strip
-        
-        return Result.new(clean_text, date)
-      end
-
-      # Split the text into words (for single-word date references)
-      words = text.split
-
-      # Find the first date keyword
-      date_word_index = nil
-      date_value = nil
-
-      words.each_with_index do |word, index|
-        clean_word = word.downcase.gsub(/[^a-z]/, '')
-        if DATE_KEYWORDS.key?(clean_word)
-          date_word_index = index
-          date_value = DATE_KEYWORDS[clean_word]
-          break
-        end
+    def to_s
+      # Include seconds in the format if they are not zero
+      if sec.zero?
+        format('%<hour>02d:%<min>02d', hour: hour, min: min)
+      else
+        format('%<hour>02d:%<min>02d:%<sec>02d', hour: hour, min: min, sec: sec)
       end
-
-      if date_word_index.nil?
-        raise ParseError, "No valid date reference found in '#{text}'"
-      end
-
-      # Calculate the date based on the keyword
-      date = calculate_date(date_value)
-
-      # Create the clean text by removing the date keyword
-      clean_words = words.dup
-      clean_words.delete_at(date_word_index)
-      clean_text = clean_words.join(" ").strip
-
-      Result.new(clean_text, date)
     end
+  end
 
-    private
-
-    # Check for day of week patterns (this Monday, next Tuesday, last Friday, etc.)
-    def check_day_of_week_patterns(text)
-      # Check for "this [day]" pattern
-      if (match = text.match(THIS_DAY_PATTERN))
-        day_name = match[1].downcase
-        day_value = DAYS_OF_WEEK[day_name]
-        date = calculate_this_day(day_value)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "next [day]" pattern
-      if (match = text.match(NEXT_DAY_PATTERN))
-        day_name = match[1].downcase
-        day_value = DAYS_OF_WEEK[day_name]
-        date = calculate_next_day(day_value)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "last [day]" pattern
-      if (match = text.match(LAST_DAY_PATTERN))
-        day_name = match[1].downcase
-        day_value = DAYS_OF_WEEK[day_name]
-        date = calculate_last_day(day_value)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
+  # Result represents a parsing result with clean text and parsed date
+  class Result
+    attr_reader :clean_text, :date, :time
 
-      nil
+    def initialize(clean_text, date, time = nil)
+      @clean_text = clean_text
+      @date = date
+      @time = time
     end
 
-    # Check for dynamic date patterns like "in X days" or "X days ago"
-    def check_dynamic_patterns(text)
-      # Check for "in X days" pattern
-      if (match = text.match(IN_X_DAYS_PATTERN))
-        days = match[1].to_i
-        date = Date.today + days
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "X days ago" pattern
-      if (match = text.match(X_DAYS_AGO_PATTERN))
-        days = match[1].to_i
-        date = Date.today - days
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "in X weeks" pattern
-      if (match = text.match(IN_X_WEEKS_PATTERN))
-        weeks = match[1].to_i
-        date = Date.today + (weeks * 7)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "X weeks ago" pattern
-      if (match = text.match(X_WEEKS_AGO_PATTERN))
-        weeks = match[1].to_i
-        date = Date.today - (weeks * 7)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
-
-      # Check for "in X months" pattern
-      if (match = text.match(IN_X_MONTHS_PATTERN))
-        months = match[1].to_i
-        date = Date.today >> months
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
+    # Alias for clean_text for backward compatibility
+    alias text clean_text
 
-      # Check for "X months ago" pattern
-      if (match = text.match(X_MONTHS_AGO_PATTERN))
-        months = match[1].to_i
-        date = Date.today << months
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
+    # Returns a DateTime object if time is available, otherwise nil
+    def datetime
+      return nil unless @time && @date
 
-      # Check for "in X years" pattern
-      if (match = text.match(IN_X_YEARS_PATTERN))
-        years = match[1].to_i
-        date = Date.new(Date.today.year + years, Date.today.month, Date.today.day)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
+      DateTime.new(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
+    end
+  end
 
-      # Check for "X years ago" pattern
-      if (match = text.match(X_YEARS_AGO_PATTERN))
-        years = match[1].to_i
-        date = Date.new(Date.today.year - years, Date.today.month, Date.today.day)
-        clean_text = text.gsub(match[0], "").strip
-        return Result.new(clean_text, date)
-      end
+  # Error raised when parsing fails
+  class ParseError < StandardError; end
 
-      nil
+  # Main parser class for the Hizuke library
+  class Parser
+    include Constants
+    include DateCalculator
+    include WeekCalculator
+    include MonthCalculator
+    include YearCalculator
+    include QuarterCalculator
+    include PeriodCalculator
+    include PatternMatcher
+
+    # Parse a date from text - class method
+    # @param text [String] the text to parse
+    # @return [Hizuke::Result] the parsing result with clean text and date
+    def self.parse(text)
+      new.parse(text)
     end
 
-    # Calculate date for "this [day]" - the current/upcoming day in this week
-    def calculate_this_day(target_wday)
-      today = Date.today
-      today_wday = today.wday
-      
-      # Calculate days until the target day in this week
-      days_diff = (target_wday - today_wday) % 7
-      
-      # If it's the same day, return today's date
-      if days_diff == 0
-        return today
-      end
-      
-      # Return the date of the next occurrence in this week
-      today + days_diff
+    # Parse a date with result details from text - class method
+    # @param text [String] the text to parse
+    # @return [Hizuke::Result] the parsing result with clean text and date
+    def self.parse_with_result(text)
+      new.parse_with_result(text)
     end
 
-    # Calculate date for "next [day]" - the day in next week
-    def calculate_next_day(target_wday)
-      today = Date.today
-      today_wday = today.wday
-      
-      # Calculate days until the next occurrence
-      days_until_target = (target_wday - today_wday) % 7
-      
-      # If today is the target day or the target day is earlier in the week,
-      # we want the day next week, so add 7 days
-      if days_until_target == 0 || target_wday < today_wday
-        days_until_target += 7
-      end
-      
-      today + days_until_target
-    end
+    # Parse a date from text
+    # @param text [String] the text to parse
+    # @return [Hizuke::Result] the parsing result with clean text and date
+    def parse(text)
+      raise ParseError, 'Cannot parse nil input' if text.nil?
+      raise ParseError, 'Cannot parse empty input' if text.empty?
 
-    # Calculate date for "last [day]" - the day in previous week
-    def calculate_last_day(target_wday)
-      today = Date.today
-      today_wday = today.wday
-      
-      # Calculate days since the last occurrence
-      days_since_target = (today_wday - target_wday) % 7
-      
-      # If today is the target day or the target day is later in the week,
-      # we want the day last week, so add 7 days
-      if days_since_target == 0 || target_wday > today_wday
-        days_since_target += 7
-      end
-      
-      today - days_since_target
+      parse_with_result(text)
     end
 
-    # Calculate the date based on the keyword value
-    def calculate_date(date_value)
-      if date_value.is_a?(Integer)
-        Date.today + date_value
-      elsif date_value == :next_week
-        # Find next Monday
-        days_until_monday = (1 - Date.today.wday) % 7
-        # If today is Monday, we want next Monday, not today
-        days_until_monday = 7 if days_until_monday == 0
-        Date.today + days_until_monday
-      elsif date_value == :last_week
-        # Find last Monday
-        days_since_monday = (Date.today.wday - 1) % 7
-        # If today is Monday, we want last Monday, not today
-        days_since_monday = 7 if days_since_monday == 0
-        Date.today - days_since_monday - 7
-      elsif date_value == :next_month
-        # Return the first day of the next month
-        next_month = Date.today >> 1
-        Date.new(next_month.year, next_month.month, 1)
-      elsif date_value == :last_month
-        # Return the first day of the previous month
-        prev_month = Date.today << 1
-        Date.new(prev_month.year, prev_month.month, 1)
-      elsif date_value == :next_year
-        # Return the first day of the next year
-        next_year = Date.today.year + 1
-        Date.new(next_year, 1, 1)
-      elsif date_value == :last_year
-        # Return the first day of the last year
-        last_year = Date.today.year - 1
-        Date.new(last_year, 1, 1)
-      elsif date_value == :next_quarter
-        # Return the first day of the next quarter
-        today = Date.today
-        current_month = today.month
-        
-        # Determine the start month of the next quarter
-        next_quarter_month = case
-                             when current_month <= 3
-                               4  # Q2 starts in April
-                             when current_month <= 6
-                               7  # Q3 starts in July
-                             when current_month <= 9
-                               10 # Q4 starts in October
-                             else
-                               1  # Q1 of next year starts in January
-                             end
-        
-        # If the next quarter is in the next year, increment the year
-        next_quarter_year = today.year
-        next_quarter_year += 1 if current_month > 9
-        
-        Date.new(next_quarter_year, next_quarter_month, 1)
-      elsif date_value == :last_quarter
-        # Return the first day of the last quarter
-        today = Date.today
-        current_month = today.month
-        
-        # Determine the start month of the last quarter
-        last_quarter_month = case
-                             when current_month <= 3
-                               10 # Q4 of last year starts in October
-                             when current_month <= 6
-                               1  # Q1 starts in January
-                             when current_month <= 9
-                               4  # Q2 starts in April
-                             else
-                               7  # Q3 starts in July
-                             end
-        
-        # If the last quarter is in the previous year, decrement the year
-        last_quarter_year = today.year
-        last_quarter_year -= 1 if current_month <= 3
-        
-        Date.new(last_quarter_year, last_quarter_month, 1)
-      elsif date_value == :this_weekend
-        # Calculate days until Saturday
-        days_until_saturday = (6 - Date.today.wday) % 7
-        # If today is Saturday or Sunday, we're already on the weekend
-        days_until_saturday = 0 if days_until_saturday == 0 || days_until_saturday == 6
-        Date.today + days_until_saturday
-      elsif date_value == :end_of_week
-        # Calculate days until Sunday (end of week)
-        days_until_sunday = (0 - Date.today.wday) % 7
-        # If today is Sunday, we're already at the end of the week
-        days_until_sunday = 0 if days_until_sunday == 0
-        Date.today + days_until_sunday
-      elsif date_value == :end_of_month
-        # Return the last day of the current month
-        # Get the first day of next month
-        next_month = Date.today >> 1
-        first_day_next_month = Date.new(next_month.year, next_month.month, 1)
-        # Subtract one day to get the last day of current month
-        first_day_next_month - 1
-      elsif date_value == :end_of_year
-        # Return the last day of the current year (December 31)
-        Date.new(Date.today.year, 12, 31)
-      elsif date_value == :mid_week
-        # Return Wednesday of the current week
-        # Calculate days until/since Wednesday (3)
-        today_wday = Date.today.wday
-        target_wday = 3 # Wednesday
-        days_diff = (target_wday - today_wday) % 7
-        # If the difference is more than 3, then Wednesday has passed this week
-        # So we need to go back to Wednesday
-        days_diff = days_diff - 7 if days_diff > 3
-        Date.today + days_diff
-      elsif date_value == :mid_month
-        # Return the 15th day of the current month
-        Date.new(Date.today.year, Date.today.month, 15)
+    # Parse a date with result details from text
+    # @param text [String] the text to parse
+    # @return [Hizuke::Result] the parsing result with clean text and date
+    def parse_with_result(text)
+      raise ParseError, 'Cannot parse nil input' if text.nil?
+      raise ParseError, 'Cannot parse empty input' if text.empty?
+
+      # First we'll try to find a date
+      result = try_parsing_strategies(text)
+
+      if result
+        # If we found a date, extract time references
+        time, clean_text = extract_time_references(result.clean_text)
+        Result.new(clean_text, result.date, time)
+      else
+        # If we didn't find a date, extract only time references
+        time, clean_text = extract_time_references(text)
+        Result.new(clean_text, nil, time)
       end
     end
   end
-end 
+end