english-to-cron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8dd87f218cf1f44ff1b8c48fa06dd08735742231ec60b46cde398642151489e
+  data.tar.gz: 0e2be7f5fcd12eb57313c98b7dc6aaa1124b096e9c7fe64ff6796bd28efaa521
+SHA512:
+  metadata.gz: 74ee1e670e395566e373fcc319b95af53d7d1a6921d3653ed59084dbe671faada7104708319a0d439329f90c600b1ad9182d68cece6c87d4d9b5efa78871a807
+  data.tar.gz: f1327e5943f8ae87f71ada74d2d799a2092d6fcfa02ccccb307be1d50f6d9e0669aeadf52a74f0e3e92a5e821156131fe7be26a81baa6b8f7b3fcb2fbb2b6140

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2025-04-06
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Vlad Dyachenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# English to CronJob Syntax Converter 
+
+
+
+ `english-to-cron` converts natural language into cron expressions, allowing developers to easily schedule cron jobs using English text.
+
+## Features
+
+- Converts various English text descriptions into cron job syntax
+- Supports complex patterns including specific days, time ranges, and more
+- Handles multiple time formats including AM/PM and 24-hour notation
+- Zero dependencies
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'english-to-cron'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install english-to-cron
+```
+
+## Usage
+
+Simply provide an English phrase describing the schedule, and the library will return the corresponding cron job syntax.
+
+```ruby
+require 'english_to_cron'
+
+# Basic usage
+EnglishToCron.parse("every 15 seconds")        # => "0/15 * * * * ? *"
+EnglishToCron.parse("every minute")            # => "0 * * * * ? *"
+EnglishToCron.parse("every day at 4:00 pm")    # => "0 0 16 */1 * ? *" 
+EnglishToCron.parse("at 10:00 am")             # => "0 0 10 * * ? *"
+EnglishToCron.parse("Run at midnight on the 1st and 15th of the month") # => "0 0 0 1,15 * ? *"
+EnglishToCron.parse("on Sunday at 12:00")      # => "0 0 12 ? * SUN *"
+```
+
+## Full List of Supported English Patterns
+
+| English Phrase | CronJob Syntax |
+|------------------------------------------------------------------	|---------------------------- |
+| every 15 seconds | 0/15 * * * * ? * |
+| run every minute | 0 * * * * ? * |
+| fire every day at 4:00 pm | 0 0 16 */1 * ? * |
+| at 10:00 am | 0 0 10 * * ? * |
+| run at midnight on the 1st and 15th of the month | 0 0 0 1,15 * ? * |
+| On Sunday at 12:00 | 0 0 12 ? * SUN * |
+| 7pm every Thursday | 0 0 19 ? * THU * |
+| midnight on Tuesdays | 0 0 0 ? * TUE * |
+
+## Error Handling
+
+The library will raise errors for invalid or unparseable inputs:
+
+```ruby
+begin
+  EnglishToCron.parse("invalid input")
+rescue EnglishToCron::Error => e
+  puts "Error: #{e.message}"
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub. This project is intended to be a safe, welcoming space for collaboration.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/english_to_cron/actions.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require_relative "stack"
+
+module EnglishToCron
+  module Actions
+    module Kind
+      FREQUENCY_WITH = :frequency_with
+      FREQUENCY_ONLY = :frequency_only
+      CLOCK_TIME = :clock_time
+      DAY = :day
+      SECOND = :second
+      MINUTE = :minute
+      HOUR = :hour
+      MONTH = :month
+      YEAR = :year
+      RANGE_START = :range_start
+      RANGE_END = :range_end
+      DAY_OF_MONTH = :day_of_month
+
+      ALL = [
+        FREQUENCY_WITH,
+        FREQUENCY_ONLY,
+        CLOCK_TIME,
+        DAY,
+        SECOND,
+        MINUTE,
+        HOUR,
+        MONTH,
+        YEAR,
+        RANGE_START,
+        RANGE_END,
+        DAY_OF_MONTH
+      ].freeze
+    end
+
+    def self.try_from_token(token)
+      Kind::ALL.each do |kind|
+        is_match = case kind
+                   when Kind::FREQUENCY_WITH then frequency_with_match?(token)
+                   when Kind::FREQUENCY_ONLY then frequency_only_match?(token)
+                   when Kind::CLOCK_TIME then clock_time_match?(token)
+                   when Kind::DAY then day_match?(token)
+                   when Kind::SECOND then second_match?(token)
+                   when Kind::MINUTE then minute_match?(token)
+                   when Kind::HOUR then hour_match?(token)
+                   when Kind::MONTH then month_match?(token)
+                   when Kind::YEAR then year_match?(token)
+                   when Kind::RANGE_START then range_start_match?(token)
+                   when Kind::RANGE_END then range_end_match?(token)
+                   when Kind::DAY_OF_MONTH then day_of_month_match?(token)
+                   end
+        return kind if is_match
+      end
+      nil
+    end
+
+    def self.process(kind, token, cron)
+      case kind
+      when Kind::FREQUENCY_WITH then process_frequency_with(token, cron)
+      when Kind::FREQUENCY_ONLY
+        frequency = parse_number(token, "frequency_only")
+        process_frequency_only(frequency, cron)
+      when Kind::CLOCK_TIME then process_clock_time(token, cron)
+      when Kind::DAY then process_day(token, cron)
+      when Kind::SECOND then process_second(token, cron)
+      when Kind::MINUTE then process_minute(token, cron)
+      when Kind::HOUR then process_hour(token, cron)
+      when Kind::MONTH then process_month(token, cron)
+      when Kind::YEAR then process_year(token, cron)
+      when Kind::RANGE_START then process_range_start(cron)
+      when Kind::RANGE_END then process_range_end(cron)
+      when Kind::DAY_OF_MONTH then process_day_of_month(token, cron)
+      end
+    end
+
+    # Token matching methods
+    def self.frequency_with_match?(token)
+      token.match?(/\b(?:every|each)\b/i)
+    end
+
+    def self.frequency_only_match?(token)
+      token.match?(/\A\d+\z/)
+    end
+
+    def self.clock_time_match?(token)
+      token.match?(/(\d+:\d+|\d+(?:am|pm)|noon|midnight)/i)
+    end
+
+    def self.day_match?(token)
+      days = %w[monday tuesday wednesday thursday friday saturday sunday mon tue wed thu fri sat sun weekend]
+      token.match?(/\b(?:#{days.join('|')}|days?)\b/i)
+    end
+    
+    def self.day_of_month_match?(token)
+      token.match?(/\b\d+(?:st|nd|rd|th)\b/i)
+    end
+
+    def self.second_match?(token)
+      token.match?(/\b(?:seconds?|secs?)\b/i)
+    end
+
+    def self.minute_match?(token)
+      token.match?(/\b(?:minutes?|mins?|min)\b/i)
+    end
+
+    def self.hour_match?(token)
+      token.match?(/\b(?:hours?|hrs?)\b/i)
+    end
+
+    def self.month_match?(token)
+      months = %w[january february march april may june july august september october november december jan feb mar apr may jun jul aug sep sept oct nov dec]
+      token.match?(/\b(?:#{months.join('|')}|months?)\b/i)
+    end
+
+    def self.year_match?(token)
+      token.match?(/\d{4}/)
+    end
+
+    def self.range_start_match?(token)
+      token.match?(/\b(?:between|starting|start)\b/i)
+    end
+
+    def self.range_end_match?(token)
+      token.match?(/\b(?:to|through|ending|end|and)\b/i)
+    end
+
+    # Processing methods
+    def self.parse_number(token, state)
+      Integer(token)
+    rescue ArgumentError
+      raise Error::ParseToNumber.new(state, token)
+    end
+
+    # Helper method to extract day number
+    def self.extract_day_number(token)
+      if token.match?(/\b(\d+)(?:st|nd|rd|th)\b/i)
+        token.match(/\b(\d+)(?:st|nd|rd|th)\b/i)[1].to_i
+      else
+        nil
+      end
+    end
+
+    # Implement process methods for each action type
+    def self.process_frequency_with(token, cron)
+      # Mark the current stack position for frequency handling
+      cron.stack << Stack.builder(Kind::FREQUENCY_WITH).build
+      true
+    end
+
+    def self.process_frequency_only(frequency, cron)
+      # Find the last FREQUENCY_WITH stack or add directly if none
+      frequency_with_stack = cron.stack.find { |s| s.owner == Kind::FREQUENCY_WITH }
+      
+      if frequency_with_stack
+        frequency_with_stack.frequency = frequency
+      else
+        # Stack for frequency
+        stack = Stack.builder(Kind::FREQUENCY_ONLY)
+          .frequency(frequency)
+          .build
+        
+        cron.stack << stack
+      end
+    end
+
+    def self.process_clock_time(token, cron)
+      min = 0
+      hour = 0
+
+      # Process special times like noon and midnight
+      if token.match?(/noon/i)
+        hour = 12
+      elsif token.match?(/midnight/i)
+        hour = 0
+      else
+        # Process normal clock times
+        if token.match?(/(am|pm)/i)
+          parts = token.gsub(/[^0-9:]/, '').split(':')
+          if parts.length == 1
+            hour = parts[0].to_i
+            hour = 0 if hour == 12
+            hour += 12 if token.match?(/pm/i) && hour != 12
+          elsif parts.length == 2
+            hour = parts[0].to_i
+            min = parts[1].to_i
+            hour = 0 if hour == 12 && token.match?(/am/i)
+            hour += 12 if token.match?(/pm/i) && hour != 12
+          end
+        else # 24-hour format
+          parts = token.split(':')
+          if parts.length == 2
+            hour = parts[0].to_i
+            min = parts[1].to_i
+          end
+        end
+      end
+
+      # Create a stack item for clock time
+      min_range = StartEnd.new(min)
+      hour_range = StartEnd.new(hour)
+      
+      stack = Stack.builder(Kind::CLOCK_TIME)
+        .min(min_range)
+        .hour(hour_range)
+        .build
+      
+      cron.stack << stack
+      true
+    end
+
+    def self.process_day(token, cron)
+      day_map = {
+        'sunday' => 'SUN', 'sun' => 'SUN',
+        'monday' => 'MON', 'mon' => 'MON',
+        'tuesday' => 'TUE', 'tue' => 'TUE',
+        'wednesday' => 'WED', 'wed' => 'WED',
+        'thursday' => 'THU', 'thu' => 'THU',
+        'friday' => 'FRI', 'fri' => 'FRI',
+        'saturday' => 'SAT', 'sat' => 'SAT',
+        'weekend' => 'SUN,SAT'
+      }
+      
+      day_of_week = nil
+      
+      day_map.each do |key, value|
+        if token.match?(/\b#{key}\b/i)
+          day_of_week = value
+          break
+        end
+      end
+      
+      if day_of_week
+        stack = Stack.builder(Kind::DAY)
+          .day_of_week(day_of_week)
+          .build
+        
+        cron.stack << stack
+      end
+      
+      true
+    end
+    
+    def self.process_day_of_month(token, cron)
+      day_num = extract_day_number(token)
+      
+      if day_num
+        day_string = StartEndString.new(day_num.to_s)
+        
+        stack = Stack.builder(Kind::DAY_OF_MONTH)
+          .day(day_string)
+          .build
+        
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_second(token, cron)
+      # Look for a frequency in the last stack item
+      frequency_stack = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_WITH && s.frequency }
+      last_frequency = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_ONLY }
+      
+      if frequency_stack && frequency_stack.frequency
+        stack = Stack.builder(Kind::SECOND)
+          .frequency(frequency_stack.frequency)
+          .build
+        
+        cron.stack << stack
+      elsif last_frequency && last_frequency.frequency
+        stack = Stack.builder(Kind::SECOND)
+          .frequency(last_frequency.frequency)
+          .build
+        
+        cron.stack << stack
+      else
+        stack = Stack.builder(Kind::SECOND).build
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_minute(token, cron)
+      # Look for a frequency in the last stack item
+      frequency_stack = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_WITH && s.frequency }
+      last_frequency = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_ONLY }
+      
+      if frequency_stack && frequency_stack.frequency
+        stack = Stack.builder(Kind::MINUTE)
+          .frequency(frequency_stack.frequency)
+          .build
+        
+        cron.stack << stack
+      elsif last_frequency && last_frequency.frequency
+        stack = Stack.builder(Kind::MINUTE)
+          .frequency(last_frequency.frequency)
+          .build
+        
+        cron.stack << stack
+      else
+        stack = Stack.builder(Kind::MINUTE).build
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_hour(token, cron)
+      # Look for a frequency in the last stack item
+      frequency_stack = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_WITH && s.frequency }
+      last_frequency = cron.stack.reverse.find { |s| s.owner == Kind::FREQUENCY_ONLY }
+      
+      if frequency_stack && frequency_stack.frequency
+        stack = Stack.builder(Kind::HOUR)
+          .frequency(frequency_stack.frequency)
+          .build
+        
+        cron.stack << stack
+      elsif last_frequency && last_frequency.frequency
+        stack = Stack.builder(Kind::HOUR)
+          .frequency(last_frequency.frequency)
+          .build
+        
+        cron.stack << stack
+      else
+        stack = Stack.builder(Kind::HOUR).build
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_month(token, cron)
+      month_map = {
+        'january' => '1', 'jan' => '1',
+        'february' => '2', 'feb' => '2',
+        'march' => '3', 'mar' => '3',
+        'april' => '4', 'apr' => '4',
+        'may' => '5',
+        'june' => '6', 'jun' => '6',
+        'july' => '7', 'jul' => '7',
+        'august' => '8', 'aug' => '8',
+        'september' => '9', 'sep' => '9', 'sept' => '9',
+        'october' => '10', 'oct' => '10',
+        'november' => '11', 'nov' => '11',
+        'december' => '12', 'dec' => '12'
+      }
+      
+      month_value = nil
+      
+      month_map.each do |key, value|
+        if token.match?(/\b#{key}\b/i)
+          month_value = value
+          break
+        end
+      end
+      
+      if month_value
+        month_range = StartEndString.new(month_value)
+        stack = Stack.builder(Kind::MONTH)
+          .month(month_range)
+          .build
+        
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_year(token, cron)
+      # We assume the token contains a year like "2024"
+      year = token.match(/(\d{4})/)&.[](1)&.to_i
+      
+      if year
+        year_range = StartEnd.new(year)
+        stack = Stack.builder(Kind::YEAR)
+          .frequency(year)
+          .build
+        
+        cron.stack << stack
+      end
+      
+      true
+    end
+
+    def self.process_range_start(cron)
+      # Mark the current position for range processing
+      # Will be processed in process_stack
+      true
+    end
+
+    def self.process_range_end(cron)
+      # Process the range based on previous tokens
+      # Will be processed in process_stack
+      true
+    end
+  end
+end 

data/lib/english_to_cron/cron.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative "syntax"
+require_relative "tokenizer"
+require_relative "actions"
+
+module EnglishToCron
+  class Cron
+    attr_accessor :syntax, :stack, :original_text
+
+    def initialize
+      @syntax = Syntax.new
+      @stack = []
+      @original_text = nil
+    end
+
+    def self.parse(text)
+      if text.nil? || text.to_s.strip.empty?
+        raise Error::InvalidInput
+      end
+      
+      cron = new
+      cron.original_text = text.to_s.downcase
+      
+      tokenizer = Tokenizer.new
+      tokens = tokenizer.run(text)
+      
+      if tokens.empty?
+        raise Error::InvalidInput
+      end
+      
+      tokens.each do |token|
+        if kind = Actions.try_from_token(token)
+          Actions.process(kind, token, cron)
+        end
+      end
+      
+      cron.process_stack
+      
+      cron.to_s
+    end
+    
+    def process_stack
+      detect_day_patterns
+      
+      process_seconds
+      process_minutes
+      process_hours
+      process_day_of_month
+      process_months
+      # process_day_of_week
+      process_years
+    end
+    
+    def detect_day_patterns
+      if @original_text =~ /(every|each) day at/i
+        @syntax.day_of_month = "*/1"
+      end
+    end
+    
+    def process_seconds
+      second_items = @stack.select { |s| s.owner == Actions::Kind::SECOND }
+      if second_items.any? { |s| s.frequency }
+        # For patterns like "every 15 seconds"
+        @syntax.seconds = "0/#{second_items.first.frequency}"
+      end
+    end
+
+    def process_minutes
+      minute_items = @stack.select { |s| s.owner == Actions::Kind::MINUTE }
+      frequency_items = @stack.select { |s| s.owner == Actions::Kind::FREQUENCY_WITH }
+      
+      if has_minute_pattern? && !has_any_time_pattern?
+        # "every minute" pattern
+        @syntax.min = "*"
+      elsif minute_items.any? { |s| s.frequency }
+        # For patterns with specific minute frequencies
+        @syntax.min = "0/#{minute_items.first.frequency}"
+      elsif @stack.any? { |s| s.owner == Actions::Kind::CLOCK_TIME }
+        # Minutes are already set by clock time processing
+      elsif !@stack.any? { |s| s.owner == Actions::Kind::MINUTE }
+        # Keep default
+      end
+    end
+
+    def process_hours
+      hour_items = @stack.select { |s| s.owner == Actions::Kind::HOUR }
+      clock_items = @stack.select { |s| s.owner == Actions::Kind::CLOCK_TIME }
+      
+      if hour_items.any? { |s| s.frequency }
+        # For patterns with specific hour frequencies
+        @syntax.hour = "0/#{hour_items.first.frequency}"
+      elsif clock_items.any?
+        # For patterns with specific clock times
+        clock_item = clock_items.first
+        if clock_item.hour && clock_item.hour.start
+          @syntax.hour = clock_item.hour.start.to_s
+          # Default minutes to 0 if not specified
+          if clock_item.min && clock_item.min.start
+            @syntax.min = clock_item.min.start.to_s
+          else
+            @syntax.min = "0"
+          end
+        end
+      end
+    end
+    
+    def process_day_of_month
+      day_items = @stack.select { |s| s.owner == Actions::Kind::DAY }
+      day_of_month_items = @stack.select { |s| s.owner == Actions::Kind::DAY_OF_MONTH }
+      
+      # Process day of week first
+      if day_items.any? { |s| s.day_of_week }
+        @syntax.day_of_week = day_items.first.day_of_week
+        @syntax.day_of_month = "?"
+        return
+      end
+      
+      # Process specific days of month
+      if day_of_month_items.any?
+        day_values = day_of_month_items.map { |s| s.day.start if s.day && s.day.start }.compact
+        
+        if day_values.any?
+          # Handle multiple days like "1,15"
+          if @original_text && @original_text.match?(/1st.+15th|15th.+1st/)
+            @syntax.day_of_month = "1,15"
+          else
+            @syntax.day_of_month = day_values.join(',')
+          end
+        end
+      end
+    end
+    
+    def process_months
+      # Handle months
+      month_items = @stack.select { |s| s.owner == Actions::Kind::MONTH }
+      
+      if month_items.any? { |s| s.month && s.month.start }
+        month_values = month_items.map { |s| s.month.start if s.month }.compact
+        @syntax.month = month_values.join(',')
+      end
+    end
+    
+    def process_years
+      year_items = @stack.select { |s| s.owner == Actions::Kind::YEAR }
+      
+      if year_items.any? { |s| s.frequency }
+        @syntax.year = year_items.first.frequency.to_s
+      end
+    end
+    
+    def has_minute_pattern?
+      # Check if we have a pattern like "every minute"
+      minute_pattern = @stack.any? { |s| s.owner == Actions::Kind::MINUTE }
+      frequency_pattern = @stack.any? { |s| s.owner == Actions::Kind::FREQUENCY_WITH }
+      
+      frequency_pattern && minute_pattern
+    end
+    
+    def has_any_time_pattern?
+      # Check if there's any time specification
+      @stack.any? { |s| s.owner == Actions::Kind::CLOCK_TIME || s.owner == Actions::Kind::HOUR }
+    end
+    
+    def has_every_day_pattern?
+      # Check for patterns like "every day at X"
+      frequency_pattern = @stack.any? { |s| s.owner == Actions::Kind::FREQUENCY_WITH }
+      day_pattern = @stack.any? { |s| 
+        s.owner == Actions::Kind::DAY && 
+        (s.day_of_week.nil? || @original_text&.match?(/every day|each day/i))
+      }
+      
+      frequency_pattern && day_pattern
+    end
+
+    def to_s
+      @syntax.to_s
+    end
+  end
+end 

data/lib/english_to_cron/error.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EnglishToCron
+  class Error < StandardError
+    class InvalidInput < Error
+      def initialize(msg = "Please enter human readable text")
+        super(msg)
+      end
+    end
+
+    class Capture < Error
+      attr_reader :state, :token
+
+      def initialize(state, token)
+        @state = state
+        @token = token
+        super("Could not capture: #{token} in state: #{state}")
+      end
+    end
+
+    class ParseToNumber < Error
+      attr_reader :state, :value
+
+      def initialize(state, value)
+        @state = state
+        @value = value
+        super("Could not parse: #{value} to number. state: #{state}")
+      end
+    end
+
+    class IncorrectValue < Error
+      attr_reader :state, :error_description
+
+      def initialize(state, error_description)
+        @state = state
+        @error_description = error_description
+        super("Value is invalid in state: #{state}. description: #{error_description}")
+      end
+    end
+  end
+end 

data/lib/english_to_cron/stack.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module EnglishToCron
+  class StartEnd
+    attr_accessor :start, :end
+
+    def initialize(start = nil, end_val = nil)
+      @start = start
+      @end = end_val
+    end
+  end
+
+  class StartEndString
+    attr_accessor :start, :end
+
+    def initialize(start = nil, end_val = nil)
+      @start = start
+      @end = end_val
+    end
+  end
+
+  class Stack
+    attr_accessor :owner, :frequency, :frequency_end, :frequency_start,
+                  :min, :hour, :day, :month, :year, :day_of_week
+
+    def initialize(owner)
+      @owner = owner
+      @frequency = nil
+      @frequency_end = nil
+      @frequency_start = nil
+      @min = nil
+      @hour = nil
+      @day = nil
+      @month = nil
+      @year = nil
+      @day_of_week = nil
+    end
+
+    def frequency_to_string
+      frequency ? frequency.to_s : "*"
+    end
+
+    class Builder
+      def initialize(owner)
+        @stack = Stack.new(owner)
+      end
+
+      def frequency(frequency)
+        @stack.frequency = frequency
+        self
+      end
+
+      def min(min)
+        @stack.min = min
+        self
+      end
+
+      def hour(hour)
+        @stack.hour = hour
+        self
+      end
+
+      def day(day)
+        @stack.day = day
+        self
+      end
+
+      def month(month)
+        @stack.month = month
+        self
+      end
+
+      def day_of_week(day_of_week)
+        @stack.day_of_week = day_of_week
+        self
+      end
+
+      def build
+        @stack
+      end
+    end
+
+    def self.builder(owner)
+      Builder.new(owner)
+    end
+  end
+end 

data/lib/english_to_cron/syntax.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EnglishToCron
+  class Syntax
+    attr_accessor :seconds, :min, :hour, :day_of_month, :month, :day_of_week, :year
+
+    def initialize
+      @seconds = "0"
+      @min = "*"
+      @hour = "*"
+      @day_of_month = "*"
+      @month = "*"
+      @day_of_week = "?"
+      @year = "*"
+    end
+
+    def to_s
+      "#{seconds} #{min} #{hour} #{day_of_month} #{month} #{day_of_week} #{year}"
+    end
+  end
+end 

data/lib/english_to_cron/tokenizer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EnglishToCron
+  class Tokenizer
+    TOKEN_PATTERN = /(?i)(?:seconds|second|secs|sec)|(?:hours?|hrs?)|(?:minutes?|mins?|min)|(?:months?|(?:january|february|march|april|may|june|july|august|september|october|november|december|jan|feb|mar|apr|may|jun|jul|aug|sept|oct|nov|dec)(?: ?and)?,? ?)+|[0-9]+(?:th|nd|rd|st)|(?:[0-9]+:)?[0-9]+ ?(?:am|pm)|[0-9]+:[0-9]+|(?:noon|midnight)|(?:days?|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|mon|tue|wed|thu|fri|sat|sun)(?: ?and)?,? ?)+|(?:[0-9]{4}[0-9]*(?: ?and)?,? ?)+|[0-9]+|(?:to|through|ending|end|and)|(?:between|starting|start)/
+
+    def initialize
+      @regex = TOKEN_PATTERN
+    end
+
+    def run(input_string)
+      input_string.scan(@regex).map { |token| token.strip.downcase }
+    end
+  end
+end 

data/lib/english_to_cron/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EnglishToCron
+  VERSION = "0.1.0"
+end 

data/lib/english_to_cron.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "english_to_cron/version"
+require_relative "english_to_cron/error"
+require_relative "english_to_cron/tokenizer"
+require_relative "english_to_cron/syntax"
+require_relative "english_to_cron/actions"
+require_relative "english_to_cron/cron"
+
+module EnglishToCron
+  def self.parse(input)
+    Cron.parse(input)
+  end
+end 

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: english-to-cron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vlad Dyachenko
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: A Ruby library that converts various English text descriptions into cron
+  job syntax.
+email:
+- gotta.go.vlad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/english_to_cron.rb
+- lib/english_to_cron/actions.rb
+- lib/english_to_cron/cron.rb
+- lib/english_to_cron/error.rb
+- lib/english_to_cron/stack.rb
+- lib/english_to_cron/syntax.rb
+- lib/english_to_cron/tokenizer.rb
+- lib/english_to_cron/version.rb
+homepage: https://github.com/wowinter13/english-to-cron
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wowinter13/english-to-cron
+  source_code_uri: https://github.com/wowinter13/english-to-cron
+  changelog_uri: https://github.com/wowinter13/english-to-cron/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: English to Cron Job Syntax Converter
+test_files: []