cronv-rb 0.2.0

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cronv-rb.gemspec
+gemspec
+
+gem 'fugit', '~> 1.2'
+gem 'logger'
+gem 'rspec', '~> 3.0'
+gem 'rubocop'
+gem 'rubocop-rspec'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Masato Yamashita
+
+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,72 @@
+# cronv-rb
+
+A Ruby implementation of [cronv](https://github.com/takumakanari/cronv) (originally written in Go) that visualizes cron schedules from crontab as an interactive HTML timeline.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cronv-rb'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install cronv-rb
+
+## Usage
+
+Pipe your crontab into `cronv` to generate an HTML timeline:
+
+```sh
+crontab -l | bundle exec ruby exe/cronv -o crontab.html
+```
+
+### Options
+
+| Option | Description | Default |
+|---|---|---|
+| `-o`, `--output PATH` | Path to output HTML file | `./crontab.html` |
+| `-d`, `--duration DURATION` | Duration to visualize (`1d` / `6h` / `30m`) | `6h` |
+| `--from-date DATE` | Start date (`YYYY/MM/DD`) | Current date (UTC) |
+| `--from-time TIME` | Start time (`HH:MM`) | Current time (UTC) |
+| `-t`, `--title TITLE` | Title label of output | `Cron Tasks` |
+| `-w`, `--width WIDTH` | Table width of output | `100` |
+
+### Examples
+
+```sh
+# Visualize the next 24 hours starting from a specific date
+crontab -l | bundle exec ruby exe/cronv \
+  -o crontab.html \
+  --from-date 2025/01/01 \
+  --from-time 00:00 \
+  -d 1d
+
+# Visualize the next 30 minutes with a custom title
+crontab -l | bundle exec ruby exe/cronv \
+  -o crontab.html \
+  -d 30m \
+  -t "My Cron Jobs"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+```sh
+bundle install
+bundle exec rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/M-Yamashita01/cronv-rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LeadingCommentSpace
+#!/usr/bin/env ruby
+# rubocop:enable Layout/LeadingCommentSpace
+
+require 'bundler/setup'
+require 'cronv/rb'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cronv-rb.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cronv_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cronv-rb'
+  spec.version       = CronvRb::VERSION
+  spec.authors       = ['Masato Yamashita']
+  spec.email         = ['4653960+M-Yamashita01@users.noreply.github.com']
+
+  spec.summary       = 'Visualize your cron schedules in crontab by Ruby'
+  spec.description   = 'A gem that rewrites cronv, originally written in Go, in Ruby to visualize your cron schedules in crontab.'
+  spec.homepage      = 'https://github.com/M-Yamashita01/cronv-rb'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/M-Yamashita01/cronv-rb'
+    spec.metadata['changelog_uri'] = 'https://github.com/M-Yamashita01/cronv-rb'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.required_ruby_version = '>= 3.2'
+  # 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(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '>= 2.5'
+  spec.add_development_dependency 'rake', '~> 13.4'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/docs/release.md

@@ -0,0 +1,136 @@
+# Release Flow
+
+## Overview
+
+This project uses an automated release flow driven by [release-please](https://github.com/googleapis/release-please)
+and Conventional Commits. There is no manual tagging.
+
+The pipeline is:
+
+```
+Conventional Commits merged to main
+   |
+   v
+release-please keeps a Release PR up to date (version bump + CHANGELOG)
+   |
+   v  (the Release PR is merged: see "How the Release PR is merged" below)
+release-please creates the tag and the GitHub Release
+   |
+   v
+the publish job builds the gem and pushes it to RubyGems (Trusted Publishing)
+```
+
+## How the Release PR is merged
+
+Patch releases ship automatically; larger releases need a human.
+
+- Patch bump (`x.y.Z`): the `auto-merge-patch` job runs weekly (Mondays 00:00 UTC
+  / 09:00 JST) and merges the open Release PR automatically when it is a patch-only
+  bump. This ships accumulated `fix:` / `fix(deps):` changes without manual action.
+  You can also trigger it on demand from the Actions tab (Run workflow).
+- Minor bump (`x.Y.0`, from `feat:`) or major bump: the Release PR is left open for
+  a human to review and merge, since these are larger changes.
+
+## Conventional Commits
+
+release-please derives the next version from commit messages, so the prefix matters:
+
+| Prefix | Effect on version (while in 0.x) |
+|--------|----------------------------------|
+| `feat:` | MINOR bump (new feature); shown in release notes |
+| `fix:` | PATCH bump (bug fix); shown in release notes |
+| `fix(deps):` | PATCH bump (dependency update, used by Renovate); shown in release notes |
+| `perf:` | PATCH bump (performance improvement); shown in release notes |
+| `feat!:` / `BREAKING CHANGE:` | MINOR bump (breaking changes stay MINOR until 1.0.0) |
+| `docs:`, `refactor:`, `chore:` | No version bump; hidden from release notes |
+
+Note on how release-please decides the bump: internally, only `feat` and
+breaking changes map to MINOR/MAJOR; every other releasable type maps to PATCH.
+To keep `docs:` / `refactor:` / `chore:` from cutting a pointless release, they
+are marked hidden in `release-please-config.json`, which also removes them from
+the release notes. There is no release-please setting that both shows a type in
+the notes and skips the version bump; that is why these types are hidden entirely.
+
+If nothing since the last release bumps the version, no Release PR is created,
+so weeks with only `docs:` / `refactor:` / `chore:` changes produce no release.
+
+## Releasing
+
+### 1. Merge feature/fix PRs to main as usual
+
+Each PR should use a Conventional Commit title. When such commits land on `main`,
+the `Release Please` workflow opens or updates a single Release PR titled
+`chore(main): release x.y.z`.
+
+### 2. The Release PR is merged
+
+- Patch-only Release PRs are merged automatically on the weekly schedule (see
+  "How the Release PR is merged" above). No action is needed.
+- Minor/major Release PRs wait for a human. Open the PR, check the proposed
+  version and the generated `CHANGELOG.md` entry, then merge when ready.
+
+### 3. Merging the Release PR triggers the release
+
+Whichever way it is merged, it:
+
+1. Updates `CHANGELOG.md`, `lib/cronv_rb/version.rb`, and
+   `.release-please-manifest.json` on `main`
+2. Creates the git tag (e.g. `v0.1.1`)
+3. Creates the GitHub Release with the changelog as its body
+
+### 4. The gem is published automatically
+
+The `publish` job in the same workflow runs when a release was created
+(`releases_created == 'true'`). It builds the gem and pushes it to
+[RubyGems](https://rubygems.org/gems/cronv-rb) using Trusted Publishing (OIDC),
+so no API key is stored in the repository.
+
+If a publish needs to be re-run or a version needs to be backfilled, trigger the
+workflow manually from the Actions tab (Run workflow) with `force_publish`
+checked. This builds and pushes whatever version is currently on `main`.
+
+### 5. Verify the release
+
+- Check the [Releases page](https://github.com/M-Yamashita01/cronv-rb/releases)
+- Confirm the new version is live on [RubyGems](https://rubygems.org/gems/cronv-rb)
+- Confirm the changelog reads correctly
+
+## Release Infrastructure
+
+| File | Purpose |
+|------|---------|
+| `.github/workflows/release-please.yml` | Maintains the Release PR on push to `main`; auto-merges patch-only Release PRs weekly; publishes the gem when a release is created |
+| `release-please-config.json` | release-please settings (release type, version bump rules, changelog sections) |
+| `.release-please-manifest.json` | Tracks the current released version |
+| `lib/cronv_rb/version.rb` | The `CronvRb::VERSION` constant; the source of truth for the version, updated by release-please |
+
+## RubyGems Trusted Publishing
+
+Publishing uses RubyGems Trusted Publishing (OIDC) instead of a stored API key.
+A one-time setup is required on RubyGems.org (Profile > Trusted Publishers):
+
+- Repository: `M-Yamashita01/cronv-rb`
+- Workflow filename: `release-please.yml`
+- Gem name: `cronv-rb`
+
+Because the gem is not yet registered, create it as a pending trusted publisher
+so the first OIDC push both creates the gem and registers ownership.
+
+## Renovate
+
+Renovate is configured to use `fix(deps):` commit messages (see `renovate.json`),
+so dependency updates become PATCH-level entries in the Release PR. This lets a
+weekly dependency refresh ship as a single patch release when the Release PR is
+merged.
+
+## Fixing a Bad Release
+
+Prefer rolling forward: fix the issue on `main` and let the next Release PR ship a
+new patch version (e.g. `v0.1.2`).
+
+If a release must be pulled:
+
+1. Delete the release from the GitHub Releases page
+2. Delete the tag: `git push origin :refs/tags/v0.1.1`
+3. Yank the gem from RubyGems if it was published: `gem yank cronv-rb -v 0.1.1`
+4. Fix the issue on `main` and ship a new patch via the normal flow

data/exe/cronv

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
+
+require 'cronv_rb'
+
+CronvRb.main

data/fixtures/sample.crontab

@@ -0,0 +1,80 @@
+# Sample crontab for comparing output between cronv-rb and the OSS cronv
+# https://github.com/takumakanari/cronv
+
+# --- Basic examples ---
+
+# Every minute
+* * * * * /usr/local/bin/every_minute.sh
+
+# Every 5 minutes
+*/5 * * * * /usr/local/bin/every_5_minutes.sh
+
+# Every 10 minutes
+*/10 * * * * /usr/local/bin/every_10_minutes.sh
+
+# Every 15 minutes
+*/15 * * * * /usr/local/bin/every_15_minutes.sh
+
+# Every 30 minutes
+*/30 * * * * /usr/local/bin/every_30_minutes.sh
+
+# --- Hourly / Daily ---
+
+# Every hour at minute 0
+0 * * * * /usr/local/bin/hourly.sh
+
+# Every day at midnight
+0 0 * * * /usr/local/bin/daily_midnight.sh
+
+# Every day at noon
+0 12 * * * /usr/local/bin/daily_noon.sh
+
+# Every day at 6 AM and 6 PM
+0 6,18 * * * /usr/local/bin/twice_daily.sh
+
+# --- Weekly ---
+
+# Every Monday at 9 AM
+0 9 * * 1 /usr/local/bin/weekly_monday.sh
+
+# Every weekday (Mon-Fri) at 8 AM
+0 8 * * 1-5 /usr/local/bin/weekday_morning.sh
+
+# Every weekend (Sat-Sun) at 10 AM
+0 10 * * 6,0 /usr/local/bin/weekend_morning.sh
+
+# --- Monthly ---
+
+# First day of every month at midnight
+0 0 1 * * /usr/local/bin/monthly_first.sh
+
+# Last possible day check: 28th of every month at 2 AM
+0 2 28 * * /usr/local/bin/monthly_28th.sh
+
+# --- Specific months ---
+
+# Every day in January at midnight
+0 0 * 1 * /usr/local/bin/january_daily.sh
+
+# Every day in July and December at noon
+0 12 * 7,12 * /usr/local/bin/july_december_noon.sh
+
+# --- Step and range combinations ---
+
+# Every 2 hours
+0 */2 * * * /usr/local/bin/every_2_hours.sh
+
+# Every 3 hours between 6 AM and 21 PM
+0 6-21/3 * * * /usr/local/bin/daytime_every_3_hours.sh
+
+# Minutes 0, 15, 30, 45 of every hour
+0,15,30,45 * * * * /usr/local/bin/quarter_hour.sh
+
+# --- @ aliases ---
+
+@hourly /usr/local/bin/at_hourly.sh
+@daily /usr/local/bin/at_daily.sh
+@weekly /usr/local/bin/at_weekly.sh
+@monthly /usr/local/bin/at_monthly.sh
+@yearly /usr/local/bin/at_yearly.sh
+@reboot /usr/local/bin/at_reboot.sh

data/lib/cronv_rb/crontab.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module CronvRb
+  class Extra
+    attr_reader :line, :label, :job
+
+    def initialize(line:, label:, job:)
+      @line = line
+      @label = label
+      @job = job
+    end
+  end
+
+  class Crontab
+    attr_reader :line, :schedule, :job
+
+    def initialize(line:, schedule:, job:)
+      @line = line
+      @schedule = schedule
+      @job = job
+    end
+
+    class << self
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Lint/UnusedMethodArgument
+      # rubocop:disable Style/OptionalArguments
+      # return [crontab, extra]
+      def parse(context = {}, line)
+        parts = line.split
+        schedule = nil
+        job = []
+
+        if parts[0].start_with?('@')
+          raise ArgumentError, "invalid crontab line: '#{line}'" if parts.length < 2
+
+          if parts[0] == '@reboot'
+            return [nil,
+                    Extra.new(
+                      line: line,
+                      label: parts[0],
+                      job: parts[1..].join(' ')
+                    )]
+          end
+
+          schedule = Schedule.new(
+            minutes: nil,
+            hour: nil,
+            day_of_month: nil,
+            month: nil,
+            day_of_week: nil,
+            year: nil,
+            schedule_alias: parts[0]
+          )
+
+          return [Crontab.new(
+            line: line,
+            schedule: schedule,
+            job: parts[1..].join(' ')
+          ), nil]
+        else
+          raise ArgumentError, "invalid crontab line: '#{line}'" if parts.length < 5
+
+          schedule = Schedule.new(
+            minutes: parts[0],
+            hour: parts[1],
+            day_of_month: parts[2],
+            month: parts[3],
+            day_of_week: parts[4],
+            year: nil,
+            schedule_alias: nil
+          )
+
+          job = parts[5..].join(' ')
+        end
+
+        [Crontab.new(
+          line: line,
+          schedule: schedule,
+          job: job
+        ), nil]
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Lint/UnusedMethodArgument
+    # rubocop:enable Style/OptionalArguments
+
+    def running_every_minutes?(schedule)
+      fields = schedule.to_crontab.split
+      fields.each_with_index.all? do |field, i|
+        if i.zero?
+          %w[* */1].include?(field)
+        else
+          field == '*'
+        end
+      end
+    end
+  end
+end

data/lib/cronv_rb/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+class Logger
+  class << self
+    def info(message)
+      info_logger.info(message)
+    end
+
+    def error(message)
+      error_logger.error(message)
+    end
+
+    private
+
+    def info_logger
+      @info_logger ||= Logger.new($stdout)
+    end
+
+    def error_logger
+      @error_logger ||= Logger.new($stderr)
+    end
+  end
+end

data/lib/cronv_rb/main.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module CronvRb
+  # rubocop:disable Metrics/AbcSize
+  def self.main
+    option = Option.new_cronv_option(Time.now)
+
+    OptionParser.new do |opt|
+      opt.on('-o', '--output PATH', 'path to .html file to output') { |v| option.output_file_path = v }
+      opt.on('-d', '--duration DURATION', 'duration to visualize in N{suffix} style. e.g.) 1d(day)/1h(hour)/1m(minute)') { |v| option.duration = v }
+      opt.on('--from-date DATE', "start date in the format '#{Option::OPT_DATE_FORMAT}' to visualize") { |v| option.from_date = v }
+      opt.on('--from-time TIME', "start time in the format '#{Option::OPT_TIME_FORMAT}' to visualize") { |v| option.from_time = v }
+      opt.on('-t', '--title TITLE', 'title/label of output') { |v| option.title = v }
+      opt.on('-w', '--width WIDTH', 'Table width of output') { |v| option.width = v.to_i }
+      opt.on('-v', '--version', 'Show version') do
+        puts "cronv-rb #{VERSION}"
+        exit
+      end
+    end.parse!
+
+    visualizer = Visualizer.new_visualizer(option)
+
+    $stdin.each_line do |line|
+      visualizer.add(line)
+    end
+
+    path = visualizer.dump
+    puts "[#{option.title}] #{visualizer.records.size} tasks."
+    puts "[#{option.title}] '#{path}' generated."
+  end
+  # rubocop:enable Metrics/AbcSize
+end

data/lib/cronv_rb/option.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module CronvRb
+  class Option
+    OPT_DATE_FORMAT = '%Y/%m/%d'
+    OPT_TIME_FORMAT = '%H:%M'
+    OPT_DEFAULT_DURATION = '6h'
+    OPT_DEFAULT_OUTPUT_PATH = './crontab.html'
+    OPT_DEFAULT_TITLE = 'Cron Tasks'
+    OPT_DEFAULT_WIDTH = 100
+
+    attr_accessor :output_file_path, :duration, :from_date, :from_time, :title, :width
+
+    def to_from_time
+      parsed = Time.strptime("#{@from_date} #{@from_time}", "#{OPT_DATE_FORMAT} #{OPT_TIME_FORMAT}")
+      Time.utc(parsed.year, parsed.month, parsed.day, parsed.hour, parsed.min, 0)
+    rescue ArgumentError => e
+      raise ArgumentError, "invalid date/time format: '#{@from_date} #{@from_time}', #{e.message}"
+    end
+
+    def to_duration_minutes
+      raise ArgumentError, "invalid duration format: '#{@duration}'" if @duration.length < 2
+
+      duration_str = @duration[0..-2]
+      unit = @duration[-1]
+
+      begin
+        duration_i = Integer(duration_str)
+      rescue ArgumentError => e
+        raise ArgumentError, "invalid duration format: '#{@duration}', #{e.message}"
+      end
+
+      case unit.downcase
+      when 'd'
+        Float(duration_i * 24 * 60)
+      when 'h'
+        Float(duration_i * 60)
+      when 'm'
+        Float(duration_i)
+      else
+        raise ArgumentError, "invalid duration format: '#{@duration}', '#{unit}' is not in d/h/m"
+      end
+    end
+
+    def self.new_cronv_option(now)
+      utc_now = now.utc
+      new(utc_now.strftime(OPT_DATE_FORMAT), utc_now.strftime(OPT_TIME_FORMAT))
+    end
+
+    private
+
+    def initialize(from_date, from_time)
+      @output_file_path = OPT_DEFAULT_OUTPUT_PATH
+      @duration = OPT_DEFAULT_DURATION
+      @from_date = from_date
+      @from_time = from_time
+      @title = OPT_DEFAULT_TITLE
+      @width = OPT_DEFAULT_WIDTH
+    end
+  end
+end

data/lib/cronv_rb/record.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'fugit'
+
+module CronvRb
+  class Record
+    class << self
+      def new_record(line:, start_time:, duration_minutes:, context: {})
+        crontab, extra = Crontab.parse(context, line)
+
+        return nil, extra if crontab.nil?
+
+        fugit_cron = Fugit.parse_cron(crontab.schedule.to_crontab)
+
+        new(crontab:, fugit_cron:, start_time:, duration_minutes:)
+      end
+    end
+
+    attr_reader :crontab, :fugit_cron, :start_time, :duration_minutes
+
+    def initialize(crontab:, fugit_cron:, start_time:, duration_minutes:)
+      @crontab = crontab
+      @fugit_cron = fugit_cron
+      # start_time class Time
+      @start_time = start_time
+      # duration_minutes class Integer
+      @duration_minutes = duration_minutes
+    end
+
+    Exec = Struct.new(:start, :end)
+
+    def iter
+      array = []
+
+      end_time = @start_time + (@duration_minutes * 60)
+      return array if @fugit_cron.nil?
+
+      # next_time is an EtOrbi::EoTime; use .to_t (converts to plain Ruby Time)
+      # for comparison to avoid timezone label mismatches ("Z" vs "UTC") that
+      # cause string comparison to fail for executions at the exact end boundary.
+      @next_time = @fugit_cron.next_time(@start_time.to_s)
+
+      while @next_time.to_t <= end_time
+        array.push({ start: @next_time.to_s, end: (@next_time + 60).to_s })
+        @next_time = @fugit_cron.next_time(@next_time.to_s)
+      end
+
+      array
+    end
+  end
+end