timeliness 0.3.7 → 0.3.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5416676829597b429ae232b78e90623d8e1aabc2
+  data.tar.gz: 0ab3eb69ceead65aa57c127daf153c7ebe8702f6
+SHA512:
+  metadata.gz: 417eee657c054357f1be5d59a461d993c95a58248dfaa942198625627d79516204917d27973ac5b17ff44429ae749abe8a727665ad50656e264745e18c6d7e4c
+  data.tar.gz: 0b6316ca2d841d7f827409e2ebcd31b9162cfa6dc29d8d686501b27b71edc34e114de8569aa4e008fe42e025974404ade97208bc4e9d815715da0c629f16e025

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode
+script: 'bundle exec rspec'

data/lib/timeliness/definitions.rb

@@ -78,7 +78,9 @@ module Timeliness
       'yyyy-mm-ddThh:nn:ssZ', # ISO 8601 without zone offset
       'yyyy-mm-ddThh:nn:sszo', # ISO 8601 with zone offset
       'yyyy-mm-ddThh:nn:ss.u', # ISO 8601 with usec
-      'yyyy-mm-ddThh:nn:ss.uzo' # ISO 8601 with usec and offset
+      'yyyy-mm-ddThh:nn:ss.uzo', # ISO 8601 with usec and offset
+      'yyyy-mm-dd hh:nn:ss zo', # Ruby time string in later versions
+      'yyyy-mm-dd hh:nn:ss tz', # Ruby time string for UTC in later versions
     ]
 
     # All tokens available for format construction. The token array is made of
@@ -145,6 +147,8 @@ module Timeliness
     }
 
     US_FORMAT_REGEXP = /\Am{1,2}[^m]/
+    FormatNotFound = Class.new(StandardError)
+    DuplicateFormat = Class.new(StandardError)
 
     class << self
       attr_accessor :time_formats, :date_formats, :datetime_formats, :format_tokens, :format_components, :timezone_mapping
@@ -160,10 +164,10 @@ module Timeliness
         formats = send("#{type}_formats")
         options = add_formats.last.is_a?(Hash) ? add_formats.pop : {}
         before  = options[:before]
-        raise "Format for :before option #{format} was not found." if before && !formats.include?(before)
+        raise FormatNotFound, "Format for :before option #{before.inspect} was not found." if before && !formats.include?(before)
 
         add_formats.each do |format|
-          raise "Format #{format} is already included in #{type} formats" if formats.include?(format)
+          raise DuplicateFormat, "Format #{format.inspect} is already included in #{type.inspect} formats" if formats.include?(format)
 
           index = before ? formats.index(before) : -1
           formats.insert(index, format)
@@ -176,7 +180,7 @@ module Timeliness
       def remove_formats(type, *remove_formats)
         remove_formats.each do |format|
           unless send("#{type}_formats").delete(format)
-            raise "Format #{format} not found in #{type} formats"
+            raise FormatNotFound, "Format #{format.inspect} not found in #{type.inspect} formats"
           end
         end
         compile_formats

data/lib/timeliness/format.rb

@@ -1,9 +1,9 @@
 module Timeliness
-  class CompilationError < StandardError; end
-
   class Format
     include Helpers
 
+    CompilationFailed = Class.new(StandardError)
+
     attr_reader :format_string, :regexp, :regexp_string, :token_count
 
     def initialize(format_string)
@@ -41,7 +41,7 @@ module Timeliness
       @regexp = Regexp.new("^(#{format})$")
       self
     rescue => ex
-      raise CompilationError, "The format '#{format_string}' failed to compile using regexp string #{format}. Error message: #{ex.inspect}"
+      raise CompilationFailed, "The format '#{format_string}' failed to compile using regexp string #{format}. Error message: #{ex.inspect}"
     end
 
     # Redefined on compile

data/lib/timeliness/format_set.rb

@@ -23,7 +23,7 @@ module Timeliness
         regexp_string = "#{regexp_string}(#{format.regexp_string})|"
         index + format.token_count + 1 # add one for wrapper capture
       }
-      @regexp = Regexp.new("^(?:#{regexp_string.chop})$")
+      @regexp = %r[\A(?:#{regexp_string.chop})\z]
       self
     end
 

data/lib/timeliness/parser.rb

@@ -5,7 +5,8 @@ module Timeliness
     class << self
 
       def parse(value, *args)
-        return value unless value.is_a?(String)
+        return value if acts_like_temporal?(value)
+        return nil unless parseable?(value)
 
         type, options = type_and_options_from_args(args)
 
@@ -47,6 +48,14 @@ module Timeliness
 
       private
 
+      def parseable?(value)
+        value.is_a?(String)
+      end
+
+      def acts_like_temporal?(value)
+        value.is_a?(Time) || value.is_a?(Date) || value.respond_to?(:acts_like_date?) || value.respond_to?(:acts_like_time?)
+      end
+
       def type_and_options_from_args(args)
         options = args.last.is_a?(Hash) ? args.pop : {}
         type_or_now = args.first
@@ -129,7 +138,7 @@ module Timeliness
 
       # Taken from ActiveSupport and simplified
       def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
-       return nil if hour > 23 || min > 59 || sec > 59
+        return nil if hour > 23 || min > 59 || sec > 59
         ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
       rescue
         offset = utc_or_local == :local ? (::Time.local(2007).utc_offset.to_r/86400) : 0

data/lib/timeliness/version.rb

@@ -1,3 +1,3 @@
 module Timeliness
-  VERSION = '0.3.7'
+  VERSION = '0.3.8'
 end

data/spec/spec_helper.rb

@@ -1,37 +1,96 @@
-require 'rspec'
-
-require 'active_support/time'
-require 'timecop'
-require 'timeliness'
-require 'timeliness/core_ext'
-
-module TimelinessHelpers
-  def parser
-    Timeliness::Parser
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
-  def definitions
-    Timeliness::Definitions
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
   end
 
-  def parse(*args)
-    Timeliness::Parser.parse(*args)
-  end
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
 
-  def current_date(options={})
-    Timeliness::Parser.send(:current_date, options)
-  end
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
 
-  def should_parse(*args)
-    Timeliness::Parser.parse(*args).should_not be_nil
-  end
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
 
-  def should_not_parse(*args)
-    Timeliness::Parser.parse(*args).should be_nil
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
   end
-end
 
-RSpec.configure do |c|
-  c.mock_with :rspec
-  c.include TimelinessHelpers
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
 end

data/spec/timeliness/core_ext/string_spec.rb

@@ -1,71 +1,69 @@
-require 'spec_helper'
-
 describe Timeliness::CoreExt, 'String' do
   # Test values taken from ActiveSupport unit tests for compatibility
 
   describe "#to_time" do
     it 'should convert valid string to Time object in default zone' do
-      "2005-02-27 23:50".to_time.should eq Time.utc(2005, 2, 27, 23, 50)
+      expect("2005-02-27 23:50".to_time).to eq Time.utc(2005, 2, 27, 23, 50)
     end
 
     it 'should convert ISO 8601 string to Time object' do
-      "2005-02-27T23:50:19.275038".to_time.should eq Time.utc(2005, 2, 27, 23, 50, 19, 275038)
+      expect("2005-02-27T23:50:19.275038".to_time).to eq Time.utc(2005, 2, 27, 23, 50, 19, 275038)
     end
 
     context "with :local" do
       it 'should convert valid string to local time' do
-        "2005-02-27 23:50".to_time(:local).should eq Time.local(2005, 2, 27, 23, 50)
+        expect("2005-02-27 23:50".to_time(:local)).to eq Time.local(2005, 2, 27, 23, 50)
       end
 
       it 'should convert ISO 8601 string to local time' do
-        "2005-02-27T23:50:19.275038".to_time(:local).should eq Time.local(2005, 2, 27, 23, 50, 19, 275038)
+        expect("2005-02-27T23:50:19.275038".to_time(:local)).to eq Time.local(2005, 2, 27, 23, 50, 19, 275038)
       end
     end
 
     it 'should convert valid future string to Time object' do
-      "2039-02-27 23:50".to_time(:local).should eq Time.local_time(2039, 2, 27, 23, 50)
+      expect("2039-02-27 23:50".to_time(:local)).to eq Time.local(2039, 2, 27, 23, 50)
     end
 
     it 'should convert valid future string to Time object' do
-      "2039-02-27 23:50".to_time.should eq DateTime.civil(2039, 2, 27, 23, 50)
+      expect("2039-02-27 23:50".to_time).to eq DateTime.civil(2039, 2, 27, 23, 50)
     end
 
     it 'should convert empty string to nil' do
-      ''.to_time.should be_nil
+      expect(''.to_time).to be_nil
     end
   end
 
   describe "#to_datetime" do
     it 'should convert valid string to DateTime object' do
-      "2039-02-27 23:50".to_datetime.should eq DateTime.civil(2039, 2, 27, 23, 50)
+      expect("2039-02-27 23:50".to_datetime).to eq DateTime.civil(2039, 2, 27, 23, 50)
     end
 
     it 'should convert to DateTime object with UTC offset' do
-      "2039-02-27 23:50".to_datetime.offset.should eq 0
+      expect("2039-02-27 23:50".to_datetime.offset).to eq 0
     end
 
     it 'should convert ISO 8601 string to DateTime object' do
       datetime = DateTime.civil(2039, 2, 27, 23, 50, 19 + Rational(275038, 1000000), "-04:00")
-      "2039-02-27T23:50:19.275038-04:00".to_datetime.should eq datetime
+      expect("2039-02-27T23:50:19.275038-04:00".to_datetime).to eq datetime
     end
 
     it 'should use Rubys default start value' do
       # Taken from ActiveSupport unit tests. Not sure on the implication.
-      "2039-02-27 23:50".to_datetime.start.should eq ::Date::ITALY
+      expect("2039-02-27 23:50".to_datetime.start).to eq ::Date::ITALY
     end
 
     it 'should convert empty string to nil' do
-      ''.to_datetime.should be_nil
+      expect(''.to_datetime).to be_nil
     end
   end
 
   describe "#to_date" do
     it 'should convert string to Date object' do
-      "2005-02-27".to_date.should eq Date.new(2005, 2, 27)
+      expect("2005-02-27".to_date).to eq Date.new(2005, 2, 27)
     end
 
     it 'should convert empty string to nil' do
-      ''.to_date.should be_nil
+      expect(''.to_date).to be_nil
     end
   end
 

data/spec/timeliness/definitions_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Timeliness::Definitions do
 
   context "add_formats" do
@@ -9,7 +7,7 @@ describe Timeliness::Definitions do
 
     it "should add format to format array" do
       definitions.add_formats(:time, "h o'clock")
-      definitions.time_formats.should include("h o'clock")
+      expect(definitions.time_formats).to include("h o'clock")
     end
 
     it "should parse new format after its added" do
@@ -19,18 +17,18 @@ describe Timeliness::Definitions do
     end
 
     it "should raise error if format exists" do
-      expect { definitions.add_formats(:time, "hh:nn:ss") }.to raise_error
+      expect { definitions.add_formats(:time, "hh:nn:ss") }.to raise_error(Timeliness::Definitions::DuplicateFormat)
     end
 
     context "with :before option" do
       it "should add new format with higher precedence" do
         definitions.add_formats(:time, "ss:hh:nn", :before => 'hh:nn:ss')
         time_array = parser._parse('59:23:58', :time)
-        time_array.should eq [nil,nil,nil,23,58,59,nil,nil]
+        expect(time_array).to eq [nil,nil,nil,23,58,59,nil,nil]
       end
 
       it "should raise error if :before format does not exist" do
-        expect { definitions.add_formats(:time, "ss:hh:nn", :before => 'nn:hh:ss') }.to raise_error
+        expect { definitions.add_formats(:time, "ss:hh:nn", :before => 'nn:hh:ss') }.to raise_error(Timeliness::Definitions::FormatNotFound)
       end
     end
 
@@ -47,13 +45,13 @@ describe Timeliness::Definitions do
 
     it "should remove a single format from the formats array for type" do
       definitions.remove_formats(:time, 'h.nn_ampm')
-      definitions.time_formats.should_not include('h.nn_ampm')
+      expect(definitions.time_formats).not_to include('h.nn_ampm')
     end
 
     it "should remove multiple formats from formats array for type" do
       definitions.remove_formats(:time, 'h:nn', 'h.nn_ampm')
-      definitions.time_formats.should_not include('h:nn')
-      definitions.time_formats.should_not include('h.nn_ampm')
+      expect(definitions.time_formats).not_to include('h:nn')
+      expect(definitions.time_formats).not_to include('h.nn_ampm')
     end
 
     it "should prevent parsing of removed format" do
@@ -63,7 +61,7 @@ describe Timeliness::Definitions do
     end
 
     it "should raise error if format does not exist" do
-      expect { definitions.remove_formats(:time, "ss:hh:nn") }.to raise_error()
+      expect { definitions.remove_formats(:time, "ss:hh:nn") }.to raise_error(Timeliness::Definitions::FormatNotFound)
     end
 
     after do
@@ -74,14 +72,14 @@ describe Timeliness::Definitions do
 
   context "use_euro_formats" do
     it "should allow ambiguous date to be parsed as European format" do
-      parser._parse('01/02/2000', :date).should eq [2000,1,2,nil,nil,nil,nil,nil]
+      expect(parser._parse('01/02/2000', :date)).to eq [2000,1,2,nil,nil,nil,nil,nil]
       definitions.use_euro_formats
-      parser._parse('01/02/2000', :date).should eq [2000,2,1,nil,nil,nil,nil,nil]
+      expect(parser._parse('01/02/2000', :date)).to eq [2000,2,1,nil,nil,nil,nil,nil]
     end
 
     it "should not parse formats on switch to euro after initial compile" do
       definitions.compile_formats
-      Timeliness::FormatSet.should_not_receive(:compile)
+      expect(Timeliness::FormatSet).not_to receive(:compile)
       definitions.use_euro_formats
     end
   end
@@ -92,14 +90,14 @@ describe Timeliness::Definitions do
     end
 
     it "should allow ambiguous date to be parsed as European format" do
-      parser._parse('01/02/2000', :date).should eq [2000,2,1,nil,nil,nil,nil,nil]
+      expect(parser._parse('01/02/2000', :date)).to eq [2000,2,1,nil,nil,nil,nil,nil]
       definitions.use_us_formats
-      parser._parse('01/02/2000', :date).should eq [2000,1,2,nil,nil,nil,nil,nil]
+      expect(parser._parse('01/02/2000', :date)).to eq [2000,1,2,nil,nil,nil,nil,nil]
     end
 
     it "should not parse formats on switch to euro after initial compile" do
       definitions.compile_formats
-      Timeliness::FormatSet.should_not_receive(:compile)
+      expect(Timeliness::FormatSet).not_to receive(:compile)
       definitions.use_us_formats
     end
   end

data/spec/timeliness/format_set_spec.rb

@@ -1,12 +1,10 @@
-require 'spec_helper'
-
 describe Timeliness::FormatSet do
   context "#compile!" do
     let(:set) { Timeliness::FormatSet.new(['yyyy-mm-dd', 'dd/mm/yyyy']) }
 
     it 'should set the regexp for the set' do
       set.compile!
-      set.regexp.should_not be_nil
+      expect(set.regexp).not_to be_nil
     end
   end
 
@@ -28,8 +26,8 @@ describe Timeliness::FormatSet do
       format_tests.each do |format, values|
         it "should correctly match times in format '#{format}'" do
           regexp = compile_regexp(format)
-          values[:pass].each {|value| value.should match(regexp)}
-          values[:fail].each {|value| value.should_not match(regexp)}
+          values[:pass].each {|value| expect(value).to match(regexp)}
+          values[:fail].each {|value| expect(value).not_to match(regexp)}
         end
       end
     end
@@ -51,8 +49,8 @@ describe Timeliness::FormatSet do
       format_tests.each do |format, values|
         it "should correctly match dates in format '#{format}'" do
           regexp = compile_regexp(format)
-          values[:pass].each {|value| value.should match(regexp)}
-          values[:fail].each {|value| value.should_not match(regexp)}
+          values[:pass].each {|value| expect(value).to match(regexp)}
+          values[:fail].each {|value| expect(value).not_to match(regexp)}
         end
       end
     end
@@ -65,8 +63,8 @@ describe Timeliness::FormatSet do
       format_tests.each do |format, values|
         it "should correctly match datetimes in format '#{format}'" do
           regexp = compile_regexp(format)
-          values[:pass].each {|value| value.should match(regexp)}
-          values[:fail].each {|value| value.should_not match(regexp)}
+          values[:pass].each {|value| expect(value).to match(regexp)}
+          values[:fail].each {|value| expect(value).not_to match(regexp)}
         end
       end
     end
@@ -77,21 +75,21 @@ describe Timeliness::FormatSet do
     let(:set) { Timeliness::FormatSet.compile(['yyyy-mm-dd', 'dd/mm/yyyy']) }
 
     it 'should return array if string matches a format in set' do
-      set.match('2000-01-02').should be_kind_of(Array)
+      expect(set.match('2000-01-02')).to be_kind_of(Array)
     end
 
     it 'should return nil if string does not matches a format in set' do
-      set.match('2nd Feb 2000').should be_nil
+      expect(set.match('2nd Feb 2000')).to be_nil
     end
 
     it 'should only use specific format string for match if provided' do
-      set.match('2000-01-02', 'yyyy-mm-dd').should be_kind_of(Array)
-      set.match('2000-01-02', 'dd/mm/yyyy').should be_nil
+      expect(set.match('2000-01-02', 'yyyy-mm-dd')).to be_kind_of(Array)
+      expect(set.match('2000-01-02', 'dd/mm/yyyy')).to be_nil
     end
 
     it 'should compile unknown format for one off match' do
-      set.match('20001011').should be_nil
-      set.match('20001011', 'yyyymmdd').should be_kind_of(Array)
+      expect(set.match('20001011')).to be_nil
+      expect(set.match('20001011', 'yyyymmdd')).to be_kind_of(Array)
     end
   end