cron_config_parser 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf8cde4d225478b58bd0ca262720c1800bbf481badd4fd4297827440ae01fc80
-  data.tar.gz: 81c27cb9f9bafcd0f6c140f5d709acf2a22ad1659d4df914b4e0233561e41d85
+  metadata.gz: 895da1f251f953d6815a2bb37ade3974189abbef9e6215c80de705b7164e6874
+  data.tar.gz: 1d1bcd7003feaf1453b86d87d96ff89126c2214d8c2218cb492e383e3b87d5cd
 SHA512:
-  metadata.gz: 91a272c9eedd125bf5160e0c9c79e0a13c9fd1daada02cdf2ce19b1c410f0cd59c6a647004f3792209e4e7e7b07d1487c4bc82cb71512a112d23358aaddd633e
-  data.tar.gz: 324653a9f72dca12c7964c4d826ebd4b94fadecc50d51d8c8eeeda89d052d51b2444dc136b23ff5f3558b9f28b2795352f2b9180469abba0e247197ec0f9ced7
+  metadata.gz: cbd0de9b030fe9134482ea5edc26fe82a87204572bf6fcdd54d9071476c1b8ee1388512236ed20c8ab4372dddcfeedf0102865b90a7357c2d5346b31822e2726
+  data.tar.gz: 9fafca4d6b2d9d03f716adf58e729fff7113009f0d1fc7ddd302d9ee3ad5dd040ddaa667e53c544a894821c4c452c867f3340a22bf7d91476df650699ae2c09d

data/Gemfile.lock

@@ -1,12 +1,22 @@
 PATH
   remote: .
   specs:
-    cron_config_parser (0.1.1)
+    cron_config_parser (0.1.2)
+      activesupport (~> 5.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    concurrent-ruby (1.1.5)
     diff-lcs (1.3)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
     rake (10.5.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
@@ -21,6 +31,9 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -37,12 +37,20 @@ enable check configured properties.
 ``` ruby
 # return false if configured nil or '*'
 config = CronConfigParser::Parser.call('00 5 * * * Asia/Tokyo')
-config.minutes_difined?
+config.minutes_configured?
 => true
-config.days_difined?
+config.days_configured?
 => false
 ```
 
+enable check next execute time.
+
+``` ruby
+config = CronConfigParser::Parser.call('00 5 * * * Asia/Tokyo')
+config.next_execute_at
+=> 2019-05-23 05:00:00 +0900
+```
+
 This gem check simple validation when CronConfigParser::CronConfig object initialize.
 If the config is invalid, Config::SyntaxError or Config::RequiredError is raised.
 
@@ -68,7 +76,7 @@ CronConfigParser::Parser.call('00 5,a * * * Asia/Tokyo', validation: false)
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cron_config_parser. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Madogiwa0124/cron_config_parser. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -76,4 +84,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the CronConfigParser project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/cron_config_parser/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the CronConfigParser project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Madogiwa0124/cron_config_parser/blob/master/CODE_OF_CONDUCT.md).

data/cron_config_parser.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "activesupport", "~> 5.2"
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/cron_config_parser.rb

@@ -1,9 +1,7 @@
 require "cron_config_parser/version"
+require 'active_support/all'
 
 module CronConfigParser
-  class ConfigSyntaxError < StandardError; end
-  class ConfigRequiredError < StandardError; end
-
   class Parser
     def self.call(cron_config, validation: true)
       new(cron_config, validation: validation).call
@@ -24,50 +22,193 @@ module CronConfigParser
   class CronConfig
     NOT_CONFIGURED_MARK = '*'.freeze
 
-    def initialize(cron_config, validation: true)
+    def initialize(cron_config, validator: CronConfigParser::Varidator, validation: true)
       cron_config = cron_config.split(' ').map { |item| item.split(',') }
       @minutes, @hours, @days, @months, @wdays, @timezone = cron_config
       # timezone is not multiple values.
       @timezone = @timezone.to_a.first
-      validate! if validation
+      validator.call!(self) if validation
     end
 
-    attr_reader :minutes, :hours, :days, :months, :wdays, :timezone
+    attr_accessor :minutes, :hours, :days, :months, :wdays, :timezone
+
+    def next_execute_at(basis_datetime: Time.current)
+      ExecuteAtCalculator.new(cron_config: self, basis_datetime: basis_datetime).call
+    end
 
-    # difine properties configured check methods
+    # define properties configured check methods
     [:minutes, :hours, :days, :months, :wdays, :timezone].each do |attr|
       define_method("#{attr}_configured?") do
         value = send(attr).class == Array ? send(attr)[0] : send(attr)
         ![NOT_CONFIGURED_MARK, nil].include?(value)
       end
     end
+  end
+
+  class Varidator
+    class ConfigSyntaxError < StandardError; end
+    class ConfigRequiredError < StandardError; end
+
+    def self.call!(cron_config)
+      new(cron_config).call!
+    end
+
+    def initialize(cron_config)
+      @cron_config = cron_config
+    end
+
+    def call!
+      raise ConfigRequiredError unless configured_required_properties?
+      raise ConfigSyntaxError   unless configured_valid_syntax_properties?
+    end
 
     private
 
-    def validate!
-      check_required_properties!
-      check_properties_syntax!
+    attr_reader :cron_config
+
+    private
+
+    def configured_required_properties?
+      ![cron_config.minutes,
+        cron_config.hours,
+        cron_config.days,
+        cron_config.months,
+        cron_config.wdays].flatten.include?(nil)
     end
 
-    def check_required_properties!
-      if [minutes, hours, days, months, wdays].flatten.include?(nil)
-        raise ConfigRequiredError
-      end
+    def configured_valid_syntax_properties?
+      return false if cron_config.minutes_configured? && !values_in_range?(:minutes) && !validate_format?(:minutes)
+      return false if cron_config.hours_configured?   && !values_in_range?(:hours)   && !validate_format?(:hours)
+      return false if cron_config.days_configured?    && !values_in_range?(:days)    && !validate_format?(:days)
+      return false if cron_config.wdays_configured?   && !values_in_range?(:wdays)   && !validate_format?(:wdays)
+      return false if cron_config.months_configured?  && !values_in_range?(:months)  && !validate_format?(:months)
+      true
     end
 
-    def check_properties_syntax!
-      raise ConfigSyntaxError if minutes_configured? && !values_in_range?(range: 0..60, values: minutes)
-      raise ConfigSyntaxError if hours_configured? && !values_in_range?(range: 0..24, values: hours)
-      raise ConfigSyntaxError if days_configured? && !values_in_range?(range: 1..31, values: days)
-      raise ConfigSyntaxError if wdays_configured? && !values_in_range?(range: 0..6, values: wdays)
+    def validate_format?(property_sym)
+      valid_count = cron_config.send(property_sym).count do |value|
+        value.match?(/(\d{1,2}|\*)(\/|-)\d{1,2}/) || value.match?(/\d{1,2}/)
+      end
+      cron_config.send(property_sym).count == valid_count
     end
 
-    def values_in_range?(range: , values:)
-      values.count == values.count { |value| range.include?(to_i(value)) }
+    def values_in_range?(property_sym)
+      values = cron_config.send(property_sym)
+      hash = { minutes: 0..60, hours: 0..24, days: 1..31, months: 1..12, wdays: 0..6 }
+      values.count == values.count { |value| hash[property_sym].include?(to_i(value)) }
     end
 
     def to_i(string)
-      Integer(string) rescue nil
+      Integer(string) rescue string
+    end
+  end
+
+  class ExecuteAtCalculator
+    WDAYS = %i[sunday monday tuesday wednesday thursday friday saturday].freeze
+
+    def initialize(cron_config:, basis_datetime:)
+      @cron_config = cron_config
+      @basis_datetime = basis_datetime
+      @execute_at = basis_datetime
+      prepare_cron_config
+    end
+
+    attr_accessor :cron_config, :basis_datetime, :execute_at
+
+    def call
+      next_minute
+      next_hour
+      next_day
+      next_wday
+      next_month
+      execute_at
+    end
+
+    private
+
+    def prepare_cron_config
+      @cron_config.minutes = parse_config_property(:minutes)
+      @cron_config.hours   = parse_config_property(:hours)
+      @cron_config.days    = parse_config_property(:days)
+      @cron_config.months  = parse_config_property(:months)
+      @cron_config.wdays   = parse_config_property(:wdays)
+    end
+
+    def to_i(value)
+      Integer(value) rescue value
+    end
+
+    def parse_config_property(property_sym)
+      cron_config.send(property_sym).map do |property|
+        next to_i(property) unless property.match?(/\/|-/)
+        next parse_for_devided_config(property, property_sym) if property.include?('/')
+        next parse_for_range_config(property) if property.include?('-')
+      end.flatten.uniq.sort
+    end
+
+    def parse_for_devided_config(property, property_sym)
+      hash = { minutes: 0..60, hours: 0..24, days: 1..31, months: 1..12, wdays: 0..6 }
+      hash[property_sym].select { |val| (val % (property).split('/')[1].to_i) == 0 }
+    end
+
+    def parse_for_range_config(property)
+      range_start, range_end = property.split('-').map(&:to_i)
+      (range_start..range_end).to_a
+    end
+
+    def next_minute
+      return @execute_at = execute_at.since(1.minute) unless cron_config.minutes_configured?
+      next_minute = cron_config.minutes.select { |config_min| config_min > execute_at.min }.first
+      @execute_at = change_to_property_and_move_up(property: next_minute, property_sym: :minutes)
+    end
+
+    def next_hour
+      return unless cron_config.hours_configured?
+      next_hour = cron_config.hours.select { |config_hour| config_hour > execute_at.hour }.first
+      @execute_at = change_to_property_and_move_up(property: next_hour, property_sym: :hours)
+      # reset minute when execute in freture and not configured minute
+      @execute_at = @execute_at.change(min: 0) unless cron_config.minutes_configured?
+    end
+
+    def next_day
+      return unless cron_config.days_configured?
+      next_day = cron_config.days.select { |config_day| config_day > execute_at.day }.first
+      @execute_at = change_to_property_and_move_up(property: next_day, property_sym: :days)
+      # reset minute when execute in freture and not configured minute
+      @execute_at = @execute_at.change(min: 0) unless cron_config.minutes_configured?
+    end
+
+    def next_wday
+      return unless cron_config.wdays_configured?
+      next_wday = cron_config.wdays.select { |config_wday| config_wday > execute_at.wday }.first
+      next_wday_sym = next_wday ? WDAYS[next_wday] : WDAYS[cron_config.wdays.first]
+      @execute_at = execute_at.next_occurring(next_wday_sym)
+      # reset minute when execute in freture and not configured minute
+      @execute_at = @execute_at.change(min: 0) unless cron_config.minutes_configured?
+    end
+
+    def next_month
+      return unless cron_config.months_configured?
+      next_month = cron_config.months.select { |config_month| config_month > execute_at.month }.first
+      @execute_at = change_to_property_and_move_up(property: next_month, property_sym: :months)
+      # reset minute when execute in freture and not configured minute
+      @execute_at = @execute_at.change(min: 0) unless cron_config.minutes_configured?
+    end
+
+    def change_to_property_and_move_up(property:, property_sym:)
+      change_property = convert_hash(property_sym)[:change_property]
+      move_up_property = convert_hash(property_sym)[:move_up_property]
+      return execute_at.change(change_property => property) if property
+      execute_at.since(1.send(move_up_property)).change(
+        change_property => cron_config.send(property_sym).first
+      )
+    end
+
+    def convert_hash(property_sym)
+      { minutes: { change_property: :min,   move_up_property: :hour },
+        hours:   { change_property: :hour,  move_up_property: :day },
+        days:    { change_property: :day,   move_up_property: :month },
+        months:  { change_property: :month, move_up_property: :year }, }[property_sym]
     end
   end
 end

data/lib/cron_config_parser/version.rb

@@ -1,3 +1,3 @@
 module CronConfigParser
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: cron_config_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Madogiwa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-18 00:00:00.000000000 Z
+date: 2019-05-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement