quando 0.0.2 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5750a6507d6b1f1a1abdaba34591014a1288d24720b6ff2d24299ce2fdb5e0
-  data.tar.gz: efc1b8ae6a9c67e55f6d941b5efbf112e869a5584060ed051f8959a0474d76fb
+  metadata.gz: dc9ef7c527d685d3da9942e1d53aff6017c012a7a25fc3e1fd47f667c2f94167
+  data.tar.gz: a1794e5af7f816d5b8edeb36bd8a762073f48afbcbc353a304d68bfd9c2a48e3
 SHA512:
-  metadata.gz: 59173a1541b71b270872725d7b2a83a30218a6cc5d30b32265389f6443d19e00a86bb3fdad51fe4ef65333ffce05288e16f34c9cfdd71dad6f4a4ab1aa1dd5c2
-  data.tar.gz: f9bb328ad18cec91a28119b3595a785d50774c94bcf3bc5bdfa41fd1fbce97d58d14e5c804d71c9102f59352edd0638d6533f3fc54acbff26b7ea60a8ac215d3
+  metadata.gz: 55afbcc5d55fd62967ed3dfbbcbccf4e23933cf44f98ae9249ff47f631c7c4a62c1dea93f6961da81d62035547d516849bd1527ca98bf060eff1a659b2a61e7a
+  data.tar.gz: d6e38f8106e168aeb5ce8b6c9e8f14108c00eff87fdba43dcf0edc75c2c1d330f248e777b461ff7378fdaa5b894a2181883013337764662b422b91ed15c2962b

data/.gitignore

@@ -1,5 +1,7 @@
 .DS_Store
-pkg
-.idea/
-docker/*
+.idea
+.gem
+bundle
 docker-compose.yml
+pkg
+up

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--require spec_helper

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quando (0.0.2)
+    quando (0.0.8)
 
 GEM
   remote: https://rubygems.org/
@@ -12,7 +12,7 @@ GEM
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    rake (10.5.0)
+    rake (11.3.0)
     rspec (3.6.0)
       rspec-core (~> 3.6.0)
       rspec-expectations (~> 3.6.0)
@@ -31,11 +31,11 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.15)
+  bundler (>= 1.15)
   pry
   quando!
-  rake (~> 10.0)
-  rspec (~> 3.0)
+  rake (~> 11)
+  rspec (>= 3.0)
 
 BUNDLED WITH
-   1.16.5
+   1.17.2

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2019 Sergey Konotopov
+
+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

@@ -4,47 +4,207 @@
 [![Build Status](https://semaphoreci.com/api/v1/kinkou/quando/branches/master/shields_badge.svg)](https://semaphoreci.com/kinkou/quando)
 [![Maintainability](https://api.codeclimate.com/v1/badges/b0653fc45ec54c23e05c/maintainability)](https://codeclimate.com/github/kinkou/quando/maintainability)
 
-Quando is a configurable date parser. Show it what's what and parse any (Gregorian calendar) date. Quando can be configured on:
+Quando is a configurable date parser which picks up where ```Date.strptime``` stops. It was made to work with non-standard, multi-language dates (that is, dates recorded by humans in languages other than English) but can be used for almost any date format.
+
+A typical use case for Quando is dealing with input like:
+
+```text
+"01 января 2019 г."
+"1-ЯНВ-19"
+"01.01.19"
+"1/Jan/2019"
+"yanvar'19"
+"ЯНВ"
+```
+
+This is a real-life example of how people would routinely write January 1, 2019 in Russia, but since many countries have their own words for month names, it might be a common problem.
+
+## How it works
+
+```bash
+gem install quando
+```
+
+and then
 
-#### Application-level:
 ```ruby
+require 'quando'
+
 Quando.configure do |c|
-  c.dlm = /[ ,-]/
+  # Define regular expressions to identify possible month names:
+  c.jan = /january|jan|yanvar|январь|января|янв/i # simplified for readability
+  # c.feb = …
+ 
+  # …more configuration…
+
+  # Then combine them into regexps that will match the date formats you accept:
+  c.formats = [
+    /#{c.day} #{c.month_txt} #{c.year} г\./i, # matches "01 января 2019 г."
+    /#{c.day}\.#{c.month_num}\.#{c.year2}/i, # matches "01.01.19"
+    /#{c.month_txt}'#{c.year2}/i, # matches "январь'19"
+    /#{c.month_txt}/i, # matches "ЯНВ"
+  ]
+end
+
+Quando.parse("01 января 2019 г.") #=> #<Date: 2019-01-01>
+Quando.parse("01.01.19") #=> #<Date: 2019-01-01>
+Quando.parse("январь'19") #=> #<Date: 2019-01-01>
+Quando.parse("ЯНВ") #=> #<Date: 2019-01-01> (given that current year is 2019)
+```
+
+## Quando in detail
+
+### Configuration object
+
+Configuration properties can be set by submitting a block to the ```Quando.configure``` method, as seen in the example above, or by calling the setter methods on the configuration object directly:
+
+```ruby
+Quando.config.jun = /qershor|mehefin/   # Albanian and Welsh month names
+Quando.config.jul = /korrik|gorffennaf/ # will make you cry
+```
+
+### Regular expressions
+
+If you need to use grouping, remember that non-capturing groups ```(?:abc)``` provide better performance.
+
+If, for some reason, you need to use named groups ```(?<name>abc)```, avoid names ```day```, ```month``` and ```year```. Quando uses them internally, so conflicts are possible.
+
+### Textual month matchers
+
+To let Quando recognize months in your language you need to define corresponding regular expressions for all months:
+
+```ruby
+Quando.configure do |c|
+  # In Finland, your matchers might look like this:
+  c.jan = /jan(?:uary)?   | tammikuu(?:ta)? /xi
+  c.feb = /feb(?:ruary)?  | helmikuu(?:ta)? /xi
+  c.mar = /mar(?:ch)?     | maaliskuu(?:ta)?/xi
+  c.apr = /apr(?:il)?     | huhtikuu(?:ta)? /xi
+  c.may = /may            | toukokuu(?:ta)? /xi
+  c.jun = /june?          | kesäkuu(?:ta)?  /xi
+  c.jul = /july?          | heinäkuu(?:ta)? /xi
+  c.aug = /aug(?:ust)?    | elokuu(?:ta)?   /xi
+  c.sep = /sep(?:tember)? | syyskuu(?:ta)?  /xi
+  c.oct = /oct(?:ober)?   | lokakuu(?:ta)?  /xi
+  c.nov = /nov(?:ember)?  | marraskuu(?:ta)?/xi
+  c.dec = /dec(?:ember)?  | joulukuu(?:ta)? /xi
+  
+  # …more configuration…
+end
+```
+
+### Numerical matchers
+
+Quando comes with defaults that will probably work in most situations:
+
+```Quando.config.day``` matches numbers from 1 to 31, both zero-padded and unpadded;
+
+```Quando.config.month_num``` matches numbers from 1 to 12, both zero-padded and unpadded;
 
-  c.jan = /janeiro/i
-  c.feb = /fevereiro/i
-  c.mar = /março/i
-  c.apr = /abril/i
-  # …
-  c.unimonth!
+```Quando.config.year``` matches any 4-digit sequence;
+```Quando.config.year2``` matches any 2-digit sequence.
 
+If you need to adjust these matchers make sure that they produce named captures ```day```, ```month``` and ```year```, respectively:
+
+```ruby
+Quando.config.day = /(?<day> …)/
+Quando.config.month_num = /(?<month> …)/
+Quando.config.year = /(?<year> …)/
+```
+
+### Delimiter matcher
+
+By default, ```Quando.config.dlm``` will greedily match spaces, dashes, dots and slashes.
+
+### Format matchers
+
+With format matchers you describe the concrete date formats that Quando will recognize. Within them you can include the date part matchers you defined previously.
+
+```Quando.config.day```, ```Quando.config.month_num```, ```Quando.config.month_txt```, ```Quando.config.year```, ```Quando.config.year2``` can be used.
+
+```Quando.config.month_txt``` is a regexp that automatically combines all textual month matchers, and will thus match any month.
+
+```ruby
+Quando.configure do |c|
+  # …some initial configuration…
+ 
   c.formats = [
-    /#{c.day} #{c.dlm} #{c.month_txt} #{c.dlm} #{c.year}/xi,
-    /#{c.year} #{c.dlm} #{c.month_txt} #{c.dlm} #{c.day}/xi,
+    /^ #{c.day} #{c.dlm} #{c.month_txt} #{c.dlm} #{c.year} $/xi,
+    # compiles into something like
+    # /^ (?<day> …) [ -.\/]+ (?<month> jan|feb|…) [ -.\/]+ (?<year> …) $/xi
+    # and returns ~ #<MatchData "14 Apr 1965" day:"14" month:"Apr" year:"1965">
+    # on successful match 
   ]
 end
+```
+
+### How dates are parsed
+
+Quando matches regular expressions from ```Quando.config.formats```, *in the specified order*, against the input. If there is a match, the resulting ```MatchData``` object is analyzed.
+
+If there is a named capture ```:day``` or ```:month```, either is used in the result, given that they are within correct range. If the format matcher did not define such named group, ```1``` is used:
+
+```ruby
+Quando.config.formats = [
+  /#{Quando.config.month_num}\.#{Quando.config.year}/
+]
 
-Quando.parse('14-abril-1965') #=> #<Date: 1965-04-14>
-Quando.parse('1965, abril 14') #=> #<Date: 1965-04-14>
+Quando.parse('04.2019') #=> #<Date: 2019-04-01>
 ```
 
-#### Instance-level:
-It will not affect your application-level configuration.
+If there is a named capture ```:year```, it is used in the result. If the format matcher did not define such named group, current UTC year is used. If the captured value is less than ```100``` (which is the case for years written as 2-digit numbers), Quando will use the ```Quando.config.century``` setting (defaults to ```21```), effectively converting, for example, ```18``` to ```2018```. Be mindful of this behaviour, adjusting ```Quando.config.century``` accordingly:
+
+```ruby
+Quando.config.formats = [Quando.config.year]
+Quando.parse('2019') #=> #<Date: 2019-01-01>
+
+Quando.config.formats = [Quando.config.year2]
+Quando.parse('65') #=> #<Date: 2065-01-01>
+
+Quando.parse('65', century: 20) #=> #<Date: 1965-01-01>
+# or
+Quando.config.century = 20
+Quando.parse('65') #=> #<Date: 1965-01-01>
+```
+
+### Defaults
+
+Out of the box, Quando will parse a reasonable variety of day-month-year ordered numerical and English textual dates. Some examples:
+
+```text
+14.4.1965, 14/04/1965, …
+14-apr-1965, 14 Apr 1965, …
+April 1965, apr 1965, …
+13.12.05, 13-12-05, …
+April, APR, …
+```
+
+See ```Quando.config.formats``` for details.
+
+### Multiple ways to configure
+
+You can configure Quando instances independently of each other and of the class:
+
 ```ruby
 Quando.parse('14-abril-1965') #=> nil
 
 date_parser = Quando::Parser.new.configure do |c|
-  # here be the options from the previous example
+  # …some configuration…
 end
 date_parser.parse('14-abril-1965') #=> #<Date: 1965-04-14>
 
 Quando.parse('14-abril-1965') #=> nil
 ```
 
-#### Or just one-time usage:
+or just pass a format matcher as a parameter:
+
 ```ruby
 m = /(?<year>#{Quando.config.year}) (?<day>\d\d) (?<month>[A-Z]+)/i
 Quando.parse('1965 14 Apr', matcher: m) #=> #<Date: 1965-04-14>
 ```
 
-Enjoy.
+In both cases it will not change the global configuration (but note that calling setter methods on ```Quando.config``` will).
+
+### Requirements
+
+Ruby >= 1.9.3. Enjoy!

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'quando'
+require 'pry'
+
+Pry.start

data/lib/quando.rb

@@ -7,8 +7,10 @@ require 'quando/parser'
 
 module Quando
 
-  # @param opts [Hash]
   # @param date [String]
+  # @param opts [Hash]
+  # @option opts [Regexp, Array<Regexp>] :matcher
+  # @option opts [Integer] :century
   # @return [Date, nil]
   def self.parse(date, opts = {})
     return if (date = date.to_s.strip).empty?
@@ -17,7 +19,13 @@ module Quando
 
     if opts[:matcher]
       p.configure do |c|
-        c.formats = [opts[:matcher]]
+        c.formats = [opts[:matcher]].flatten
+      end
+    end
+
+    if opts[:century]
+      p.configure do |c|
+        c.century = opts[:century]
       end
     end
 

data/lib/quando/config.rb

@@ -4,77 +4,118 @@
 module Quando
   class Config
 
-    AVAILABLE_OPTIONS = [
-      :dlm, :year, :day,
-      :jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec,
-      :month_num, :month_txt,
-      :formats
-    ]
+    MONTHS = [:jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec]
+    AUTOUPDATE = [:dlm, :year, :year2, :day, *MONTHS, :month_num]
+    COMPOUND = [:month_txt, :formats]
+    OPTIONS = [*AUTOUPDATE, *COMPOUND]
+    CENTURY = 21
 
-    attr_accessor *AVAILABLE_OPTIONS
+    private_constant :AUTOUPDATE, :COMPOUND, :OPTIONS
 
-    MONTHS = [:jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec]
+    attr_accessor *OPTIONS
 
     def initialize
-      @dlm = /[ -.\/\\]/
-      @year = /(?<year>(?:\d{2})|(?:\d{4}))/i
-      @month_num = /(?<month>(?:1[0-2])|(?:0?[1-9]))/
-      @day = /(?<day>(?:[3][0-1])|(?:[1-2][0-9])|(?:0?[1-9]))/
-
-      @jan = /(?:JANUARY)|(?:JAN\.?)/i
-      @feb = /(?:FEBRUARY)|(?:FEB\.?)/i
-      @mar = /(?:MARCH)|(?:MAR\.?)/i
-      @apr = /(?:APRIL)|(?:APR\.?)/i
-      @may = /(?:MAY\.?)/i
-      @jun = /(?:JUNE)|(?:JUN\.?)/i
-      @jul = /(?:JULY)|(?:JUL\.?)/i
-      @aug = /(?:AUGUST)|(?:AUG\.?)/i
-      @sep = /(?:SEPTEMBER)|(?:SEPT?\.?)/i
-      @oct = /(?:OCTOBER)|(?:OCT\.?)/i
-      @nov = /(?:NOVEMBER)|(?:NOV\.?)/i
-      @dec = /(?:DECEMBER)|(?:DEC\.?)/i
+      @dlm = /[- .\/]+/
+      @year = /(?<year>\d{4})/
+      @year2 = /(?<year>\d{2})/
+      @month_num = /(?<month> 1[012] | 0?[1-9])/x
+      @day = /(?<day> 3[01] | [12]\d | 0?[1-9])/x
+
+      @jan = /JAN(?:UARY)?/i
+      @feb = /FEB(?:RUARY)?/i
+      @mar = /MAR(?:CH)?/i
+      @apr = /APR(?:IL)?/i
+      @may = /MAY/i
+      @jun = /JUNE?/i
+      @jul = /JULY?/i
+      @aug = /AUG(?:UST)?/i
+      @sep = /SEP(?:TEMBER)?/i
+      @oct = /OCT(?:OBER)?/i
+      @nov = /NOV(?:EMBER)?/i
+      @dec = /DEC(?:EMBER)?/i
+
+      self.century=(CENTURY)
 
       uniupdate!
     end
 
+    # Sets @month_txt, a compound of all month regexps that matches any month name
+    def unimonth!
+      all_months_txt_rxs = MONTHS.map { |m| instance_variable_get("@#{m}".to_sym) }.join('|')
+      @month_txt = Regexp.new("(?<month>#{all_months_txt_rxs})", true)
+    end
+
+    # Sets @formats which is an array of regexps used in succession to match and identify date parts
     def uniformats!
       @formats = [
-        # 14.4.1965, 14/04/1965, 13-12-05
-        /\A\s* #{@day} #{@dlm} #{@month_num} #{@dlm} #{@year} \s*\z/xi,
+        # Formats with a 4-digits year
+        # 14.4.1965, 14/04/1965, 14-4-1965, 14 04 1965, …
+        /^\s* #{@day} #{@dlm} #{@month_num} #{@dlm} #{@year} \s*$/xi,
+
+        # 14-APRIL-1965, 14-apr-1965, 14/Apr/1965, …
+        /^\s* #{@day} #{@dlm} #{@month_txt} #{@dlm} #{@year} \s*$/xi,
 
-        # 14-APRIL-1965, 14-apr-65, 13/Dec/05, …
-        /\A\s* #{@day} #{@dlm} #{@month_txt} #{@dlm} #{@year} \s*\z/xi,
+        # April 1965, apr.1965, …
+        /^\s* #{@month_txt} #{@dlm} #{@year} \s*$/xi,
 
-        # April 1965, apr.1965, DEC-05, …
-        /\A\s* #{@month_txt} #{@dlm} #{@year} \s*\z/xi,
+        # Same formats with a 2-digits year
+        # 13.12.05, 13/12/05, 13-12-05, …
+        /^\s* #{@day} #{@dlm} #{@month_num} #{@dlm} #{@year2} \s*$/xi,
 
-        # April, DECEMBER, apr., …
-        /\A\s* #{@month_txt} \s*\z/xi,
+        # April, DECEMBER, sep., …
+        /^\s* #{@month_txt} \s*$/xi,
       ]
     end
 
-    def unimonth!
-      all_months_txt_rxs = MONTHS.map { |m| instance_variable_get("@#{m}".to_sym) }.join('|')
-      @month_txt = Regexp.new("(?<month>#{all_months_txt_rxs})", true)
+    # @return [Integer]
+    def century
+      @century
+    end
+
+    # @param value [Integer]
+    # @return [Integer]
+    def century=(value)
+      @century = (value == 0 ? 1 : value) || CENTURY
     end
 
+    # A single method to update all compound matchers when a part matcher was changed
     def uniupdate!
       unimonth!
       uniformats!
     end
 
+    # Batch-define setters for date part matchers (listed in AUTOUPDATE) that, when set,
+    # automatically update the compound matchers (listed in COMPOUND)
+    AUTOUPDATE.each do |var|
+      # def jan=(regexp)
+      #   return regexp if @jan == regexp
+      #   @jan = regexp
+      #   uniupdate!
+      # end
+      define_method("#{var}=".to_sym) do |regexp|
+        var_name = "@#{var}".to_sym
+        return regexp if instance_variable_get(var_name) == regexp
+        instance_variable_set(var_name, regexp)
+        uniupdate!
+      end
+    end
   end
 
+  # Quando's class-level configuration
   # @return [Quando::Config]
   def self.config
     @config ||= Config.new
   end
 
+  # @return [Quando::Config]
   def self.configure
     config unless @config
     yield(config) if block_given?
+    @config
   end
 
+  # Reset Quando's class-level configuration to defaults
+  # @return [Quando::Config]
   def self.reset!
     @config = Config.new
   end

data/lib/quando/parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Quando
-
   class Parser
 
     def initialize
@@ -10,7 +9,7 @@ module Quando
 
     # @return [Quando::Parser]
     def configure
-      yield(@config = Quando.config.dup)
+      yield(@config ||= Quando.config.dup)
       self
     end
 
@@ -22,11 +21,11 @@ module Quando
     # @param text_date [String]
     # @return [Date, nil]
     def parse(text_date)
-      config.formats.each do |rx|
-        @date_parts = text_date.match(rx)
+      config.formats.each do |regexp|
+        @date_parts = text_date.match(regexp)
         next unless @date_parts
 
-        @current_format = rx
+        @current_format = regexp
         year, month, day = detect_year, detect_month, detect_day
         next unless (year && month && day)
 
@@ -40,39 +39,39 @@ module Quando
 
     # @return [Integer, nil]
     def detect_year
-      return Time.now.year unless searched?(:year)
+      return Time.now.utc.year unless wanted?(:year)
       return unless found?(:year)
 
       year = @date_parts[:year].to_i
-      year < 100 ? year + 2000 : year
+      year.abs < 100 ? year + century_to_hundreds : year
     end
 
     # @return [Integer, nil]
     def detect_month
-      return 1 unless searched?(:month)
+      return 1 unless wanted?(:month)
       return unless found?(:month)
 
       month = @date_parts[:month]
 
-      if config.month_num.match(month)
-        month.to_i
-      else
-        month_index = Quando::Config::MONTHS.find_index do |month_name|
-          month_name_rx = config.send(month_name)
-          month_name_rx.match(month)
-        end
+      month_index = Quando::Config::MONTHS.find_index do |month_name|
+        config.send(month_name) =~ month
+      end
 
-        month_index + 1 if month_index
+      if month_index
+        month_index += 1
+        return month_index if valid_month?(month_index)
       end
+
+      month.to_i if valid_month?(month)
     end
 
     # @return [Integer, nil]
     def detect_day
-      return 1 unless searched?(:day)
+      return 1 unless wanted?(:day)
       return unless found?(:day)
 
       day = @date_parts[:day].to_i
-      day if (1..31).include?(day)
+      day if valid_day?(day)
     end
 
     # @param date_part [Symbol]
@@ -81,10 +80,23 @@ module Quando
     end
 
     # @param date_part [Symbol]
-    def searched?(date_part)
-      !!@current_format.named_captures[date_part.to_s]
+    def wanted?(date_part)
+      @current_format.names.include?(date_part.to_s)
     end
 
-  end
+    # @param value [Integer]
+    def valid_month?(value)
+      (1..12).include?(value.to_i)
+    end
 
+    # @param value [Integer]
+    def valid_day?(value)
+      (1..31).include?(value.to_i)
+    end
+
+    def century_to_hundreds
+      (config.century > 0 ? config.century - 1 : config.century + 1) * 100
+    end
+
+  end
 end

data/lib/quando/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quando
-  VERSION = '0.0.2'
+  VERSION = '0.0.8'
 end

data/quando.gemspec

@@ -11,14 +11,17 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Configurable date parser}
   spec.description   = %q{Parse dates in any language and format by setting your own recognition patterns}
   spec.homepage      = 'https://github.com/kinkou/quando'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_development_dependency 'bundler', '>= 1.15'
+  spec.add_development_dependency 'rake', '~> 11'
+  spec.add_development_dependency 'rspec', '>= 3.0'
   spec.add_development_dependency 'pry'
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: quando
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.8
 platform: ruby
 authors:
 - Sergey Konotopov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-13 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
 - !ruby/object:Gem::Dependency
@@ -30,26 +30,26 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
@@ -79,15 +79,18 @@ files:
 - ".rspec"
 - Gemfile
 - Gemfile.lock
+- LICENSE.md
 - README.md
 - Rakefile
+- bin/console
 - lib/quando.rb
 - lib/quando/config.rb
 - lib/quando/parser.rb
 - lib/quando/version.rb
 - quando.gemspec
 homepage: https://github.com/kinkou/quando
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -97,15 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Configurable date parser