hizuke 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d343b5de1fbff044ba0cb10fdd1d9b23d5bd478abd7188583993e43f09e9ea1
-  data.tar.gz: d9a3b6746cf3da6dc60837a4e831bf2de0f510c69f62b8a11708293ff614d596
+  metadata.gz: 21dc88226bf08c961ed63958ab1dc38ca4a9c324ed2259fbfcd5cda208a43247
+  data.tar.gz: 9bb2da3217a6b090b0036e4804d4860d156dd6d996aeff8d1b2705f43c146eda
 SHA512:
-  metadata.gz: 77caa4db90322b19a37da5e82b875b88a00656675e17746962f4f305ca4365c7990855bbdd1241abfe5419efdd66da01f0a06caeaf5821514c07e9eaea54d0bf
-  data.tar.gz: d10748679690b857877d2bbcc33168499ee2f2459d37f7662b04b98570d266f09254bf96989fdb80b61aaf4a217a11517e57c79cb0623cde364b7b3699890b05
+  metadata.gz: 5c8dc6d727568a43564b707858469fa75639fc93b75c49fc299f0de6a08ac88ce316a3aa27e7efbf3d35d7a26e795ba3881a9d3472628749a75b1e4213cde239
+  data.tar.gz: 46bb31b32c3e40b54973757b5e954dbd91841fc7cc09febf50d3f704e6cb312dca3e0f472ae91e2cd876fcdba7aa510fb83a8c5d813e9a524532a1dc2b6049f5

data/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.3] - 2023-05-09
+
+### Added
+- Support for quarterly date references:
+  - "next quarter" / "nextquarter" - returns the first day of the next quarter
+  - "last quarter" / "lastquarter" - returns the first day of the last quarter
+- Support for relative day references:
+  - "day after tomorrow" / "dayaftertomorrow"
+  - "day before yesterday" / "daybeforeyesterday"
+- Support for dynamic time spans:
+  - "in X days", "X days ago"
+  - "in X weeks", "X weeks ago"
+  - "in X months", "X months ago"
+  - "in X years", "X years ago"
+- Support for specific days of the week:
+  - "this Monday", "this Tuesday", etc.
+  - "next Monday", "next Tuesday", etc.
+  - "last Monday", "last Tuesday", etc.
+- Support for additional time references:
+  - "last week" / "lastweek"
+  - "last month" / "lastmonth"
+  - "last year" / "lastyear"
+  - "end of week" / "endofweek"
+  - "end of month" / "endofmonth" 
+  - "end of year" / "endofyear"
+  - "mid week" / "midweek"
+  - "mid month" / "midmonth"
+- Updated documentation to reflect all new functionality
+
+## [0.0.2] - 2025-04-23
+
+### Added
+- Support for additional date keywords:
+  - "next week" / "nextweek"
+  - "next month" / "nextmonth"
+  - "next year" / "nextyear"
+  - "this weekend" / "thisweekend"
+- Enhanced parsing to support compound date expressions with spaces
+
 ## [0.0.1] - 2025-04-12
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hizuke (0.0.1)
+    hizuke (0.0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -41,9 +41,29 @@ puts result.date  # => <Date: 2023-03-31> (represents today's date)
 result = Hizuke.parse("call mom yesterday")
 puts result.text  # => "call mom"
 puts result.date  # => <Date: 2023-03-30> (represents yesterday's date)
+
+# Parse text with next week's date
+result = Hizuke.parse("team meeting next week")
+puts result.text  # => "team meeting"
+puts result.date  # => <Date: 2023-04-04> (represents the next Monday)
+
+# Parse text with next month's date
+result = Hizuke.parse("vacation next month")
+puts result.text  # => "vacation"
+puts result.date  # => <Date: 2023-05-01> (represents the first day of the next month)
+
+# Parse text with next year's date
+result = Hizuke.parse("conference next year")
+puts result.text  # => "conference"
+puts result.date  # => <Date: 2024-01-01> (represents the first day of the next year)
+
+# Parse text with this weekend's date
+result = Hizuke.parse("hiking this weekend")
+puts result.text  # => "hiking"
+puts result.date  # => <Date: 2023-04-01> (represents the next Saturday)
 ```
 
-The parser is case-insensitive and can handle date references located anywhere in the text.
+The parser is case-insensitive and can handle date references located anywhere in the text. It also supports date references with or without spaces (e.g., "nextweek" or "next week").
 
 ## Supported Date Keywords
 
@@ -52,6 +72,33 @@ Currently, the following English date keywords are supported:
 - `yesterday` - returns yesterday's date
 - `today` - returns today's date
 - `tomorrow` - returns tomorrow's date
+- `day after tomorrow` / `dayaftertomorrow` - returns the date two days from today
+- `day before yesterday` / `daybeforeyesterday` - returns the date two days before today
+- `in X days` - returns the date X days from today (where X is any number)
+- `X days ago` - returns the date X days before today (where X is any number)
+- `in X weeks` - returns the date X weeks from today (where X is any number)
+- `X weeks ago` - returns the date X weeks before today (where X is any number)
+- `in X months` - returns the date X months from today (where X is any number)
+- `X months ago` - returns the date X months before today (where X is any number)
+- `in X years` - returns the date X years from today (where X is any number)
+- `X years ago` - returns the date X years before today (where X is any number)
+- `this Monday`, `this Tuesday`, etc. - returns the date of the specified day in the current week
+- `next Monday`, `next Tuesday`, etc. - returns the date of the specified day in the next week
+- `last Monday`, `last Tuesday`, etc. - returns the date of the specified day in the previous week
+- `next week` / `nextweek` - returns the date of the next Monday
+- `last week` / `lastweek` - returns the date of the previous Monday
+- `next month` / `nextmonth` - returns the first day of the next month
+- `last month` / `lastmonth` - returns the first day of the previous month
+- `next year` / `nextyear` - returns the first day of the next year
+- `last year` / `lastyear` - returns the first day of the previous year
+- `this weekend` / `thisweekend` - returns the date of the upcoming Saturday (or today if it's already the weekend)
+- `end of week` / `endofweek` - returns the date of the upcoming Sunday (end of week)
+- `end of month` / `endofmonth` - returns the date of the last day of the current month
+- `end of year` / `endofyear` - returns the date of December 31st of the current year
+- `mid week` / `midweek` - returns the date of Wednesday of the current week
+- `mid month` / `midmonth` - returns the date of the 15th day of the current month
+- `next quarter` / `nextquarter` - returns the first day of the next quarter
+- `last quarter` / `lastquarter` - returns the first day of the last quarter
 
 ## Development
 

data/lib/hizuke/parser.rb

@@ -15,13 +15,71 @@ module Hizuke
 
   # 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
+      "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.
     #
@@ -41,18 +99,54 @@ module Hizuke
       # Check if text is nil or empty
       raise ParseError, "Input text cannot be nil or empty" if text.nil? || text.empty?
 
-      # Split the text into words
+      # 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_offset = 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_offset = DATE_KEYWORDS[clean_word]
+          date_value = DATE_KEYWORDS[clean_word]
           break
         end
       end
@@ -62,7 +156,7 @@ module Hizuke
       end
 
       # Calculate the date based on the keyword
-      date = Date.today + date_offset
+      date = calculate_date(date_value)
 
       # Create the clean text by removing the date keyword
       clean_words = words.dup
@@ -71,5 +165,273 @@ module Hizuke
 
       Result.new(clean_text, date)
     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
+
+      nil
+    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
+
+      # 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
+
+      # 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
+
+      # 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
+
+      nil
+    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
+    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
+
+    # 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
+    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)
+      end
+    end
   end
 end 

data/lib/hizuke/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hizuke
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Juraj Maťaše
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-11 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,8 +52,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.21'
-description: Parse dates from text containing keywords like 'yesterday', 'today',
-  and 'tomorrow'
+description: Hizuke is a lightweight utility that extracts dates from text by recognizing
+  common time expressions. It cleans the original text and returns both the parsed
+  date and the text without the date reference.
 email:
 - juraj@hey.com
 executables: []
@@ -94,5 +95,5 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: A simple date parser for text containing time references
+summary: A simple date parser for natural language time references
 test_files: []