rlocu 0.1.0 → 0.2.1

data/lib/rlocu/utilities/lat_long_radius.rb

@@ -0,0 +1,27 @@
+module Rlocu
+  module Utilities
+    class LatLongRadius
+      attr_reader :lat, :long, :radius
+      def initialize(lat:, long:, radius: 5000)
+        if !lat.is_a?(Numeric) || !long.is_a?(Numeric) || !radius.is_a?(Numeric)
+          raise ArgumentError.new "Parameters must be numeric (floats)"
+        end
+        @lat = lat
+        @long = long
+        @radius = radius
+      end
+
+      def self.bounds(lat_lng1, lat_lng2)
+        "#{@lat_lng1.to_s}|#{@lat_lng2.to_s}"
+      end
+
+      def to_s
+        "#{lat},#{long}"
+      end
+
+      def to_a
+        [lat, long, radius]
+      end
+    end
+  end
+end

data/lib/rlocu/venue.rb

@@ -1,34 +1,117 @@
 module Rlocu
   class Venue
-    PROPERTIES = [:name, :locality, :street_address, 
-      :cuisines, :region, :long, :phone, :postal_code, 
-      :categories, :has_menu, :country, :lat, :id, 
-      :website_url, :resource_uri]
-    # the Venue class encapsulates the venue_details also
-    # keeping them separate for maintainability when they eventually change
-    VENUE_DETAILS = [:open_hours, :facebook_url, :twitter_id,
-      :similar_venues, :redirected_from]
-    attr_reader :menus
-    (PROPERTIES | VENUE_DETAILS).each {|prop| attr_accessor prop}
-
-    def initialize(meta_venue)
+    ExternalID = Struct.new(:id, :url, :mobile_url)
+    Category = Struct.new(:name, :str_id)
+    Contact = Struct.new(:phone, :fax, :email, :phones, :faxes, :emails, :business_owner)
+    # skipping Locu object for now
+    Delivery = Struct.new(:will_deliver, :hours, :minimum_order, :areas)
+    # skipping Extended object for now
+    Media = Struct.new(:cover_photo, :venue_photos, :menu_photos, :logos, :videos)
+    ATTRIBUTES = %i{locu_id name short_name description website_url menu_url menus menu_items open_hours external redirected_from categories location contact locu delivery extended media}
+
+    ATTRIBUTES.each { |prop| attr_accessor prop }
+
+    def initialize(venue)
+      @external = []
+      @categories = []
       @menus = []
-      update(meta_venue)
+      @not_supported_attributes = []
+      build_from_hash(venue)
+    end
+
+    def build_from_hash(venue)
+      venue.each do |k,v|
+        begin
+          self.send("#{k.to_s}=", v)
+        rescue NoMethodError
+          @not_supported_attributes << k
+        end
+      end
+    end
+
+    def latitude
+      location.latitude
+    end
+
+    def longitude
+      location.longitude
     end
-    
-    def update(meta_venue)
-      meta_venue.each {|k,v| self.send("#{k.to_s}=",v) }
+
+    def not_supported_attributes
+      @not_supported_attributes
+    end
+
+    def external=(externals_list)
+      @external = []
+      externals_list.each { |external_id| @external << ExternalID.new(id: external_id['id'], url: external_id['url'], mobile_url: external_id['mobile_url'])}
+    end
+
+    def categories=(categories_list)
+      @categories = []
+      categories_list.each do |category|
+        c = Category.new
+        category.each { |k,v| c.send("#{k.to_s}=", v) }
+        @categories << c
+      end
+    end
+
+    def location=(location)
+      @location = Location.new(location)
     end
 
-    # override some of the writers
-    def menus=(meta_menus)
-      # menus is an array of menu hashes
-      # don't keep adding and duplicating if there are already menus
-      @menus = []        
-      meta_menus.each do |h|
-        @menus << Menu.new(h)
+    def contact=(contact)
+      c = Contact.new
+      contact.each { |k,v| c.send("#{k.to_s}=", v) }
+      @location = c
+    end
+
+    def delivery=(delivery)
+      d = Delivery.new
+      delivery.each { |k,v| d.send("#{k.to_s}=", v) }
+      @location = l
+    end
+
+    def extended=(extended)
+      e = Extended.new
+      extended.each { |k,v| e.send("#{k.to_s}=", v) }
+      @extended = e
+    end
+
+    def media=(media)
+      m = Media.new
+      media.each { |k,v| m.send("#{k.to_s}=", v) }
+      @media = m
+    end
+
+    def menus=(menu_list)
+      @menus = []
+      menu_list.each do |menu|
+        @menus << Menu.new(menu)
+      end
+    end
+
+    class Location
+      attr_reader :address1, :address2, :address3, :locality, :region, :postal_code, :country, :geo
+      def initialize(location)
+        @address1 = location['address1']
+        @address2 = location['address2']
+        @address3 = location['address3']
+        @locality = location['locality']
+        @region = location['region']
+        @postal_code = location['postal_code']
+        @country = location['country']
+        @geo = GeoJSON.new(location['geo'])
+      end
+
+      def latitude
+        geo.latitude
+      end
+
+      def longitude
+        geo.longitude
       end
     end
 
+    # skipping menu_items since they can be accessed through the menus and only 15 are returned currently
   end
-end
+end

data/lib/rlocu/venue_query.rb

@@ -0,0 +1,35 @@
+require 'rest-client'
+require 'json'
+
+module Rlocu
+  class VenueQuery
+    include Rlocu::QueryBuilder
+    VenueQueryError = Class.new(StandardError)
+
+    attr_reader :return_fields
+
+    def initialize(query_conditions:, return_fields:)
+      raise ArgumentError, 'Query Conditions Param must be an array of QueryConditions.' if !query_conditions.is_a?(Array) || !query_conditions.first.is_a?(QueryCondition)
+
+      raise ArgumentError, 'Return Fields Param must be an array of fields.' if !return_fields.is_a?(Array) || return_fields.empty?
+      @query_conditions = query_conditions
+      @return_fields = return_fields
+    end
+
+    def query_conditions
+      @query_conditions.map(&:to_h)
+    end
+
+    def form_data
+      {api_key: Rlocu.api_key, fields: return_fields, venue_queries: query_conditions }.to_json
+    end
+
+    def query
+      # TODO wrap this in a timeout
+      result = JSON.parse(RestClient.post(base_url, form_data))
+      status = result['status']
+      raise VenueQueryError.new("Query failed with status [#{status}] and http_status [#{result['http_status']}]") unless status == 'success'
+      result['venues'].each.reduce([]) { |accum, venue| accum << Rlocu::Venue.new(venue) }
+    end
+  end
+end

data/lib/rlocu/venue_search.rb

@@ -1,27 +1,45 @@
-require 'open-uri'
-require 'JSON'
-
 module Rlocu
-  module VenueSearch
-    PARAMETERS = [:name, :has_menu, :category, :cuisine, :website_url, :open_at, :street_address, 
-                  :locality, :region, :postal_code, :country, :location, :radius, :bounds]
-    
-    def self.query(params, &block)    
-      unsupported = params.keys.reduce([]) {|memo,p| memo << p unless PARAMETERS.include? p; memo }
-      raise ArgumentError.new "Unsupported parameter to Rlocu::VenuSearch (#{unsupported})" unless unsupported.empty?
-      response = {}
-      open(url(params)) {|request| response = JSON.parse(request.read)}
-      venues = []
-      venues = response['objects'].reduce(venues) {|arr, o| arr << Rlocu::Venue.new(o) ; arr }
-      venues.each { |venue| yield venue } if block_given?
-      return venues
+  class VenueSearch
+    def initialize(return_fields: [])
+      @return_fields = return_fields.empty? ? %w{locu_id name location description menus} : return_fields
+      @key_value_conditions = []
     end
 
-    private
+    def with_menus
+      @key_value_conditions << QueryBuilder::KeyValueCondition.new(key: 'menus', value: true, condition: '$present')
+      self
+    end
+
+    def in_lat_long_radius(lat:, long:, radius:)
+      lat_long_radius = Utilities::LatLongRadius.new(lat: lat, long: long, radius: radius)
+      @key_value_conditions << QueryBuilder::KeyValueCondition.new(key: 'location', value: lat_long_radius, condition: '$in_lat_lng_radius')
+      self
+    end
+
+    def locu_id(locu_id)
+      @key_value_conditions << QueryBuilder::KeyValueCondition.new(key: 'locu_id', value: locu_id)
+      self
+    end
 
-    def self.url(params)
-      "#{Rlocu.http_base}venue/search/?#{Rlocu.encode(params)}"
+    def name(name)
+      @key_value_conditions << QueryBuilder::KeyValueCondition.new(key: 'name', value: name)
+      self
     end
-    
+
+    def in_categories(categories)
+      raise ArgumentError unless categories.is_a? Array
+      @key_value_conditions << QueryBuilder::KeyValueCondition.new(key: 'categories', value: categories, condition: '$contains_any')
+      self
+    end
+
+    def search
+      conditions = [QueryBuilder::QueryCondition.new(key_value_conditions: key_value_conditions)]
+      venue_query = VenueQuery.new(query_conditions: conditions, return_fields: return_fields)
+      venue_query.query
+    end
+
+    private
+
+    attr_reader :return_fields, :key_value_conditions
   end
-end
+end

data/lib/rlocu/version.rb

@@ -1,3 +1,3 @@
 module Rlocu
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/rlocu.gemspec

@@ -3,17 +3,18 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rlocu/version'
 
-Gem::Specification.new do |gem|
-  gem.name          = "rlocu"
-  gem.version       = Rlocu::VERSION
-  gem.authors       = ["Stephen Philp"]
-  gem.email         = ["stephen@stephenphilp.com"]
-  gem.description   = %q{A simple ruby wrapper for the Locu API}
-  gem.summary       = %q{Rlocu is a ruby wrapper for Locu's API. The Locu API gives you access to real-time local business data, from opening hours to price lists, such as restaurant menus.}
-  gem.homepage      = "https://github.com/swelltrain/rlocu"
+Gem::Specification.new do |spec|
+  spec.name          = "rlocu"
+  spec.version       = Rlocu::VERSION
+  spec.authors       = ["Stephen Philp"]
+  spec.email         = ["stephen@stephenphilp.com"]
+  spec.description   = %q{A simple ruby wrapper for the Locu API}
+  spec.summary       = %q{Rlocu is a ruby wrapper for Locu's API. The Locu API gives you access to real-time local business data, from opening hours to price lists, such as restaurant menus.}
+  spec.homepage      = "https://github.com/swelltrain/rlocu"
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.add_development_dependency('rspec')
+  spec.add_runtime_dependency('rest-client')
+  spec.require_paths = ["lib"]
 end

data/spec/config_rlocu_spec_helper.rb

@@ -0,0 +1,5 @@
+require 'yaml'
+
+configs = YAML::load(File.open(File.expand_path('../../.config', __FILE__)))
+
+Rlocu.configure { |rlocu| rlocu.api_key = configs['API_KEY'] }

data/spec/geo_json_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+include Rlocu
+
+RSpec.describe GeoJSON, '#new' do
+  it "should raise ArgumentError if geo['type'] does not exist" do
+    expect{ GeoJSON.new({}) }.to raise_error(ArgumentError)
+  end
+
+  it "should raise ArgumentError if geo['coordinates'] does not exist" do
+    expect{ GeoJSON.new({'type' => 'Point'}) }.to raise_error(ArgumentError)
+  end
+end

data/spec/menu/item_spec.rb

@@ -0,0 +1,13 @@
+include Rlocu
+
+RSpec.describe Menu::Item, '#new' do
+  it 'should set type, name, description, price and option groups' do
+    item = Menu::Item.new(item_hash)
+
+    expect(item.type).to eq(item_hash['type'])
+    expect(item.name).to eq(item_hash['name'])
+    expect(item.description).to eq(item_hash['description'])
+    expect(item.price).to eq(item_hash['price'])
+    expect(item.option_groups).not_to be_empty
+  end
+end

data/spec/menu/menu_item_spec.rb

@@ -0,0 +1,13 @@
+include Rlocu
+
+RSpec.describe Menu::MenuItem, '#new' do
+  it 'should set menu_name, section_name, subsection_name, section_text, type, currency_symbol and photos' do
+    menu_item = Menu::MenuItem.new(menu_menu_item_hash)
+    expect(menu_item.menu_name).to eq(menu_menu_item_hash['menu_name'])
+    expect(menu_item.section_name).to eq(menu_menu_item_hash['section_name'])
+    expect(menu_item.subsection_name).to eq(menu_menu_item_hash['subsection_name'])
+    expect(menu_item.section_text).to eq(menu_menu_item_hash['section_text'])
+    expect(menu_item.currency_symbol).to eq(menu_menu_item_hash['currency_symbol'])
+    expect(menu_item.photos).not_to be_empty
+  end
+end

data/spec/menu/option_group_spec.rb

@@ -0,0 +1,10 @@
+include Rlocu
+
+RSpec.describe Menu::OptionGroup, '#new' do
+  it 'should set the name, text and options' do
+    option_group = Menu::OptionGroup.new(menu_option_group)
+    expect(option_group.type).to eq(menu_option_group['type'])
+    expect(option_group.text).to eq(menu_option_group['text'])
+    expect(option_group.options).not_to be_empty
+  end
+end

data/spec/menu/option_spec.rb

@@ -0,0 +1,9 @@
+include Rlocu
+
+RSpec.describe Menu::Option, '#new' do
+  it 'should set the name and price' do
+    option = Menu::Option.new(menu_option)
+    expect(option.name).to eq(menu_option['name'])
+    expect(option.price).to eq(menu_option['price'])
+  end
+end

data/spec/menu/section_spec.rb

@@ -0,0 +1,9 @@
+include Rlocu
+
+RSpec.describe Menu::Section, '#new' do
+  it 'should set section name and subsections' do
+    menu_section = Menu::Section.new(menu_section_hash)
+    expect(menu_section.section_name).to eq(menu_section_hash['section_name'])
+    expect(menu_section.subsections).not_to be_empty
+  end
+end

data/spec/menu/section_text_spec.rb

@@ -0,0 +1,9 @@
+include Rlocu
+
+RSpec.describe Menu::SectionText, '#new' do
+  it 'should set type and text' do
+    menu_section_text = Menu::SectionText.new(menu_section_text_hash)
+    expect(menu_section_text.type).to eq(menu_section_text_hash['type'])
+    expect(menu_section_text.text).to eq(menu_section_text_hash['text'])
+  end
+end

data/spec/menu/subsection_spec.rb

@@ -0,0 +1,9 @@
+include Rlocu
+
+RSpec.describe Menu::Subsection, '#new' do
+  it 'should set subsection_name and contents' do
+    menu_subsection = Menu::Subsection.new(menu_subsection_hash)
+    expect(menu_subsection.subsection_name).to eq(menu_subsection_hash['subsection_name'])
+    expect(menu_subsection.contents).not_to be_empty
+  end
+end

data/spec/menu_spec.rb

@@ -0,0 +1,9 @@
+include Rlocu
+
+RSpec.describe Menu, '#new' do
+  it 'should set menu name and sections' do
+    menu = Menu.new(menu_hash)
+    expect(menu.menu_name).to eq(menu_hash['menu_name'])
+    expect(menu.sections).not_to be_empty
+  end
+end

data/spec/query/key_value_condition_spec.rb

@@ -0,0 +1,37 @@
+include Rlocu::QueryBuilder
+include Rlocu::Utilities
+
+RSpec.describe KeyValueCondition, '#new' do
+  context "when condition is not one of #{KeyValueCondition::ValidConditions}" do
+    it 'should raise ArgumentError' do
+      expect{ KeyValueCondition.new(key: 'spec', value: 'spec', condition: 'spec') }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when condition is $in_lat_lng_radius' do
+    context 'when value is not a LatLongRadius' do
+      it 'should raise an ArgumentError' do
+        expect{ KeyValueCondition.new(key: 'location', value: 'spec', condition: '$in_lat_lng_radius') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end
+
+RSpec.describe KeyValueCondition, '#to_h' do
+  let(:value) { LatLongRadius.new(lat: 1, long: 1) }
+
+  let!(:key_value_condition) {KeyValueCondition.new(key: 'location', value: value, condition: '$in_lat_lng_radius')}
+
+  context 'when condition is specified' do
+    context 'when value is a LatLongRadius' do
+      it 'should call to_a on the value' do
+        expect(value).to receive(:to_a)
+        key_value_condition.to_h
+      end
+    end
+  end
+
+  it 'should return a hash' do
+    expect(key_value_condition.to_h).to be_a_kind_of(Hash)
+  end
+end