rlocu 0.1.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3487ae33152629fffe23b46033f4b39a33b3f6b
+  data.tar.gz: 91c4d5c8fa76b87538ca8ba49cae5d6ebc96c9de
+SHA512:
+  metadata.gz: 30eb21a8d1bb3d2f8191b0fa3cc963ccf82fe5ce3b0a1bc5ff89bb2e14f7e20900e2e5b722df5c34ebaaf04de415770816a35cc91cf8c96ac0dce3b65469efac
+  data.tar.gz: a8f7f656d564ddcd620e8fd1e67e8cd151bbf1d0a4c5cfbd20b85e65f0ce337fb0efa2a22bbb557a02edffd144c93c48c66943dc8d5ebb98e40047a9fa4bc170

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/README.md

@@ -1,6 +1,12 @@
 # Rlocu
 
-A simple, unoffical, and currently incomplete wrapper for the Locu API (locu.com)
+A simple, unoffical, and somewhat complete wrapper for the Locu Version 2 API (locu.com)
+
+Currrently supports Venue Searches by
+* lat long radius
+* locu id
+* in categories
+* with menus
 
 ## Installation
 
@@ -10,46 +16,41 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
-Or install it yourself as:
+Or install it yourself:
 
     $ gem install rlocu
 
 ## Getting Started
 
-When you require Rlocu it runs config! on itself to set api_key and http_base.  It reads these values from a YAML .config file in .lib/ exa:
+Before executing any Rlocu queries you need to configure it.
 
-API_KEY: 'yourapikeyyourapikeyyourapikey'
-HTTP_BASE: 'https://api.locu.com/v1_0/'
+    Rlocu.configure do |conf|
+      conf.api_key = 'yourapikeyyourapikeyyourapikey'
+    end
 
 ## Usage
+In general you search Locu with `RLocu::VenueSearch`.
 
-Right now the only functionality covered is Venue Search to search for venues, and Venue Details which gets you menus, etc.
-Everything is under the Rlocu namespace. 
+The class takes an optional parameter `return_fields` which is an array of venue fields* (properties) that should be returned.  It defaults to:
 
-Venue Search
-Pass a hash of params to Rlocu::VenueSearch.query()
-Returns an array of venues (Rlocu::Venue)
-Or you can pass it a block to iterate through the venues:
+    %w{locu_id name location description menus}
 
-    Rlocu::VenueSearch.query(postal_code: '90278', cuisine: 'Thai') do |v|
-      puts v.name
-    end
+*See Locu Developer Docs for available fields.
 
-Venue Details
-You can pass an array of up to 5 venues to Rlocu::VenueDetails()
-Returns an array of Rlocu::Venues with the detail data (th venue search and detail search have overlapping attributes).
+There are several instance methods that follow the typical usage pattern.  Each adds a `QueryBuilder::KeyValueCondition` to the `@key_value_conditions` array and returns `self` so they can be chained together.  This creates a restrictive && filter (ie search for venues that satisfy this condition and this condition.)  Then you call `search` to perform the search with the query that has been built.
+
+Example:
+
+    venues = Rlocu::VenueSearch.new.in_lat_long_radius(lat: my_latitude, long: my_longitude, radius: 2000).with_menus.search
+
+## The Objects
+
+`Rlocu::Venue` has many `Rlocu::Menu`.  Both objects map instance variables to (most of) the properties from the Locu API.
 
-Or you can pass it a block to iterate through the venues:
-    Rlocu::VenueDetails.query(array_of_venues) do |v|
-      puts v.twitter_id
-    end
 
-Object Space
-The object space essentially follows the Locu API with two little utility objects:
-RLocu::Location
-Rlocu::Bounds
+`RLocu::Menu#to_s` creates a rough  ascii print of the menu, but should give a fairly decent example for displaying.
 
 ## Contributing
 

data/Rakefile

@@ -1,12 +1,13 @@
 require "bundler/gem_tasks"
 
-require 'rake/testtask'
+# tests run with minitest_helper.rb
+# require 'rake/testtask'
 
-task default: [:test]
+# task default: [:test]
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/test*.rb']
-  #t.verbose = true
-end
+# Rake::TestTask.new do |t|
+#   t.libs << 'test'
+#   t.test_files = FileList['test/test*.rb']
+#   #t.verbose = true
+# end
 

data/lib/rlocu.rb

@@ -1,8 +1,23 @@
-#require "rlocu/version"
-require_relative 'rlocu/config'
-require_relative 'rlocu/venue'
+
+module Rlocu
+  RlocuError = Class.new(StandardError)
+  class << self
+    attr_accessor :api_key
+    def configure
+      yield self
+    end
+
+    def api_version
+      'v2'
+    end
+  end
+end
+
+require_relative 'rlocu/version'
+require_relative 'rlocu/utilities/lat_long_radius'
+require_relative 'rlocu/geo_json'
 require_relative 'rlocu/menu'
+require_relative 'rlocu/venue'
+require_relative 'rlocu/query_builder'
+require_relative 'rlocu/venue_query'
 require_relative 'rlocu/venue_search'
-require_relative 'rlocu/venue_details'
-require_relative 'utilities'
-

data/lib/rlocu/geo_json.rb

@@ -0,0 +1,22 @@
+module Rlocu
+  class GeoJSON
+    def initialize(geo)
+      raise ArgumentError unless geo['type']
+      raise ArgumentError unless geo['coordinates']
+      @point = geo['type']
+      @coordinates = geo['coordinates']
+    end
+
+    def longitude
+      coordinates[0]
+    end
+
+    def latitude
+      coordinates[1]
+    end
+
+    private
+
+    attr_reader :coordinates
+  end
+end

data/lib/rlocu/menu.rb

@@ -1,130 +1,144 @@
 module Rlocu
   class Menu
-    attr_accessor :name
-    attr_reader :sections
+    attr_reader :menu_name, :sections
 
-    def initialize(meta_menu)
-      @name = meta_menu['menu_name']
-      self.sections = meta_menu['sections']
+    def initialize(menu_hash)
+      @menu_name = menu_hash['menu_name']
+      self.sections = menu_hash['sections']
     end
 
-    def sections=(meta_sections)
+    def sections=(sections_list)
       @sections = []
-      meta_sections.each {|h| @sections << Section.new(h)}
+      sections_list.each { |section| @sections << Section.new(section) } unless sections_list.nil?
     end
 
-  end
-
-  class Section
-    attr_accessor :name
-    attr_reader :subsections
-
-    def initialize(meta_section)
-      @name = meta_section['section_name']
-      self.subsections = meta_section['subsections']
-    end
-
-    def subsections=(meta_subsections)
-      @subsections = []
-      meta_subsections.each {|h| @subsections << Subsection.new(h)}
+    def to_s
+      str = "Menu: #{menu_name}\n"
+      sections.each do |section|
+        str << "-----#{section.section_name}-----\n"
+        section.subsections.each do |subsection|
+          str << "---#{subsection.subsection_name}---\n"
+          subsection.contents.each do |content|
+            case content
+            when SectionText
+              str << "SECTION TEXT : #{content.to_s}\n"
+            when MenuItem
+              str << "MENU ITEM : #{content.name} #{content.description} #{content.price}\n"
+              content.option_groups.each do |opt_group|
+                str << "OPTION GROUP : #{opt_group.text}\n"
+                opt_group.options.each do |option|
+                  str << "OPTION  :  #{option.to_s}\n"
+                end
+              end
+            end
+          end
+        end
+      end
+      str
     end
 
-  end
-
-  class Subsection
-    attr_accessor :name
-    attr_reader :contents
-
-    def initialize(meta_subsection)
-      @name = meta_subsection['subsection_name']
-      self.contents = meta_subsection['contents']
-    end
+    class Section
+      attr_reader :section_name, :subsections
+      def initialize(section_hash)
+        @section_name = section_hash['section_name']
+        self.subsections = section_hash['subsections']
+      end
 
-    def contents=(meta_contents)
-      @contents = []
-      meta_contents.each do |h|
-        #TODO: raise error if type is different
-        @contents << case h['type']
-          when 'SECTION_TEXT'
-            SectionText.new(h)
-          when 'ITEM'
-            MenuItem.new(h)
-        end  
+      def subsections=(subsections_list)
+        @subsections = []
+        subsections_list.each { |subsection| @subsections << Subsection.new(subsection) } unless subsections_list.nil?
       end
     end
 
-  end
-
-  class SectionText
-    attr_accessor :type, :text
-
-    def initialize(meta_section_text)
-      @type = meta_section_text['type']
-      @text = meta_section_text['text']
-    end
+    class Subsection
+      attr_reader :subsection_name, :contents
+      def initialize(subsection_hash)
+        @subsection_name = subsection_hash['subsection_name']
+        self.contents = subsection_hash['contents']
+      end
 
-    def to_s
-      @text
+      def contents=(contents_list)
+        @contents = []
+        return if contents_list.nil?
+        contents_list.each do |content|
+          #TODO: raise error if type is different
+          @contents << case content['type']
+            when 'SECTION_TEXT'
+              SectionText.new(content)
+            when 'ITEM'
+              MenuItem.new(content)
+          end
+        end
+      end
     end
-  
-  end
 
-# create a to_s for each that can be over-ridden by the user
-  class MenuItem
-    attr_accessor :type, :name, :description, :price
-    attr_reader :option_groups
-
-    def initialize(meta_menu_item)
-      @type = meta_menu_item['type']
-      @name = meta_menu_item['name']
-      @description = meta_menu_item['description']
-      @price = meta_menu_item['price']
-      self.option_groups = meta_menu_item['option_groups'] 
-    end
+    class SectionText
+      attr_reader :type, :text
+      def initialize(section_text_hash)
+        @type = section_text_hash['type']
+        @text = section_text_hash['text']
+      end
 
-    def option_groups=(meta_option_groups)
-      @option_groups = []
-      meta_option_groups.each { |h| @option_groups << OptionGroup.new(h) } if meta_option_groups
+      def to_s
+        @text
+      end
     end
 
-  end
-
-  class OptionGroup
-    attr_accessor :type, :text
-    attr_reader :options
+    class Item
+      attr_reader :type, :name, :description, :price, :option_groups
+      def initialize(item_hash)
+        @type = item_hash['type']
+        @name = item_hash['name']
+        @description = item_hash['description']
+        @price = item_hash['price']
+        self.option_groups = item_hash['option_groups']
+      end
 
-    def initialize(meta_option_group)
-      @type = meta_option_group['type']
-      @text = meta_option_group['text']
-      self.options = meta_option_group['options'] 
+      def option_groups=(option_groups_list)
+        @option_groups = []
+        return if option_groups_list.nil?
+        option_groups_list.each { |option_group| @option_groups << OptionGroup.new(option_group) }
+      end
     end
 
-    def options=(meta_options)
-      @options = []
-      meta_options.each {|h| @options << Option.new(h) } if meta_options
+    class MenuItem < Item
+      attr_reader :menu_name, :section_name, :subsection_name, :section_text, :type, :currency_symbol, :photos
+      def initialize(menu_item_hash)
+        @menu_name = menu_item_hash['menu_name']
+        @section_name = menu_item_hash['section_name']
+        @subsection_name = menu_item_hash['subsection_name']
+        @section_text = menu_item_hash['section_text']
+        @currency_symbol = menu_item_hash['currency_symbol']
+        @photos = menu_item_hash['photos']
+        super
+      end
     end
 
+    class OptionGroup
+      attr_reader :options, :type, :text
+      def initialize(option_group_hash)
+        @type = option_group_hash['type']
+        @text = option_group_hash['text']
+        self.options = option_group_hash['options']
+      end
 
-  end
-
-  class Option
-    attr_accessor :name
-    attr_writer :price
-
-    def initialize(meta_option)
-      @name = meta_option['name']
-      @price = meta_option['price']
+      def options=(options_list)
+        @options = []
+        options_list.each { |option| @options << Option.new(option) } unless options_list.nil?
+      end
     end
 
-    def price
-      # price can be relative indicated by a + in the price
-      # not currently doing anything w it 
-      @price
-    end
+    class Option
+      attr_reader :name, :price
+      def initialize(option_hash)
+        @name = option_hash['name']
+        @price = option_hash['price']
+        # price can be relative indicated by a + in the price
+      end
 
-    def to_s
-      "#{name} #{price}"
+      def to_s
+        "#{name} #{price}"
+      end
     end
-
   end
-end
+end

data/lib/rlocu/query_builder.rb

@@ -0,0 +1,55 @@
+module Rlocu
+  module QueryBuilder
+    def base_url
+      "https://api.locu.com/v2/venue/search"
+    end
+
+    class QueryCondition
+      attr_reader :key_value_conditions
+      def initialize(key_value_conditions:)
+        @key_value_conditions = key_value_conditions
+      end
+
+      def to_h
+        h = {}
+        key_value_conditions.each { |condition| h.merge!(condition.to_h) }
+        h
+      end
+    end
+
+    class KeyValueCondition
+      attr_reader :key, :value, :condition
+      ValidConditions = %w{$present $gt $lt $ge $le $contains_any $contains_all $contains_none $in_lat_lng_bbox $in_lat_lng_radius} << nil
+      def initialize(key:, value:, condition: nil)
+        @key = key
+        @value = value
+        @condition = condition
+        raise ArgumentError unless valid?
+      end
+
+      def to_h
+        if condition
+          if value.is_a?(Utilities::LatLongRadius)
+            {key => {'geo' => {condition => value.to_a}}}
+          elsif key == 'categories'
+            {key => {'str_id' => {condition => value}}}
+          else
+            {key => {condition => value}}
+          end
+        else
+          {key => value}
+        end
+      end
+
+      private
+
+      def valid?
+        # check if the condition and value are appropriate
+        return false unless ValidConditions.include? condition
+        return false if condition =~ /\$in_lat_lng/ && !value.is_a?(Utilities::LatLongRadius)
+        return false if condition == '$contains_any' && !value.is_a?(Array)
+        true
+      end
+    end
+  end
+end