Class: String

Inherits:
Object show all
Defined in:
lib/ruby_units/string.rb,
lib/rails_units/string.rb

Overview

make a string into a unit

Instance Method Summary collapse

Instance Method Details

#%(*args) ⇒ Object

format unit output using formating codes ‘%0.2f’ % ‘1 mm’.unit => ‘1.00 mm’



12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/ruby_units/string.rb', line 12

def %(*args)
  return "" if self.empty?
  case
  when args.first.is_a?(Unit)
    args.first.to_s(self)
  when (!defined?(Uncertain).nil? && args.first.is_a?(Uncertain))
    args.first.to_s(self)
  when args.first.is_a?(Complex)
    args.first.to_s
  else
    unit_format(*args)
  end
end

#ago ⇒ Object

“5 min”.ago



44
45
46
 
# File 'lib/ruby_units/string.rb', line 44

def ago
  self.unit.ago
end

#before(time_point = ::Time.now) ⇒ Object 



48
49
50
 
# File 'lib/ruby_units/string.rb', line 48

def before(time_point = ::Time.now)
  self.unit.before(time_point)
end

#before_now ⇒ Object 



52
53
54
 
# File 'lib/ruby_units/string.rb', line 52

def before_now
  self.before('now')
end

#datetime(options = {}) ⇒ Object 



119
120
121
 
# File 'lib/ruby_units/string.rb', line 119

def datetime(options = {})
  self.to_datetime(options) rescue self.to_time(options)
end

#from(time_point = ::Time.now) ⇒ Object Also known as: after

“5 min”.from(“now”)



32
33
34
35
 
# File 'lib/ruby_units/string.rb', line 32

def from(time_point = ::Time.now)
  return old_from(time_point) if self.respond_to?(:old_from) && time_point.instance_of?(Integer)
  self.unit.from(time_point)
end

#from_now ⇒ Object 



39
40
41
 
# File 'lib/ruby_units/string.rb', line 39

def from_now
  self.from('now')
end

#old_from ⇒ Object

“5 min”.from(“now”)



28
29
30
31
 
# File 'lib/ruby_units/string.rb', line 28

def from(time_point = ::Time.now)
  return old_from(time_point) if self.respond_to?(:old_from) && time_point.instance_of?(Integer)
  self.unit.from(time_point)
end

#since(time_point = ::Time.now) ⇒ Object 



56
57
58
 
# File 'lib/ruby_units/string.rb', line 56

def since(time_point = ::Time.now)
  self.unit.since(time_point)
end

#time(options = {}) ⇒ Object 



64
65
66
 
# File 'lib/ruby_units/string.rb', line 64

def time(options = {})
  self.to_time(options) rescue self.to_datetime(options)
end

#to_date(options = {}) ⇒ Object

Raises:

  • (RuntimeError) 


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/ruby_units/string.rb', line 102

def to_date(options={})
  begin
    r = Chronic.parse(self,options).to_date
  rescue
    r = case
    when self == "today"
      Date.today
    when RUBY_VERSION < "1.9"
      Date.civil(*ParseDate.parsedate(self)[0..5].compact)
    else
      Date.parse(self)
    end
  end
  raise RuntimeError, 'Invalid Date String' if r == Date.new
  return r
end

#to_datetime(options = {}) ⇒ Object

Raises:

  • (RuntimeError) 


86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/ruby_units/string.rb', line 86

def to_datetime(options = {})
  begin
    # raises an exception if Chronic.parse = nil or if Chronic not defined
    r = Chronic.parse(self,options).send(:to_datetime)
  rescue Exception  => e
    r = case
    when self.to_s == "now"
      DateTime.now
    else
      DateTime.parse(self)
    end
  end
  raise RuntimeError, "Invalid Time String (#{self.to_s})" if r == DateTime.new
  return r
end

#to_time(options = {}) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/ruby_units/string.rb', line 68

def to_time(options = {})
  begin
    #raises exception when Chronic not defined or when it returns a nil (i.e., can't parse the input)
    r = Chronic.parse(self,options)
    raise(ArgumentError, 'Invalid Time String') unless r
    return r
  rescue
    case
    when self == "now"
      Time.now
    when Time.respond_to?(:parse)
      Time.parse(self)
    else
      Time.local(*ParseDate.parsedate(self))
    end
  end
end

#to_unit(other = nil) ⇒ Object Also known as: unit, u 



4
5
6
 
# File 'lib/ruby_units/string.rb', line 4

def to_unit(other = nil)
  other ? Unit.new(self).to(other) : Unit.new(self)
end

#unit_format ⇒ Object

format unit output using formating codes ‘%0.2f’ % ‘1 mm’.unit => ‘1.00 mm’



9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/ruby_units/string.rb', line 9

def %(*args)
  return "" if self.empty?
  case
  when args.first.is_a?(Unit)
    args.first.to_s(self)
  when (!defined?(Uncertain).nil? && args.first.is_a?(Uncertain))
    args.first.to_s(self)
  when args.first.is_a?(Complex)
    args.first.to_s
  else
    unit_format(*args)
  end
end

#until(time_point = ::Time.now) ⇒ Object 



60
61
62
 
# File 'lib/ruby_units/string.rb', line 60

def until(time_point = ::Time.now)
  self.unit.until(time_point)
end