Class: Backburner::DataObject

Inherits:
RecursiveOpenStruct
  • Object
show all
Defined in:
lib/backburner/data_object.rb

Constant Summary collapse

TIME_REGEXP = 
/(^\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}:\d{4})(-\d{2})$/

Instance Method Summary collapse

Constructor Details

#initialize(h = {}, args = {recurse_over_arrays: true}) ⇒ DataObject

Returns a new instance of DataObject.



10
11
12
 
# File 'lib/backburner/data_object.rb', line 10

def initialize h={}, args={recurse_over_arrays: true}
  super
end

Instance Method Details

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


51
52
53
 
# File 'lib/backburner/data_object.rb', line 51

def empty?
  @table.empty?
end

#new_ostruct_member(name) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/backburner/data_object.rb', line 14

def new_ostruct_member(name)
  name = name.to_sym
  unless self.respond_to?(name)
    class << self; self; end.class_eval do
      define_method(name) do
        v = @table[name]
        if v.is_a?(Hash)
          @sub_elements[name] ||= self.class.new(v, :recurse_over_arrays => @recurse_over_arrays)
        elsif v.is_a?(Array) and @recurse_over_arrays
          @sub_elements[name] ||= recurse_over_array v
        elsif v.is_a?(String)
          case v
            when /^\d+$/ then v.to_i
            when /^\d+\.\d+$/ then v.to_f
            when TIME_REGEXP then parse_time(v)
            when /^Yes$/i then true
            when /^No$/i then false
            else v
          end
        else
          v
        end
      end
      define_method("#{name}=") { |x| modifiable[name] = x }
      define_method("#{name}_as_a_hash") { @table[name] }
    end
  end
  name
end

#parse_time(time_string) ⇒ Object 



44
45
46
47
48
49
 
# File 'lib/backburner/data_object.rb', line 44

def parse_time(time_string)
  res = time_string.scan TIME_REGEXP
  time = Time.parse res[0][0]
  time += res[0][1].to_i*60*60
  time
end

#search(name) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/backburner/data_object.rb', line 55

def search name
  result = dig @table, name
  begin
    case result
      when /^\d+$/ then result.to_i
      when /^\d+\.\d+$/ then result.to_f
      when /^\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}:\d{4}-\d{2}$/ then Time.parse(result)
      when /^Yes$/i then true
      when /^No$/i then false
      else result
    end
  rescue
    result
  end
end

#to_xml ⇒ Object 



71
72
73
74
75
76
77
78
79
 
# File 'lib/backburner/data_object.rb', line 71

def to_xml
  builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
    xml.send @table.keys.first.to_s.camelize
  end
  document = builder.doc
  root_element = document.children[0]
  xml = xml_dig root_element, @table.values.first, document
  document.to_xml + "\n"
end