dater 0.2.7 → 0.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dater (0.2.6)
+    dater (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,6 +3,8 @@
 Dater
 =====
 
+Dater
+
 Convert a period of time expressed in a literal way like 'in 2 days' to a formatted future date with a given format. It aims to be helpful in regression tests when you have to deal with dinamic dates.
 
 You can also, convert dates from 'dd/mm/yyyy' to 'yyyy-mm-dd' or viceversa.
@@ -29,54 +31,101 @@ Or install it yourself as:
 
 ## Usage
 
-	#Require gem
+    require 'dater'
+
+    date=Dater::Resolver.new('%Y-%m-%d')
+
+    #date.for(String) 
+    #Example:
+    date.for("in 2 weeks")
+    =begin
+    String could be:
+    "in 4 days"     # => yyyy-mm-dd (date for 4 days from the date of today)
+    "in 2 weeks"    # => yyyy-mm-dd (date for 2 weeks from the date of today)
+    "in 10 months"  # => yyyy-mm-dd (date for 10 months from the date of today)
+    "in 1 year"     # => yyyy-mm-dd (date for 1 year from the date of today)
+    "next day"      # => yyyy-mm-dd (date for tomorrow from the date of today)
+    "next week"     # => yyyy-mm-dd (adds a period of time for a week and returns the date)
+    "next month"    # => yyyy-mm-dd (adds a period of time for a month and returns the date)
+    "next year"     # => yyyy-mm-dd (adds a period of time for a year and returns the date)
+    "yesterday"     # => yyyy-mm-dd (date of yesterday)
+    "today"         # => yyyy-mm-dd (date of today)
+    "tomorrow"      # => yyyy-mm-dd (date of tomorrow)
+    "2 days ago"	# => yyyy-mm-dd (N days ago from today)
+    "3 weeks ago"	# => yyyy-mm-dd (N weeks ago from today)
+    "4 months ago"	# => yyyy-mm-dd (N months ago from today)
+    "1 year ago"	# => yyyy-mm-dd (N year ago from today)
+
+    #Some equivalent methods you can use:
+    date.yesterday
+    date.today
+    date.tomorrow
+    date.sunday
+    date.monday
+    date.thuesday
+    date.wednesday
+    date.thursday
+    date.friday
+    date.saturday
+    date.next_day
+    date.next_week
+    date.next_month
+    date.next_year
+    =end
+
+# Special feature
+
+later and before
+
+Giving the keywords 'later' or 'before' at the end of the string, Dater allows you to request dates from the last date requested. If there isn't any date requested previously, it takes as last requested date today's date
+
+    date.for("2 days later") # => You will get the date for two days later from the last requested date.
+Example: Supose that the last requested date was 10/12/2013 (dd/mm/YYYY), using '2 days later' will give the result '12/12/2013'. 
+
+    date.for("1 month before") # => You will get the date for one month before from the last requested date.
 
-	require 'dater'
+If the argument is nil, it will return nil. But you can initialize Dater object with 'today_for_nil' flag like:
 
-	#Initialize a dater object with a format to convert to:
+    date = Dater::Resolver.new("%Y-%m-%d", true)
 
-	date=Dater::Resolver.new('%Y-%m-%d')
+    date.for #=> yyyy-mm-dd (date of today)
 
-	#To get the converted date:
+You'll find format directives at following link:
 
-	date.for("in 4 days") # => yyyy-mm-dd (date for 4 days from the date of today)
-	date.for("in 2 weeks") # => yyyy-mm-dd (date for 2 weeks from the date of today)
-	date.for("in 10 months") # => yyyy-mm-dd (date for 10 months from the date of today)
-	date.for("in 1 year") # => yyyy-mm-dd (date for 1 year from the date of today)
+http://apidock.com/ruby/Time/strftime
 
-	date.for("today") # => yyyy-mm-dd (date of today)
+It does not work correctly with leap-years and calculates months of 30 days only.
 
-	date.for("tomorrow") # => yyyy-mm-dd (date of tomorrow)
 
-	date.for("yesterday") # => yyyy-mm-dd (date of yesterday)
+It supports following languages: English (lang='en'), Spanish (lang='es') and Portuguese (lang='pt')
 
-If the argument is nil, it will return nil. But you can initialize Dater object with 'today_for_nil' flag like:
+***
 
-	date = Dater::Resolver.new("%Y-%m-%d", true)
 
-	date.for #=> yyyy-mm-dd (date of today)
+Si deseas usar esta gema en español puedes inicializar la clase de la siguiente manera:
 
-You'll find format directives at following link:
+    fecha=Dater::Resolver.new('%Y-%m-%d', false, "es")
+    fecha.para("en 1 semana")
+    fecha.ayer
+    fecha.hoy
+    fecha.mañana
 
-http://apidock.com/ruby/Time/strftime
 
-It does not work correctly with leap-years and calculates months of 30 days only.
+Con eso puedes pasar argumentos en idioma español (por ejemplo 'en 2 días', 'en 10 meses', 'en 1 año')
 
-==================================================
 
-Si deseas usar esta gema en español puedes inicializar la clase de la siguiente manera:
+***
 
-	date=Dater::Resolver.new('%Y-%m-%d', false "es")
+Se você quiser usar esta gem em Português, você pode inicializar a classe da seguinte forma:
 
-Con eso puedes pasar argumentos en idioma español (por ejemplo 'en 2 días', 'en 10 meses', 'en 1 año')
+    data=Dater::Resolver.new('%Y-%m-%d', false, "pt")
+    data.para("em 2 dias")
 
-==================================================
+## Contributor
 
-Se você quiser usar esta gem em Português, você pode inicializar a classe da seguinte forma:
+Federico Hertzulis
 
-	date=Dater::Resolver.new('%Y-%m-%d', "pt")
 
-Com isso você pode passar argumentos em Português (em 2 dias, em 10 meses, 1 ano)
 ## Contributing
 
 1. Fork it

data/dater.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |spec|
   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"
 end

data/lib/dater.rb

@@ -1,6 +1,5 @@
-# coding: utf-8
+# encoding: utf-8
 require 'date'
-require_relative "dater/version"
 
 module Dater
   
@@ -8,197 +7,312 @@ module Dater
 		
 		attr_accessor :format, :lang
 
-		DICTIONARY = {
-			day:  		{ "en"=>/day/, 			"es" => /(dia|día)/,  "pt" => /dia/, 	:mult =>	86400},
-			week: 		{ "en"=>/week/, 		"es" => /semana/, 		"pt" => /semana/, :mult =>	604800},
-			month: 		{ "en"=>/month/,		"es" => /mes/, 				"pt" => /mes/, 	:mult =>  2592000},
-			year: 		{ "en"=>/year/, 		"es" => /año/, 				"pt" => /ano/, 	:mult =>  31536000},
-			today: 		{ "en"=>'today', 		"es" => 'hoy', 				"pt" => 'hoje' 	},
-			tomorrow: { "en"=>'tomorrow', "es" => 'mañana',			"pt" => 'manhã' 	},
-			yesterday:{ "en"=>'yesterday',"es" => 'ayer', 			"pt" => 'ontem' 	}
-		}
 
 		# Creates a Dater::Resolver object
 		#
 		# @param [String] format = date format
-		# @param [Boolean] today_for_nil = Indicates if must return today'd date if argument in for method is nil
 		# @param [String] lang = languaje for matching (en=english, es=spanish, pt=portuguese)
-		def initialize(format='%Y-%m-%d', today_for_nil=false, lang="en")
+		# @param [Boolean] today_for_nil = Indicates if must return today's date if given argument is nil
+		def initialize(format='%Y-%m-%d', lang="en", today_for_nil=false)
 			@today_for_nil=today_for_nil
 			@format=format
-			@lang=lang if ["en","es","pt"].include? lang
+			@lang=lang if ["en","es","pt"].include? lang 
 		end
 
+
+
 		# Convert the period of time passed as argument to the configured format
 		#
-		# @param [String] period = a period of time like "in 3 days" or "in 10 months" or "in 2 years". It could be a formatted date to convert to the wanted format
-		# @return [String] converted date to the configured format. If period is nil, returns date for tomorrow 
+		# @param [String] period = a period of time expreseed in a literal way to convert to the configured format (@format)
+		# @return [String] converted date to the configured format. If period is nil and @today_for_nil is true, returns date for tomorrow. Else returns nil
 		def for(period=nil)
-			if period.nil?
-				return  @today_for_nil ? (Time.now).strftime(@format) : nil
-			end
-			@date=case period.downcase 	
-			when DICTIONARY[:today][@lang]
-				self.today(false)
-			when DICTIONARY[:tomorrow][@lang]
-				self.tomorrow(false)
-			when DICTIONARY[:yesterday][@lang]
-				self.yesterday(false)
-			when /\d+.\d+.\d+/
-				time_from_date(period)	
-			when /\d+\s.+/
-				Time.now+period.scan(/\d+/)[0].to_i*multiply_by(period)
-			else
+			if period.nil? or period == ""
+				period = now.strftime(@format) if today_for_nil
 				return period
+			else
+ 				@last_date = @date = time_for_period(period)
+				@date.strftime(@format) if @date.respond_to? :strftime
 			end
-			 # unless parts.nil?
-			return @date.strftime(@format)
 		end
 
-		# Spanish for 'for' method
-		#
-		#
+		# Spanish and portuguese equivalent for 'for' method
+		# 
 		def para(period)
 			self.for(period)
 		end
 
-		# Returns the time for today
-		#
-		# @param [Boolean] formatted = indicates if has to return today time in configured format
-		# @return [Time] today's time (formatted or not)
-		def today(formatted=true)
-			time=Time.now
-			time=time.strftime(@format) if formatted
-			time
+
+		private 
+
+		PORTUGUESE = {
+			day:/dia/i,
+			week:/semana/i,
+			month:/mes/i,
+			year:/ano/i,
+			today:/hoje/,
+			tomorrow:/amanhã/i,
+			yesterday:/ontem/i,
+			in:/em/i,
+			next:/prox/i,
+			later:/depois/i,
+			ago:/atras/i, 
+			before:/antes/i,
+			monday:/segunda/i,
+			tuesday:/terca/i,
+			wednesday:/quarta/i,
+			thursday:/quinta/i,
+			friday:/sexta/i,
+			saturday:/sabado/i,
+			sunday:/domingo/i
+		}
+
+		SPANISH = {
+			day:/dia/i,
+			week:/semana/i,
+			month:/mes/i,
+			year:/año/i,
+			today:/hoy/i,
+			tomorrow:/mañana/i,
+			yesterday:/ayer/i,
+			in:/en/i,
+			next:/prox/i,
+			later:/despues/i,
+			ago:/atras/i,
+			before:/antes/i,
+			monday:/lunes/i,
+			tuesday:/martes/i,
+			wednesday:/miercoles/i,
+			thursday:/jueves/i,
+			friday:/viernes/i,
+			saturday:/sabado/i,
+			sunday:/domingo/i
+		}
+
+		TIME_IN_SECONDS = {
+			day: 86400,
+			week: 604800,
+			month: 2592000,
+			year: 31536000
+		}
+
+		WEEKDAYS 	= [	"sunday",	"monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]
+
+		def spanish_translator word
+			word.split(" ").map do |word|
+				translate_from_spanish word				
+			end.join(" ")
+		end
+		
+		def translate_from_spanish word
+			SPANISH.each_pair do |k,v|
+				return k.to_s if word =~ v
+			end
+			word
 		end
 
-		# Spanish for today method
-		def hoy
-			self.today(true)
+		def portuguese_translator word
+			word.split(" ").map do |word|
+				translate_from_portuguese word				
+			end.join(" ")
 		end
 
-		# Portuguese for today method
-		#
-		#
-		def hoje
-			self.today(true)
+		def translate_from_portuguese word
+			PORTUGUESE.each_pair do |k,v|
+				return k.to_s if word =~ v
+			end
+			word
 		end
 
-		# Returns the time for yesterday.
+		# Returns the formatted date according to the given period of time expresed in a literal way
 		# 
-		# @param [Boolean] formatted = indicates if has to return the value in configured format
-		# @return [Time] time for yesterday (formatted or not)
-		def yesterday(formatted=true)
-			time = one_day_diff(false)
-			time = time.strftime(@format) if formatted
-			time
+		# @param [String] period = time expressed literally (e.g: in 2 days)
+		# @return [String] formatted time
+		def time_for_period(period=nil)
+			word = english_for no_special_chars(period)
+			
+			@last_date = case word
+			
+			when /today/i
+				now
+
+			when /tomorrow/i
+				tomorrow_time
+
+			when /yesterday/i
+				yesterday_time
+
+			when /sunday/i, /monday/i, /tuesday/i, /wednesday/i, /thursday/i, /friday/i, /saturday/i 				
+				time_for_weekday(word)
+
+			when /next/i
+				now + period_of_time_from_string(word.gsub("next","1"))
+
+			when /last/i
+				now - period_of_time_from_string(word.gsub("last","1"))				
+
+			when /before/i
+				@last_date ||= now 
+				@last_date -=  period_of_time_from_string(word)
+
+			when /ago/i
+				@last_date  ||= now 
+				now - period_of_time_from_string(word)
+
+			when /later/i
+				@last_date ||= now
+				@last_date +=  period_of_time_from_string(word)
+
+			when /in/i
+				now + period_of_time_from_string(word)
+
+			when /day/i, /month/i, /week/i, /year/i
+				move_to(word)
+
+			when /\d+.\d+.\d+/
+				time_from_date(word)	
+			end
+				
+				return @last_date
+		end
+		
+		# Returns now time
+		# @return [Time] @last_date = today's time
+		def now
+			@last_date=Time.now
 		end
 
-		# Spanish for yesterday method
-		#
-		#
-		def ayer
-			self.yesterday(true)
+		def yesterday_time
+			@last_date = Time.now - TIME_IN_SECONDS[:day]
 		end
 
-		# Portuges for yesterday method
-		#
-		#
-		def ontem
-			self.yesterday(true)
+		def tomorrow_time
+			@last_date = Time.now + TIME_IN_SECONDS[:day]
 		end
 
+		def english_for(word=nil)
+			unless word.nil?
+				word = no_special_chars(word.downcase)
+			end
+			case @lang
+			when /es/,/sp/
+				spanish_translator word				
+			when /pt/,/port/
+				portuguese_translator word
+			else
+				word
+			end
+		end
 
-		# Returns time value for tomorrow. Formated or not according to formatted param
-		#
-		# @param [Boolean] formatted = if true time is returned with format
+
+		
+
+		# Returns one week/month/year of difference from today's date. Formatted or not according to formatted param
 		#
-		def tomorrow(formatted=true)
-			time = one_day_diff(true)
-			time=time.strftime(@format) if formatted
-			time
+		# @param [String] period = the factor of difference (day, week, month, year) from today's date
+		# @return [Time]
+		def next(period)
+			Time.now + multiply_by(period)
 		end
 
-		# Spanish for tomorrow method
+		# Returns one week/month/year of difference from today's date. Formatted or not according to formatted param
 		#
-		# 
-		def mañana
-			self.tomorrow(true)
+		# @param [String] period = the factor of difference (day, week, month, year) from today's date
+		# @return [Time]
+		def last(period)
+			Time.now - multiply_by(period)
 		end
 
-		# Portugues for tomorrow method
-		#
-		#
-		def manhã
-			self.tomorrow(true)
+		# Returns the number of seconds for the given string to add or substract according to argument
+		# If argument has the word 'last' it goes backward, else forward
+		def move_to(word)
+			word.scan(/last/i).size>0 ? self.last(word) : self.next(word)
 		end
 
-		# Return one day of difference. One day more or less according to plus param. It is used by tomorrow and yesterday methods
-		#
-		# @param [Boolean] plus = if true, return one day more, else one day before
-		# @return [Time]
-		def one_day_diff(plus=true)
-			time=Time.now
-			diff = DICTIONARY[:day][:mult]
-			plus ? time+diff : time-diff
+		def time_for_weekday(word)
+			day = WEEKDAYS.select{ |day| day if day==word.scan(/[a-zA-Z]+/).last }.join
+			@count = Time.now
+			
+			# Add one day if today is the same required week day 
+			@count += move_a_day(word) if is_required_day?(@count, day)
+			
+			until is_required_day?(@count, day)
+				@count+= move_a_day(word)
+			end
+			@count
+
 		end
 
-	private
+		# Return a day to add or substrac according to the given word
+		# Substract if word contains 'last' word
+		# @return +/-[Fixnum] time in seconds for a day (+/-)
+		def move_a_day(word)
+			word.scan(/last/i).size > 0 ? a_day_backward : a_day_forward
+		end
+
+		# Returns the amount in seconds for a day (positive)
+		def a_day_forward
+			TIME_IN_SECONDS[:day]
+		end
+
+		# Returns the amount in seconds for a day (negative)
+		def a_day_backward
+			-TIME_IN_SECONDS[:day]
+		end
 
 		# Scans if period has day word
 		# 
-		# @param [String] period = a string to convert to configured format
+		# @param [String] period 
 		# @return [Boolean] true if perdiod contains the word day
 		def is_day?(period)
-			true if period.scan(DICTIONARY[:day][@lang]).size > 0
+			period.scan(/day/i).size > 0
 		end
 
 		# Multiplication factor for a day
 		# 
-		# @param [String] period = the string to convert to
+		# @param [String] period 
 		# @return [Fixnum] multiplication factor for a day
 		def day_mult(period)
-			DICTIONARY[:day][:mult] if is_day?(period)			 
+			TIME_IN_SECONDS[:day] if is_day?(english_for period)		 
 		end
 
 		# Scans if period has week word
 		# 
-		# @param [String] period = a string to convert to configured format
+		# @param [String] period 
 		# @return [Boolean] true if perdiod contains the word week
 		def is_week?(period)
-			true if period.scan(DICTIONARY[:week][@lang]).size > 0
+			period.scan(/week/i).size > 0
 		end
 
 		# Multiplication factor for a week
 		# 
-		# @param [String] period = the string to convert to
+		# @param [String] period 
 		# @return [Fixnum] multiplication factor for a week
 		def week_mult(period)
-			DICTIONARY[:week][:mult] if is_week?(period)
+			TIME_IN_SECONDS[:week] if is_week?(english_for period)
 		end
 
-		# Scans if period has week month
+		# Scans if period has month word
 		# 
-		# @param [String] period = a string to convert to configured format
+		# @param [String] period 
 		# @return [Boolean] true if perdiod contains the word month
 		def is_month?(period)
-			true if period.scan(DICTIONARY[:month][@lang]).size > 0
+			period.scan(/month/).size > 0
 		end
 		
 		# Multiplication factor for a month
 		# 
-		# @param [String] period = the string to convert to
+		# @param [String] period 
 		# @return [Fixnum] multiplication factor for a month
 		def month_mult(period)
-			DICTIONARY[:month][:mult] if is_month?(period)
+			TIME_IN_SECONDS[:month] if is_month?(english_for period)
 		end
 
-		# Scans if period has week year
+		# Scans if period string contain year word
 		# 
-		# @param [String] period = a string to convert to configured format
+		# @param [String] period to scan
 		# @return [Boolean] true if perdiod contains the word year
 		def is_year?(period)
-			true if period.scan(DICTIONARY[:year][@lang]).size > 0
+			period.scan(/year/i).size > 0
 		end
 
 		# Multiplication factor for a year
@@ -206,28 +320,93 @@ module Dater
 		# @param [String] period = the string to convert to
 		# @return [Fixnum] multiplication factor for a year
 		def year_mult(period)
-			DICTIONARY[:year][:mult] if is_year?(period)
+			TIME_IN_SECONDS[:year] if is_year?(english_for period)
 		end
 
-
-		# Set true the matched keyword in a given string
+		# Returns seconds to multiply by for the given string
 		# 
 		# @param [String] period = the period of time expressed in a literal way
-		# @param [String] lang = the languaje to eval
-		# @return [Hash] times
+		# @return [Fixnum] number to multiply by
 		def multiply_by(period)
 			return day_mult(period) || week_mult(period) || month_mult(period) || year_mult(period) || 1
 		end
+	
+		# Method to know if the day is the required day
+		# 
+		# @param [Time] time
+		# @param [String] day = to match in case statement
+		# @return [Boolean] = true if day is the required day
+		def is_required_day?(time, day)
+			case english_for(day).to_s
+			when /monday/i
+				time.monday? 
+			when /tuesday/i
+				time.tuesday? 
+			when /wednesday/i
+				time.wednesday? 
+			when /thursday/i
+				time.thursday? 
+			when /friday/i
+				time.friday? 
+			when /saturday/i
+				time.saturday? 
+			when /sunday/i
+				time.sunday? 
+			else
+				false
+			end
+		end
 
-		
 		# Return the Time object according to the splitted date in the given array  
-		# |
-		# @param [Array] date = date splitted
+		# 
+		# @param [String] date
 		# @return [Time] 
 		def time_from_date(date)
 			numbers=date.scan(/\d+/).map!{|i| i.to_i}
 			day=numbers[2-numbers.index(numbers.max)]
 			Date.new(numbers.max,numbers[1],day).to_time 
 		end
+
+		
+		# Returns the time according to the given string
+		#
+		# @param [String] word = period of time in literal way
+		# @return [Fixnum] multiplication factor (seconds)
+		def period_of_time_from_string(word)
+			word.scan(/\d+/)[0].to_i * multiply_by(word)
+		end
+
+		# Try to convert Missing methods to string and call to for method with converted string
+		# 
+		# 
+		def method_missing(meth)
+			# if meth.to_s =~ /^(next_|próximo_|proximo_|last_|último_|ultimo_|in_|\d_|for).+$/i
+			self.class.send :define_method, meth do
+				string = meth.to_s.gsub("_"," ")
+				self.for("for('#{string}')")
+			end
+			begin
+				self.send(meth.to_s)
+			rescue
+				raise "Method does not exists (#{meth})."
+			end
+		end
+
+		def no_special_chars(arg)
+			arg.\
+			gsub('á', 'a').\
+			gsub('é', 'e').\
+			gsub('í', 'i').\
+			gsub('ó', 'o').\
+			gsub('ú', 'u').\
+			gsub('ç', 'c').\
+			gsub('Á', 'a').\
+			gsub('É', 'e').\
+			gsub('Í', 'i').\
+			gsub('Ó', 'o').\
+			gsub('Ú', 'u').\
+			gsub('Ñ', 'n').\
+			gsub('Ç', 'c')
+		end
 	end
-end
+end

data/lib/dater/version.rb

@@ -1,3 +1,3 @@
 module Dater
-  VERSION = "0.2.7"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dater
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-13 00:00:00.000000000 Z
+date: 2013-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,12 +73,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -58735641299839235
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -58735641299839235
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25