hizuke 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21dc88226bf08c961ed63958ab1dc38ca4a9c324ed2259fbfcd5cda208a43247
-  data.tar.gz: 9bb2da3217a6b090b0036e4804d4860d156dd6d996aeff8d1b2705f43c146eda
+  metadata.gz: 6a44032e09036e25847a067394cf50b60f47197e5fe4d29b068c0e822960db9d
+  data.tar.gz: 8f6a2d515fe0b1b64e970ef5ced8aad5aaa96febfd6c44448dc765d78521a709
 SHA512:
-  metadata.gz: 5c8dc6d727568a43564b707858469fa75639fc93b75c49fc299f0de6a08ac88ce316a3aa27e7efbf3d35d7a26e795ba3881a9d3472628749a75b1e4213cde239
-  data.tar.gz: 46bb31b32c3e40b54973757b5e954dbd91841fc7cc09febf50d3f704e6cb312dca3e0f472ae91e2cd876fcdba7aa510fb83a8c5d813e9a524532a1dc2b6049f5
+  metadata.gz: be87cac6f8fdf4ca69ca42641ad214804787a498b019d80b80b263835ce5fed52215af0d1f6e04e30e12889c710cb56db7df19a2c20c056c4969c97cfddbbd90
+  data.tar.gz: 8e36da5a76ea3f9940b3970bab64a6dd2fa33a050caf02d9dd743e2052773ea4f28678f142dc82ce4b16dd436d0396b07afcb8bf961f9168e5d9d8fed2c733e6

data/CHANGELOG.md

@@ -5,7 +5,29 @@ 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
+## [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:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hizuke (0.0.2)
+    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:
@@ -100,6 +166,26 @@ Currently, the following English date keywords are supported:
 - `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
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -108,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,17 +1,71 @@
 # 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
@@ -80,6 +134,15 @@ module Hizuke
     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.
     #
@@ -99,20 +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(text)
-      return result if result
+      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(text)
-      return result if result
+      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
@@ -128,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
@@ -152,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
@@ -161,9 +266,9 @@ 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

data/lib/hizuke/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hizuke
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Juraj Maťaše
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-24 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