RitoPlz 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 410c20f3f3797b9a40552076870c2503d4df3bf3
+  data.tar.gz: d08ec90bd1dce5c095cb7511bdf4e219b9604fce
+SHA512:
+  metadata.gz: d241d3f7cfea0605994845a5566acf4f108d58f7ddb9e48f05ecdac4f919d6244effce04f393e0babeb37beafc55c928ae0248bdab14fbccda66877821a594c4
+  data.tar.gz: 0614774dac244704f7dec90da8745c0d32892b1f1c4fc57484abcd89a0034296f225e4b565c1b7251094f090d60d03e6bf511b9fecbb319af996cec8de8ac606

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.2.0
+
+script: 'bundle exec rake deploy'

data/Gemfile

@@ -0,0 +1,9 @@
+ruby '2.2.0'
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in RitoPlz.gemspec
+gemspec
+
+gem 'pry'
+gem 'rspec'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Luke Jones
+
+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,82 @@
+# RitoPlz
+[![Build Status](https://travis-ci.org/gjh33/RitoPlz.svg?branch=master)](https://travis-ci.org/gjh33/RitoPlz)
+
+RitoPlz is an independently developed easy to use API wrapper for Riot Games API.
+The main goal of this project is to provide a very clean, easy to use API which should not result in any frustration. Should you find yourself frustrated please open a Bug Report so I can make the necessary changes. The source code should also be simple and easy to read.
+
+##Goals
+The goals for this project are very important. If you feel the project is not meeting these goals, please make a bug report or fork the project.
+
+* Simplicity. This wrapper should be stupid simple. No meta programming. No hidden bullshit. Very clear. If you dont like something about this gem, you should be able to manipulate it without issue to your needs.
+* Well documented. You should have no questions if you've read all the documentation on github. You should never be confused, and this should all be very easy.
+* No frustration. The reason for the first 2 goals is to minimize frustration. I'm sick and tired of using API wrappers only to find they lack a feature, or have a bug, and it's impossible to figure out why.
+* Barebones. This should be barebones and as close to riot's api as possible. No model associations, no fancy features. This gem should be what you use when you want to make a fancier wrapper.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'RitoPlz'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install RitoPlz
+
+## Usage
+
+### Configuration
+Before using RitoPlz you must first configure the application with your api key. Other configuration options are available and will be listed below
+
+```ruby
+RitoPlz.configure do |config|
+  config.api_key = "my_awesome_riot_api_key" #your secret api key provided to you by riot
+  config.default_region = :na #default region when building the client
+end
+```
+
+It's recommended to never commit your api key. A good practice is to use environment variables. For dev use `gem 'dot-env'` to configure environment variables, then on your production server set an environment variable. Ruby has a built in `ENV['KEY']` command to access environment variables. For example:
+```ruby
+RitoPlz.configure do |config|
+  config.api_key = ENV['RIOT_SECRET_KEY'] #Where 'RIOT_SECRET_KEY' is the name of your environment variable
+end
+```
+
+### Building the client
+All api calls should be made through the client. Though it is possible to instantiate the endpoint classes directly, it is recommended you use the client which provides default configuration and a clean interface for making calls. You can build the client like so:
+```ruby
+client = RitoPlz::Client.new #Client with the region set to the configured default region (by default :na)
+client = RitoPlz::Client.new(region: :euw) #Client with a region different from the default region
+```
+Clients are bound to the region you instantiate them with. If your application requires the use of multiple regions, It's recommended you create a client for each region you'll require. Clients are not heavy and can be created frequently without worry.
+
+### Making an api call
+This API wrapper is designed to closely mimick the api documentation on Riot's website. It's recommended that you read through their documentation when using this wrapper. For example if you wanted to make a call to summoner api and get a summoner by name, on Riot's site they provide the documenation for "/api/lol/{region}/v1.4/summoner/by-name/{summonerNames}". In RitoPlz you would write
+```ruby
+client = RitoPlz::Client.new
+client.summoner.by_names("summonerA", "summonerB")
+```
+The API endpoints return response objects from the net/http standard ruby library. This way you have full access to all the response data, headers, and more.
+
+The best way to learn to use the api wrapper, is to type what feels natural when reading the riot api. If that doesn't work, read the source code. It's very easy to understand. Every endpoint is in a class inside lib/RitoPlz/API/. Reading that class you'll see the available methods. This wrapper is designed to be stupid simple, so you should have no trouble reading, expanding upon, and tinkering with the code.
+
+To see more in depth documentation, read the readme inside RiotPlz/API/
+
+## Development
+
+Clone the git repository and then run 'bundle install'. The project should now run. You can check to be sure by running 'rspec' and checking all tests are passing.
+
+You have access to a console courtesy of pry in bin/console
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/RitoPlz/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/RitoPlz.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'RitoPlz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "RitoPlz"
+  spec.version       = RitoPlz::VERSION
+  spec.authors       = ["Luke Jones"]
+  spec.email         = ["manhappylife@yahoo.ca"]
+
+  spec.summary       = %q{A simple riot api wrapper with the aim of being easy to use and well documented.}
+  spec.description   = %q{The aim of RitoPlz is to provide a simple, clean, and easy to use ruby API wrapper. My priority is to provide a gem that is well documented and that you should never get frustrated with. If I fail to meet these goals please open a bug report in GitHub so I can fix the problem.}
+  spec.homepage      = "http://github.com/gjh33/RitoPlz"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec"
+end

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "RitoPlz"
+
+# 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.
+
+require "pry"
+Pry.start

data/bin/setup

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

data/lib/RitoPlz.rb

@@ -0,0 +1,41 @@
+require "RitoPlz/version"
+require "RitoPlz/configuration"
+require "RitoPlz/client"
+
+module RitoPlz
+  REGION_TO_PLATFORM = {
+    na: :na1,
+    euw: :euw1,
+    eune: :eun1,
+    jp: :jp1,
+    kr: :kr,
+    oce: :oc1,
+    br: :br1,
+    lan: :la1,
+    las: :la2,
+    ru: :ru,
+    tr: :tr1,
+    pbe: :pbe1
+  }
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.to_platform(region)
+    region = region.to_sym
+    REGION_TO_PLATFORM[region]
+  end
+end

data/lib/RitoPlz/API/README.md

@@ -0,0 +1,75 @@
+# RitoPlz API Documentation
+
+## Method Naming Convention
+RitoPlz has a somewhat simple naming convention. RitoPlz follows the riot api documentation. However there are a few exceptions where Riot's documentation doesn't suit the needs of an abstract api wrapper. We'll cover these rules here. Alternatively you could just go read the source code and figure out what all the methods are called.
+
+### ID values
+When an api call requires ID values to be passed, the endpoint is named based on ambiguity. For example, if you want to get champion data by id, you can call
+```ruby
+client = RitoPlz::Client.new
+client.champion.by_id
+```
+Here RitoPlz uses `by_id` because it is clear who the id belongs to. If not specified the id belongs to the name of the api, in this case "champion". However in another case where the id value is ambiguous like in the league api, RitoPlz uses the convention of `by_resource_id`. For example if you wanted to get the league data for a player:
+```ruby
+client = RitoPlz::Client.new
+client.league.by_player_id(1)
+```
+As you can see since the id doesn't belong to the league itself, RitoPlz names the id.
+
+Sometimes more complexity is needed. For example lets say you want the runs for a specific summoner. Here you must request the resource by the id.
+```ruby
+client = RitoPlz::Client.new
+client.summoner.runes_by_player_ids(1, 2, 3, 4)
+```
+
+### All resources
+When an api returns all resources, RitoPlz uses simlar convention to IDs. When it's not ambiguous and the requested resource matches the name of the api, you can simply call `all`. An example is the champion api:
+```ruby
+client = RitoPlz::Client.new
+client.champion.all
+```
+However when it's ambiguous what's being requested, RiotPlz uses `all_resources` convention. For example:
+```ruby
+client = RitoPlz::Client.new
+client.static_data.all_champions
+```
+
+### Multiple parameters
+Some Riot APIs take a list of names, ids, etc in an api call. RitoPlz supports this using ruby's * operator. You can provide the list directly in the arguments, or pass an array. For example:
+```ruby
+client = RitoPlz::Client.new
+client.league.by_player_ids(0, 1, 2, 3) #passed directly
+
+player_ids = [0, 1, 2, 3]
+client.league.by_player_ids(player_ids) #passed as an array
+```
+
+### Special APIs
+Some of Riot's APIs are special to a specific resource. For example champion mastery. RitoPlz handles this by passing the param to the api object upon instantiation. When calling from the client, the argument goes in the direct method call like so:
+```ruby
+client = RitoPlz::Client.new
+client.champion_mastery(288831).all_champions #the player id is passed into the first method call, and all chained methods after will use that id
+```
+
+Right now there are only two that do this: stats, and championmastery
+
+### Optional parameters
+Optional parameters are easy with RitoPlz. Let's use matchlist as an example. You can pull up the api on Riot's site to see what's up.
+```ruby
+client = RitoPlz::Client.new
+client.match_list.by_player_id(beginIndex: 1000, endIndex: 5000, seasons: [:SEASON2014, :SEASON2015, :SEASON2016])
+```
+The optional parameters are simply passed in as a hash to the endpoint. Easy right? Your arrays are automatically converted to a comma seperated string that Riot's API will receive.
+
+### Tournament API
+Riot's tournament api made it difficult for RitoPlz to use the usual convention. I recommend reading the source code, however I will do my best to explain.
+
+Some API require body and query params. RitoPlz combines these into 1 hash for parameters. If the parameter is a path parameter (in the path for the api call, not params) then it is a mandatory parameter for the method. The only exception being generating a tournament code. For this api, tournamentId is a mandatory param despite it not being part of the path, but part of the body. This choice was made because the other code apis use the tournamentId in the path. Riot's inconsistancy forced my hand here. Here are the method signatures so you can be clear what can be called. Anything in "params" is part of the body or query params. See Riot's official API doc for these values.
+```ruby
+generate_code(tournament_id, params) # Example params: { teamSize: 5, spectatorType: :ALL, pickType: :BLIND_PICK, mapType: :SUMMONERS_RIFT, count: 5 }
+get_code_info(tournament_code)
+update_code_info(tournament_code, params) # Similar params to generate_code. See Riot API for possible params
+get_lobby_events(tournament_code)
+create_provider(params) # Example params: { url: 'http://www.test.com/riot_response_handler' }. you can pass region, but it will default to your client's region if you dont
+create_tournament(params) # Example params: { name: 'MyTournament', providerId: 000 }
+```

data/lib/RitoPlz/API/base.rb

@@ -0,0 +1,11 @@
+module RitoPlz
+  module API
+    class Base
+      protected
+
+      def api_path
+        ""
+      end
+    end
+  end
+end

data/lib/RitoPlz/API/champion.rb

@@ -0,0 +1,28 @@
+require 'RitoPlz/API/base'
+require 'RitoPlz/API/request'
+
+module RitoPlz
+  module API
+    class Champion < Base
+      def initialize(region)
+        @region = region
+      end
+
+      def all(query_params = {})
+        request = Request.new(@region, api_path)
+        request.get(query_params)
+      end
+
+      def by_id(id)
+        request = Request.new(@region, api_path("/#{id}"))
+        request.get
+      end
+
+      protected
+
+      def api_path(additional_path = "")
+        "/api/lol/#{@region}/v1.2/champion" + additional_path
+      end
+    end
+  end
+end

data/lib/RitoPlz/API/champion_mastery.rb

@@ -0,0 +1,43 @@
+require 'RitoPlz/API/base'
+require 'RitoPlz/API/request'
+
+module RitoPlz
+  module API
+    class ChampionMastery < Base
+      def initialize(region, player_id)
+        @region = region
+        @player_id = player_id
+      end
+
+      def all_champions
+        request = Request.new(@region, api_path("/champions"))
+        request.get
+      end
+
+      def by_champion_id(champion_id)
+        request = Request.new(@region, api_path("/champion/#{champion_id}"))
+        request.get
+      end
+
+      def score
+        request = Request.new(@region, api_path("/score"))
+        request.get
+      end
+
+      def top(query_params = {})
+        request = Request.new(@region, api_path("/topchampions"))
+        request.get(query_params)
+      end
+
+      protected
+
+      def platform
+        RitoPlz.to_platform(@region)
+      end
+
+      def api_path(additional_path = "")
+        "/championmastery/location/#{platform}/player/#{@player_id}" + additional_path
+      end
+    end
+  end
+end

data/lib/RitoPlz/API/current_game.rb

@@ -0,0 +1,27 @@
+require 'RitoPlz/API/base'
+require 'RitoPlz/API/request'
+
+module RitoPlz
+  module API
+    class CurrentGame < Base
+      def initialize(region)
+        @region = region
+      end
+
+      def by_player_id(player_id)
+        request = Request.new(@region, api_path("/#{player_id}"))
+        request.get
+      end
+
+      protected
+
+      def platform
+        RitoPlz.to_platform(@region)
+      end
+
+      def api_path(additional_path = "")
+        "/observer-mode/rest/consumer/getSpectatorGameInfo/#{platform}" + additional_path
+      end
+    end
+  end
+end

data/lib/RitoPlz/API/exceptions.rb

@@ -0,0 +1,123 @@
+module RitoPlz
+  module API
+    class BadRequestException < StandardError
+      def initialize
+        msg = %{
+400 (BAD REQUEST)
+This error indicates that there is a syntax error in the request and the request has therefore been denied. The client should not continue to make similar requests without modifying the syntax or the requests being made.
+
+Common Reasons:
+  > A provided parameter was in the wrong format
+  > A required parameter was not provided
+
+This one is likely our fault, file a bug report
+        }
+
+        super(msg)
+      end
+    end
+
+    class UnauthorizedException < StandardError
+      def initialize
+        msg = %{
+401 (UNAUTHORIZED)
+This error indicates that your api key was not authorized for the request you tried to make
+
+Common Reason:
+  > Make sure you configured your api key before making the request
+  > Make sure you entered your api key correctly when you configured
+  > Make sure your api key has access to the request you want to make
+        }
+
+        super(msg)
+      end
+    end
+
+    class ForbiddenException < StandardError
+      def initialize
+        msg = %{
+403 (FORBIDDEN)
+This error indicates that you are forbidden to access this request
+
+Common Reason:
+  > Make sure you configured your api key before making the request
+        }
+
+        super(msg)
+      end
+    end
+
+    class NotFoundException < StandardError
+      def initialize
+        msg = %{
+404 (NOT FOUND)
+This error indicates that the server failed to recognize your api request
+
+Common Reason:
+  > You're looking for an ID that doesn't exist
+        }
+
+        super(msg)
+      end
+    end
+
+    class UnsupportedMediaTypeException < StandardError
+      def initialize
+        msg = %{
+415 (UNSUPPORTED MEDIA TYPE)
+This error indicates that the body of the request was not in a recognizable format
+
+Common Reason:
+  > We fucked up
+  > You're trying to modify our code and you fucked up
+        }
+
+        super(msg)
+      end
+    end
+
+    class RateLimitExceededException < StandardError
+      def initialize
+        msg = %{
+429 (RATE LIMIT EXCEEDED)
+This error indicates you've went over your rate limit. Check your api access rates on Riot's API page.
+
+Common Reason:
+  > Calm down there big boy, easy on the requests
+        }
+
+        super(msg)
+      end
+    end
+
+    class InternalServerException < StandardError
+      def initialize
+        msg = %{
+500 (INTERNAL SERVER ERROR)
+This error indicates that Riot fucked up. This one's my favorite.
+
+Common Reason:
+  > Spaghetti code
+        }
+
+        super(msg)
+      end
+    end
+
+    class ServiceUnavailableException < StandardError
+      def initialize
+        msg = %{
+503 (SERVICE UNAVAILABLE)
+This error indicates that Riot's server is unavailable
+
+Common Reason:
+  > You live in EUW
+  > r/dota launched a mass ddos attack
+  > Dyrus tried to use the microwave in the server room
+        }
+
+        super(msg)
+      end
+    end
+  end
+end