romato 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e56e0be07e20c75547441183ab19f7a19dc13bc6
+  data.tar.gz: 44741fe930dd130556e5f98cfcc525ef62a6df94
+SHA512:
+  metadata.gz: 27c621d407c6fb5f63d537b9f7ecba8fbdcaea669d751cfe7f6f109f3ed790e0d011b389c284bd4d26845e72a07a583550a4ed4a47684b4bd478101e959c5fee
+  data.tar.gz: c99073a0b37412d0e2f87c48d5bce173ea165f42549e8fb93934b2fb501f12d00ffc5b0a53ca7ec1d6e19f42e83cdb00c444fc2e5b0bdd8c3fb0b46ccc245fb4

data/#Gemfile#

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zomatastic.gemspec
+gemspec
+
+gem 'httparty'
+gem 'hashdot' 

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,88 @@
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
+
+- [Contributor Covenant Code of Conduct](#contributor-covenant-code-of-conduct)
+  - [Our Pledge](#our-pledge)
+  - [Our Standards](#our-standards)
+  - [Our Responsibilities](#our-responsibilities)
+  - [Scope](#scope)
+  - [Enforcement](#enforcement)
+  - [Attribution](#attribution)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at kyleannen@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zomatastic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kyle Annen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,661 @@
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
+
+- [Romato - Zomato API Wrapper for Ruby](#romato---zomato-api-wrapper-for-ruby)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Initialization](#initialization)
+        - [Romato::Zomato.new()](#romatozomatonew)
+  - [Methods](#methods)
+    - [Common Methods (as defined by Zomato API)](#common-methods-as-defined-by-zomato-api)
+      - [Romato::Zomato.get_categories()](#romatozomatoget_categories)
+      - [Romato::Zomato.get_cities(options)](#romatozomatoget_citiesoptions)
+      - [Romato::Zomato.get_collections(options)](#romatozomatoget_collectionsoptions)
+      - [Romato::Zomato.get_cuisines()](#romatozomatoget_cuisines)
+  - [Development](#development)
+  - [Contributing](#contributing)
+  - [License](#license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# Romato - Zomato API Wrapper for Ruby
+
+A simple api wrapper for Zomato API, all methods coorelate to the API definitions in the Zomato API documentation: https://developers.zomato.com/documentation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'romato'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install romato
+
+## Usage
+
+All api methods accept an options hash if the API call accepts parameters, and directly mirror the API parameters defined by the Zomato API v2.1.
+
+## Initialization
+___
+
+##### Romato::Zomato.new()
+
+The initialization of the class accetps an options parameter as a hash. Provide the API key here as a hash.
+
+`zomato_instance = Romato::Zomato.new("APIKEY")`
+
+## Methods
+
+### Common Methods (as defined by Zomato API)
+___
+#### Romato::Zomato.get_categories()
+
+Get the categories of venues defined by Zomato, accepts no parameters.
+
+`zomato_instance.get_categories()`
+
+Response: 
+
+```ruby
+{
+	"categories"=>
+	[
+		{"categories"=>{"id"=>1, "name"=>"Delivery"}}, 
+		{"categories"=>{"id"=>2, "name"=>"Dine-out"}}, 
+		{"categories"=>{"id"=>3, "name"=>"Nightlife"}}, 
+		{"categories"=>{"id"=>4, "name"=>"Catching-up"}}, 
+		{"categories"=>{"id"=>5, "name"=>"Takeaway"}}, 
+		{"categories"=>{"id"=>6, "name"=>"Cafes"}}, 
+		{"categories"=>{"id"=>7, "name"=>"Daily Menus"}}, 
+		{"categories"=>{"id"=>8, "name"=>"Breakfast"}}, 
+		{"categories"=>{"id"=>9, "name"=>"Lunch"}}, 
+		{"categories"=>{"id"=>10, "name"=>"Dinner"}}, 
+		{"categories"=>{"id"=>11, "name"=>"Pubs & Bars"}}, 
+		{"categories"=>{"id"=>12, "name"=>"Premium Delivery"}}, 
+		{"categories"=>{"id"=>13, "name"=>"Pocket Friendly Delivery"}}, 
+		{"categories"=>{"id"=>14, "name"=>"Clubs & Lounges"}}
+	]
+}
+```
+
+Categories will be accessible through the class variable `categories`
+
+`zomato_instance.categories`
+
+#### Romato::Zomato.get_cities(options)
+
+View API documentation here: https://developers.zomato.com/documentation#!/common/cities
+
+Accepts `options` hash with the following values:
+* `q` query by city name
+* `count` max results to return (optional)
+
+or
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+* `count` max results to return (optional)
+
+or
+
+* `city_ids` comma seperated city ids string
+* `count` max results to return (optional)
+
+Example Options Hash `{ q: "seattle", count: 30 }`
+
+Usage `zomato_instance.get_cities( {q: "seattle", count: 30} )`
+
+Access through class variable `cities`
+
+`zomato_instance.cities`
+
+```ruby 
+{
+	"location_suggestions"=>
+	[
+		{
+			"id"=>279, 
+			"name"=>"Seattle, WA", 
+			"country_id"=>216, 
+			"country_name"=>"United States", 
+			"discovery_enabled"=>1, 
+			"has_new_ad_format"=>0, 
+			"is_state"=>0, 
+			"state_id"=>115, 
+			"state_name"=>"Washington State", 
+			"state_code"=>"WA"}
+	], 
+	"status"=>"success", 
+	"has_more"=>0, 
+	"has_total"=>0
+} 
+```
+
+#### Romato::Zomato.get_collections(options)
+
+View API documentation here: https://developers.zomato.com/documentation#!/common/collections
+
+Accepts `options` hash with the following values:
+* `city_id` query collections by city id
+* `count` max results (optional)
+
+or 
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+* `count` max results (optional)
+
+Usage `zomato_instance.get_collections( { city_id: 279, count: 1000 })`
+
+Access through class variable `collections`
+
+`zomato_instance.collections`
+
+```ruby
+{
+     "collections" => [
+        [ 0] {
+            "collection" => {
+                "collection_id" => 1,
+                    "res_count" => 30,
+                    "image_url" => "https://b.zmtcdn.com/data/collections/e140962ec7eecbb851155fe0bb0cd28c_1463395649.jpg",
+                          "url" => "https://www.zomato.com/moscow-id/top-restaurants?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                        "title" => "Trending this Week",
+                  "description" => "The most popular restaurants in town this week",
+                    "share_url" => "http://www.zoma.to/c-279/1"
+            }
+        },
+        [ 1] {
+            "collection" => {
+                "collection_id" => 29,
+                    "res_count" => 31,
+                    "image_url" => "https://b.zmtcdn.com/data/collections/4661c54a624d8a055119af2d0ccde724_1463399059.jpg",
+                          "url" => "https://www.zomato.com/moscow-id/best-new-restaurants?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                        "title" => "Newly Opened",
+                  "description" => "The best new places in town",
+                    "share_url" => "http://www.zoma.to/c-279/29"
+            }
+        },
+        ........
+```
+
+#### Romato::Zomato.get_cuisines()
+
+View API documentation here: https://developers.zomato.com/documentation#!/common/cuisines
+
+Accepts `options` hash with the following values:
+* `city_id` query collections by city id
+
+
+or 
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+
+
+Usage `zomato_instance.get_cuisines( { city_id: 279 })`
+
+Access through class variable `cuisines`
+
+`zomato_instance.cuisines`
+
+```ruby
+{
+    "cuisines" => [
+        [  0] {
+            "cuisine" => {
+                  "cuisine_id" => 6,
+                "cuisine_name" => "Afghani"
+            }
+        },
+        [  1] {
+            "cuisine" => {
+                  "cuisine_id" => 152,
+                "cuisine_name" => "African"
+            }
+        },
+        [  2] {
+            "cuisine" => {
+                  "cuisine_id" => 1,
+                "cuisine_name" => "American"
+            }
+        },
+        ...
+```
+
+#### Romato::Zomato.get_establishments()
+
+View API documentation here: https://developers.zomato.com/documentation#!/common/establishments
+
+*Note: Establishments returns categories of establishments, rather than a list of establishments*
+
+
+Accepts `options` hash with the following values:
+* `city_id` query collections by city id
+
+
+or 
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+
+
+Usage `zomato_instance.get_establishments( { city_id: 279 })`
+
+Access through class variable `establishments`
+
+`zomato_instance.establishments`
+
+```ruby 
+{
+    "establishments" => [
+        [ 0] {
+            "establishment" => {
+                  "id" => 275,
+                "name" => "Pizzeria"
+            }
+        },
+        [ 1] {
+            "establishment" => {
+                  "id" => 21,
+                "name" => "Quick Bites"
+            }
+        },
+        [ 2] {
+            "establishment" => {
+                  "id" => 281,
+                "name" => "Fast Food"
+            }
+        },
+        ...
+```
+
+
+#### Romato::Zomato.get_geocode()
+
+View API documentation here: https://developers.zomato.com/documentation#!/common/geocode
+
+*Note: geocode is used to return the location name of a given lat/lon, including locality name and nearby restaurants. In depth information is provided, examine the response for more details.*
+
+
+Accepts `options` hash with the following values:
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+
+
+Usage `zomato_instance.get_geocode( { lat: "40.742051", lon: "-74.004821" } )`
+
+Access through class variable `geocode`
+
+`zomato_instance.geocode`
+
+```ruby 
+{
+              "location" => {
+         "entity_type" => "",
+           "entity_id" => 0,
+               "title" => "Chelsea",
+            "latitude" => "40.7445500495",
+           "longitude" => "-73.9971540829",
+             "city_id" => 280,
+           "city_name" => "New York City",
+          "country_id" => 216,
+        "country_name" => "United States"
+    },
+            "popularity" => {
+             "popularity" => "5.00",
+        "nightlife_index" => "4.94",
+             "nearby_res" => [
+            [0] "16765367",
+            [1] "16761344",
+            [2] "16767139",
+            [3] "16777934",
+            [4] "16777961",
+            [5] "16777384",
+            [6] "16761868",
+            [7] "16771928",
+            [8] "16760901"
+        ],
+        ...
+```
+
+### Location Methods (as defined by Zomato API)
+
+#### Romato::Zomato.get_location_details()
+
+View API documentation here: https://developers.zomato.com/documentation#!/location/location_details
+
+*Note: The amount of information returned is quite large, examine the response for more detail.*
+
+Accepts `options` hash with the following values:
+
+* `entity_id` the id of the location entity
+* `entity_type` the type i.e. city, locality
+
+
+Usage `zomato_instance.get_location_details( { entity_id: 279, entity_type: "city" } )`
+
+Access through class variable `location_details`
+
+`zomato_instance.location_details`
+
+```ruby 
+{
+               "popularity" => "4.88",
+          "nightlife_index" => "4.84",
+               "nearby_res" => [
+        [0] "16718075",
+        [1] "16718098",
+        [2] "16720781",
+        [3] "16717315",
+        [4] "16720700",
+        [5] "16718128",
+        [6] "16718982",
+        [7] "16718725",
+        [8] "16727949"
+    ],
+             "top_cuisines" => [
+        [0] "Cafe",
+        [1] "Sandwich",
+        [2] "American",
+        [3] "Bar Food",
+        [4] "Pacific Northwest"
+    ],
+           "popularity_res" => "100",
+            "nightlife_res" => "10",
+                  "subzone" => "Downtown",
+               "subzone_id" => 113179,
+                     "city" => "Seattle",
+                 "location" => {
+         "entity_type" => "city",
+           "entity_id" => "279",
+               "title" => "Seattle, Washington State",
+            "latitude" => 47.60577,
+           "longitude" => -122.329437,
+             "city_id" => 279,
+           "city_name" => "Seattle",
+          "country_id" => 216,
+        "country_name" => "United States"
+    },
+    ...
+```
+#### Romato::Zomato.get_locations()
+
+View API documentation here: https://developers.zomato.com/documentation#!/location/locations
+
+Accepts `options` hash with the following values:
+
+* `query` use a string to query the location name
+* `count` max results to return (optional)
+
+or 
+
+* `lat` query in conjunction with lon
+* `lon` query in conjunction with lat
+* `count` max results to return (optional)
+
+Usage `zomato_instance.get_locations( { lat: "40.742051", lon: "-74.004821" } )`
+
+Access through class variable `locations`
+
+`zomato_instance.locations`
+
+```ruby 
+{
+    "location_suggestions" => [
+        [0] {
+             "entity_type" => "group",
+               "entity_id" => 36932,
+                   "title" => "Chelsea Market, Chelsea, New York City",
+                "latitude" => 40.742051,
+               "longitude" => -74.004821,
+                 "city_id" => 280,
+               "city_name" => "New York City",
+              "country_id" => 216,
+            "country_name" => "United States"
+        }
+    ],
+                  "status" => "success",
+                "has_more" => 0,
+               "has_total" => 0
+}
+```
+
+## Restaurant Methods (as defined by Zomato API)
+
+#### Romato::Zomato.get_daily_menu()
+
+View API documentation here: https://developers.zomato.com/documentation#!/restaurant/restaurant
+
+Accepts `options` hash with the following values:
+
+* `res_id` restaurant id
+
+Usage `zomato_instance.get_daily_menu( { res_id: "16717368" } )`
+
+Access through class variable `daily_menu`
+
+`zomato_instance.daily_menu`
+
+```ruby
+{
+                       "R" => {
+        "res_id" => 16717368
+    },
+                  "apikey" => "f47a72ab00afe64aab78b9919ee3d427",
+                      "id" => "16717368",
+                    "name" => "Canlis",
+                     "url" => "https://www.zomato.com/seattle/canlis-westlake?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                "location" => {
+           "address" => "2576 Aurora Avenue North, WA 98109",
+          "locality" => "Westlake",
+              "city" => "Seattle",
+           "city_id" => 279,
+          "latitude" => "47.6429138889",
+         "longitude" => "-122.3468250000",
+           "zipcode" => "98109",
+        "country_id" => 216
+    },
+                "cuisines" => "Pacific Northwest, Seafood",
+    "average_cost_for_two" => 150,
+             "price_range" => 4,
+                "currency" => "$",
+                  "offers" => [],
+                   "thumb" => "https://b.zmtcdn.com/data/pictures/8/16717368/840eb8f385b06e0408e6ab9e533533da_featured_v2.jpg",
+             "user_rating" => {
+        "aggregate_rating" => "3.7",
+             "rating_text" => "Good",
+            "rating_color" => "9ACD32",
+                   "votes" => "1431"
+    },
+              "photos_url" => "https://www.zomato.com/seattle/canlis-westlake/photos#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                "menu_url" => "https://www.zomato.com/seattle/canlis-westlake/menu#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+          "featured_image" => "https://b.zmtcdn.com/data/pictures/8/16717368/840eb8f385b06e0408e6ab9e533533da_featured_v2.jpg",
+     "has_online_delivery" => 0,
+       "is_delivering_now" => 0,
+                "deeplink" => "zomato://r/16717368",
+       "has_table_booking" => 0,
+              "events_url" => "https://www.zomato.com/seattle/canlis-westlake/events#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1"
+}
+```
+
+#### Romato::Zomato.get_restaurant()
+
+View API documentation here: https://developers.zomato.com/documentation#!/restaurant/restaurant_0
+
+Accepts `options` hash with the following values:
+
+* `res_id` restaurant id
+
+Usage `zomato_instance.get_restaurant( { res_id: "16717368" } )`
+
+Access through class variable `restaurant`
+
+`zomato_instance.restaurant`
+
+```ruby
+{
+                       "R" => {
+        "res_id" => 16717368
+    },
+                  "apikey" => "f47a72ab00afe64aab78b9919ee3d427",
+                      "id" => "16717368",
+                    "name" => "Canlis",
+                     "url" => "https://www.zomato.com/seattle/canlis-westlake?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                "location" => {
+           "address" => "2576 Aurora Avenue North, WA 98109",
+          "locality" => "Westlake",
+              "city" => "Seattle",
+           "city_id" => 279,
+          "latitude" => "47.6429138889",
+         "longitude" => "-122.3468250000",
+           "zipcode" => "98109",
+        "country_id" => 216
+    },
+                "cuisines" => "Pacific Northwest, Seafood",
+    "average_cost_for_two" => 150,
+             "price_range" => 4,
+                "currency" => "$",
+                  "offers" => [],
+                   "thumb" => "https://b.zmtcdn.com/data/pictures/8/16717368/840eb8f385b06e0408e6ab9e533533da_featured_v2.jpg",
+             "user_rating" => {
+        "aggregate_rating" => "3.7",
+             "rating_text" => "Good",
+            "rating_color" => "9ACD32",
+                   "votes" => "1431"
+    },
+              "photos_url" => "https://www.zomato.com/seattle/canlis-westlake/photos#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                "menu_url" => "https://www.zomato.com/seattle/canlis-westlake/menu#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+          "featured_image" => "https://b.zmtcdn.com/data/pictures/8/16717368/840eb8f385b06e0408e6ab9e533533da_featured_v2.jpg",
+     "has_online_delivery" => 0,
+       "is_delivering_now" => 0,
+                "deeplink" => "zomato://r/16717368",
+       "has_table_booking" => 0,
+              "events_url" => "https://www.zomato.com/seattle/canlis-westlake/events#tabtop?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1"
+}
+```
+
+#### Romato::Zomato.get_reviews()
+
+View API documentation here: https://developers.zomato.com/documentation#!/restaurant/reviews
+
+Accepts `options` hash with the following values:
+
+* `res_id` restaurant id
+* `start` which review to begin query
+* `count` max number of results
+
+Usage `zomato_instance.get_reviews( { res_id: "16717368" } )`
+
+Access through class variable `reviews`
+
+`zomato_instance.reviews`
+
+```ruby
+{
+                              "reviews_count" => 58,
+                              "reviews_start" => 0,
+                              "reviews_shown" => 5,
+                               "user_reviews" => [
+        [0] {
+            "review" => {
+                              "rating" => 4.5,
+                         "review_text" => "Canlis July 28, 2016  Seattle, Washington  Generation Owner Brian Canlis Executive Chef Brady Williams Executive Sous Chef Baruch Ellsworth Wine & Spirits Director Nelson Daquip Sommelier & Vice Director Jackson Rohrbaugh  Accolades:  -4 Stars, Seattle Times -Relais & Chateaux -Wine Spectator Grand Award -James Beard Outstanding Wine Service Nomination -James Beard Outstanding Service Nomination -James Beard Best Chef Northwest Nomination -Highest Overall Rating, Zagat -Top 50 Restaurants in Ame...",
+                                  "id" => "27856458",
+                        "rating_color" => "3F7E00",
+                "review_time_friendly" => "one month ago",
+                         "rating_text" => "Loved it!",
+                           "timestamp" => 1470513585,
+                               "likes" => 0,
+                                "user" => {
+                                "name" => "Lee Pitofsky",
+                       "zomato_handle" => "Lpit8",
+                        "foodie_level" => "Super Foodie",
+                    "foodie_level_num" => 8,
+                        "foodie_color" => "f58552",
+                         "profile_url" => "https://www.zomato.com/Lpit8?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+                       "profile_image" => "https://b.zmtcdn.com/data/user_profile_pictures/249/d795854560c55d98e622b91881695249.jpg?fit=around%7C100%3A100&crop=100%3A100%3B%2A%2C%2A",
+                    "profile_deeplink" => "zomato://u/23178569"
+                },
+                      "comments_count" => 0
+            }
+        },
+        ...
+```
+
+#### Romato::Zomato.search()
+
+View API documentation here: https://developers.zomato.com/documentation#!/restaurant/search
+
+*Note: To use the search method it is highly recommended to read the documentation and will require some exploration.*
+
+Accepts `options` hash with the following values:
+
+* `entity_id`
+* `entity_type`
+* `q`
+* `start`
+* `count`
+* `lat`
+* `lon`
+* `radius`
+* `cuisines`
+* `establishment_type`
+* `collection_id`
+* `category`
+* `sort`
+* `order`
+
+Usage `zomato_instance.get_search( { entity_id: "279", cuisines: "997" } )`
+
+Access through class variable `search`
+
+`zomato_instance.search`
+{
+  "results_found": 1232547,
+  "results_start": 0,
+  "results_shown": 20,
+  "restaurants": [
+    {
+      "restaurant": {
+        "R": {
+          "res_id": 50474
+        },
+        "apikey": "f47a72ab00afe64aab78b9919ee3d427",
+        "id": "50474",
+        "name": "Empire Restaurant",
+        "url": "https://www.zomato.com/bangalore/empire-restaurant-koramangala-5th-block?utm_source=api_basic_user&utm_medium=api&utm_campaign=v2.1",
+        "location": {
+          "address": "103, Industrial Area, 5th Block, Near Jyothi Nivas College, Koramangala 5th Block, Bangalore",
+          "locality": "Koramangala 5th Block",
+          "city": "Bangalore",
+          "city_id": 4,
+          "latitude": "12.9348880271",
+          "longitude": "77.6160025969",
+          ...
+```ruby
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kyle-annen/romato. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "romato"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/romato.rb

@@ -0,0 +1,255 @@
+require "romato/version"
+module Romato
+	#use HTTParty for simple http calls
+	require 'httparty'
+
+	class Zomato
+		#assign the variable to be accessed through dot notation
+		attr_accessor :locations, :location_details, :categories, :cities, 
+		:collections, :cuisines, :establishments, :geocode, :daily_menu, 
+		:reviews, :search, :restaurant
+
+		#initializes provided api_key
+		#headers and base uri should not change
+		def initialize(api_key)
+			@api_key = api_key
+			@headers = {"Accept" => "application/JSON", "user-key" => @api_key}
+			@base_uri = "https://developers.zomato.com/api/v2.1/"
+		end
+
+		# COMMON Category
+		# returns a list of categories (food categories)
+		# https://developers.zomato.com/documentation#!/common/categories
+		def get_categories()
+			zomoato_categories_url = @base_uri + "categories"
+			response = HTTParty.get(zomoato_categories_url, headers: @headers)
+			if response.success?
+				@categories = response.parsed_response
+			else
+				raise response.response
+			end
+			return @categories
+		end
+
+		# pass hash to get cities, valid key / value pairs below
+		# q = ""seattle, lat = "", lon = "" , city_ids ="", count=50
+		# {q: "seattle", lat: "", lon: "", city_ids: "", count=50 }
+		def get_cities(options)
+			url_base = @base_uri + "cities?" 
+			a = options.key?(:q) ? "&q=#{options[:q]}" : ""
+			b = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			c = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			d = options.key?(:city_ids) ? "&city_ids=#{options[:city_ids]}" : ""
+			e = options.key?(:count) ? "&count=#{options[:count]}" : ""
+			zomato_cities_url = url_base + a + b + c + d + e
+
+			response = HTTParty.get(zomato_cities_url, headers: @headers)
+			if response.success?
+				@cities = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+		def get_collections(options)
+			url_base = @base_uri + "collections?"
+			a = options.key?(:city_id) ? "&city_id=#{options[:city_id]}" : ""
+			b = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			c = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			d = options.key?(:count) ? "&count=#{options[:count]}" : ""
+			zomato_collections_url = url_base + a + b + c + d
+
+			response = HTTParty.get(zomato_collections_url, headers: @headers)
+			if response.success?
+				@collections = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+		# returns a hash of cuisines in a particular city or geographic location
+		# accepts a hash: options. Required values either
+		# {city_id: "279"}
+		# or
+		# {lat: 32.342, lon: 12.234}
+		# utilizes string interpolation, any value will be interpolated to string and passed to the api endpoint
+		# as an html argument
+		def get_cuisines(options)
+			url_base = @base_uri + "cuisines?"
+			a = options.key?(:city_id) ? "&city_id=#{options[:city_id]}" : ""
+			b = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			c = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			zomato_cuisines_url = url_base + a + b + c
+
+			response = HTTParty.get(zomato_cuisines_url, headers: @headers)
+			if response.success?
+				@cuisines = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+
+		# returns a hash of establishment categories in a particular city or geographic location
+		# accepts a hash: options. Required values either
+		# {city_id: "279"}
+		# or
+		# {lat: 32.342, lon: 12.234}
+		# utilizes string interpolation, any value will be interpolated to string and passed to the api endpoint
+		# as an html argument
+		def get_establishments(options)
+			url_base = @base_uri + "establishments?"
+			a = options.key?(:city_id) ? "&city_id=#{options[:city_id]}" : ""
+			b = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			c = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			zomato_establishments_url = url_base + a + b + c
+
+			response = HTTParty.get(zomato_establishments_url, headers: @headers)
+			if response.success?
+				@establishments = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+		#returns the information to a cooresponding geographical coordinate
+		#accepts options hash
+		#hash example
+		#options: {lat: 24.5344, lon: -12.3423}
+		def get_geocode(options)
+			url_base = @base_uri + "geocode?"
+			a = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			b = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			zomato_geocode_url = url_base + a + b
+
+			response = HTTParty.get(zomato_geocode_url, headers: @headers)
+			if response.success?
+				@geocode = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+		#LOCATION
+
+		# Sets the locations details to @location_details
+		# https://developers.zomato.com/documentation#!/location/location_details
+		# options passed as hash, both entity_id and entity_type are required
+		# options hash example: {entity_id: "279", entity_type: "seattle"}
+		def get_location_details(options)
+			zomato_location_details_url = @base_uri + 
+				"/location_details?entity_id=#{options[:entity_id]}&entity_type=#{options[:entity_type]}"
+			response = HTTParty.get(zomato_location_details_url, headers: @headers)
+			if response.success?
+				@location_details = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+		#sets location guesses based on the query to @locations
+		#query and latitude/longitude are required
+		#hash returned can be viewed in Zomato documentation
+		#https://developers.zomato.com/documentation#!/location/locations
+		#options passed as a hash
+		#options hash example: {query: "seattle", lat: "47.6906021", lon}
+		def get_locations(options)	
+			url_base = @base_uri + "locations?"
+			a = options.has_key?(:query) ? "&query=#{options[:query]}" : ""
+			b = options.has_key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			c = options.has_key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			d = options.has_key?(:count) ? "&count=#{options[:count]}" : ""
+			zomato_locations_url = url_base + a + b + c + d
+
+			response = HTTParty.get(zomato_locations_url, headers: @headers)
+			if response.success?
+				@locations = []
+				#for result in response.parsed_response.location_suggestions
+					@locations = response.parsed_response
+				#end
+			else
+				raise response.response
+			end
+		end
+
+		
+
+
+		#RESTAURANT
+		# accepts options hash as parameters
+		# options example: {res_id: "279"}
+		def get_daily_menu(options)
+			zomato_daily_menu_url = @base_uri +
+				"restaurant?res_id=#{options[:res_id]}"
+			response = HTTParty.get(zomato_daily_menu_url, headers: @headers)
+			if response.success?
+				@daily_menu = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+
+		# get the details from the restaurant
+		# https://developers.zomato.com/documentation#!/restaurant/restaurant_0
+		# # accepts options hash as parameters
+		# options example: {res_id: "279"}
+		def get_restaurant(options)
+
+			zomato_restaurant_details_url = @base_uri +
+				"restaurant?res_id=#{options[:res_id]}"
+			response = HTTParty.get(zomato_restaurant_details_url, headers: @headers)
+			if response.success?
+				@restaurant = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+
+
+		def get_reviews(options)
+			url_base = @base_uri + "reviews?" 
+			a = options.key?(:res_id) ? "&res_id=#{options[:res_id]}" : ""
+			b = options.key?(:start) ? "&start=#{options[:start]}" : ""
+			c = options.key?(:count) ? "&count=#{options[:count]}" : ""
+			zomato_reviews_url = url_base + a + b + c
+
+			response = HTTParty.get(zomato_reviews_url, headers: @headers)
+
+			if response.success?
+				@reviews = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+
+
+		def get_search(options)
+			url_base = @base_uri + "search?"
+			a = options.key?(:entity_id) ? "&entity_id=#{options[:entity_id]}" : ""
+			b = options.key?(:entity_type) ? "&entity_type=#{options[:entity_type]}" : ""
+			c = options.key?(:q) ? "&q=#{options[:q]}" : ""
+			d = options.key?(:start) ? "&start=#{options[:start]}" : ""
+			e = options.key?(:count) ? "&count=#{options[:count]}" : ""
+			f = options.key?(:lat) ? "&lat=#{options[:lat]}" : ""
+			g = options.key?(:lon) ? "&lon=#{options[:lon]}" : ""
+			h = options.key?(:radius) ? "&radius=#{options[:radius]}" : ""
+			i = options.key?(:cuisines) ? "&cuisines=#{options[:cuisines]}" : ""
+			j = options.key?(:establishment_type) ? "&establishment_type=#{options[:establishment_type]}" : ""
+			k = options.key?(:collection_id) ? "&collection_id=#{options[:collection_id]}" : ""
+			l = options.key?(:category) ? "&category=#{options[:category]}" : ""
+			m = options.key?(:sort) ? "&sort=#{options[:sort]}" : ""
+			n = options.key?(:order) ? "&order=#{options[:order]}" : ""
+			zomato_search_url = a + b + c + d + e + f + g + h + i + j + k + l + m + n
+
+			response = HTTParty.get(zomato_search_url, headers: @headers)
+
+			if response.success?
+				@search = response.parsed_response
+			else
+				raise response.response
+			end
+		end
+	end
+end

data/lib/romato/version.rb

@@ -0,0 +1,3 @@
+module Romato
+  VERSION = "0.1.0"
+end

data/romato.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'romato/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "romato"
+  spec.version       = Romato::VERSION
+  spec.authors       = ["Kyle Annen"]
+  spec.email         = ["kyleannen@gmail.com"]
+
+  spec.summary       = %q{Romato is an API wrapper for Zomato API v2.1.}
+  spec.description   = %q{Romato provides a class, Zomato, which has methods cooresponding to each API class provided under the Zomato API documentation.  Please read through the Zomato API terms of use: https://www.zomato.com/api_policy}
+  spec.homepage      = "http://www.github.com/kyle-annen/romato"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "httparty"
+  spec.add_runtime_dependency "bundler", "~> 1.13"
+  spec.add_runtime_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "rspec", "~> 3.0"
+
+  spec.add_development_dependency "httparty"
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"  
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: romato
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyle Annen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'Romato provides a class, Zomato, which has methods cooresponding to
+  each API class provided under the Zomato API documentation.  Please read through
+  the Zomato API terms of use: https://www.zomato.com/api_policy'
+email:
+- kyleannen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "#Gemfile#"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/romato.rb
+- lib/romato/version.rb
+- romato.gemspec
+homepage: http://www.github.com/kyle-annen/romato
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Romato is an API wrapper for Zomato API v2.1.
+test_files: []