canvas_interactor 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b740eae5b741f2cc3cb016872d0c1de2c187da0340f00427de63b99d3821077
+  data.tar.gz: 8bdb6648bb107a0a6abe6ffce96b61f63e1aa28bc3218347921a24f15294776b
+SHA512:
+  metadata.gz: c903d982ff10c452e26953dbf43ce9d9bae5dc93719c3461f4f36a54481c2cd198b4f3baa19256c88e9f7041ab87f03169d3aba768236939aba6f00c75c20ed2
+  data.tar.gz: 5fef267c4effc9b4d66493893bfc2767fe5363c964f8663c65f373272ca318f6fe48036063dfebf8e8ce70810d140191514501eb4e1f47331128cf40b1228e8c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Ahmad Hassan
+
+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,86 @@
+# CanvasInteractor
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'canvas_interactor'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install canvas_interactor
+```
+
+1.To copy these migrations into the application and migrate run the following command
+
+```
+$ bundle install
+$ bundle exec rake railties:install:migrations
+$ bundle exec rake db:migrate
+```
+
+* If you would like to run migrations only from one engine, you can do it by specifying SCOPE:
+
+`$ bin/rails db:migrate SCOPE=canvas_interactor`
+
+2.Then, mount the engine to your app by adding this line to your routes.rb file
+
+`mount CanvasInteractor::Engine => "/canvas_interactor"`
+
+3.Next, include the engine in your ApplicationController
+
+```
+class ApplicationController < ActionController::Base
+  include CanvasOauth::CanvasApplication
+
+  ...
+end
+```
+
+After that, create an `canvas.yml` file in your `config/` folder that looks something like this (or see `config/canvas.yml.example` for a template):
+
+```
+default: &default
+  key: your_key
+  secret: your_secret
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default
+```
+## Usage
+
+TODO:
+
+## Configuring the Tool Consumer
+
+You will need a developer key and secret from canvas, which should be entered into you `canvas.yml` file.
+
+## Quick Start
+
+TODO:
+
+## Contributing
+Contributors are welcome.
+
+`er.ahmad.hassan@gmail.com`
+https://twitter.com/TheAhmadHassanK
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CanvasInteractor'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/assets/config/canvas_interactor_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/canvas_interactor .js
+//= link_directory ../stylesheets/canvas_interactor .css

data/app/assets/javascripts/canvas_interactor/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require rails-ujs
+//= require activestorage
+//= require_tree .

data/app/assets/stylesheets/canvas_interactor/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/canvas_interactor/application_controller.rb

@@ -0,0 +1,6 @@
+module CanvasInteractor
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    include CanvasInteractor::CanvasApplication
+  end
+end

data/app/controllers/canvas_interactor/canvas_controller.rb

@@ -0,0 +1,25 @@
+module CanvasInteractor
+  class CanvasController < CanvasInteractor::ApplicationController
+    skip_before_action :request_canvas_authentication
+
+    def oauth
+      if verify_oauth2_state(params[:state]) && params[:code]
+        if token = canvas.get_access_token(params[:code])
+          if CanvasInteractor::Authorization.cache_token(token, user_id, tool_consumer_instance_guid)
+            redirect_to main_app.root_path
+          else
+            render text: "Error: unable to save token"
+          end
+        else
+          render text: "Error: invalid code - #{params[:code]}"
+        end
+      else
+        render text: "#{CanvasInteractor::Config.tool_name} needs access to your account in order to function properly. Please try again and click log in to approve the integration."
+      end
+    end
+
+    def verify_oauth2_state(callback_state)
+      callback_state.present? && callback_state == session.delete(:oauth2_state)
+    end
+  end
+end

data/app/helpers/canvas_interactor/application_helper.rb

@@ -0,0 +1,4 @@
+module CanvasInteractor
+  module ApplicationHelper
+  end
+end

data/app/jobs/canvas_interactor/application_job.rb

@@ -0,0 +1,4 @@
+module CanvasInteractor
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/canvas_interactor/application_mailer.rb

@@ -0,0 +1,6 @@
+module CanvasInteractor
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/canvas_interactor/application_record.rb

@@ -0,0 +1,5 @@
+module CanvasInteractor
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/canvas_interactor/authorization.rb

@@ -0,0 +1,26 @@
+module CanvasInteractor
+  class Authorization < ApplicationRecord
+    validates :canvas_user_id, :token, :last_used_at, presence: true
+
+    def self.cache_token(token, user_id, tool_consumer_instance_guid)
+      create do |t|
+        t.token = token
+        t.canvas_user_id = user_id
+        t.tool_consumer_instance_guid = tool_consumer_instance_guid
+        t.last_used_at = Time.now
+      end
+    end
+
+    def self.fetch_token(user_id, tool_consumer_instance_guid)
+      user_tokens = where(canvas_user_id: user_id, tool_consumer_instance_guid: tool_consumer_instance_guid).order('created_at DESC')
+      if canvas_auth = user_tokens.first
+        canvas_auth.update_attribute(:last_used_at, Time.now)
+        return canvas_auth.token
+      end
+    end
+
+    def self.clear_tokens(user_id, tool_consumer_instance_guid)
+      where(canvas_user_id: user_id, tool_consumer_instance_guid: tool_consumer_instance_guid).destroy_all
+    end
+  end
+end

data/app/views/layouts/canvas_interactor/application.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Canvas interactor</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "canvas_interactor/application", media: "all" %>
+  <%= javascript_include_tag "canvas_interactor/application" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,3 @@
+CanvasInteractor::Engine.routes.draw do
+  match '/', to: 'canvas#oauth', via: :get, as: :canvas_oauth
+end

data/db/migrate/20180607153145_create_canvas_interactor_authorizations.rb

@@ -0,0 +1,12 @@
+class CreateCanvasInteractorAuthorizations < ActiveRecord::Migration[5.2]
+  def change
+    create_table :canvas_interactor_authorizations do |t|
+      t.integer :canvas_user_id
+      t.string :tool_consumer_instance_guid, :null => false
+      t.string :token
+      t.datetime :last_used_at
+
+      t.timestamps
+    end
+  end
+end

data/lib/canvas_interactor.rb

@@ -0,0 +1,21 @@
+require 'canvas_interactor/engine'
+require 'ostruct'
+require 'httparty'
+require 'link_header'
+require 'canvas_interactor/config'
+require 'canvas_interactor/canvas_application'
+require 'canvas_interactor/canvas_api'
+require 'canvas_interactor/canvas_api_extensions'
+require 'canvas_interactor/canvas_config'
+
+module CanvasInteractor
+  mattr_accessor :app_root
+
+  def self.setup
+    yield self
+  end
+
+  def self.config
+    yield(CanvasInteractor::Config)
+  end
+end

data/lib/canvas_interactor/canvas_api.rb

@@ -0,0 +1,249 @@
+module CanvasInteractor
+  class CanvasApi
+    include HTTParty
+    PER_PAGE = 50
+
+    attr_accessor :token, :key, :secret
+    attr_reader :canvas_url
+
+    def initialize(canvas_url, token, key, secret)
+      self.canvas_url = canvas_url
+      self.token = token
+      self.key = key
+      self.secret = secret
+    end
+
+    def authenticated_request(method, *params)
+      params << {} if params.size == 1
+
+      params.last[:headers] ||= {}
+      params.last[:headers]['Authorization'] = "Bearer #{token}"
+
+      start = Time.now
+
+      response = self.class.send(method, *params)
+
+      Rails.logger.info {
+        stop = Time.now
+        elapsed = ((stop - start) * 1000).round(2)
+
+        params.last[:headers].reject! { |k| k == 'Authorization' }
+        "API call (#{elapsed}ms): #{method} #{params.inspect}"
+      }
+
+      if response && response.unauthorized?
+        if response.headers['WWW-Authenticate'].present?
+          raise CanvasApi::Authenticate
+        else
+          raise CanvasApi::Unauthorized
+        end
+      else
+        return response
+      end
+    end
+
+    def paginated_get(*params)
+      params[1] ||= {}
+      params[1][:query] ||= {}
+      params[1][:query][:per_page] = PER_PAGE
+
+      all_pages = []
+
+      while params[0] do
+        if current_page = authenticated_get(*params)
+          all_pages += current_page if valid_page?(current_page)
+
+          links = LinkHeader.parse(current_page.headers['link'])
+          params[0] = links.find_link(["rel", "next"]).try(:href)
+        else
+          params[0] = nil
+        end
+      end
+
+      all_pages
+    end
+
+    def get_report(account_id, report_type, params)
+      report = authenticated_post("/api/v1/accounts/#{account_id}/reports/#{report_type}", { body: params })
+      report = authenticated_get "/api/v1/accounts/#{account_id}/reports/#{report_type}/#{report['id']}"
+      while report['status'] == 'running'
+        sleep(4)
+        report = authenticated_get "/api/v1/accounts/#{account_id}/reports/#{report_type}/#{report['id']}"
+      end
+
+      if report['status'] == 'complete'
+        file_id = report['file_url'].match(/files\/([0-9]+)\/download/)[1]
+        file = get_file(file_id)
+        return hash_csv(self.class.get(file['url'], limit: 15).parsed_response)
+      else
+        return report
+      end
+    end
+
+    def valid_page?(page)
+      page && page.size > 0
+    end
+
+    def get_file(file_id)
+      authenticated_get "/api/v1/files/#{file_id}"
+    end
+
+    def get_accounts_provisioning_report(account_id)
+      get_report(account_id, :provisioning_csv, 'parameters[accounts]' => true)
+    end
+
+    #Needs to be refactored to somewhere more generic
+    def hash_csv(csv_string)
+      require 'csv'
+
+      csv = CSV.parse(csv_string)
+      headers = csv.shift
+      output = []
+
+      csv.each do |row|
+        hash = {}
+        headers.each do |header|
+          hash[header] = row.shift.to_s
+        end
+        output << hash
+      end
+
+      return output
+    end
+
+    def authenticated_get(*params)
+      authenticated_request(:get, *params)
+    end
+
+    def authenticated_post(*params)
+      authenticated_request(:post, *params)
+    end
+
+    def authenticated_put(*params)
+      authenticated_request(:put, *params)
+    end
+
+    def get_courses
+      paginated_get "/api/v1/courses"
+    end
+
+    def get_account(account_id)
+      authenticated_get "/api/v1/accounts/#{account_id}"
+    end
+
+    def get_account_sub_accounts(account_id)
+      paginated_get "/api/v1/accounts/#{account_id}/sub_accounts", { query: { :recursive => true } }
+    end
+
+    def get_account_courses(account_id)
+      paginated_get "/api/v1/accounts/#{account_id}/courses"
+    end
+
+    def get_account_users(account_id)
+      paginated_get "/api/v1/accounts/#{account_id}/users"
+    end
+
+    def get_course(course_id)
+      authenticated_get "/api/v1/courses/#{course_id}"
+    end
+
+    def get_section_enrollments(section_id)
+      paginated_get "/api/v1/sections/#{section_id}/enrollments"
+    end
+
+    def get_user_enrollments(user_id)
+      paginated_get "/api/v1/users/#{user_id}/enrollments"
+    end
+
+    def get_course_users(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/users"
+    end
+
+    def get_all_course_users(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/users", { query: {enrollment_state: ["active","invited","rejected","completed","inactive"] } }
+    end
+
+    def get_course_teachers_and_tas(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/users", { query: { enrollment_type: ['teacher', 'ta'] } }
+    end
+
+    def get_course_students(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/students"
+    end
+
+    def get_section(section_id)
+      authenticated_get "/api/v1/sections/#{section_id}"
+    end
+
+    def get_sections(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/sections", { query: { :include => ['students', 'avatar_url', 'enrollments'] } }
+    end
+
+    def get_assignments(course_id)
+      paginated_get "/api/v1/courses/#{course_id}/assignments"
+    end
+
+    def get_assignment(course_id, assignment_id)
+      authenticated_get "/api/v1/courses/#{course_id}/assignments/#{assignment_id}"
+    end
+
+    def get_user_profile(user_id)
+      authenticated_get "/api/v1/users/#{user_id}/profile"
+    end
+
+    def create_assignment(course_id, params)
+      authenticated_post "/api/v1/courses/#{course_id}/assignments", { body: { assignment: params } }
+    end
+
+    def grade_assignment(course_id, assignment_id, user_id, params)
+      authenticated_put "/api/v1/courses/#{course_id}/assignments/#{assignment_id}/submissions/#{user_id}", { body: params }
+    end
+
+    def course_account_id(course_id)
+      course = get_course(course_id)
+      course['account_id'] if course
+    end
+
+    def root_account_id(account_id)
+      if account_id && account = get_account(account_id)
+        root_id = account['root_account_id']
+      end
+
+      root_id || account_id
+    end
+
+    def course_root_account_id(course_id)
+      root_account_id(course_account_id(course_id))
+    end
+
+    def auth_url(redirect_uri, oauth2_state)
+      "#{canvas_url}/login/oauth2/auth?client_id=#{key}&response_type=code&state=#{oauth2_state}&redirect_uri=#{redirect_uri}"
+    end
+
+    def get_access_token(code)
+      params = {
+        body: {
+          client_id: key,
+          client_secret: secret,
+          code: code
+        }
+      }
+
+      response = self.class.post '/login/oauth2/token', params
+      self.token = response['access_token']
+    end
+
+    def hex_sis_id(name, value)
+      hex = value.unpack("H*")[0]
+      return "hex:#{name}:#{hex}"
+    end
+
+    def canvas_url=(value)
+      @canvas_url = value
+      self.class.base_uri(value)
+    end
+  end
+
+  class CanvasApi::Unauthorized < StandardError ; end
+  class CanvasApi::Authenticate < StandardError ; end
+end

data/lib/canvas_interactor/canvas_api_extensions.rb

@@ -0,0 +1,8 @@
+module CanvasInteractor
+  class CanvasApiExtensions
+    def self.build(canvas_url, user_id, tool_consumer_instance_guid)
+      token = CanvasInteractor::Authorization.fetch_token(user_id, tool_consumer_instance_guid)
+      CanvasApi.new(canvas_url, token, CanvasConfig.key, CanvasConfig.secret)
+    end
+  end
+end

data/lib/canvas_interactor/canvas_application.rb

@@ -0,0 +1,65 @@
+module CanvasInteractor
+  module CanvasApplication
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+    end
+
+    included do
+      helper_method :canvas
+
+      rescue_from CanvasApi::Authenticate, with: :reauthenticate
+      rescue_from CanvasApi::Unauthorized, with: :unauthorized_canvas_access
+      before_action :request_canvas_authentication
+    end
+
+    protected
+    def initialize_canvas
+      @canvas = ::CanvasInteractor::CanvasApiExtensions.build(canvas_url, user_id, tool_consumer_instance_guid)
+    end
+
+    def canvas
+      @canvas || initialize_canvas
+    end
+
+    def canvas_token
+      ::CanvasInteractor::Authorization.fetch_token(user_id, tool_consumer_instance_guid)
+    end
+
+    def request_canvas_authentication
+      if !params[:code].present? && !canvas_token.present?
+        session[:oauth2_state] = SecureRandom.urlsafe_base64(24)
+        redirect_to canvas.auth_url(canvas_interactor_url, session[:oauth2_state])
+      end
+    end
+
+    def not_acceptable
+      render text: "Unable to process request", status: 406
+    end
+
+    def unauthorized_canvas_access
+      render text: "Your Canvas Developer Key is not authorized to access this data.", status: 401
+    end
+
+    def reauthenticate
+      ::CanvasInteractor::Authorization.clear_tokens(user_id, tool_consumer_instance_guid)
+      request_canvas_authentication
+    end
+
+    # these next three methods rely on external session data and either need to
+    # be overridden or the session data needs to be set up by the time the
+    # oauth filter runs (like with the lti_provider_engine)
+
+    def canvas_url
+      session[:canvas_url]
+    end
+
+    def user_id
+      session[:user_id]
+    end
+
+    def tool_consumer_instance_guid
+      session[:tool_consumer_instance_guid]
+    end
+  end
+end

data/lib/canvas_interactor/canvas_config.rb

@@ -0,0 +1,28 @@
+module CanvasInteractor
+  module CanvasConfig
+    mattr_accessor :key, :secret
+
+    def self.load_config
+      YAML::load(File.open(config_file))[Rails.env]
+    end
+
+    def self.config_file
+      CanvasOauth.app_root.join('config/canvas.yml')
+    end
+
+    def self.setup!
+      if File.exists?(config_file)
+        Rails.logger.info "Initializing Canvas using configuration in #{config_file}"
+        config = load_config
+        self.key = config['key']
+        self.secret = config['secret']
+      elsif ENV['CANVAS_KEY'].present? && ENV['CANVAS_SECRET'].present?
+        Rails.logger.info "Initializing Canvas using environment vars CANVAS_KEY and CANVAS_SECRET"
+        self.key = ENV['CANVAS_KEY']
+        self.secret = ENV['CANVAS_SECRET']
+      else
+        raise "Warning: Canvas key and secret not configured (RAILS_ENV = #{ENV['RAILS_ENV']})."
+      end
+    end
+  end
+end

data/lib/canvas_interactor/config.rb

@@ -0,0 +1,3 @@
+module CanvasInteractor
+  Config = OpenStruct.new
+end

data/lib/canvas_interactor/engine.rb

@@ -0,0 +1,5 @@
+module CanvasInteractor
+  class Engine < ::Rails::Engine
+    isolate_namespace CanvasInteractor
+  end
+end

data/lib/canvas_interactor/version.rb

@@ -0,0 +1,3 @@
+module CanvasInteractor
+  VERSION = '1.0.1'
+end

data/lib/tasks/canvas_interactor_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :canvas_interactor do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,259 @@
+--- !ruby/object:Gem::Specification
+name: canvas_interactor
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Ahmad Hassan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: link_header
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+- !ruby/object:Gem::Dependency
+  name: pg
+  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: sqlite3
+  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: rspec
+  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: rspec-its
+  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: rspec-rails
+  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: rspec-rails-mocha
+  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: shoulda-matchers
+  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: webmock
+  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: guard-rspec
+  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: rb-fsevent
+  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'
+description: Canvas Interactor is a mountable engine for handling the oauth workflow
+  with canvas and making api calls from your rails app.
+email:
+- er.ahmad.hassan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/canvas_interactor_manifest.js
+- app/assets/javascripts/canvas_interactor/application.js
+- app/assets/stylesheets/canvas_interactor/application.css
+- app/controllers/canvas_interactor/application_controller.rb
+- app/controllers/canvas_interactor/canvas_controller.rb
+- app/helpers/canvas_interactor/application_helper.rb
+- app/jobs/canvas_interactor/application_job.rb
+- app/mailers/canvas_interactor/application_mailer.rb
+- app/models/canvas_interactor/application_record.rb
+- app/models/canvas_interactor/authorization.rb
+- app/views/layouts/canvas_interactor/application.html.erb
+- config/routes.rb
+- db/migrate/20180607153145_create_canvas_interactor_authorizations.rb
+- lib/canvas_interactor.rb
+- lib/canvas_interactor/canvas_api.rb
+- lib/canvas_interactor/canvas_api_extensions.rb
+- lib/canvas_interactor/canvas_application.rb
+- lib/canvas_interactor/canvas_config.rb
+- lib/canvas_interactor/config.rb
+- lib/canvas_interactor/engine.rb
+- lib/canvas_interactor/version.rb
+- lib/tasks/canvas_interactor_tasks.rake
+homepage: https://github.com/ahmadhasankhan/canvas_interactor
+licenses:
+- MIT
+metadata: {}
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Canvas Interactor is a mountable engine for handling the oauth workflow with
+  canvas and making api calls from your rails app.
+test_files: []