date_manager 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in date_manager.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2015 Fernando
+MIT License
+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,178 @@
+[![Build Status](https://semaphoreci.com/api/v1/projects/c1127eeb-9c13-44dd-baeb-155ce4a54493/425379/badge.svg)](https://semaphoreci.com/fegoa89/date-manager)
+# DateManager
+
+Parse, validate, manipulate, and display dates.
+
+# Start
+
+DateManager is a gem for convert/parse/compare two strings into date a DateTime object and manipulate them .
+For handle different dates format, I did this gem based on the most used formats in different countries (https://en.wikipedia.org/wiki/Date_format_by_country#Listing), from where I can divide it in three basic types :
+
+- MDY - Month/Day/Year mm/dd/yyyy
+- DMY - Day/Month/Year dd/mm/yyyy
+- YMD - Year/Month/Day yyyy/mm/dd
+
+# Using DateManager
+
+Create an instance:
+
+    $ @dates = DateManager.new('2012/02/02', '2012/02/03')
+
+The standard string input is the YMD format .
+
+You can set any other string input format (Like day - month - year) passing the date format as a third parameter like :
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+
+or
+
+    $ @dates = DateManager.new('12/30/2015', '12/31/2015', 'MDY')
+
+
+If the format is given as a DMY ( for example) and it does not contains a third parameter that indicates that the strings given are build on this format, the first date and the last date wont be possible to get set .
+You can use a '.' , '-' or '/' as a component separator for separate the different components of the dates, it will be translated into '/'.
+
+After a succesfull creation of an object, keep in mind the date range you are passing. The first date (first string given) should be older than the second date (second string given). If not it does not have sense (you can test it calling the method '#valid_date_range?' . The purpose of this gem is play between the dates of two dates :) )
+
+# Methods
+
+## start_date
+Returns the start_date object :
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+    $ @dates.start_date
+    $ #<DateTime: 2015-03-02T00:00:00+00:00 ((2457084j,0s,0n),+0s,2299161j)>
+
+## finish_date
+Returns the finish_date object :
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+    $ @dates.finish_date
+    $ #<DateTime: 2015-03-03T00:00:00+00:00 ((2457085j,0s,0n),+0s,2299161j)>
+
+## format
+Returns the date format :
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+    $ @dates.format
+    $ DMY
+
+## valid_date_range?
+
+Compares if the first string given is a date older than the second string given .
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+    $ @dates.valid_date_range?
+    $ true
+
+## days_between_dates
+
+Gives back the quantity of days between these dates
+
+    $ @dates = DateManager.new('02/03/2015', '03/03/2015', 'DMY')
+    $ @dates.days_between_dates
+    $ 1
+
+## months_between_dates
+
+Gives back the quantity of months between these dates
+
+    $ @dates = DateManager.new('02/02/2015', '03/03/2015', 'DMY')
+    $ @dates.months_between_dates
+    $ 1
+
+## years_between_dates
+
+Gives back the quantity of years between these dates
+
+    $ @dates = DateManager.new('03/03/2014', '03/03/2015', 'DMY')
+    $ @dates.years_between_dates
+    $ 1
+
+## start_date_leap_year?
+
+Returns true or false depending if the start_date object is a leap year or not
+    $ @dates = DateManager.new('03/03/2014', '03/03/2015', 'DMY')
+    $ @dates.start_date_leap_year?
+    $ false
+
+## finish_date_leap_year?
+
+Returns true or false depending if the finish_date object is a leap year or not
+
+Gives back the quantity of years between these dates
+
+    $ @dates = DateManager.new('03/03/2014', '03/03/2016', 'DMY')
+    $ @dates.finish_date_leap_year?
+    $ true
+
+## differences_between_dates
+
+Returns a hash containing the quantity of years / months / days between the dates
+
+    $ @dates = DateManager.new('03/03/2014', '03/03/2016', 'DMY')
+    $ @dates.differences_between_dates
+    $ {:years=>2, :months=>24, :days=>731}
+
+## readable_days_between_dates(language = {})
+
+Returns a string with quantity of days in between. Only Spanish and English are supported.
+
+    $ @dates = DateManager.new('02/02/2015', '03/03/2015', 'DMY')
+    $ @dates.readable_days_between_dates
+    $ 29 days
+
+## readable_months_between_dates(language = {})
+
+Returns a string with the quantity of months in between. Only Spanish and English are supported.
+
+    $ @dates = DateManager.new('02/02/2015', '03/04/2015', 'DMY')
+    $ @dates.readable_months_between_dates
+    $ 2 months
+
+## human_readable_format
+
+Returns a string with start_date and finish_date object in a human readable way . Only Spanish and English are supported.
+
+    $ @dates = DateManager.new('2012/02/01', '2012/02/03')
+    $ @dates.human_readable_format
+    $ "First date : February 01, 2012 Wednesday - Second date : February 03, 2012 Friday"
+
+## working_days
+
+Return quantity of working days between dates
+
+    $ @dates = DateManager.new('2012/02/01', '2012/02/03')
+    $ @dates.working_days
+    $ 3
+
+## total_weekend_days
+
+Return quantity of saturdays / sundays between dates
+
+    $ @dates = DateManager.new('2015/01/30', '2015/02/13')
+    $ @dates.total_weekend_days
+    $ 4
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'date_manager'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install date_manager
+
+
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/date_manager.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'date_manager/version'
+Gem::Specification.new do |spec|
+  spec.name = "date_manager"
+  spec.version = DateManager::VERSION
+  spec.authors = ["Fernando"]
+  spec.email = ["fgonzalezaguilera@gmail.com"]
+  spec.description = %q{Parse, validate, manipulate, and display dates.}
+  spec.summary = %q{}
+  spec.homepage = ""
+  spec.license = "MIT"
+  spec.files = `git ls-files`.split($/)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+end

data/lib/date_manager.rb

@@ -0,0 +1,87 @@
+require 'date'
+require 'yaml'
+require 'date_manager/version'
+require 'date_manager/date_parser'
+require 'date_manager/human_readable_parser'
+
+class DateManager
+
+  attr_accessor :start_date, :finish_date, :format
+
+  def initialize(start_date, finish_date, format = {})
+    @start_date, @finish_date = initialize_date_parser(start_date, finish_date, format).parse
+    @format = initialize_date_parser(start_date, finish_date, format).format
+  end
+
+  def valid_date_range?
+    # Compares if the start_date is lower than finish_date
+    @start_date < @finish_date
+  end
+
+  def days_between_dates
+    if valid_date_range?
+      @finish_date.mjd - @start_date.mjd
+    end
+  end
+
+  def months_between_dates
+    if valid_date_range?
+      (@finish_date.year * 12 + @finish_date.month) - (@start_date.year * 12 + @start_date.month)
+    end
+  end
+
+  def years_between_dates
+    if valid_date_range?
+      @finish_date.year - @start_date.year
+    end
+  end
+
+  def start_date_leap_year?
+    # Determines if a year is a leap year
+    Date.leap?( @start_date.year )
+  end
+
+  def finish_date_leap_year?
+    # Determines if a year is a leap year
+    Date.leap?( @finish_date.year )
+  end
+
+  def differences_between_dates
+    # Returns a hash that includes the quantity of years, months and days between
+    { years: years_between_dates, months: months_between_dates, days: days_between_dates }
+  end
+
+  def readable_days_between_dates(language = {})
+    # returns a string with the quantity of days between dates
+    if valid_date_range?
+      HumanReadableParser.days_between_dates( days_between_dates, language)
+    end
+  end
+
+  def human_readable_format(language = {})
+    # returns a string with start_date and finish_date object in a human readable way
+    HumanReadableParser.to_human_readable_date(@start_date, @finish_date, language)
+  end
+
+  def readable_months_between_dates(language = {})
+    # returns a string with the quantity of months between dates
+    HumanReadableParser.months_between_dates(months_between_dates, language)
+  end
+
+  def working_days
+    # Return quantity of working days
+    (@start_date..@finish_date).select{ |day| (1..5).include?(day.wday) }.length
+  end
+
+  def total_weekend_days
+    # Return quantity of weekend days
+    (@start_date..@finish_date).select{ |day| [0, 6].include?(day.wday) }.length
+  end
+
+  private
+
+    def initialize_date_parser(start_date, finish_date, format)
+      DateParser.new(start_date, finish_date, format)
+    end
+
+end

data/lib/date_manager/date_parser.rb

@@ -0,0 +1,93 @@
+class DateParser
+  # Valid date formats by country - based on https://en.wikipedia.org/wiki/Date_format_by_country#Listing
+  # Dates formats
+  # MDY -> mm/dd/yyyy  DateTime.parse("6/15/2012", '%m/%d/%Y') - ^\d{2}(-|.|\/)\d{2}(-|.|\/)\d{4}$
+  # DMY -> dd/mm/yyyy  DateTime.parse("15/6/2012", '%d/%m/%Y') - ^\d{2}(-|.|\/)\d{2}(-|.|\/)\d{4}$
+  # YMD -> yyyy/mm/dd  DateTime.parse("2012/6/15", '%Y/%m/%d') - ^\d{4}(-|.|\/)\d{2}(-|.|\/)\d{2}$ with seconds '^\d{4}(-|.|\/)\d{2}(-|.|\/)\d{2} \d{2}:\d{2}:\d{2}$/', '2008-09-01 12:35:45'
+  # DateParser.new('02/02/2012','02/02/2013', 'DMY')
+  attr_accessor :start_date, :finish_date, :format
+
+  OTHER_COMPONENT_SEPARATOR = {'.' => '/', '-' => '/'}
+  DATE_FORMAT               = ['MDY', 'DMY', 'YMD']
+
+  def initialize(start_date, finish_date, format = '')
+    @format      = get_format(format)
+    @start_date  = start_date
+    @finish_date = finish_date
+  end
+
+  def parse
+    if valid_country_format_date?
+      parse_date
+    end
+  end
+
+  private
+
+  def valid_country_format_date?
+    # Check if the format given is included into the date formats we can handle
+    DATE_FORMAT.include?(@format)
+  end
+
+  def get_format(format)
+    # If there is no format present, automatically assigns 'YMD' date format
+    ( format.nil? || format.empty? ) ? 'YMD' : analyze_format_string(format.upcase)
+  end
+
+  def analyze_format_string(format)
+    DATE_FORMAT.include?(format.upcase) ? format : nil
+  end
+
+  def has_correct_structure?(regex)
+    # Compares the string given for both dates with the regex expresion for
+    # this date format
+    @start_date =~ regex && @start_date =~ regex
+  end
+
+  def parse_date
+    # Validates and convert the string based on the date format
+    case @format
+      when 'MDY'
+        validate_string(date_format_structure[:mdy])
+      when 'DMY'
+        validate_string(date_format_structure[:dmy])
+      else
+        validate_string(date_format_structure[:ymd])
+    end
+  end
+
+  def validate_string(date_format)
+    # If the structure of the string coincides with the regex expression for this date format
+    # then it cleans the string if it contains the dates separated with '.' or '-'
+    # and convert it to an Date object
+    if has_correct_structure?(date_format[:regex])
+      clean_date_separator
+      convert_to_date_object(date_format[:structure])
+    end
+  end
+
+  def clean_date_separator
+    OTHER_COMPONENT_SEPARATOR.each do |key, value|
+      @start_date.gsub!(key, value)   if @start_date.include?(key)
+      @finish_date.gsub!(key, value)  if @finish_date.include?(key)
+    end
+  end
+
+  def date_format_structure
+    # Hash that contains the structure that this date format has (m - Month, d - Day, Y - Year)
+    # for be parsed to a valid Date object.
+    # Contains the regular expression for compare the exact position of the day, month
+    # and year, depending on the date format
+    {
+      mdy: { structure: '%m/%d/%Y', regex: /^\d{2}(-|.|\/)\d{2}(-|.|\/)\d{4}$/ },
+      dmy: { structure: '%d/%m/%Y', regex: /^\d{2}(-|.|\/)\d{2}(-|.|\/)\d{4}$/ },
+      ymd: { structure: '%Y/%m/%d', regex: /^\d{4}(-|.|\/)\d{2}(-|.|\/)\d{2}$/ }
+    }
+  end
+
+  def convert_to_date_object(structure)
+    # Returns two Date objects
+    [ DateTime.parse(@start_date, structure), DateTime.parse(@finish_date, structure) ]
+  end
+
+end

data/lib/date_manager/human_readable_parser.rb

@@ -0,0 +1,26 @@
+class HumanReadableParser
+
+  def self.to_human_readable_date(start_date, finish_date, language = {})
+    load_translation(language)["long_readable_format"] % { first_date: "#{start_date.strftime("%B %d, %Y %A")}", last_date: "#{finish_date.strftime("%B %d, %Y %A")}" }
+  end
+
+  def self.days_between_dates(days, language = {})
+    load_translation(language)["days_between_dates"] % { total_days: days }
+  end
+
+  def self.months_between_dates(months, language = {})
+    load_translation(language)["months_between_dates"] % { total_months: months }
+  end
+
+  private
+
+    def self.load_translation(language)
+      # Loads translation.yml
+      if not language.empty?
+        @file ||= YAML.load_file("lib/translations/translation.yml")[language]
+      else
+        @sfile ||= YAML.load_file("lib/translations/translation.yml")['en']
+      end
+    end
+
+end

data/lib/date_manager/version.rb

@@ -0,0 +1,3 @@
+class DateManager
+  VERSION = "0.0.1"
+end

data/lib/translations/translation.yml

@@ -0,0 +1,9 @@
+en:
+  long_readable_format:  'First date : %{first_date} - Second date : %{last_date}'
+  days_between_dates:    '%{total_days} days'
+  months_between_dates:  '%{total_months} months'
+
+es:
+  long_readable_format:  'Primera Fecha : %{first_date} - Segunda Fecha : %{last_date}'
+  days_between_dates:    '%{total_days} dias'
+  months_between_dates:  '%{total_months} meses'

data/spec/date_manager_spec.rb

@@ -0,0 +1,264 @@
+require 'date_manager'
+
+describe DateManager do
+
+  describe '#initialize' do
+    context 'with valid params given' do
+      cases = [ { first_date: '2012/02/02', second_date: '2012/02/03' , format: 'YMD', date_structure: '%Y/%m/%d' },
+                { first_date: '2012.02.02', second_date: '2012.02.03' , format: 'YMD', date_structure: '%Y/%m/%d' },
+                { first_date: '2012-02-02', second_date: '2012-02-03' , format: 'YMD', date_structure: '%Y/%m/%d' },
+                { first_date: '01/02/2015', second_date: '01/03/2015' , format: 'MDY', date_structure: '%m/%d/%Y' },
+                { first_date: '01.02.2015', second_date: '01.03.2015' , format: 'MDY', date_structure: '%m/%d/%Y' },
+                { first_date: '01-02-2015', second_date: '01-03-2015' , format: 'MDY', date_structure: '%m/%d/%Y' },
+                { first_date: '01/03/2015', second_date: '02/03/2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                { first_date: '01.03.2015', second_date: '02.03.2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                { first_date: '01-03-2015', second_date: '02-03-2015' , format: 'DMY', date_structure: '%d/%m/%Y' } ]
+
+      cases.each do |example|
+
+        let(:first_date_to_date)  { DateTime.parse( example[:first_date], example[:date_structure]) }
+
+        let(:second_date_to_date) { DateTime.parse( example[:second_date], example[:second_date]) }
+
+        let(:format) { example[:format] }
+
+        subject { DateManager.new( example[:first_date], example[:second_date], format ) }
+
+        it 'sets a date object on @start_date' do
+          expect( subject.start_date ).to eq( first_date_to_date )
+        end
+
+        it 'sets a date object on @finish_date' do
+          expect( subject.finish_date ).to eq( second_date_to_date )
+        end
+
+        it 'sets the format' do
+          expect( subject.format ).to eq( format )
+        end
+
+      end
+    end
+
+    context 'when no date format is given' do
+
+      ymd_cases = [ { first_date: '2012/02/02', second_date: '2012/02/03', date_structure: '%Y/%m/%d' },
+                    { first_date: '2012.02.02', second_date: '2012.02.03', date_structure: '%Y/%m/%d' },
+                    { first_date: '2012-02-02', second_date: '2012-02-03', date_structure: '%Y/%m/%d' } ]
+
+      context 'and the format dates have YMD format' do
+        ymd_cases.each do |example|
+
+          let(:first_date_to_date)  { DateTime.parse( example[:first_date], example[:date_structure]) }
+
+          let(:second_date_to_date) { DateTime.parse( example[:second_date], example[:second_date]) }
+
+          subject { DateManager.new( example[:first_date], example[:second_date] ) }
+
+          it 'only allow date strings with YMD format' do
+            expect( subject.start_date ).to eq( first_date_to_date )
+          end
+
+          it 'sets format to YMD' do
+            expect( subject.format ).to eq( 'YMD' )
+          end
+
+        end
+      end
+
+    end
+
+    context 'and the format dates are not YMD' do
+      cases = [ { first_date: '01/02/2015', second_date: '01/03/2015' , date_structure: '%m/%d/%Y' },
+                { first_date: '01.02.2015', second_date: '01.03.2015' , date_structure: '%m/%d/%Y' },
+                { first_date: '01-02-2015', second_date: '01-03-2015' , date_structure: '%m/%d/%Y' },
+                { first_date: '01/03/2015', second_date: '02/03/2015' , date_structure: '%d/%m/%Y' },
+                { first_date: '01.03.2015', second_date: '02.03.2015' , date_structure: '%d/%m/%Y' },
+                { first_date: '01-03-2015', second_date: '02-03-2015' , date_structure: '%d/%m/%Y' } ]
+
+      cases.each do |ymd|
+
+        subject { DateManager.new( ymd[:first_date], ymd[:second_date] ) }
+
+        it 'does not allow to set an object when no format is given and the date format is not YMD' do
+          expect( subject.start_date ).to  eq( nil )
+          expect( subject.finish_date ).to eq( nil )
+        end
+
+      end
+    end
+
+  end
+
+  describe '#valid_date_range?' do
+
+    context 'when the first date is smaller than the second date' do
+      it 'the result is true' do
+        expect( DateManager.new( '01/02/2015', '01/03/2015', 'DMY' ).valid_date_range? ).to be true
+      end
+    end
+
+    context 'when the first date is bigger than the second date' do
+      it 'the result is true' do
+        expect( DateManager.new( '02/03/2015', '01/03/2015', 'DMY' ).valid_date_range? ).to be false
+      end
+    end
+
+  end
+
+  describe '#days_between_dates' do
+
+    context 'with start date "01/02/2015" and finish date 01/03/2015' do
+      it 'the result is 28' do
+        expect( DateManager.new( '01/02/2015', '01/03/2015', 'DMY' ).days_between_dates ).to eq(28)
+      end
+    end
+
+    context 'without a valid date range' do
+      it 'the result is nil' do
+        expect( DateManager.new( '02/03/2015', '01/03/2015', 'DMY' ).days_between_dates ).to eq(nil)
+      end
+    end
+
+  end
+
+  describe '#months_between_dates' do
+
+    cases = [ { first_date: '01/02/2015', second_date: '01/03/2015' , expected_result: 1 },
+              { first_date: '01/02/2015', second_date: '02/02/2015' , expected_result: 0 },
+              { first_date: '01/12/2014', second_date: '02/12/2015' , expected_result: 12 },
+              { first_date: '02/03/2015', second_date: '01/03/2015' , expected_result: nil },
+              { first_date: '01/02/2015', second_date: '01/02/2015' , expected_result: nil } ]
+
+    context 'based on the above inputs' do
+      cases.each do |ymd|
+        it 'the result is #{ymd[:expected_result]}' do
+          expect( DateManager.new( ymd[:first_date], ymd[:second_date], 'DMY' ).months_between_dates ).to eq(ymd[:expected_result])
+        end
+      end
+    end
+
+  end
+
+  describe '#years_between_dates' do
+
+    cases = [ { first_date: '01/02/2015', second_date: '01/03/2015' , expected_result: 0 },
+              { first_date: '01/02/2015', second_date: '02/02/2015' , expected_result: 0 },
+              { first_date: '01/12/2014', second_date: '02/12/2015' , expected_result: 1 },
+              { first_date: '02/03/2015', second_date: '01/03/2015' , expected_result: nil },
+              { first_date: '01/02/2015', second_date: '01/02/2015' , expected_result: nil } ]
+
+    context 'based on the above inputs' do
+      cases.each do |ymd|
+        it 'the result is #{ymd[:expected_result]}' do
+          expect( DateManager.new( ymd[:first_date], ymd[:second_date], 'DMY' ).years_between_dates ).to eq(ymd[:expected_result])
+        end
+      end
+    end
+
+  end
+
+  describe '#differences_between_dates' do
+
+    context 'with start date "01/02/2015" and finish date 01/03/2015' do
+      it 'returns an array like {years: 0, months: 1, days: 28}' do
+        expect( DateManager.new( '01/02/2015', '01/03/2015', 'DMY' ).differences_between_dates ).to eq({years: 0, months: 1, days: 28})
+      end
+    end
+
+    context 'with start date "01/12/2014" and finish date 02/12/2015' do
+      it 'returns an array like {years: 1, months: 12, days: 366}' do
+        expect( DateManager.new( '01/12/2014', '02/12/2015', 'DMY' ).differences_between_dates ).to eq({years: 1, months: 12, days: 366})
+      end
+    end
+
+  end
+
+  describe '#start_date_leap_year?' do
+    context 'with start date "01/12/2016" and finish date 02/12/2020' do
+      it 'returns true - 2016 is a leap year' do
+        expect( DateManager.new( '01/12/2016', '02/12/2020', 'DMY' ).start_date_leap_year? ).to be true
+      end
+
+      it 'returns false - 2015 is not a leap year' do
+        expect( DateManager.new( '01/12/2015', '02/12/2020', 'DMY' ).start_date_leap_year? ).to be false
+      end
+    end
+  end
+
+  describe '#start_date_leap_year?' do
+    context 'with start date "01/12/2016" and finish date 02/12/2020' do
+      it 'returns true - 2020 is a leap year' do
+        expect( DateManager.new( '01/12/2015', '02/12/2020', 'DMY' ).finish_date_leap_year? ).to be true
+      end
+
+      it 'returns false - 2015 is not a leap year' do
+        expect( DateManager.new( '01/12/2015', '02/12/2015', 'DMY' ).finish_date_leap_year? ).to be false
+      end
+    end
+  end
+
+  describe '#human_readable_format' do
+    context 'with start date "01/12/2016" and finish date 02/12/2020' do
+      it 'returns -> "Date range between February 02, 2012 Thursday and February 03, 2012 Friday" ' do
+        expected_string = "First date : February 02, 2012 Thursday - Second date : February 03, 2012 Friday"
+        expect( DateManager.new( '2012/02/02', '2012/02/03' ).human_readable_format ).to eq(expected_string)
+      end
+    end
+  end
+
+  describe '#readable_days_between_dates' do
+    context 'with start date "2012/02/02" and finish date 2012/02/03' do
+      it 'returns -> "2 days" ' do
+        expected_string = "2 days"
+        expect( DateManager.new( '2012/02/01', '2012/02/03' ).readable_days_between_dates ).to eq(expected_string)
+      end
+    end
+  end
+
+  describe '#readable_months_between_dates' do
+    context 'with start date "2012/02/02" and finish date 2012/02/03' do
+      it 'returns -> "0 months" ' do
+        expected_string = "0 months"
+        expect( DateManager.new( '2012/02/01', '2012/02/03' ).readable_months_between_dates ).to eq(expected_string)
+      end
+    end
+  end
+
+  describe '#working_days' do
+    context 'with start date "2015/02/01" and finish date 2015/02/03' do
+      it 'returns 2 - First date is sunday and second tuesday' do
+        expect( DateManager.new( '2015/02/01', '2015/02/03' ).working_days ).to eq(2)
+      end
+    end
+
+    context 'with start date "2015/02/02" and finish date 2015/02/16' do
+      it 'returns 11 - First date is monday and second monday two weeks after' do
+        expect( DateManager.new( '2015/02/02', '2015/02/16' ).working_days ).to eq(11)
+      end
+    end
+
+    context 'with start date "2015/02/04" and finish date 2015/02/05' do
+      it 'returns 0 - First date is saturday and second sunday' do
+        expect( DateManager.new( '2015/04/04', '2015/04/05' ).working_days ).to eq(0)
+      end
+    end
+
+  end
+
+  describe '#total_weekend_days' do
+
+    cases = [ { first_date: '2015/02/02', second_date: '2015/02/05' , expected_result: 0 },
+              { first_date: '2015/02/01', second_date: '2015/02/03' , expected_result: 1 },
+              { first_date: '2015/01/30', second_date: '2015/02/13' , expected_result: 4 },
+              { first_date: '2015/01/30', second_date: '2015/02/20' , expected_result: 6 }]
+
+    context 'context based on the above inputs' do
+      cases.each do |ymd|
+        it 'the result is #{ymd[:expected_result]}' do
+          expect( DateManager.new( ymd[:first_date], ymd[:second_date] ).total_weekend_days ).to eq(ymd[:expected_result])
+        end
+      end
+    end
+
+  end
+end

data/spec/date_parser_spec.rb

@@ -0,0 +1,144 @@
+require 'date_manager'
+
+describe DateParser do
+
+  describe '#initialize' do
+
+      context 'with a valid date_format given' do
+
+        DateParser::DATE_FORMAT.each do |format|
+          it '#{format} gets set' do
+            expect( DateParser.new('', '', format).format ).to eq(format)
+          end
+
+          it '#{format} gets set if it is in a lowercase' do
+            expect( DateParser.new('', '', format.downcase).format ).to eq(format)
+          end
+
+        end
+      end
+
+      context 'with a wrong date_format given' do
+
+        context 'if date_format is not present' do
+          it 'is set to YMD' do
+            expect( DateParser.new('', '').format ).to eq('YMD')
+          end
+        end
+
+        context 'if date_format is empty' do
+          it 'is set to YMD' do
+            expect( DateParser.new('', '', '').format ).to eq('YMD')
+          end
+        end
+
+        context 'if date_format is nil' do
+          it 'is set to YMD' do
+            expect( DateParser.new('', '', '').format ).to eq('YMD')
+          end
+        end
+
+        context 'if date_format given is not correct' do
+          it 'is set to nil' do
+            expect( DateParser.new('', '', 'whatever').format ).to eq(nil)
+          end
+        end
+
+      end
+
+  end
+
+  describe '#parse' do
+
+    context 'with a valid start date and finish date' do
+      context 'and a wrong date_format given' do
+        it 'returns nil' do
+          expect( DateParser.new( '02/03/2015', '03/03/2015', nil).parse ).to eq(nil)
+        end
+      end
+
+      context 'and valid YMD dates' do
+
+        context 'with valid params given' do
+          ymd_cases = [ { first_date: '2012/02/02', second_date: '2012/02/03' , format: 'YMD', date_structure: '%Y/%m/%d' },
+                        { first_date: '2012.02.02', second_date: '2012.02.03' , format: 'YMD', date_structure: '%Y/%m/%d' },
+                        { first_date: '2012-02-02', second_date: '2012-02-03' , format: 'YMD', date_structure: '%Y/%m/%d' } ]
+
+          ymd_cases.each do |ymd|
+
+            let(:result_objects_array) { [ DateTime.parse( ymd[:first_date], ymd[:date_structure]), DateTime.parse( ymd[:second_date], ymd[:date_structure]) ] }
+
+            it 'returns 2 Date objects for YMD format' do
+              expect( DateParser.new( ymd[:first_date], ymd[:second_date], ymd[:format]).parse ).to eq(result_objects_array )
+            end
+          end
+        end
+      end
+
+      context 'and valid MDY dates' do
+
+        context 'with valid params given' do
+          mdy_cases = [ { first_date: '01/02/2015', second_date: '01/03/2015' , format: 'MDY', date_structure: '%m/%d/%Y' },
+                        { first_date: '01.02.2015', second_date: '01.03.2015' , format: 'MDY', date_structure: '%m/%d/%Y' },
+                        { first_date: '01-02-2015', second_date: '01-03-2015' , format: 'MDY', date_structure: '%m/%d/%Y' } ]
+
+          mdy_cases.each do |mdy|
+
+            let(:result_objects_array) { [ DateTime.parse( mdy[:first_date], mdy[:date_structure]), DateTime.parse( mdy[:second_date], mdy[:date_structure]) ] }
+
+            it 'returns 2 Date objects for YMD format' do
+              expect( DateParser.new( mdy[:first_date], mdy[:second_date], mdy[:format]).parse ).to eq(result_objects_array )
+            end
+          end
+        end
+      end
+
+      context 'and valid DMY dates' do
+
+        context 'with valid params given' do
+          dmy_cases = [ { first_date: '01/03/2015', second_date: '02/03/2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                        { first_date: '01.03.2015', second_date: '02.03.2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                        { first_date: '01-03-2015', second_date: '02-03-2015' , format: 'DMY', date_structure: '%d/%m/%Y' } ]
+
+          dmy_cases.each do |dmy|
+
+            let(:result_objects_array) { [ DateTime.parse( dmy[:first_date], dmy[:date_structure]), DateTime.parse( dmy[:second_date], dmy[:date_structure]) ] }
+
+            it 'returns 2 Date objects for YMD format' do
+              expect( DateParser.new( dmy[:first_date], dmy[:second_date], dmy[:format]).parse ).to eq(result_objects_array )
+            end
+          end
+        end
+      end
+    end
+
+  context 'when the format of the dates is not correct' do
+    context 'with no valid params given' do
+      dmy_cases = [ { first_date: '99/03/2015', second_date: '02/03/2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                    { first_date: '01.13.2015', second_date: '42.03.2015' , format: 'DMY', date_structure: '%d/%m/%Y' },
+                    { first_date: '00-03-2015', second_date: '02-19-2015' , format: 'DMY', date_structure: '%d/%m/%Y' } ]
+
+      dmy_cases.each do |dmy|
+        it 'returns an ArgumentError - invalid date' do
+          expect{ DateParser.new( dmy[:first_date], dmy[:second_date], dmy[:format]).parse }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  context 'when the format of the dates does not belong to the structured format' do
+    dmy_cases = [ { first_date: '01/03/2015', second_date: '02/03/2015' , format: 'YMD', date_structure: '%d/%m/%Y' },
+                  { first_date: '31.03.2015', second_date: '31.12.2015' , format: ''   , date_structure: '%d/%m/%Y' },
+                  { first_date: '2012-03-02', second_date: '2012-03-04' , format: 'DMY', date_structure: '%d/%m/%Y' } ]
+
+    dmy_cases.each do |dmy|
+      it 'returns an ArgumentError - invalid date' do
+        expect( DateParser.new( dmy[:first_date], dmy[:second_date], dmy[:format]).parse ).to be_nil
+      end
+    end
+
+  end
+
+  end
+
+end

data/spec/human_readable_parser_spec.rb

@@ -0,0 +1,48 @@
+require 'date_manager'
+
+describe HumanReadableParser do
+
+  subject { DateManager.new( '2012/02/01', '2012/02/03' ) }
+
+  describe '.to_human_readable_date' do
+    context "giving two DateTime object" do
+      it "should return an human readable string containing date, month and year" do
+        expected_string = "First date : February 01, 2012 Wednesday - Second date : February 03, 2012 Friday"
+        expect(HumanReadableParser.to_human_readable_date(subject.start_date, subject.finish_date)).to eq(expected_string)
+      end
+    end
+
+  end
+
+  describe '.days_between_dates' do
+    context "giving two DateTime object" do
+      it "should return an human readable string containing the days in between" do
+        expected_string = "2 days"
+        expect(HumanReadableParser.days_between_dates(subject.days_between_dates)).to eq(expected_string)
+      end
+    end
+
+    context "giving two DateTime object and a language" do
+      it "should return an human readable string containing the days in between translated to spanish" do
+        expected_string = "2 dias"
+        expect(HumanReadableParser.days_between_dates(subject.days_between_dates, 'es')).to eq(expected_string)
+      end
+    end
+  end
+
+  describe '.months_between_dates' do
+    context "giving two DateTime object" do
+      it "should return an human readable string containing the months in between" do
+        expected_string = "0 months"
+        expect(HumanReadableParser.months_between_dates(subject.months_between_dates)).to eq(expected_string)
+      end
+    end
+
+    context "giving two DateTime object and a language" do
+      it "should return an human readable string containing the months in between" do
+        expected_string = "0 meses"
+        expect(HumanReadableParser.months_between_dates(subject.months_between_dates, 'es')).to eq(expected_string)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'date_manager'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: date_manager
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Fernando
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse, validate, manipulate, and display dates.
+email:
+- fgonzalezaguilera@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- date_manager.gemspec
+- lib/date_manager.rb
+- lib/date_manager/date_parser.rb
+- lib/date_manager/human_readable_parser.rb
+- lib/date_manager/version.rb
+- lib/translations/translation.yml
+- spec/date_manager_spec.rb
+- spec/date_parser_spec.rb
+- spec/human_readable_parser_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/date_manager_spec.rb
+- spec/date_parser_spec.rb
+- spec/human_readable_parser_spec.rb
+- spec/spec_helper.rb