Class: Warekky::EraGroup

Inherits:
Object
  • Object
show all
Defined in:
lib/warekky/era_group.rb

Direct Known Subclasses

Ja

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ EraGroup

Returns a new instance of EraGroup.



6
7
8
 
# File 'lib/warekky/era_group.rb', line 6

def initialize
  @formats = self.class.formats.dup
end

Class Attribute Details

.parse_regexp_builder ⇒ Object

Returns the value of attribute parse_regexp_builder.



105
106
107
 
# File 'lib/warekky/era_group.rb', line 105

def parse_regexp_builder
  @parse_regexp_builder
end

Class Method Details

.era(first, last, key, sign, options = {}) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/warekky/era_group.rb', line 94

def era(first, last, key, sign, options = {})
  key = key.to_sym
  result = Era.new(key, sign, first, last, options).freeze
  eras << result
  result
end

.era_extra_names ⇒ Object 



101
102
103
 
# File 'lib/warekky/era_group.rb', line 101

def era_extra_names
  eras.map{|era| era.options.keys}.flatten.uniq
end

.era_replacements ⇒ Object 



118
119
120
 
# File 'lib/warekky/era_group.rb', line 118

def era_replacements
  @era_replacements ||= Regexp.union(eras.map(&parse_regexp_builder).flatten)
end

.eras ⇒ Object 



76
77
78
 
# File 'lib/warekky/era_group.rb', line 76

def eras
  @eras ||= []
end

.format(pattern, &block) ⇒ Object 



126
127
128
 
# File 'lib/warekky/era_group.rb', line 126

def format(pattern, &block)
  formats[pattern] = block
end

.formats ⇒ Object 



122
123
124
 
# File 'lib/warekky/era_group.rb', line 122

def formats
  @formats ||= {}
end

.formats_regexp ⇒ Object 



130
131
132
133
 
# File 'lib/warekky/era_group.rb', line 130

def formats_regexp
  @formats_regexp ||=
    Regexp.union(*formats.map{|(k,v)| /(#{Regexp.escape(k)})/})
end

.name_to_era ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/warekky/era_group.rb', line 79

def name_to_era
  unless @name_to_era
    @name_to_era = eras.inject({}) do |d, era|
      d[era.key] = era
      d[era.key.to_s] = era
      d[era.sign] = era
      era_extra_names.each do |extra_name|
        d[era[extra_name]] = era
      end
      d
    end
  end
  @name_to_era
end

.parse_regexp(&block) ⇒ Object 



106
107
108
 
# File 'lib/warekky/era_group.rb', line 106

def parse_regexp(&block)
  @parse_regexp_builder = block
end

.replace_before_parse(*replacements) ⇒ Object 



114
115
116
 
# File 'lib/warekky/era_group.rb', line 114

def replace_before_parse(*replacements)
  @replacements_before_parse = replacements
end

.replacements_before_parse ⇒ Object 



110
111
112
 
# File 'lib/warekky/era_group.rb', line 110

def replacements_before_parse
  @replacements_before_parse ||= []
end

Instance Method Details

#[](era_name_or_date_or_time) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/warekky/era_group.rb', line 57

def [](era_name_or_date_or_time)
  return nil unless era_name_or_date_or_time
  case era_name_or_date_or_time
  when Symbol, String then
    name_to_era[era_name_or_date_or_time]
  when Time, Date then
    eras.detect{|era| era.match?(era_name_or_date_or_time)}
  else
    raise ArgumentError, "#{self.class.name}#[] doesn't support #{era_name_or_date_or_time.inspect}"
  end
end

#parse(str, options = {}) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/warekky/era_group.rb', line 20

def parse(str, options = {})
  options = {
    :class => Date
  }.update(options || {})
  str = str.dup
  replacements_before_parse.each_with_index do |dic, idx|
    str.gsub!(replacements_regexp_before_parse[idx]){|s| dic[s]}
  end
  era_dic = name_to_era
  str.gsub!(era_replacements) do
    md = Regexp.last_match
    h = Hash[*md.captures]
    h.delete(nil)
    s = h.keys.first
    era = era_dic[s]
    raise ArgumentError, "Era not found for #{s.inspect}" unless era
    era.to_ad_year(h[s]).to_s
  end
  Warekky.try_without(options[:class], :parse, str)
end

#replacements_regexp_before_parse ⇒ Object 



69
70
71
72
73
 
# File 'lib/warekky/era_group.rb', line 69

def replacements_regexp_before_parse
  @replacements_regexp_before_parse ||=
    replacements_before_parse.map{|replacements|
    Regexp.union(*replacements.keys.map{|s| /(#{Regexp.escape(s)})/})}
end

#strftime(d, format) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/warekky/era_group.rb', line 41

def strftime(d, format)
  return Warekky.try_without(d, :strftime, format) unless formats_regexp.match(format)
  era = self[d]
  era_year = era ? era.to_era_year(d.year) : d.year
  format = format.dup
  format.gsub!(formats_regexp) do
    md = Regexp.last_match
    s = md.captures.compact.first
    rep = formats[s]
    raise ArgumentError, "replacement not found for #{s.inspect}" unless rep
    res = rep.call(era, era_year)
    res
  end
  Warekky.try_without(d, :strftime, format)
end