lms-api 1.17.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfafd60f403921db6037838554ff73e249aba5b3d19946a6a001c73598534ee8
+  data.tar.gz: 5ba978a32528ff25e6139d18ddaf60e3b82bbf1b412d357c6562d9bccfbf4939
+SHA512:
+  metadata.gz: 71254525d790ceceb28697bed2871c0b1994586c536e523d4a75f27e3a38bb1a9e61a0d7b099eb2c042ef900238bfd296c8bcae53cb98311c9c6d92ecfb01501
+  data.tar.gz: bc99de213a91082613dab0c2cfe82e1eec4c40813271146e7e341aded7bf51a02e07eced2982c8ff4870eb283448d9639820073208e3fee5650e071d78609d9c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016-2017 Atomic Jolt
+
+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,84 @@
+# LMS API
+
+This project provides a wrapper around the Instructure Canvas API.
+
+
+## Installation
+
+To install, add `lms-api` to your Gemfile:
+
+```ruby
+    gem "lms-api"
+```
+
+
+## Configuration
+
+Your app must tell the gem which model is used to represent the
+authentication state. For instance, if you're using ActiveRecord, you
+might have an `Authentication` model, which encapsulates a temporary
+API token.
+
+```ruby
+class Authentication < ActiveRecord::Base
+  # token: string
+end
+```
+
+Then, you tell the gem about this model:
+
+```ruby
+LMS::Canvas.auth_state_model = Authentication
+```
+
+This allows the gem to transparently refresh the token when the token
+expires, and do so in a way that respects multiple processes all trying
+to do so in parallel.
+
+
+## Usage
+
+To use the API wrapper, instantiate a `LMS::Canvas` instance with the
+url of the LMS instance you want to communicate with, as well as the
+current authentication object, and (optionally) a hash of options to use
+when refreshing the API token.
+
+Require the gem:
+`require "lms_api"`
+
+```ruby
+auth = Authentication.first # or however you are storing global auth state
+api = LMS::Canvas.new("http://your.canvas.instance", auth,
+        client_id: "...",
+        client_secret: "..."
+        redirect_uri: "..."
+        refresh_token: "...")
+```
+
+You can get the URL for a given LMS interface via the `::lms_url`
+class method:
+
+```ruby
+params = {
+  id: id,
+  course_id: course_id,
+  controller: "foo",
+  account_id: 1,
+  all_dates: true,
+  other_param: "foobar"}
+
+url = LMS::Canvas.lms_url("GET_SINGLE_ASSIGNMENT", params)
+```
+
+Once you have the URL, you can send the request by using `api_*_request`
+methods:
+
+* `api_get_request(url, headers={})`
+* `api_post_request(url, payload, headers={})`
+* `api_delete_request(url, headers={})`
+* `api_get_all_request(url, headers={})`
+* `api_get_blocks_request(url, headers={}, &block)`
+
+The last two are convenience methods for fetching multiple pages of data.
+The `api_get_all_request` method returns all rows in a single array. The
+`api_get_blocks_request` method yields each "chunk" of data to the block.

data/Rakefile

@@ -0,0 +1,27 @@
+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    = "LMS API"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+load "./lib/tasks/canvas_api.rake"
+
+Bundler::GemHelper.install_tasks
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+end

data/lib/canvas_api.rb

@@ -0,0 +1,4 @@
+module CanvasApi
+end
+
+require "canvas_api/builder"

data/lib/canvas_api/builder.rb

@@ -0,0 +1,121 @@
+require "canvas_api/render"
+require "byebug"
+module CanvasApi
+
+  class Builder
+
+    #
+    # project_root: This is the directory where the canvas_urls.rb file will be written.
+    # This file contains all urls and functions for access to the Canvas API from this gem (lms_api).
+    # client_app_path: This where all client side Javascript for accessing the Canvas API will be written.
+    # server_app_path: This is where all server side Javascript for accessing the Canvas API will be written.
+    # Currently, this is generating GraphQL for Javascript and Ruby
+    #
+    def self.build(project_root, client_app_path, server_app_path, elixir_app_path, rb_graphql_app_path)
+      endpoint = "https://canvas.instructure.com/doc/api"
+      directory = HTTParty.get("#{endpoint}/api-docs.json")
+
+      lms_urls_rb = []
+      lms_urls_js = []
+      lms_urls_ex = []
+      course_ids_required_rb = []
+      models = []
+      js_graphql_queries = []
+      js_graphql_mutations = []
+
+      rb_graphql_fields = []
+      rb_graphql_mutations = []
+      rb_forward_declarations = []
+
+      nicknames = []
+
+      # Elixir has a default action that raises
+      lms_urls_ex << CanvasApi::Render.new("./templates/ex_default_action.erb", nil, nil, nil, nil, nil, nil, nil).render
+
+      directory["apis"].each do |api|
+        puts "Generating #{api['description']}"
+        resource = HTTParty.get("#{endpoint}#{api['path']}")
+        constants = []
+        resource["apis"].each do |resource_api|
+          resource_api["operations"].each do |operation|
+
+            # Prevent duplicates
+            nickname = operation["nickname"]
+            if nicknames.include?(nickname)
+              nickname = "#{api["description"].gsub(" ", "_").downcase}_#{nickname}"
+            end
+            nicknames << nickname
+            operation["nickname"] = nickname
+
+            parameters = operation["parameters"]
+            constants << CanvasApi::Render.new("./templates/constant.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            lms_urls_rb << CanvasApi::Render.new("./templates/rb_url.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            lms_urls_js << CanvasApi::Render.new("./templates/js_url.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            lms_urls_ex << CanvasApi::Render.new("./templates/ex_url.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            lms_urls_ex << CanvasApi::Render.new("./templates/ex_action.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+
+            if parameters.detect{ |param| param["name"] == "course_id" && param["paramType"] == "path" }
+              course_ids_required_rb << CanvasApi::Render.new("./templates/course_id_required.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            end
+
+            if operation["method"].casecmp("GET") == 0
+              js_graphql_queries << CanvasApi::Render.new("./templates/js_graphql_query.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+
+              # One file per Canvas graphql resolver
+              canvas_graphql_resolver_renderer = CanvasApi::Render.new("./templates/rb_graphql_resolver.erb", api, resource, resource_api, operation, parameters, nil, nil)
+              canvas_graphql_resolver_renderer.save("#{rb_graphql_app_path}/lib/lms_graphql/resolvers/canvas/#{canvas_graphql_resolver_renderer.nickname}.rb")
+              rb_graphql_fields << CanvasApi::Render.new("./templates/rb_graphql_field.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            else
+              js_graphql_mutations << CanvasApi::Render.new("./templates/js_graphql_mutation.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+
+              rb_graphql_mutation_renderer = CanvasApi::Render.new("./templates/rb_graphql_mutation.erb", api, resource, resource_api, operation, parameters, nil, nil)
+              rb_graphql_mutation_renderer.save("#{rb_graphql_app_path}/lib/lms_graphql/mutations/canvas/#{rb_graphql_mutation_renderer.nickname}.rb")
+              rb_graphql_mutations << CanvasApi::Render.new("./templates/rb_graphql_mutation_include.erb", api, resource, resource_api, operation, parameters, nil, nil).render
+            end
+
+          end
+        end
+
+        resource["models"].map do |_name, model|
+          if model["properties"] # Don't generate models without properties
+            models << CanvasApi::Render.new("./templates/js_graphql_model.erb", api, resource, nil, nil, nil, nil, model).render
+          end
+
+          # Generate one file for each Canvas graphql type
+          canvas_graphql_type_render = CanvasApi::Render.new("./templates/rb_graphql_type.erb", api, resource, nil, nil, nil, nil, model)
+          canvas_graphql_type_render.save("#{rb_graphql_app_path}/lib/lms_graphql/types/canvas/#{model['id'].underscore.singularize}.rb")
+
+          canvas_graphql_input_render = CanvasApi::Render.new("./templates/rb_graphql_input_type.erb", api, resource, nil, nil, nil, nil, model)
+          canvas_graphql_input_render.save("#{rb_graphql_app_path}/lib/lms_graphql/types/canvas/#{model['id'].underscore.singularize}_input.rb")
+
+          rb_forward_declarations << "class Canvas#{model['id'].singularize}Input < BaseInputObject;end"
+          rb_forward_declarations << "class Canvas#{model['id'].singularize} < BaseType;end"
+        end
+
+        # Generate one file of constants for every LMS API
+        constants_renderer = CanvasApi::Render.new("./templates/constants.erb", api, resource, nil, nil, nil, constants, nil)
+        constants_renderer.save("#{client_app_path}/#{constants_renderer.name}.js")
+      end
+
+      CanvasApi::Render.new("./templates/rb_urls.erb", nil, nil, nil, nil, nil, lms_urls_rb, nil).save("#{project_root}/lib/lms/canvas_urls.rb")
+      CanvasApi::Render.new("./templates/js_urls.erb", nil, nil, nil, nil, nil, lms_urls_js, nil).save("#{server_app_path}/lib/canvas/urls.js")
+
+      # The elixir urls are sorted, to prevent linter errors
+      CanvasApi::Render.new("./templates/ex_urls.erb", nil, nil, nil, nil, nil, lms_urls_ex.sort, nil).save("#{elixir_app_path}/lib/canvas/actions.ex")
+
+      CanvasApi::Render.new("./templates/course_ids_required.erb", nil, nil, nil, nil, nil, course_ids_required_rb, nil).save("#{project_root}/lib/lms/course_ids_required.rb")
+
+      # GraphQL Javascript - still not complete
+      CanvasApi::Render.new("./templates/js_graphql_types.erb", nil, nil, nil, nil, nil, models.compact, nil).save("#{server_app_path}/lib/canvas/graphql_types.js")
+      CanvasApi::Render.new("./templates/js_graphql_queries.erb", nil, nil, nil, nil, nil, js_graphql_queries, nil).save("#{server_app_path}/lib/canvas/graphql_queries.js")
+      CanvasApi::Render.new("./templates/js_graphql_mutations.erb", nil, nil, nil, nil, nil, js_graphql_mutations, nil).save("#{server_app_path}/lib/canvas/graphql_mutations.js")
+
+      # GraphQL Ruby
+      CanvasApi::Render.new("./templates/rb_forward_declarations.erb", nil, nil, nil, nil, nil, rb_forward_declarations, nil).save("#{rb_graphql_app_path}/lib/lms_graphql/types/canvas_forward_declarations.rb")
+      CanvasApi::Render.new("./templates/rb_graphql_root_query.erb", nil, nil, nil, nil, nil, rb_graphql_fields, nil).save("#{rb_graphql_app_path}/lib/lms_graphql/types/canvas/query_type.rb")
+      CanvasApi::Render.new("./templates/rb_graphql_mutations.erb", nil, nil, nil, nil, nil, rb_graphql_mutations, nil).save("#{rb_graphql_app_path}/lib/lms_graphql/mutations/canvas/mutations.rb")
+    end
+
+  end
+
+end

data/lib/canvas_api/js_graphql_helpers.rb

@@ -0,0 +1,98 @@
+module CanvasApi
+
+  module GraphQLHelpers
+
+    def graphql_type(name, property)
+      if property["$ref"]
+        "#{property['$ref']}, resolve: function(model){ return model.#{name}; }"
+      else
+        type = property["type"]
+        case type
+        when "integer", "string", "boolean", "datetime", "number"
+          graphql_primitive(type, property["format"])
+        when "array"
+          begin
+            type = if property["items"]["$ref"]
+                     property["items"]["$ref"]
+                   else
+                     graphql_primitive(property["items"]["type"], property["items"]["format"])
+                   end
+          rescue
+            puts "Unable to discover list type for '#{name}' ('#{property}'). Defaulting to GraphQLString"
+            type = "GraphQLString"
+          end
+          "new GraphQLList(#{type})"
+        when "object"
+          puts "Using string type for '#{name}' ('#{property}') of type object."
+          "GraphQLString"
+        else
+          puts "Unable to match '#{name}' requested property '#{property}' to GraphQL Type."
+          "GraphQLString"
+        end
+      end
+    end
+
+    def graphql_primitive(type, format)
+      case type
+      when "integer"
+        "GraphQLInt"
+      when "number"
+        if format == "float64"
+          "GraphQLFloat"
+        else
+          # TODO many of the LMS types with 'number' don't indicate a type so we have to guess
+          # Hopefully that changes. For now we go with float
+          "GraphQLFloat"
+        end
+      when "string"
+        "GraphQLString"
+      when "boolean"
+        "GraphQLBoolean"
+      when "datetime"
+        "GraphQLDateTime"
+      else
+        raise "Unable to match requested primitive '#{type}' to GraphQL Type."
+      end
+    end
+
+    def graphql_resolve(name, property)
+      if property["$ref"]
+        "resolve(model){ return model.#{name}; }"
+      elsif property["type"] == "array" && property["items"] && property["items"]["$ref"]
+        "resolve(model){ return model.#{name}; }"
+      end
+      "resolve(model){ return model.#{name}; }"
+    end
+
+    def graphql_fields(model, resource_name)
+      model["properties"].map do |name, property|
+        # HACK. This property doesn't have any metadata. Throw in a couple lines of code
+        # specific to this field.
+        if name == "created_source" && property == "manual|sis|api"
+          "#{name}: new GraphQLEnumType({ name: '#{name}', values: { manual: { value: 'manual' }, sis: { value: 'sis' }, api: { value: 'api' } } })"
+        else
+
+          description = ""
+          if property["description"].present? && property["example"].present?
+            description << "#{safe_js(property['description'])}. Example: #{safe_js(property['example'])}".gsub("..", "").gsub("\n", " ")
+          end
+
+          if type = graphql_type(name, property)
+            resolve = graphql_resolve(name, property)
+            resolve = "#{resolve}, " if resolve.present?
+            "#{name}: { type: #{type}, #{resolve}description: \"#{description}\" }"
+          end
+
+        end
+      end.compact
+    end
+
+    def safe_js(str)
+      str = str.join(", ") if str.is_a?(Array)
+      str = str.map { |_k, v| v }.join(", ") if str.is_a?(Hash)
+      return str unless str.is_a?(String)
+      str.gsub('"', "'")
+    end
+  end
+
+end

data/lib/canvas_api/js_helpers.rb

@@ -0,0 +1,58 @@
+module CanvasApi
+  module JsHelpers
+
+    def js_url_parts(api_url)
+      api_url.split(/(\{[a-z_]+\})/).map do |part|
+        if part[0] == "{"
+          arg = part.gsub(/[\{\}]/, "")
+          "args['#{arg}']"
+        else
+          %{"#{part}"}
+        end
+      end
+    end
+
+    def js_args(args)
+      if args.present?
+        "['#{args.join("', '")}']"
+      else
+        "[]"
+      end
+    end
+
+    def parameters_doc(operation, method)
+      if operation["parameters"].present?
+        parameters = operation["parameters"].
+          reject { |p| p["paramType"] == "path" }.
+          map { |p| "#{p['name']}#{p['required'] ? ' (required)' : ''}" }.
+          compact
+        if parameters.present?
+          if method == "get"
+            "\n// const query = {\n//   #{parameters.join("\n//   ")}\n// }"
+          else
+            "\n// const body = {\n//   #{parameters.join("\n//   ")}\n// }"
+          end
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+    def key_args(args)
+      if args.blank?
+        ""
+      elsif args.length > 1
+        "#{nickname}_{#{args.join('}_{')}}"
+      else
+        "#{nickname}_#{args[0]}"
+      end
+    end
+
+    def reducer_key(nickname, args)
+      "#{nickname}#{key_args(args)}"
+    end
+
+  end
+end

data/lib/canvas_api/rb_graphql_helpers.rb

@@ -0,0 +1,241 @@
+module CanvasApi
+  module GraphQLHelpers
+
+    def graphql_type(name, property, return_type = false, model = nil, input_type = false)
+      if property["$ref"]
+        canvas_name(property['$ref'], input_type)
+      elsif property["allowableValues"]
+        enum_class_name(model, name)
+      else
+        type = property["type"].downcase
+        case type
+        when "{success: true}"
+          "String"
+        when "integer", "string", "boolean", "datetime", "number", "date"
+          graphql_primitive(name, type, property["format"])
+        when "void"
+          "Boolean"
+        when "array"
+          begin
+            type = if property["items"]["$ref"] == "[Integer]"
+                    "[Int]"
+                  elsif property["items"]["$ref"] == "Array"
+                    "[String]"
+                  elsif property["items"]["$ref"] == "[String]"
+                    "[String]"
+                  elsif property["items"]["$ref"] == "DateTime" || property["items"]["$ref"] == "Date"
+                    "[LMSGraphQL::Types::DateTimeType]"
+                  elsif property["items"]["$ref"]
+                    # HACK on https://canvas.instructure.com/doc/api/submissions.json
+                    # the ref value is set to a full sentence rather than a
+                    # simple type, so we look for that specific value
+                    if property["items"]["$ref"].include?("UserDisplay if anonymous grading is not enabled")
+                      "[LMSGraphQL::Types::Canvas::CanvasUserDisplay]"
+                    elsif property["items"]["$ref"].include?("Url String The url to the result that was created")
+                      "String"
+                    else
+                      "[#{canvas_name(property["items"]["$ref"], input_type)}]"
+                    end
+                  else
+                    graphql_primitive(name, property["items"]["type"].downcase, property["items"]["format"])
+                  end
+          rescue
+            puts "Unable to discover list type for '#{name}' ('#{property}'). Defaulting to String"
+            type = "String"
+          end
+          type
+        when "object"
+          puts "Using string type for '#{name}' ('#{property}') of type object."
+          "String"
+        else
+          if property["type"] == "TermsOfService"
+            # HACK There's no TermsOfService object so we return a string
+            "String"
+          elsif property["type"] == "list of content items"
+            # HACK There's no list of content items object so we return an array of string
+            "[String]"
+          elsif property["type"].include?('{ "unread_count": "integer" }')
+            # HACK TODO this should probably be a different type.
+            "Int"
+          elsif return_type
+            canvas_name(property["type"], input_type)
+          else
+            puts "Unable to match '#{name}' requested property '#{property}' to GraphQL Type."
+            "String"
+          end
+        end
+      end
+    end
+
+    def canvas_name(type, input_type = false)
+      # Remove chars and fix spelling errors
+      name = type.split('|').first.strip.gsub(" ", "_").singularize.gsub("MediaTrackk", "MediaTrack")
+      "LMSGraphQL::Types::Canvas::Canvas#{name}#{input_type ? 'Input' : ''}"
+    end
+
+    def graphql_primitive(name, type, format)
+      return "[ID]" if name.end_with?("_ids")
+      return "ID" if name == "id" || name.end_with?("_id")
+      case type
+      when "integer"
+        "Int"
+      when "number"
+        if format == "float64"
+          "Float"
+        else
+          # TODO many of the LMS types with 'number' don't indicate a type so we have to guess
+          # Hopefully that changes. For now we go with float
+          "Float"
+        end
+      when "string"
+        "String"
+      when "boolean"
+        "Boolean"
+      when "datetime"
+        "LMSGraphQL::Types::DateTimeType"
+      when "date"
+        "LMSGraphQL::Types::DateTimeType"
+      else
+        raise "Unable to match requested primitive '#{type}' to GraphQL Type."
+      end
+    end
+
+    def enum_class_name(model, field_name)
+      "#{model['id'].classify}#{field_name.classify}Enum"
+    end
+
+    def graphql_field_enums(model)
+      return unless model["properties"]
+      enums = model["properties"].map do |name, property|
+        if property["allowableValues"]
+          values = property["allowableValues"]["values"].map do |value|
+            "value \"#{value}\""
+          end.join("\n          ")
+          <<-CODE
+        class #{enum_class_name(model, name)} < ::GraphQL::Schema::Enum
+          #{values}
+        end
+          CODE
+        end
+      end.compact
+      if enums.length > 0
+        enums.join("\n        ")
+      else
+        ""
+      end
+    end
+
+    def graphql_fields(model, resource_name, argument = false, input_type = false)
+      if !model["properties"]
+        puts "NO properties for #{resource_name} !!!!!!!!!!!!!!!!!!!!!"
+        return []
+      end
+      model["properties"].map do |name, property|
+        description = ""
+        description << "#{safe_rb(property['description'])}." if property["description"].present?
+        description << "Example: #{safe_rb(property['example'])}".gsub("..", "").gsub("\n", " ") if property["example"].present?
+
+        # clean up name
+        name = nested_arg(name)
+
+        if type = graphql_type(name, property, false, model, input_type)
+          if argument
+            <<-CODE
+  argument :#{name.underscore}, #{type}, "#{description}", required: false
+            CODE
+          else
+            <<-CODE
+  field :#{name.underscore}, #{type}, "#{description}", null: true
+            CODE
+          end
+        else
+          puts "Unable to determine type for #{name}"
+        end
+      end.compact
+    end
+
+    def type_from_operation(operation)
+      type = graphql_type("operation", operation, true)
+    end
+
+    def name_from_operation(operation)
+      type = no_brackets_period(type_from_operation(@operation))
+      if !is_basic_type(type)
+        make_file_name(type)
+      else
+        "return_value"
+      end
+    end
+
+    def is_basic_type(type)
+      ["Int", "String", "Boolean", "LMSGraphQL::Types::DateTimeType", "Float", "ID"].include?(type)
+    end
+
+    def no_brackets_period(str)
+      str.gsub("[", "").gsub("]", "").gsub(".", "")
+    end
+
+    def make_file_name(str)
+      str.underscore.split("/").last.split("|").first.gsub("canvas_", "").gsub(" ", "_").strip.singularize
+    end
+
+    def require_from_operation(operation)
+      type = no_brackets_period(type_from_operation(@operation))
+      if !is_basic_type(type)
+        "require_relative \"../../types/canvas/#{make_file_name(type)}\""
+      end
+    end
+
+    def require_from_properties(model)
+      return unless model["properties"]
+      requires = model["properties"].map do |name, property|
+        type = no_brackets_period(graphql_type(name, property, true, model))
+        if !is_basic_type(type) && !property["allowableValues"]
+          "require_relative \"#{make_file_name(type)}\""
+        end
+      end.compact
+      if requires.length > 0
+        requires.join("\n")
+      else
+        ""
+      end
+    end
+
+    def safe_rb(str)
+      str = str.join(", ") if str.is_a?(Array)
+      str = str.map { |_k, v| v }.join(", ") if str.is_a?(Hash)
+      return str unless str.is_a?(String)
+      str.gsub('"', "'")
+    end
+
+    def nested_arg(str)
+      # TODO/HACK we are replacing values from the string here to get things to work for now.
+      # However, removing these symbols means that the methods that use the arguments
+      # generated herein will have bugs and be unusable.
+      str.gsub("[", "_").
+        gsub("]", "").
+        gsub("*", "star").
+        gsub("<", "_").
+        gsub(">", "_").
+        gsub("`", "").
+        gsub("https://canvas.instructure.com/lti/", "").
+        gsub("https://www.instructure.com/", "").
+        gsub("https://purl.imsglobal.org/spec/lti/claim/", "").
+        gsub(".", "")
+    end
+
+    def params_as_string(parameters, paramTypes)
+      filtered = parameters.select{ |p| paramTypes.include?(p["paramType"]) }
+      if filtered && !filtered.empty?
+        s = filtered.
+          map{ |p| "              \"#{p['name']}\": #{nested_arg(p['name'])}" }.
+          join(",\n")
+        "            {\n#{s}\n            }"
+      else
+        "            {}"
+      end
+    end
+
+  end
+
+end