Class: Songdrop::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/songdrop/parser.rb

Class Method Summary collapse

Class Method Details

.objectize(type, properties) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/songdrop/parser.rb', line 65

def self.objectize(type, properties)
  case type.to_sym
    when :user then User.new(properties)
    when :drop then Drop.new(properties)
    when :song then Song.new(properties)
    when :mix then Mix.new(properties)
    when :artist then Artist.new(properties)
    when :play then Play.new(properties)
    when :error then Error.new(properties)
    when :errors then Errors.new(properties)
    else "[Songdrop::Parser] Don't know how to objectize #{type}"
  end
end

.parse(response, headers = {}) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
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
 
# File 'lib/songdrop/parser.rb', line 4

def self.parse(response, headers={})

  if response.is_a?(Hash) and response['object']

    # we only got one object back
    return objectize(response['object'], parse_object(response))

  elsif response.is_a?(Hash)

    # we got a hash pointer to objects
    return response.keys.collect do |object|
      objectize(object, parse_object(response[object]))
    end

  elsif response.is_a? Array

    # we got an array of objects back
    result = response.collect do |object|
      properties = parse_object(object)
      objectize(object['object'], properties)
    end

    if headers[:x_pagination]
      collection = Collection.new(JSON.parse(headers[:x_pagination]))
      collection.replace(result)
      return collection
    else
      return result
    end

  else
    puts "[Songdrop::Parser] Unexpected response type #{response.class}"
    return response
  end
end

.parse_object(hash) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/songdrop/parser.rb', line 40

def self.parse_object(hash)
  # puts "[Songdrop::Parser] PARSE #{hash.inspect}"
  properties = {}

  hash.keys.each do |property|
    # puts "[Songdrop::Parser] #{property} is a #{property.class}"
    if hash[property].is_a?(Array)
      # puts "[Songdrop::Parser] parsing array #{property}"
      objects = []
      hash[property].each do |el|
        objects << objectize(el['object'], parse_object(el))
      end
      properties[property.to_sym] = objects
    elsif hash[property].is_a?(Hash) and hash[property]['object']
      # puts "[Songdrop::Parser] parsing hash #{property} of type #{hash[property]['object']}"
      object = objectize(hash[property]['object'], parse_object(hash[property]))
      properties[property.to_sym] = object
    else
      properties[property.to_sym] = hash[property]
    end
  end

  properties
end