hungry 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.rvmrc
+Gemfile.lock
+pkg/*
+tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format s

data/Gemfile

@@ -0,0 +1,13 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in eet.nu.gemspec
+gemspec
+
+# Support for guard:
+gem 'guard'
+gem 'guard-bundler'
+gem 'guard-rspec'
+gem 'guard-spork'
+gem 'rb-fsevent'
+gem 'rb-readline'
+gem 'fuubar'

data/Guardfile

@@ -0,0 +1,11 @@
+require 'rb-readline'
+
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec', version: 2, cli: '--format Fuubar --colour' do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/hungry.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'hungry'
+
+Gem::Specification.new do |s|
+  s.name        = 'hungry'
+  s.version     = Hungry::VERSION
+  s.authors     = ['Tom-Eric Gerritsen']
+  s.email       = ['tomeric@eet.nu']
+  s.homepage    = 'http://github.com/eet-nu/hungry'
+  s.summary     = %q{An interface to the Eet.nu API.}
+  s.description = %q{An interface to the Eet.nu API.}
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  # specify any dependencies here:
+  s.add_dependency 'httparty'
+  s.add_dependency 'rack'
+  
+  # specify any development dependencies here:
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'fakeweb'
+end

data/lib/hungry.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH << File.expand_path('..', __FILE__)
+
+require 'support/presence'
+require 'support/symbolize_keys'
+
+module Hungry
+  VERSION = '0.0.1'
+  
+  class << self
+    attr_accessor :api_url
+  end
+  
+  self.api_url = 'http://api.eet.nu/'
+  
+  ### LIBRARY:
+  
+  autoload :City,        'hungry/city'
+  autoload :Collection,  'hungry/collection'
+  autoload :Country,     'hungry/country'
+  autoload :Geolocation, 'hungry/geolocation'
+  autoload :Location,    'hungry/location'
+  autoload :Region,      'hungry/region'
+  autoload :Resource,    'hungry/resource'
+  autoload :Review,      'hungry/review'
+  autoload :Site,        'hungry/site'
+  autoload :Tag,         'hungry/tag'
+  autoload :Util,        'hungry/util'
+  autoload :Venue,       'hungry/venue'
+  
+  ### EXCEPTIONS:
+  
+  # Exception raised when a geolocation is required, but it is not given:
+  class GeolocationNotGiven  < StandardError; end
+  
+  # Exception raised when an endpoint is not specified for a resource:
+  class EndpointNotSpecified < StandardError; end
+end

data/lib/hungry/city.rb

@@ -0,0 +1,7 @@
+module Hungry
+  class City < Location
+    
+    self.default_criteria = { type: 'City' }
+    
+  end
+end

data/lib/hungry/collection.rb

@@ -0,0 +1,65 @@
+require 'httparty'
+require 'cgi'
+
+module Hungry
+  class Collection
+    include Enumerable
+    include HTTParty
+    
+    autoload :Pagination, 'hungry/collection/pagination'
+    
+    attr_reader :klass, :endpoint, :criteria
+    
+    ### CLASS METHODS:
+    
+    def self.get(*args)
+      puts "[Collection]: GET #{args.map(&:inspect).join(', ')}"
+      self.base_uri Hungry.api_url
+      super
+    end
+    
+    ### INSTANCE METHODS:
+    
+    def initialize(klass, endpoint, criteria = {})
+      @klass    = klass
+      @endpoint = endpoint
+      @criteria = criteria.symbolize_keys
+    end
+    
+    def from_url(url)
+      uri     = URI.parse(url)
+      options = Util.params_from_uri(uri) || klass.default_criteria
+      
+      self.class.new(klass, uri.path, options)
+    end
+    
+    def all(new_criteria = {})
+      self.class.new(klass, endpoint, criteria.merge(new_criteria))
+    end
+    
+    def count(*args)
+      if args.present?
+        super
+      else
+        response['results'].count
+      end
+    end
+    
+    def each(&block)
+      response['results'].each do |result|
+        yield klass.new(result)
+      end
+    end
+    
+    private
+    
+    def response
+      raise NoEndpointSpecified unless endpoint
+      
+      @response ||= begin
+        uri = Util.uri_with_params(endpoint, criteria)
+        self.class.get uri
+      end
+    end
+  end
+end

data/lib/hungry/collection/pagination.rb

@@ -0,0 +1,71 @@
+module Hungry
+  class Collection
+    module Pagination
+      class NotPaginatedError < StandardError; end
+      
+      def paginate(page, options = {})
+        all options.merge(page: page)
+      end
+      
+      def paginated?
+        pagination.present?
+      end
+      
+      def per_page
+        if paginated?
+          pagination['per_page'].to_i
+        else
+          response['results'].length
+        end
+      end
+      
+      def total_entries
+        if paginated?
+          pagination['total_entries'].to_i
+        else
+          response['results'].length
+        end
+      end
+      
+      def total_pages
+        if paginated?
+          pagination['total_pages'].to_i
+        else
+          1
+        end
+      end
+      
+      def current_page
+        if paginated?
+          pagination['current_page'].to_i
+        else
+          1
+        end
+      end
+      
+      def previous_page
+        current_page - 1 if paginated? && current_page > 1
+      end
+      
+      def next_page
+        current_page + 1 if paginated? && current_page < total_pages
+      end
+      
+      def previous
+        raise NotPaginatedError unless paginated?
+        all page: previous_page if previous_page
+      end
+      
+      def next
+        raise NotPaginatedError unless paginated?
+        all page: next_page if next_page
+      end
+      
+      private
+      
+      def pagination
+        response['pagination']
+      end
+    end
+  end
+end

data/lib/hungry/country.rb

@@ -0,0 +1,7 @@
+module Hungry
+  class Country < Location
+    
+    self.default_criteria = { type: 'Country' }
+    
+  end
+end

data/lib/hungry/geolocation.rb

@@ -0,0 +1,63 @@
+module Hungry
+  class Geolocation
+    attr_accessor :latitude, :longitude
+    
+    def self.parse(input)
+      # input is already a Geolocation, so we can return it early:
+      return input if input.is_a?(self)
+
+      if input.respond_to?(:geolocation)
+        # input has a geolocation attribute, so try to use that one first:
+        geolocation = parse(input.geolocation) 
+        return geolocation if geolocation
+      end
+      
+      coordinates = []
+      
+      if input.respond_to?(:latitude) && input.respond_to?(:longitude)
+        # input has latitude and longitude attributes, so use those:
+        coordinates = [input.latitude, input.longitude]
+        
+      elsif input.respond_to?(:lat) && input.respond_to?(:lng)
+        # input has lat and lng attributes, so use those:
+        coordinates = [input.lat, input.lng]
+        
+      elsif input.respond_to?(:match)
+        # Example: "50.8469397,5.6927505"
+        #
+        # input is a String, so we can use a regular expression to extract
+        # latitude and longitude:
+        if match = input.match(/^(?<latitude>[0-9\.]+),\s?(?<longitude>[0-9\.]+)$/)
+          coordinates = [match[:latitude], match[:longitude]]
+        end
+        
+      elsif input.respond_to?(:keys)
+        # Example: { latitude: 50.8469397, longitude: 5.6927505 }
+        #
+        # input is a Hash, so we can extract values with the keys:
+        coordinates = [input[:latitude] || input[:lat], input[:longitude] || input[:lng]]
+        
+      elsif input.respond_to?(:[])
+        # Example: [50.8469397, 5.6927505]
+        #
+        # input is an Array, so we need the first and second value:
+        coordinates = input[0], input[1]
+      end
+      
+      coordinates = coordinates.map(&:presence).compact
+      
+      if coordinates.length == 2 && coordinates.all? { |coordinate| Util.is_numeric?(coordinate) }
+        new(*coordinates)
+      end
+    end
+    
+    def initialize(latitude, longitude)
+      self.latitude  = latitude.to_f
+      self.longitude = longitude.to_f
+    end
+    
+    def to_s
+      [latitude, longitude].join(',')
+    end
+  end
+end

data/lib/hungry/location.rb

@@ -0,0 +1,23 @@
+module Hungry
+  class Location < Resource
+    
+    self.endpoint = '/locations'
+    
+    ### ATTRIBUTES:
+    
+                  ### Location:
+    attr_accessor :id, :name, :type, :url, :geolocation,
+                  
+                  ### Utility:
+                  :resources, :counters
+    
+    ### RESOURCES:
+    
+    has_many :venues, Venue
+    
+    has_many :nearby_venues, Venue
+    
+    has_many :tags, Tag
+    
+  end
+end

data/lib/hungry/region.rb

@@ -0,0 +1,7 @@
+module Hungry
+  class Region < Location
+    
+    self.default_criteria = { type: 'Region' }
+    
+  end
+end

data/lib/hungry/resource.rb

@@ -0,0 +1,93 @@
+require 'httparty'
+
+module Hungry
+  class Resource
+    include HTTParty
+    
+    attr_accessor :attributes
+    
+    ### CLASS METHODS:
+    
+    def self.get(*args)
+      puts "[Resource]: GET #{args.map(&:inspect).join(', ')}"
+      self.base_uri Hungry.api_url
+      super
+    end
+    
+    def self.belongs_to(resource, klass = Resource)
+      define_method resource do
+        if url = resources[resource]
+          attributes = self.class.get url
+          klass.new(attributes)
+        end
+      end
+    end
+    
+    def self.has_many(resource, klass = Resource)
+      define_method resource do
+        if url = resources[resource]
+          klass.collection.from_url(url)
+        end
+      end
+    end
+    
+    class << self
+      include Enumerable
+      
+      attr_writer :endpoint
+      attr_writer :default_criteria
+      
+      def endpoint
+        @endpoint || (superclass.respond_to?(:endpoint) ? superclass.endpoint : nil)
+      end
+      
+      def default_criteria
+        if @default_criteria.respond_to?(:call)
+          @default_criteria.call
+        else
+          @default_criteria || {}
+        end
+      end
+      
+      def collection
+        Collection.new(self, endpoint, default_criteria)
+      end
+      
+      def find(id)
+        raise NoEndpointSpecified unless endpoint
+        
+        response = get "#{endpoint}/#{id}"
+        
+        if response.code == 200
+          new(response)
+        end
+      end
+      
+      def all(criteria = {})
+        collection.all(criteria)
+      end
+      
+      def each(&block)
+        all.each(&block)
+      end
+    end
+    
+    ### INSTANCE METHODS:
+    
+    def initialize(new_attributes = {})
+      self.attributes = {}
+      
+      new_attributes.each do |key, value|
+        if value.respond_to?(:symbolize_keys)
+          value = value.symbolize_keys
+        end
+        
+        attributes[key] = value
+        
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/hungry/review.rb

@@ -0,0 +1,19 @@
+require 'httparty'
+
+module Hungry
+  class Review < Resource
+    
+    ### ATTRIBUTES:
+    
+                  ### Review:
+    attr_accessor :id, :body, :rating, :scores, :author,
+                  
+                  ### Utility:
+                  :created_at, :updated_at
+    
+    ### RESOURCES:
+    
+    belongs_to :venue, Venue
+    
+  end
+end

data/lib/hungry/site.rb

@@ -0,0 +1,22 @@
+module Hungry
+  class Site < Resource
+    
+    self.endpoint = '/sites'
+    
+    ### ATTRIBUTES:
+    
+                  ### Preview:
+    attr_accessor :id, :name, :title, :subtitle, :identifier, :default, :locale,
+                  :url, :timezone, :country, :applications,
+                  
+                  ### Utility:
+                  :resources,  :counters
+    
+    ### FINDERS:
+    
+    def self.with_hostname(hostname)
+      collection.all(hostname: hostname).first
+    end
+    
+  end
+end

data/lib/hungry/tag.rb

@@ -0,0 +1,21 @@
+module Hungry
+  class Tag < Resource
+    
+    self.endpoint = '/tags'
+    
+    ### ATTRIBUTES:
+    
+                  ### Tag:
+    attr_accessor :id, :name, :context,
+                  
+                  ### Utility:
+                  :resources, :counters
+    
+    ### RESOURCES:
+    
+    has_many :venues, Venue
+    
+    has_many :tags, Tag
+    
+  end
+end

data/lib/hungry/util.rb

@@ -0,0 +1,26 @@
+require 'cgi'
+require 'rack/utils'
+
+module Hungry
+  module Util
+    extend self
+    
+    def params_from_uri(uri)
+      uri = URI.parse(uri) unless uri.is_a?(URI)
+      Rack::Utils.parse_query(uri.query) if uri.query.present?
+    end
+    
+    def uri_with_params(uri, params = {})
+      params = params.map { |k,v| "#{k}=#{CGI.escape(v.to_s)}" }
+                     .join('&')
+                     .presence
+      
+      [uri, params].compact
+                   .join('?')
+    end
+    
+    def is_numeric?(value)
+      value.to_s =~ /^[+-]?[\d]+(\.[\d]+){0,1}$/
+    end
+  end
+end

data/lib/hungry/venue.rb

@@ -0,0 +1,57 @@
+module Hungry
+  class Venue < Resource
+    autoload :Collection, 'hungry/venue/collection'
+    
+    self.endpoint = '/venues'
+    
+    ### RESOURCES:
+    
+    has_many :reviews, Review
+    
+    belongs_to :country, Country
+    
+    belongs_to :region, Region
+    
+    belongs_to :city, City
+    
+    ### ATTRIBUTES:
+    
+                  ### Preview:
+    attr_accessor :id, :name, :category, :telephone, :fax, :website_url,
+                  :tagline, :rating, :url, :address, :geolocation, :relevance,
+                  :distance, :plan,
+                  
+                  ### Full:
+                  :reachability, :staff, :prices, :capacity, :description,
+                  :tags, :menus, :images, :maintainers, :awards, :opening_hours,
+                  
+                  ### Utility:
+                  :resources,  :counters, :created_at, :updated_at
+    
+    ### FINDERS:
+    
+    def self.collection
+      Collection.new(self, endpoint, default_criteria)
+    end
+    
+    def self.search(query)
+      collection.search(query)
+    end
+    
+    def self.nearby(geolocation, options = {})
+      collection.nearby(geolocation, options)
+    end
+    
+    def self.tagged_with(*tags)
+      collection.tagged_with(*tags)
+    end
+    
+    def self.sort_by(sortable)
+      collection.sort_by(sortable)
+    end
+    
+    def self.paginate(page, options = {})
+      collection.paginate(page, options)
+    end
+  end
+end

data/lib/hungry/venue/collection.rb

@@ -0,0 +1,37 @@
+module Hungry
+  class Venue
+    class Collection < Hungry::Collection
+      include Pagination
+      
+      def search(query)
+        all query: query
+      end
+      
+      def nearby(location, options = {})
+        options[:geolocation]   = Geolocation.parse(location)
+        options[:sort_by]     ||= 'distance'
+        
+        all options
+      end
+      
+      def tagged_with(*tags)
+        all tags: (current_tags + tags.flatten).compact.join(',')
+      end
+      
+      def sort_by(subject)
+        all sort_by: subject
+      end
+      
+      private
+      
+      def current_tags
+        if criteria[:tags].is_a?(String)
+          criteria[:tags].gsub(/\s+/, '')
+                         .split(',')
+        else
+          criteria[:tags] || []
+        end
+      end
+    end
+  end
+end

data/lib/support/presence.rb

@@ -0,0 +1,20 @@
+begin
+  # Add support for Object#presence:
+  require 'active_support/core_ext/object/blank'
+
+rescue LoadError => e
+  Object.class_eval do
+    unless respond_to?(:present?)
+      def present?
+        !!presence
+      end
+    end
+    
+    unless respond_to?(:presence)
+      def presence
+        return nil if respond_to?(:empty?) ? empty? : !self
+        self
+      end
+    end
+  end
+end

data/lib/support/symbolize_keys.rb

@@ -0,0 +1,16 @@
+begin
+  # Add support for Hash#symbolize_keys:
+  require 'active_support/core_ext/hash/keys'
+
+rescue LoadError => e
+  Hash.class_eval do
+    unless respond_to?(:symbolize_keys)
+      def symbolize_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+      end
+    end
+  end
+end

data/spec/hungry/geolocation_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Hungry::Geolocation do
+  let(:geo) { Hungry::Geolocation.new(50.8469397, 5.6927505) }
+
+  describe '.parse' do
+    context 'with a Geolocation' do
+      it 'returns the given Geolocation' do
+        Hungry::Geolocation.parse(geo).should == geo
+      end
+    end
+
+    context 'with an Object' do
+      it 'returns a Geolocation object for objects with a latitude and longitude' do
+        object = Class.new do
+          def latitude;  50.8469397; end
+          def longitude;  5.6927505; end
+        end.new
+
+        geo = Hungry::Geolocation.parse(object)
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns a Geolocation object for objects with a lat and lng' do
+        object = Class.new do
+          def lat; 50.8469397; end
+          def lng;  5.6927505; end
+        end.new
+
+        geo = Hungry::Geolocation.parse(object)
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns a Geolocation object for objects that have a valid geolocation' do
+        object = Class.new do
+          def geolocation; Hungry::Geolocation.new(50.8469397, 5.6927505); end
+        end.new
+
+        geo = Hungry::Geolocation.parse(object)
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns nil for objects without geo information' do
+        geo = Hungry::Geolocation.parse(Object.new)
+        geo.should be_nil
+      end
+
+      it 'returns nil for objects that have an invalid geolocation' do
+        object = Class.new do
+          def geolocation; "just a string"; end
+        end.new
+
+        geo = Hungry::Geolocation.parse(object)
+        geo.should be_nil
+      end
+    end
+
+    context 'with a String' do
+      it 'returns a Geolocation object' do
+        geo = Hungry::Geolocation.parse('50.8469397,5.6927505')
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns nil if the string can not be parsed' do
+        geo = Hungry::Geolocation.parse('not-a,geolocation')
+        geo.should be_nil
+      end
+    end
+
+    context 'with an Array' do
+      it 'returns a Geolocation object' do
+        geo = Hungry::Geolocation.parse([50.8469397, 5.6927505])
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns nil if the array can not be parsed' do
+        geo = Hungry::Geolocation.parse(['not a', 'geolocation'])
+        geo.should be_nil
+      end
+    end
+
+    context 'with a Hash' do
+      it 'returns a Geolocation object' do
+        geo = Hungry::Geolocation.parse(latitude: 50.8469397, longitude: 5.6927505)
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'supports abbreviated keys' do
+        geo = Hungry::Geolocation.parse(lat: 50.8469397, lng: 5.6927505)
+        geo.latitude.should  == 50.8469397
+        geo.longitude.should ==  5.6927505
+      end
+
+      it 'returns nil if the hash can not be parsed' do
+        geo = Hungry::Geolocation.parse(a: 'b', c: 'd')
+        geo.should be_nil
+      end
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets latitude' do
+      geo.latitude.should == 50.8469397
+    end
+
+    it 'sets longitude' do
+      geo.longitude.should == 5.6927505
+    end
+  end
+
+  describe '#to_s' do
+    it 'joins latitude and longitude with a ","' do
+      geo.to_s.should == "50.8469397,5.6927505"
+    end
+  end
+end

data/spec/hungry/util_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Hungry::Util do
+  describe '#params_from_uri' do
+    it 'returns a hash representing the params in the given URL' do
+      hash = Hungry::Util.params_from_uri 'http://www.google.com/search?q=ruby&lang=en'
+      hash.should == { 'q' => 'ruby', 'lang' => 'en' }
+    end
+  end
+  
+  describe '#uri_with_params' do
+    it 'returns a clean URL if there no hash is given' do
+      url = Hungry::Util.uri_with_params('http://www.google.com/')
+      url.should == 'http://www.google.com/'
+    end
+    
+    it 'returns an URL with params representing the given hash' do
+      url = Hungry::Util.uri_with_params('http://www.google.com/search', 'q' => 'ruby', 'lang' => 'en')
+      url.should == 'http://www.google.com/search?q=ruby&lang=en'
+    end
+  end
+  
+  describe '#is_numeric?' do
+    it 'returns true for integers' do
+      Hungry::Util.is_numeric?(100).should be_true
+    end
+
+    it 'returns true for floats' do
+      Hungry::Util.is_numeric?(10.0).should be_true
+    end
+
+    it 'returns true for integers in strings' do
+      Hungry::Util.is_numeric?('100').should be_true
+    end
+
+    it 'returns true for floats in strings' do
+      Hungry::Util.is_numeric?('10.0').should be_true
+    end
+
+    it 'returns true for negative integers in strings' do
+      Hungry::Util.is_numeric?('-100').should be_true
+    end
+
+    it 'returns true for negative floats in strings' do
+      Hungry::Util.is_numeric?('-10.0').should be_true
+    end
+
+    it 'returns false for non numeric values' do
+      Hungry::Util.is_numeric?('abc').should be_false
+      Hungry::Util.is_numeric?('1a3').should be_false
+      Hungry::Util.is_numeric?('1.0.0').should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../lib/hungry',  __FILE__)
+
+require 'fakeweb'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: hungry
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tom-Eric Gerritsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An interface to the Eet.nu API.
+email:
+- tomeric@eet.nu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- Rakefile
+- hungry.gemspec
+- lib/hungry.rb
+- lib/hungry/city.rb
+- lib/hungry/collection.rb
+- lib/hungry/collection/pagination.rb
+- lib/hungry/country.rb
+- lib/hungry/geolocation.rb
+- lib/hungry/location.rb
+- lib/hungry/region.rb
+- lib/hungry/resource.rb
+- lib/hungry/review.rb
+- lib/hungry/site.rb
+- lib/hungry/tag.rb
+- lib/hungry/util.rb
+- lib/hungry/venue.rb
+- lib/hungry/venue/collection.rb
+- lib/support/presence.rb
+- lib/support/symbolize_keys.rb
+- spec/hungry/geolocation_spec.rb
+- spec/hungry/util_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/eet-nu/hungry
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: An interface to the Eet.nu API.
+test_files:
+- spec/hungry/geolocation_spec.rb
+- spec/hungry/util_spec.rb
+- spec/spec_helper.rb