yum 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5d26bebf5c6c74410fc71d51da982ce75de56c0
+  data.tar.gz: 58d9f153290b02e63befbd6e6da11a0169cfcdc5
+SHA512:
+  metadata.gz: aac9925d5c3dcecd5e47447da91c90d19573f9da85a74bcc4895b61661110748c33e26ac24dcd3aaf1831c4b1acab8d32b05ec4656e10ad79584fa165664ff46
+  data.tar.gz: 508ae09de4c28b3b7a34a14f852248c82a7cce77df6b22c20e6fbaac92b78d53ad3e5b1ad9defc68bc334c184c1636191768ff24178f9a2ff99fd1d0b93e38d0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Simon Štefunko
+
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 halfdeadpie
+
+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,98 @@
+# Yum
+
+The Yum is the application with command line interface. The main purpose of this application is to increase your cookings
+skills, which are represented as the level. All you need to do is to generate the recipe which you like, cook the food, eat it
+and review it using scale from 0 to 3. The better food you prepare, the more XP points you get. Increasing your XP points leads
+to increasing your level. And your level and XP points "unlock" for you more difficult recipes, which needs more time too cook.
+
+The application uses the Yummly API to access the recipes of the food:
+
+    ```https://developer.yummly.com/```
+    
+There is also used the Backendless REST as the storage of users data:
+
+    ```https://backendless.com/docs/rest/doc.html```
+    
+Application uses Faraday adapter for executing the requests:
+
+    ```http://www.rubydoc.info/gems/faraday/Faraday/Adapter```
+
+As the new user, you should registrate first with your email and password. After login, you start at level 0 and you
+are able to generate recipe. So let's cook!
+
+## Installation
+
+You are able to install this gem using this command:
+
+    $ gem install yum
+
+Or you can download it from Github and install it this way:
+
+    $ gem build yum.gemspec
+    $ gem install yum-[VERSION].gem
+    
+## Usage
+
+All functionality of this command line application is provided trough the command ```yum```. Before using this
+application, you must set two environment variables ```BACKENDLESS_KEY``` and ```YUMMLY_KEY```, which
+are specific for this application.
+
+_Because it is an academic application, you need to ask for the keys from author._
+
+Registration:
+
+    $ yum register EMAIL PASSWORD
+    
+Login:
+
+    $ yum login EMAIL PASSWORD
+    
+Recipe may be generated only for the logged user, because its difficulty _(maximal time for cooking)_ is computed from user's level.
+User is also able to set filter for searching in recipes _(holiday recipes, diet, natioanl cuisines, ingredients, phrase,...)_ 
+The command that provides recipe looks like this:
+
+    $ yum [OPTIONS] recipe
+    
+The user is able to view his last recipe
+
+    $ yum last
+    
+Expected scenario how to play this _game_ is when user generaters the recipe, he cooks it after that. After all that
+cooking and eating, user is able to review his prepared food from 0 to 3 points. The reviews provides XP points to user.
+The user is able to review his last food only once. After that, his last food is deleted from the database.
+
+    $ yum review [0..3]
+
+To display the user's stats _(email, level, xp)_, you should use this command:
+
+    $ yum user
+    
+## Documentation
+
+To generate the documentation using the ```yard``` use the command
+
+    $ yard doc
+    
+## Tests
+
+To run the tests using the ```rspec``` set the ```BACKENDLESS_KEY``` and ```YUMMLY_KEY``` and use the command:
+
+    $ rspec spec 
+    
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Tasks
+
+- [x] generates recipes from https://www.yummly.com/ for user depending on user's level
+- [x] after cooking the food, the user or user's friend is able to evaluate the food
+- [x] the user gain XP depending on the evaluation of the cooked food
+- [x] the user is able to filter diet
+- [x] the user is able to filter national cuisine
+- [x] the user is able to filter ingredients
+- [x] the user is able to choose aprox. time for cooking - _time depends on user's level_
+- [x] the user is able to filter the holiday recipes
+- [x] the user is able to set personal data in configuration file - _user doesn't need configuration file, application uses Backendless database_
+- [x] docummentation
+- [x] tests

data/bin/yum

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'yum'
+
+Yum::Yummer.cli

data/lib/backendless.rb

@@ -0,0 +1,116 @@
+# Provides communication with Backendless API
+# that is used to store data about the users
+class Backendless
+  # Backendless application ID - this shouldn't change
+  @app_id = 'B04D050F-9131-884B-FFBE-F3A2EC48B300'
+
+  # Backendless application KEY - this must be set as
+  # the ENV variable 'BACKENDLESS_KEY'
+  @app_key = ENV['BACKENDLESS_KEY']
+
+  # URI to the Backendless including Application ID and KEY
+  @uri = "https://api.backendless.com/#{@app_id}/#{@app_key}/"
+
+  # Creates the generic connection to Backendless and add
+  # mandatory headers
+  #
+  # @return [Faraday connection] generic connection
+  def self.generic_connection
+    conn = Faraday.new(url: @uri)
+    conn.headers['Content-Type'] = 'application/json'
+    conn.headers['application-type'] = 'REST'
+    conn
+  end
+
+  # Register the user in the Backendless database
+  # and provides response
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @return [String, nil] The response of registration
+  def self.register(email, password)
+    conn = generic_connection
+    body = build_registration_body email, password
+    response = conn.post 'users/register', body.to_json
+    process_response response
+  end
+
+  # Login the user in the Backendless database
+  # and provides the response
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @return [String, nil] The response of login
+  def self.login(email, password)
+    conn = generic_connection
+    body = build_login_body email, password
+    response = conn.post 'users/login', body.to_json
+    process_response response
+  end
+
+  # Process the response of request according to status
+  #
+  # @param response [Faraday response] the response of request
+  # @return [String, nil] The response body
+  def self.process_response(response)
+    if response.status.equal? 200
+      response.body
+    elsif [409, 400, 401].include? response.status
+      nil
+    else
+      abort('I can not communicate with the user data. Set the BACKENDLESS_KEY')
+    end
+  end
+
+  # Builds the body of registration request
+  # with email and password
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @return [Hash] the body for registration
+  def self.build_registration_body(email, password)
+    body = {
+      email: email,
+      password: password
+    }
+    body
+  end
+
+  # Builds the body of login request
+  # with email and password
+  #
+  # @param login [String] email of the user
+  # @param password [String] password of the user
+  # @return [Hash] the body for login
+  def self.build_login_body(login, password)
+    body = {
+      login: login,
+      password: password
+    }
+    body
+  end
+
+  # Provides the last food of user
+  #
+  # @param user_object_id [String] ObjectID of the user data
+  # @return [String] The food id of last recipe
+  def self.last(user_object_id)
+    conn = generic_connection
+    response = conn.get "users/#{user_object_id}"
+    Parser.extract_food_id response.body
+  end
+
+  # Update the property in userdata
+  #
+  # @param object_id [String] the object ID of user data
+  # @param user_token [String] token receved from login operation
+  # @return [Faraday response, nil] The body of the response
+  def self.update(object_id, user_token, key, value)
+    conn = generic_connection
+    conn.headers['user-token'] = user_token
+    body = {}
+    body[key] = value
+    response = conn.put "data/users/#{object_id}", body.to_json
+    process_response response
+  end
+end

data/lib/cli_parser.rb

@@ -0,0 +1,122 @@
+# The command line interface parser
+class CliParser
+  # Options of the command line parser
+  @options = {}
+
+  # help message
+  @help = {
+    holiday: 'Include/exclude holiday recipes',
+    ing: 'Include/exclude recipes with ingredients',
+    cui: 'Include/exclude recipes of national cuisines',
+    diet: 'Include/exclude diet recipes',
+    phrase: 'Includes recipes with phrase in name'
+  }
+
+  # building the banner
+  @banner = "Usage: yum [options] SUBCOMMAND\n"
+  @banner += "\nSUBCOMMANDS:\n"
+  @banner += "\trecipe\t\t-\t\tGenerates recipe according to parameters\n\n"
+  @banner += "\tregister USERNAME PASSWORD\t\t-\t\tRegister the new user\n\n"
+  @banner += "\tlogin USERNAME PASSWORD\t\t-\t\tLogin the user\n\n"
+  @banner += "\tlast\t\t-\t\tPrint the last generated food\n\n"
+  @banner += "\treview REVIEW\t\t-\t\tUser reviews the last generated"
+  @banner += "food from 0 to 3 points and gain the XP points\n\n"
+  @banner += "\tuser\t\t-\t\tPrints the user stats\n\n"
+
+  # Parse the options in command line
+  def self.parse_opts
+    OptionParser.new do |opts|
+      opts.banner = @banner
+
+      # help message option
+      opts.on('--help',
+              'Prints help message') do
+        puts opts
+        exit
+      end
+
+      # version message option
+      opts.on('--version',
+              'Prints version') do
+        puts "yum #{Yum::VERSION}"
+        exit
+      end
+
+      # phrase -----------------------------------------------------------------
+      # include recipe with phrase
+      opts.on('-p', '--phrase PHRASE', @help[:phrase]) do |phrase|
+        @options[:q] = phrase
+      end
+
+      # holiday ----------------------------------------------------------------
+      # include holiday recipes
+      opts.on('-h', '--holiday HOLIDAY', @help[:holiday]) do |holiday|
+        @options[:allowedHoliday] = holiday
+      end
+
+      # exclude holiday recipes
+      opts.on('--eh', '--excluded-holiday HOLIDAY', @help[:holiday]) do |hol|
+        @options[:excludedHoliday] = hol
+      end
+
+      # ingredients ------------------------------------------------------------
+      # include ingredients in recipes
+      opts.on('-i', '--ingredients INGREDIENT', @help[:ing]) do |ing|
+        @options[:allowedIngredient] = ing
+      end
+
+      # exclude holiday in recipes
+      opts.on('--ei', '--excluded-ingredient INGREDIENT', @help[:ing]) do |ing|
+        @options[:excludedIngredient] = ing
+      end
+
+      # cuisines ---------------------------------------------------------------
+      # include cuisines in recipes
+      opts.on('-c', '--cuisine CUISINE', @help[:cui]) do |cui|
+        @options[:allowedCuisine] = cui
+      end
+
+      # exclude cuisines in recipes
+      opts.on('--ec', '--excluded-cuisine CUISINE', @help[:cui]) do |cui|
+        @options[:excludedCuisine] = cui
+      end
+      # diets ------------------------------------------------------------------
+      # include diets in recipes
+      opts.on('-d', '--diet DIET', @help[:diet]) do |diet|
+        @options[:allowedDiet] = diet
+      end
+
+      # exclude diets in recipes
+      opts.on('--ed', '--excluded-diet DIET', @help[:diet]) do |diet|
+        @options[:excludedDiet] = diet
+      end
+    end.parse!
+  rescue OptionParser::InvalidOption => e
+    abort(e)
+  end
+
+  # Parse the arguments in the command line
+  def self.parse_argv
+    client = Client.new
+    subcommands = {
+      recipe: -> { client.recipe @options },
+      register: -> { client.register ARGV[1], ARGV[2] },
+      login: -> { client.login ARGV[1], ARGV[2] },
+      last: -> { client.last },
+      review: -> { client.review ARGV[1] },
+      user: -> { client.user }
+    }
+    call_subcommand subcommands[ARGV[0].to_sym]
+  end
+
+  # Tries to call subcommand extracted from hash
+  #
+  # @param command [String] subcommand to call
+  def self.call_subcommand(command)
+    if command.nil?
+      abort(@banner)
+    else
+      command.call
+    end
+  end
+end

data/lib/client.rb

@@ -0,0 +1,65 @@
+# Encapsulate all the main functionality and represents the client
+# using the user database and Yummly API
+class Client
+  # Provides the recipe for the logged user according
+  # to his level and searching parameters
+  #
+  # @param parameters [Hash] searching parameters from from the command line
+  def recipe(parameters)
+    user = User.new
+    user.read_creddentials
+    user.login
+    generated_food = YumConnector.search parameters, user.xp
+    abort("Sorry, I can't find food for you like that") if generated_food.nil?
+    user.update_last_food_id generated_food.id
+    puts generated_food.to_str
+  end
+
+  # Register the user using Backendless
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  def register(email, password)
+    user = User.new
+    puts user.register email, password
+  end
+
+  # Login the user using Backendless
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  def login(email, password)
+    user = User.new
+    puts user.login email, password
+  end
+
+  # Provides the last recipe of logged user
+  def last
+    user = User.new
+    user.read_creddentials
+    user.login
+    last_food = YumConnector.food_by_id user.last
+    puts last_food.to_str
+  end
+
+  # Reviews the cooked food of the last recipe of logged user
+  def review(rating)
+    user = User.new
+    user.read_creddentials
+    user.login
+    response = user.review rating
+    if response
+      puts 'Last food reviewed!'
+    else
+      puts 'Nothing to review'
+    end
+  end
+
+  # Provides the stats of the user
+  def user
+    user = User.new
+    user.read_creddentials
+    user.login
+    puts user.to_str
+  end
+end

data/lib/food.rb

@@ -0,0 +1,39 @@
+# Represents single recipe from Yummly
+class Food
+  # the id of the recipe on Yummly
+  attr_reader :id
+
+  # Creates food with the parameters from JSON
+  #
+  # @param food_json [JSON] recipe encapsulated in json from Yummly
+  def initialize(food_json)
+    @name = food_json['name']
+    @id = food_json['id']
+    @aprox_time = food_json['totalTime']
+    @image_url = image_url food_json
+    @ingredients = food_json['ingredientLines']
+    @guide_url = food_json['source']['sourceRecipeUrl']
+  end
+
+  # Extract image from json
+  #
+  # @param food_json [JSON] recipe encapsulated in json from Yummly
+  # @return [String] URL of the image
+  def image_url(food_json)
+    food_json['images'][0].values.first
+  end
+
+  # Provides stats of the user in human-readble form
+  #
+  # @return [String] stats of the user
+  def to_str
+    result = @name
+    result += "\nID: #{@id}"
+    result += "\n\nApproximate time: #{@aprox_time}"
+    result += "\nImage URL: #{@image_url}\n"
+    result += "\nIngredients:\n"
+    result += @ingredients.join("\n")
+    result += "\n\nStep-by-step:  #{@guide_url}\n"
+    result
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,85 @@
+# Provides parsing methods of all kind
+class Parser
+  # Extract the search value from json according to the description
+  #
+  # @param json [JSON] metadata from Yummly API
+  # @param description [String] local description of data
+  # @return [String] search value from metadata for Yummly API
+  def self.get_search_value(json, description)
+    json.each do |metapar|
+      ext_hash = metapar.select { |k, _| k.downcase.include? 'description' }
+      extern = ext_hash.values.first.downcase
+      local = description.downcase
+      return metapar['searchValue'] if "\b#{local}\b".match(extern)
+    end
+  end
+
+  # Parse the jsonp to json
+  #
+  # @param jsonp [String] jsonp format to parse
+  # @param key [String] key used in slicing jsonp
+  # @return [JSON] parsed json from jsonp
+  def self.jsonp_to_json(jsonp, key)
+    metadata_key = slice_metadata_key key
+    first_split = jsonp.split("set_metadata('#{metadata_key}', ")[1]
+    second_split = first_split.split(');')[0]
+    JSON.parse second_split
+  end
+
+  # Extracts the food id from json
+  #
+  # @param food_json [JSON] the food json
+  # @return [String] id of the food from json
+  def self.food_id(food_json)
+    abort("Sorry, I can't find food for you like that :(") if food_json.nil?
+    id = food_json['id']
+    id
+  end
+
+  # Extracts the metadata key from search parameter
+  #
+  # @param key [String] key to be sliced
+  # @return [String] metadata key
+  def self.slice_metadata_key(key)
+    metadata_key = key.to_s
+    metadata_key.slice!('allowed') if metadata_key.include? 'allowed'
+    metadata_key.slice!('excluded') if metadata_key.include? 'exclude'
+    metadata_key.downcase
+  end
+
+  # Extracts object ID from lofin response
+  #
+  # @param login_response [JSON] response from login
+  # @return [Strng] object ID of the user data
+  def self.login_object_id(login_response)
+    j = JSON.parse login_response
+    j['objectId']
+  end
+
+  # Extracts the food id from response
+  #
+  # @param response [String] response body containing the recipe
+  # @return [String] food id from response
+  def self.extract_food_id(response)
+    j = JSON.parse response
+    j['food_id']
+  end
+
+  # Extracts the user token from response
+  #
+  # @param response [String] response body containing user token after login
+  # @return [String] user token generated when logged in
+  def self.extract_user_token(response)
+    j = JSON.parse response
+    j['user-token']
+  end
+
+  # Extract value of XP points
+  #
+  # @param response [String] response bode containing the XP value
+  # @return [String] XP points of the user
+  def self.extract_xp(response)
+    j = JSON.parse response
+    j['xp']
+  end
+end

data/lib/request.rb

@@ -0,0 +1,157 @@
+# Manages Yummly requests using the Faraday adapter
+class Request
+  # Yummly URI
+  @uri = 'http://api.yummly.com/v1/api/'
+
+  # application ID should not be changed
+  @app_id = 'a9ceda48'
+
+  # application KEY from the ENV variable
+  @app_key = ENV['YUMMLY_KEY']
+
+  # the maximum searched results
+  @max_results = 3
+
+  # Creates the generic connection for Yummly API
+  #
+  # @return [Faraday connection] connection to Yummly with mandatory headers
+  def self.generic_connection
+    conn = Faraday.new(url: @uri)
+    conn.headers['X-Yummly-App-ID'] = @app_id
+    conn.headers['X-Yummly-App-Key'] = @app_key
+    conn
+  end
+
+  # ----------------------------------------------------------------------------
+  # Search the recipes filtrated with parameters
+  #
+  # @param parameters [Hash] searching parameters from command line
+  # @param xp [Integer] XP points of user for setting max cooking time
+  # @return [String] Response body containing founded recipes
+  def self.search(parameters = {}, xp = 0)
+    # build generic connection
+    conn = generic_connection
+
+    # set the search parameters
+    search_parameters = {}
+
+    # add phrase if exists
+    add_phrase parameters, search_parameters
+
+    # add other search parameters
+    add_search_parameters parameters, search_parameters
+
+    # add max searching results
+    add_max_results search_parameters
+
+    # calculate max cooking time according to the user's XP
+    add_max_time search_parameters, xp
+
+    # execute the request to /recipes with search parameters
+    response = conn.get 'recipes', search_parameters
+
+    # return body if OK response
+    process_response response
+  end
+
+  # Provides recipe by ID
+  #
+  # @param food_id [String] recipe id of food on Yummly
+  # @return [String] response body containing the recipe data
+  def self.get_recipe(food_id)
+    # build generic connection
+    conn = generic_connection
+
+    # get food by its ID on yummly
+    response = conn.get "recipe/#{food_id}"
+
+    # return body if OK response
+    process_response response
+  end
+
+  # Processes response of all kind from Yummly
+  #
+  # @param response [Faraday response] response from Yummly
+  # @return [String] body of response
+  def self.process_response(response)
+    if response.status.eql? 200
+      response.body
+    else
+      abort('I can not communicate with Yummly. Set the YUMMLY_KEY')
+    end
+  end
+
+  # Add max results parameter to searching parameters
+  #
+  # @param parameters [Hash] searching parameters
+  def self.add_max_results(parameters)
+    parameters['maxResult'] = @max_results
+  end
+
+  # Add parameters from command line to searching parameters
+  #
+  # @param parameters [Hash] parameters from command line
+  # @param search_parameters [Hash] search parameters in proper form for request
+  def self.add_search_parameters(parameters, search_parameters)
+    parameters.each do |key, value|
+      metadata = get_metadata key
+      metadata_json = Parser.jsonp_to_json metadata, key
+      init_search_parameters search_parameters, key
+      multiple_parameters = value.split(',')
+      multiple_parameters.each do |single_parameter|
+        search_value = Parser.get_search_value metadata_json, single_parameter
+        build_search_parameters search_parameters, key, search_value
+      end
+    end
+  end
+
+  # Add phrase to searching parameters
+  #
+  # @param parameters [Hash] parameters from command line
+  # @param search_parameters [Hash] search parameters in proper form for request
+  def self.add_phrase(parameters, search_parameters)
+    hash_phrase = {}
+    hash_phrase[:q] = parameters[:q] if parameters[:q]
+    parameters.delete :q
+    init_search_parameters search_parameters, :q
+    build_search_parameters search_parameters, :q, hash_phrase.values.first
+  end
+
+  # Provides metadata by key
+  #
+  # @param key [String] key of metadata
+  # @return [String] response body of metadata
+  def self.get_metadata(key)
+    metadata_key = Parser.slice_metadata_key key
+    conn = generic_connection
+    meta_response = conn.get "metadata/#{metadata_key}"
+    process_response meta_response
+  end
+
+  # Initialize the search parameters array in hash on key position
+  #
+  # @param search_parameters [Hash] search parameters for request
+  # @param key [String] key of metadata
+  def self.init_search_parameters(search_parameters, key)
+    search_parameters[key] = []
+  end
+
+  # Build the array in hash on key position
+  #
+  # @param search_parameters [Hash] search parameters for request
+  # @param key [String] key from metadata
+  # @param search_value [String] value from metadata for searching
+  def self.build_search_parameters(search_parameters, key, search_value)
+    search_parameters[key].push search_value
+  end
+
+  # Add maximal time for cooking computed from XP points of user
+  #
+  # @param parameters [Hash] search parameters for request
+  # @param xp [String] XP points of the user
+  def self.add_max_time(parameters, xp)
+    parameter = xp * @max_results * 10
+    parameter = 80 if (xp * @max_results).eql? 0
+    parameters['maxTotalTimeInSeconds'] = parameter
+  end
+end

data/lib/user.rb

@@ -0,0 +1,137 @@
+# Represents the user of this application
+class User
+  # has email, password, token and xp points during the runtime
+  attr_reader :email, :password, :token, :xp
+
+  # Constructor creates the new user with unset email and password
+  def self.initialize
+    @email = nil
+    @password = nil
+  end
+
+  # Register the user using Backendless
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @return [String] state of the registration in human-readable form
+  def register(email, password)
+    response = Backendless.register email, password
+    if response
+      'Registration sucessful'
+    else
+      'Registration failed'
+    end
+  end
+
+  # Login the user using Backendless
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @return [String] state of the login in human-readable form
+  def login(email = @email, password = @password)
+    response = Backendless.login email, password
+    if response
+      process_login_response email, password, response
+      store_creddentials
+      'Login success'
+    else
+      abort('Login failed')
+    end
+  end
+
+  # Process the login response and set the attributes of user
+  #
+  # @param email [String] email of the user
+  # @param password [String] password of the user
+  # @param response [JSON] response from login to Backendless
+  def process_login_response(email, password, response)
+    @email = email
+    @password = password
+    @token = Parser.extract_user_token response
+    @id = Parser.login_object_id response
+    @xp = Parser.extract_xp response
+  end
+
+  # Provides the last recipe of user
+  #
+  # @return [String] the last food id of the user
+  def last
+    login_response = Backendless.login @email, @password
+    object_id = Parser.login_object_id login_response
+    Backendless.last(object_id)
+  end
+
+  # Stores the credentials to 'creddentials.csv' to achieve persistence
+  def store_creddentials
+    CSV.open('creddentials.csv', 'w') do |csv|
+      csv << [@email, @password]
+    end
+    read_creddentials
+  end
+
+  # Reads the credentials from the 'creddentials.csv' and set them
+  def read_creddentials
+    creddentials = []
+    CSV.foreach 'creddentials.csv' do |record|
+      creddentials << record
+    end
+    @email = creddentials[0][0]
+    @password = creddentials[0][1]
+  rescue StandardError => e
+    abort("You are not logged in!\nERROR:\n#{e}")
+  end
+
+  # Updates the last food id in Backendless database
+  #
+  # @param food_id [String] the id of food from Yummly
+  # @return [true, nil] the state of the operation
+  def update_last_food_id(food_id)
+    response = Backendless.update(@id, @token, 'food_id', food_id)
+    true if response
+  end
+
+  # Reviews the last food of the user
+  #
+  # @param rating [String] the rating of the last food from 0 to 3
+  # @return [true, nil] the status of the operation
+  def review(rating)
+    real_rating = check_rating rating
+    @xp += real_rating
+    last_food = Backendless.last @id
+    return false if last_food.eql? 'Empty plate'
+    response = Backendless.update(@id, @token, 'xp', @xp)
+    update_last_food_id 'Empty plate' if response
+    true if response
+  end
+
+  # Checks the boundary on food rating
+  #
+  # @param rating [String] rating of food
+  # @return [String] real rating in proper interval
+  def check_rating(rating)
+    abort('Rating points missing!') if rating.nil?
+    real_rating = Integer(rating)
+    real_rating = 3 if real_rating > 3
+    real_rating = 0 if real_rating < 0
+    real_rating
+  end
+
+  # Provides the user stats in human-readable form
+  #
+  # @return [String] user stats
+  def to_str
+    result = "Email: #{@email}\n"
+    lvl = level xp
+    result += "Level: #{lvl}\n"
+    result += "XP: #{@xp}\n"
+    result
+  end
+
+  # Computes the level from XP
+  #
+  # @param xp [Integer] XP points of the user gained from ratings of his food
+  # @return [String] level of the user
+  def level(xp)
+    xp / 10
+  end
+end

data/lib/yum.rb

@@ -0,0 +1,25 @@
+require 'yum/version'
+require 'csv'
+require 'faraday'
+require 'optparse'
+require 'json'
+require 'backendless'
+require 'cli_parser'
+require 'client'
+require 'food'
+require 'parser'
+require 'request'
+require 'user'
+require 'yum_connector'
+
+# Encapsulate the Yum application
+module Yum
+  # Uniters all main methods of user interface
+  class Yummer
+    # Unites Command Line parser methods
+    def self.cli
+      CliParser.parse_opts
+      CliParser.parse_argv
+    end
+  end
+end

data/lib/yum/version.rb

@@ -0,0 +1,13 @@
+# This is the module of Yum application.
+# This module encapsulate functionality that provides this application
+# Example:
+# user regtration,
+# user login,
+# user stats,
+# recipe generation,
+# recipe review,
+# leveling in cooking skills,
+module Yum
+  # version of the gem
+  VERSION = '0.1.6'
+end

data/lib/yum_connector.rb

@@ -0,0 +1,26 @@
+# Handles connection using Requests and provides the results to client
+class YumConnector
+  # Searches the food according to search parameters from command line
+  #
+  # @param parameters [Hash] parameters from the command line
+  # @param xp [Integer] the XP points of the user
+  # @return [Food] new food randomly chosen from searched results
+  def self.search(parameters, xp)
+    result = Request.search parameters, xp
+    return nil if result.nil?
+    searched_result = JSON.parse result
+    id = Parser.food_id searched_result['matches'].sample
+    food_json = JSON.parse Request.get_recipe id
+    Food.new food_json
+  end
+
+  # Provides the food from Yummly by its id
+  #
+  # @param food_id [String] the id of the food on Yummly
+  # @return [Food] the food recipe from Yummly
+  def self.food_by_id(food_id)
+    return food_id if food_id.eql? 'Empty plate'
+    food_json = JSON.parse Request.get_recipe food_id
+    Food.new food_json
+  end
+end

data/yum.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('lib/yum/version', __dir__)
+
+Gem::Specification.new do |s|
+  s.name        = 'yum'
+  s.version     = Yum::VERSION
+  s.homepage    = 'https://github.com/HalfDeadPie/yum-lite-ruby'
+  s.license     = 'MIT'
+  s.author      = 'Simon Stefunko'
+  s.email       = 's.stefunko@gmail.com'
+
+  s.summary     = 'Improve your cooking skills'
+
+  s.files       = Dir['bin/*', 'lib/**/*', '*.gemspec', 'LICENSE*', 'README*']
+  s.executables = Dir['bin/*'].map { |f| File.basename(f) }
+  s.has_rdoc    = 'yard'
+
+  s.required_ruby_version = '>= 2.2'
+  s.add_runtime_dependency 'faraday', '~> 0.14', '>= 0.14.0'
+  s.add_runtime_dependency 'json', '~> 2.0', '>= 2.0.4'
+
+  s.add_development_dependency 'rake', '~> 12.0'
+  s.add_development_dependency 'rspec', '~> 3.6'
+  s.add_development_dependency 'yard', '~> 0.9'
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: yum
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Simon Stefunko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email: s.stefunko@gmail.com
+executables:
+- yum
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- LICENSE.txt
+- README.md
+- bin/yum
+- lib/backendless.rb
+- lib/cli_parser.rb
+- lib/client.rb
+- lib/food.rb
+- lib/parser.rb
+- lib/request.rb
+- lib/user.rb
+- lib/yum.rb
+- lib/yum/version.rb
+- lib/yum_connector.rb
+- yum.gemspec
+homepage: https://github.com/HalfDeadPie/yum-lite-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Improve your cooking skills
+test_files: []