hizuke 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 064d7574f7151fdf7695b789dd4812f38c6becb6226b7bda807d0339dc0fc8e1
-  data.tar.gz: 48c23cc779ae564bc3625176f7af74ebb2c0b33a7f4f67cea5098851c35de2e0
+  metadata.gz: 6a44032e09036e25847a067394cf50b60f47197e5fe4d29b068c0e822960db9d
+  data.tar.gz: 8f6a2d515fe0b1b64e970ef5ced8aad5aaa96febfd6c44448dc765d78521a709
 SHA512:
-  metadata.gz: 22380b935099c93601a9ac54837e4378935037d653e5ee557c1fc7cdd31098245fbb3bc4c3e5c6623c431fdb9f54138fb3445dbe18e9197721caf6d082c25e16
-  data.tar.gz: e00e4fe32d48188761db0f070d55bddf9bd31915f2a4336c2846704aaf4286f1b1e7c132070029a39afa558a264b1badc1734934c47f9d059334a9f06d809416
+  metadata.gz: be87cac6f8fdf4ca69ca42641ad214804787a498b019d80b80b263835ce5fed52215af0d1f6e04e30e12889c710cb56db7df19a2c20c056c4969c97cfddbbd90
+  data.tar.gz: 8e36da5a76ea3f9940b3970bab64a6dd2fa33a050caf02d9dd743e2052773ea4f28678f142dc82ce4b16dd436d0396b07afcb8bf961f9168e5d9d8fed2c733e6

data/CHANGELOG.md

@@ -5,6 +5,57 @@ 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.4] - 2025-04-29
+
+### Added
+- Support for time recognition in text:
+  - "at X" format (e.g., "at 10" for 10:00)
+  - "@ X" alternative syntax
+  - Time with minutes "at X:Y" (e.g., "at 10:30")
+  - Time with seconds "at X:Y:Z" (e.g., "at 10:30:45")
+  - AM/PM format "at Xam/pm" (e.g., "at 10am", "at 7pm")
+- New attributes in Result class:
+  - `time` attribute to access the extracted time
+  - `datetime` method to get a combined Time object of date and time
+- Created a dedicated `TimeOfDay` class for better time handling with cleaner display
+- Support for word-based time expressions:
+  - "at noon" - returns 12:00
+  - "at midnight" - returns 00:00
+  - "in the morning" - returns configurable time (default 08:00)
+  - "in the evening" - returns configurable time (default 20:00)
+- Configuration system to customize times for "morning" and "evening"
+- Comprehensive tests for time parsing functionality
+- Updated documentation with time parsing examples and supported formats
+
+## [0.0.3] - 2025-04-24
+
+### 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

data/Gemfile.lock

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

data/README.md

@@ -1,6 +1,6 @@
 # Hizuke
 
-Hizuke is a simple Ruby gem that parses text containing date references like "yesterday", "today", and "tomorrow". It extracts the date and returns the clean text without the date reference.
+Hizuke is a simple Ruby gem that parses text containing date references like "yesterday", "today", and "tomorrow". It extracts the date and returns the clean text without the date reference. It can also recognize time references like "at 10" or "at 7pm".
 
 ## Installation
 
@@ -61,10 +61,76 @@ puts result.date  # => <Date: 2024-01-01> (represents the first day of the next
 result = Hizuke.parse("hiking this weekend")
 puts result.text  # => "hiking"
 puts result.date  # => <Date: 2023-04-01> (represents the next Saturday)
+
+# Parse text with time
+result = Hizuke.parse("meeting tomorrow at 10")
+puts result.text  # => "meeting"
+puts result.date  # => <Date: 2023-04-01> (represents tomorrow's date)
+puts result.time  # => 10:00 (represents the time)
+puts result.datetime  # => 2023-04-01 10:00:00 (combines date and time)
+
+# Parse text with time including minutes
+result = Hizuke.parse("call client today at 14:30")
+puts result.text  # => "call client"
+puts result.date  # => <Date: 2023-03-31> (represents today's date)
+puts result.time  # => 14:30 (represents the time)
+puts result.datetime  # => 2023-03-31 14:30:00 (combines date and time)
+
+# Parse text with AM/PM time
+result = Hizuke.parse("lunch meeting tomorrow at 12pm")
+puts result.text  # => "lunch meeting"
+puts result.date  # => <Date: 2023-04-01> (represents tomorrow's date)
+puts result.time  # => 12:00 (represents the time, noon)
+puts result.datetime  # => 2023-04-01 12:00:00 (combines date and time)
+
+# Parse text with word-based time
+result = Hizuke.parse("dinner tomorrow at noon")
+puts result.text  # => "dinner"
+puts result.date  # => <Date: 2023-04-01> (represents tomorrow's date)
+puts result.time  # => 12:00 (represents noon)
+
+result = Hizuke.parse("flight today at midnight")
+puts result.text  # => "flight"
+puts result.date  # => <Date: 2023-03-31> (represents today's date)
+puts result.time  # => 00:00 (represents midnight)
+
+result = Hizuke.parse("breakfast tomorrow in the morning")
+puts result.text  # => "breakfast"
+puts result.date  # => <Date: 2023-04-01> (represents tomorrow's date)
+puts result.time  # => 08:00 (default morning time)
+
+result = Hizuke.parse("dinner today in the evening")
+puts result.text  # => "dinner"
+puts result.date  # => <Date: 2023-03-31> (represents today's date)
+puts result.time  # => 20:00 (default evening time)
 ```
 
 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").
 
+## Configuration
+
+You can configure the time values for "in the morning" and "in the evening" expressions:
+
+```ruby
+Hizuke.configure do |config|
+  # Set morning time to 9:30
+  config.morning_time = { hour: 9, min: 30 }
+  
+  # Set evening time to 7:00 PM
+  config.evening_time = { hour: 19, min: 0 }
+end
+
+# Now when parsing "in the morning", it will return 9:30
+result = Hizuke.parse("breakfast tomorrow in the morning")
+puts result.time  # => 09:30
+
+# And "in the evening" will return 19:00
+result = Hizuke.parse("dinner today in the evening")
+puts result.time  # => 19:00
+```
+
+By default, "in the morning" is set to 8:00 and "in the evening" is set to 20:00.
+
 ## Supported Date Keywords
 
 Currently, the following English date keywords are supported:
@@ -72,10 +138,53 @@ 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
+
+## Supported Time Formats
+
+The following time formats are supported:
+
+### Numeric time formats
+- `at X` - where X is a number (e.g., "at 10" for 10:00)
+- `@ X` - alternative syntax with @ symbol
+- `at X:Y` - where X is hours and Y is minutes (e.g., "at 10:30")
+- `at X:Y:Z` - where X is hours, Y is minutes, and Z is seconds
+- `at Xam/pm` - with AM/PM indicator (e.g., "at 10am", "at 7pm")
+- `at X:Yam/pm` - with minutes and AM/PM indicator (e.g., "at 10:30am")
+
+### Word-based time formats
+- `at noon` - returns 12:00
+- `at midnight` - returns 00:00
+- `in the morning` - returns configurable time (default 08:00)
+- `in the evening` - returns configurable time (default 20:00)
+
+When time is included, you can access it through the `time` attribute of the result. The time is displayed in the format "HH:MM" or "HH:MM:SS" if seconds are present. Additionally, you can use the `datetime` attribute to get a Time object combining both the date and time information.
 
 ## Development
 
@@ -85,7 +194,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/hizuke.
+Bug reports and pull requests are welcome on GitHub at https://github.com/majur/hizuke.
 
 ## License
 

data/hizuke.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/hizuke/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "hizuke"
+  spec.version = Hizuke::VERSION
+  spec.authors = ["Juraj Maťaše"]
+  spec.email = ["juraj@hey.com"]
+
+  spec.summary = "A simple date parser for natural language time references"
+  spec.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."
+  spec.homepage = "https://github.com/majur/hizuke"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Add development dependencies here
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+end 

data/lib/hizuke/parser.rb

@@ -1,35 +1,148 @@
 # frozen_string_literal: true
 
 require "date"
+require "time"
 
 module Hizuke
-  # Result object containing the clean text and extracted date
+  # Simple class to represent a time of day without a date
+  class TimeOfDay
+    attr_reader :hour, :min, :sec
+    
+    def initialize(hour, min = 0, sec = 0)
+      @hour = hour
+      @min = min
+      @sec = sec
+    end
+    
+    def to_s
+      if sec == 0
+        format("%02d:%02d", hour, min)
+      else
+        format("%02d:%02d:%02d", hour, min, sec)
+      end
+    end
+    
+    def inspect
+      to_s
+    end
+  end
+  
+  # Result object containing the clean text and extracted date/time
   class Result
-    attr_reader :text, :date
+    attr_reader :text, :date, :time
 
-    def initialize(text, date)
+    def initialize(text, date, time = nil)
       @text = text
       @date = date
+      @time = time
+    end
+
+    def datetime
+      return nil unless @time
+      
+      # Combine date and time into a Time object
+      Time.new(@date.year, @date.month, @date.day, 
+              @time.hour, @time.min, @time.sec)
+    end
+  end
+  
+  # Configuration class for Hizuke
+  class Configuration
+    attr_accessor :morning_time, :evening_time
+    
+    def initialize
+      @morning_time = { hour: 8, min: 0 }
+      @evening_time = { hour: 20, min: 0 }
     end
   end
+  
+  # Allows configuration of Hizuke
+  def self.configure
+    @configuration ||= Configuration.new
+    yield(@configuration) if block_given?
+  end
+  
+  # Returns the configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  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
+      "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
+
+    # Regex patterns for time references
+    TIME_PATTERN = /(?:at|@)\s*(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?\s*(am|pm)?/i
+    
+    # Regex patterns for word-based time references
+    NOON_PATTERN = /at\s+noon/i
+    MIDNIGHT_PATTERN = /at\s+midnight/i
+    MORNING_PATTERN = /in\s+the\s+morning/i
+    EVENING_PATTERN = /in\s+the\s+evening/i
+    
     # Parse text containing time references and extract both
     # the clean text and the date.
     #
@@ -49,12 +162,62 @@ module Hizuke
       # Check if text is nil or empty
       raise ParseError, "Input text cannot be nil or empty" if text.nil? || text.empty?
 
+      # Extract time if present
+      extracted_time = nil
+      clean_text = text
+
+      # Try to match word-based time patterns first
+      if match = clean_text.match(NOON_PATTERN)
+        extracted_time = TimeOfDay.new(12, 0, 0)
+        clean_text = clean_text.gsub(match[0], "").strip
+      elsif match = clean_text.match(MIDNIGHT_PATTERN)
+        extracted_time = TimeOfDay.new(0, 0, 0)
+        clean_text = clean_text.gsub(match[0], "").strip
+      elsif match = clean_text.match(MORNING_PATTERN)
+        config = Hizuke.configuration
+        extracted_time = TimeOfDay.new(config.morning_time[:hour], config.morning_time[:min], 0)
+        clean_text = clean_text.gsub(match[0], "").strip
+      elsif match = clean_text.match(EVENING_PATTERN)
+        config = Hizuke.configuration
+        extracted_time = TimeOfDay.new(config.evening_time[:hour], config.evening_time[:min], 0)
+        clean_text = clean_text.gsub(match[0], "").strip
+      # Then try the numeric time pattern
+      elsif time_match = clean_text.match(TIME_PATTERN)
+        hour = time_match[1].to_i
+        min = time_match[2] ? time_match[2].to_i : 0
+        sec = time_match[3] ? time_match[3].to_i : 0
+        
+        # Adjust for AM/PM
+        if time_match[4]&.downcase == "pm" && hour < 12
+          hour += 12
+        elsif time_match[4]&.downcase == "am" && hour == 12
+          hour = 0
+        end
+        
+        extracted_time = TimeOfDay.new(hour, min, sec)
+        
+        # Remove the time expression from the text
+        clean_text = clean_text.gsub(time_match[0], "").strip
+      end
+
+      # Check for dynamic patterns first (in X days, X days ago)
+      result = check_dynamic_patterns(clean_text)
+      if result
+        return Result.new(result.text, result.date, extracted_time)
+      end
+
+      # Check for day of week patterns (this Monday, next Tuesday, etc.)
+      result = check_day_of_week_patterns(clean_text)
+      if result
+        return Result.new(result.text, result.date, extracted_time)
+      end
+
       # 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)
+        if clean_text.downcase.include?(compound_key)
+          start_idx = clean_text.downcase.index(compound_key)
           end_idx = start_idx + compound_key.length - 1
           compound_matches[compound_key] = [start_idx, end_idx]
         end
@@ -70,15 +233,15 @@ module Hizuke
         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
+        final_text = clean_text.dup
+        final_text.slice!(indices[0]..indices[1])
+        final_text = final_text.strip
         
-        return Result.new(clean_text, date)
+        return Result.new(final_text, date, extracted_time)
       end
 
       # Split the text into words (for single-word date references)
-      words = text.split
+      words = clean_text.split
 
       # Find the first date keyword
       date_word_index = nil
@@ -94,7 +257,7 @@ module Hizuke
       end
 
       if date_word_index.nil?
-        raise ParseError, "No valid date reference found in '#{text}'"
+        raise ParseError, "No valid date reference found in '#{clean_text}'"
       end
 
       # Calculate the date based on the keyword
@@ -103,13 +266,165 @@ module Hizuke
       # 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
+      final_text = clean_words.join(" ").strip
 
-      Result.new(clean_text, date)
+      Result.new(final_text, date, extracted_time)
     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)
@@ -120,20 +435,107 @@ module Hizuke
         # 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

data/lib/hizuke/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hizuke
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Juraj Maťaše
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -67,6 +67,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- hizuke.gemspec
 - lib/hizuke.rb
 - lib/hizuke/parser.rb
 - lib/hizuke/version.rb