hungry 0.0.1 → 0.1.0

data/lib/hungry/menu/category.rb

@@ -0,0 +1,22 @@
+module Hungry
+  class Menu
+    class Category < Resource
+      
+      attr_accessor :id, :name, :dishes, :menu
+      
+      def dishes
+        @dishes ||= []
+      end
+      
+      def dishes=(new_dishes)
+        @dishes = new_dishes.map do |attributes|
+          dish = Menu::Dish.new(attributes)
+          dish.category    = self
+          dish.data_source = data_source
+          dish
+        end
+      end
+      
+    end
+  end
+end

data/lib/hungry/menu/dish.rb

@@ -0,0 +1,22 @@
+module Hungry
+  class Menu
+    class Dish < Resource
+      
+      attr_accessor :name, :price, :description, :options, :photos, :category
+      
+      def options
+        @options ||= []
+      end
+      
+      def options=(new_options)
+        @options = new_options.map do |attributes|
+          option = Menu::Option.new(attributes)
+          option.dish        = self
+          option.data_source = data_source
+          option
+        end
+      end
+      
+    end
+  end
+end

data/lib/hungry/menu/option.rb

@@ -0,0 +1,9 @@
+module Hungry
+  class Menu
+    class Option < Resource
+      
+      attr_accessor :description, :price, :dish
+      
+    end
+  end
+end

data/lib/hungry/resource.rb

@@ -1,32 +1,69 @@
-require 'httparty'
+require 'httparty' unless defined? HTTParty
 
 module Hungry
   class Resource
     include HTTParty
     
-    attr_accessor :attributes
+    attr_accessor :attributes, :resources, :data_source
     
     ### 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)
+    def self.belongs_to(resource, klass = 'Resource')
       define_method resource do
-        if url = resources[resource]
-          attributes = self.class.get url
-          klass.new(attributes)
+        @belongs_to ||= {}
+        @belongs_to[resource] ||= begin
+          klass = Kernel.const_get(klass) if klass.is_a?(String)
+          
+          if attributes[resource].present?
+            resource = klass.new attributes[resource]
+            resource.data_source = data_source
+            resource
+          elsif url = resources[resource]
+            attributes = self.class.get url
+            resource = klass.new attributes
+            resource.data_source = url
+            resource
+          end
         end
       end
     end
     
-    def self.has_many(resource, klass = Resource)
+    def self.has_many(resource, klass = 'Resource')
       define_method resource do
-        if url = resources[resource]
-          klass.collection.from_url(url)
+        @has_many ||= {}
+        @has_many[resource] ||= begin
+          klass = Kernel.const_get(klass) if klass.is_a?(String)
+          
+          if url = resources[resource]
+            collection = klass.collection.from_url(url)
+            
+            if attributes[resource].present?
+              collection.results = attributes[resource]
+            end
+            
+            collection
+          end
+        end
+      end
+    end
+    
+    def self.lazy_load(*attributes)
+      attributes.each do |attribute|
+        alias_method "#{attribute}_without_lazy_load".to_sym, attribute
+        define_method attribute do
+          result = send "#{attribute}_without_lazy_load".to_sym
+          
+          if !result.present? && (canonical_data_source != data_source && canonical_data_source.present?)
+            reload
+            send "#{attribute}_without_lazy_load".to_sym
+          else
+            result
+          end
         end
       end
     end
@@ -56,13 +93,23 @@ module Hungry
       def find(id)
         raise NoEndpointSpecified unless endpoint
         
-        response = get "#{endpoint}/#{id}"
+        uri = "#{endpoint}/#{id}"
+        
+        Util.log "GET: #{uri}"
+        response = get uri
         
         if response.code == 200
-          new(response)
+          attributes = Util.parse_json(response.body)
+          resource = new(attributes)
+          resource.data_source = uri
+          resource
         end
       end
       
+      def first(n = 1)
+        collection.first(n)
+      end
+      
       def all(criteria = {})
         collection.all(criteria)
       end
@@ -89,5 +136,26 @@ module Hungry
         end
       end
     end
+    
+    def canonical_data_source
+      resources && resources[:self]
+    end
+    
+    def reload
+      resource = self.class.find id
+      
+      if resource
+        self.data_source = resource.data_source
+        initialize resource.attributes
+      else
+        self.data_source = nil
+        initialize Hash[*attributes.keys.map { |key| [key, nil] }]
+      end
+      
+      @has_many   = {}
+      @belongs_to = {}
+      
+      self
+    end
   end
 end

data/lib/hungry/response.rb

@@ -0,0 +1,17 @@
+module Hungry
+  class Response < Resource
+    
+    ### RESOURCES:
+    
+    belongs_to :review, 'Hungry::Review'
+    
+    ### ATTRIBUTES:
+    
+                  ### Review:
+    attr_accessor :id, :body, :author,
+                  
+                  ### Utility:
+                  :created_at, :updated_at
+    
+  end
+end

data/lib/hungry/review.rb

@@ -1,8 +1,12 @@
-require 'httparty'
-
 module Hungry
   class Review < Resource
     
+    ### RESOURCES:
+    
+    belongs_to :venue, 'Hungry::Venue'
+    
+    has_many :responses, 'Hungry::Response'
+    
     ### ATTRIBUTES:
     
                   ### Review:
@@ -11,9 +15,5 @@ module Hungry
                   ### Utility:
                   :created_at, :updated_at
     
-    ### RESOURCES:
-    
-    belongs_to :venue, Venue
-    
   end
 end

data/lib/hungry/site.rb

@@ -3,19 +3,33 @@ module Hungry
     
     self.endpoint = '/sites'
     
+    ### FINDERS:
+    
+    def self.with_hostname(hostname)
+      collection.all(hostname: hostname).first
+    end
+    
+    def self.for_country(country)
+      collection.all(country: country.id).first
+    end
+    
+    def self.default_site
+      collection.all(default: true).first
+    end
+    
+    
     ### ATTRIBUTES:
     
                   ### Preview:
     attr_accessor :id, :name, :title, :subtitle, :identifier, :default, :locale,
-                  :url, :timezone, :country, :applications,
+                  :url, :email, :support_email, :timezone, :country, :applications,
                   
                   ### Utility:
-                  :resources,  :counters
+                  :resources, :counters
     
-    ### FINDERS:
-    
-    def self.with_hostname(hostname)
-      collection.all(hostname: hostname).first
+    def hostname
+      uri = URI.parse(url) rescue nil
+      uri && uri.hostname
     end
     
   end

data/lib/hungry/tag.rb

@@ -3,6 +3,12 @@ module Hungry
     
     self.endpoint = '/tags'
     
+    ### RESOURCES:
+    
+    has_many :venues, 'Hungry::Venue'
+    
+    has_many :tags, 'Hungry::Tag'
+    
     ### ATTRIBUTES:
     
                   ### Tag:
@@ -10,12 +16,5 @@ module Hungry
                   
                   ### Utility:
                   :resources, :counters
-    
-    ### RESOURCES:
-    
-    has_many :venues, Venue
-    
-    has_many :tags, Tag
-    
   end
 end

data/lib/hungry/user.rb

@@ -0,0 +1,77 @@
+module Hungry
+  class User < Resource
+    
+    self.endpoint = '/users'
+    
+    ### ASSOCIATIONS:
+    
+    has_many :reviews, 'Hungry::Review'
+    
+    ### FINDERS:
+    
+    def self.with_ip(ip_address)
+      collection.all(ip: ip_address)
+    end
+    
+    ### CLASS METHODS:
+    
+    def self.authenticate_with_persistence_token(persistence_token)
+      result = authenticate_via_api 'Cookie' => "persistence_token=#{persistence_token}"
+      return false unless result.present?
+      
+      from_json(result)
+    end
+    
+    def self.authenticate_with_perishable_token(perishable_token)
+      result = authenticate_via_api query: "perishable_token=#{perishable_token}"
+      return false unless result.present?
+      
+      from_json(result)
+    end
+    
+    def self.from_json(json)
+      new Util.parse_json(json)
+    end
+    
+    def self.authenticate_via_api(options = {})
+      options = {
+        path:  '/account.json',
+        query: nil
+      }.merge(options)
+      
+      url = URI.parse(Hungry.api_url)
+      url.path  = options.delete(:path)
+      url.query = options.delete(:query)
+      
+      http = Net::HTTP.new(url.host, url.port)
+      if url.scheme == 'https'
+        http.use_ssl     = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      
+      request  = Net::HTTP::Get.new(url.request_uri, options)
+      response = http.request request
+      
+      if response.code.to_i == 200
+        response.body
+      else
+        false
+      end
+    end
+    
+    ### ATTRIBUTES:
+    
+                  ### Preview:
+    attr_accessor :id, :name, :avatar, :slug, :profile_url, :score, :bio,
+                  :location, :email,
+                  
+                  ### FULL:
+                  :gender, :birth_date, :website_url, :persistence_token,
+                  :single_access_token, :maintainer_of, :connections,
+                  :device_tokens, :admin,
+                  
+                  ### Utility:
+                  :resources, :counters, :created_at, :updated_at, :activated_at
+    
+  end
+end

data/lib/hungry/util.rb

@@ -1,13 +1,23 @@
-require 'cgi'
-require 'rack/utils'
+require 'cgi' unless defined?(CGI)
 
 module Hungry
   module Util
     extend self
     
+    def log(message, type = :info)
+      if Hungry.logger
+        message = "[Hungry] #{message}"
+        Hungry.logger.send(type, message)
+      end
+    end
+    
+    def parse_json(json)
+      Hungry.json_parser.call(json)
+    end
+    
     def params_from_uri(uri)
       uri = URI.parse(uri) unless uri.is_a?(URI)
-      Rack::Utils.parse_query(uri.query) if uri.query.present?
+      parse_query(uri.query) if uri.query.present?
     end
     
     def uri_with_params(uri, params = {})
@@ -20,7 +30,37 @@ module Hungry
     end
     
     def is_numeric?(value)
-      value.to_s =~ /^[+-]?[\d]+(\.[\d]+){0,1}$/
+      !!(value.to_s =~ /^[+-]?[\d]+(\.[\d]+){0,1}$/)
+    end
+    
+    private
+    
+    # Copied from rack/utils:
+    def unescape(s, encoding = Encoding::UTF_8)
+      URI.decode_www_form_component(s, encoding)
+    end
+    
+    def parse_query(qs, d = nil, &unescaper)
+      unescaper ||= method(:unescape)
+      
+      params = {}
+      
+      (qs || '').split(d ? /[#{d}] */ : /[&;] */n).each do |p|
+        next if p.empty?
+        k, v = p.split('=', 2).map(&unescaper)
+        
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+      
+      params
     end
   end
 end

data/lib/hungry/venue.rb

@@ -6,27 +6,13 @@ module Hungry
     
     ### RESOURCES:
     
-    has_many :reviews, Review
+    has_many :reviews, 'Hungry::Review'
     
-    belongs_to :country, Country
+    belongs_to :country, 'Hungry::Country'
     
-    belongs_to :region, Region
+    belongs_to :region, 'Hungry::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
+    belongs_to :city, 'Hungry::City'
     
     ### FINDERS:
     
@@ -50,8 +36,43 @@ module Hungry
       collection.sort_by(sortable)
     end
     
+    def self.maintainable_by(user_or_id)
+      collection.maintainable_by(user_or_id)
+    end
+    
     def self.paginate(page, options = {})
       collection.paginate(page, options)
     end
+    
+    ### ATTRIBUTES:
+    
+                  ### Preview:
+    attr_accessor :id, :name, :category, :telephone, :fax, :website_url,
+                  :tagline, :rating, :url, :address, :geolocation, 
+                  :currency_symbol, :relevance, :distance, :plan,
+                  
+                  ### Full:
+                  :reachability, :staff, :prices, :capacity, :description,
+                  :tags, :menus, :images, :maintainers, :awards, :opening_hours,
+                  :holidays,
+                  
+                  ### Utility:
+                  :counters, :created_at, :updated_at, :status
+    
+    lazy_load :tags, :menus, :maintainers, :opening_hours, :holidays
+    
+    def geolocation=(new_coordinates)
+      @geolocation = Geolocation.parse(new_coordinates).tap do |geo|
+        attributes[:geolocation] = geo
+      end
+    end
+    
+    def menus=(new_menus)
+      @menus = new_menus.map do |attributes|
+        menu = Menu.new(attributes)
+        menu.data_source = data_source
+        menu
+      end
+    end
   end
 end