ims-lti 1.2.9 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 801e423357504d51cc0289e45e364d026abd4bbad20dfca90107725796cd258f
-  data.tar.gz: cfdcb37216eef088886486f951af05f719b086f7f32f7d8d83dc04f3020b563e
+SHA1:
+  metadata.gz: d9a9be3ac5b5acb2c58f5c961cb68be59accfa3f
+  data.tar.gz: d5dba5360e965a35e54fe010800735e4d087fe25
 SHA512:
-  metadata.gz: fcc31ec46d3fccb7585bbe3d6dff5ab88227ccea12b4c056a2f8c588a864b26bb9d74d13601e2b08f7bcc404d215b4b0be14a3b96b613b79e795edfeb8ad2d0c
-  data.tar.gz: 0bfa98f889d2b848e03200a22f76447bab3df748c9b6a351d42d5ec9218838ba749f5751af59efd5ae8f7db701a28fcf5b8b92cecb253ebfc097cce3cfb7ff59
+  metadata.gz: 9b45fee316f01a2681c78bc047d7710e3d7ad502afb170407a15e00e2f1f3305742e03024b92d9feca47b650bc93792d1b9ab26176fd92f3ea00137200961350
+  data.tar.gz: 947ca33099a7285791b82e5e0b9d1fa92202d1370a36a0fae5fb83f2d35fb84cbb790f40cff88fc57a18b1e2e0525018b5585e26995547ff7108ede73768acb7

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Instructure
+
+MIT License
+
+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

@@ -1,129 +1,28 @@
 # IMS LTI
 
-This ruby library is to help create Tool Providers and Tool Consumers for the
-[IMS LTI standard](http://www.imsglobal.org/lti/index.html).
+#Version 2.x is currently BETA
 
-## Installation
-This is packaged as the `ims-lti` rubygem, so you can just add the dependency to
-your Gemfile or install the gem on your system:
-
-    gem install ims-lti
-
-To require the library in your project:
-
-    require 'ims/lti'
-
-To validate the OAuth signatures you need to require the appropriate request
-proxy for your application. For example:
-
-    # For a Rails 5 (and 2.3) app:
-    require 'oauth/request_proxy/action_controller_request'
-
-    # For a Sinatra or a Rails 3 or 4 app:
-    require 'oauth/request_proxy/rack_request'
-    # You also need to explicitly enable OAuth 1 support in the environment.rb or an initializer:
-    OAUTH_10_SUPPORT = true
-
-For further information see the [oauth-ruby](https://github.com/oauth-xx/oauth-ruby) project.
-
-As a quick debugging note, if you forget that step, you'll get an error like:
-
-    OAuth::RequestProxy::UnknownRequestType
-
-## Usage
-This readme won't cover the LTI standard, just how to use the library. It will be
-very helpful to read the [LTI documentation](http://www.imsglobal.org/lti/index.html)
-
-In LTI there are Tool Providers (TP) and Tool Consumers (TC), this library is
-useful for implementing both. Here is an overview of the communication process:
-[LTI 1.1 Introduction](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560461)
-
-This library doesn't help you manage the consumer keys and secrets. The POST
-headers/parameters will contain the `oauth_consumer_key` and your app can use
-that to look up the appropriate `oauth_consumer_secret`.
-
-Your app will also need to manage the OAuth nonce to make sure the same nonce
-isn't used twice with the same timestamp. [Read the LTI documentation on OAuth](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560468).
+LTI ruby implementation
 
-### Tool Provider
-As a TP your app will receive a POST request with a bunch of
-[LTI launch data](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560465)
-and it will be signed with OAuth using a key/secret that both the TP and TC share.
-This is covered in the [LTI security model](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560466)
-
-Here is an example of a simple TP Sinatra app using this gem:
-[LTI Tool Provider](https://github.com/instructure/lti1_tool_provider_example)
-
-Once you find the `oauth_consumer_secret` based on the `oauth_consumer_key` in
-the request, you can initialize a `ToolProvider` object with them and the post parameters:
-
-```ruby
-# Initialize TP object with OAuth creds and post parameters
-provider = IMS::LTI::ToolProvider.new(consumer_key, consumer_secret, params)
-
-# Verify OAuth signature by passing the request object
-if provider.valid_request?(request)
-  # success
-else
-  # handle invalid OAuth
-end
-```
-
-Once your TP object is initialized and verified you can load your tool. All of the
-[launch data](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560465)
-is available in the TP object along with some convenience methods like `provider.username`
-which will try to find the name from the 3 potential name launch data attributes.
-
-#### Returning Results of a Quiz/Assignment
-If your TP provides some kind of assessment service you can write grades back to
-the TC. This is documented in the LTI docs [here](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560471).
-
-You can check whether the TC is expecting a grade write-back:
-
-```ruby
-if provider.outcome_service?
-  # ready for grade write-back
-else
-  # normal tool launch without grade write-back
-end
-```
-
-To write the grade back to the TC your tool will do a POST directly back to the
-URL the TC passed in the launch data. You can use the TP object to do that for you:
-
-```ruby
-# post the score to the TC, score should be a float >= 0.0 and <= 1.0
-# this returns an OutcomeResponse object
-response = provider.post_replace_result!(score)
-if response.success?
-  # grade write worked
-elsif response.processing?
-elsif response.unsupported?
-else
-  # failed
-end
-```
-
-You can see the error code documentation
-[here](http://www.imsglobal.org/gws/gwsv1p0/imsgws_baseProfv1p0.html#1639667).
+## Installation
 
-### Tool Consumer
-As a Tool Consumer your app will POST an OAuth-signed launch requests to TPs with the necessary
-[LTI launch data](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560465).
-This is covered in the [LTI security model](http://www.imsglobal.org/LTI/v1p1/ltiIMGv1p1.html#_Toc319560466)
+Add this line to your application's Gemfile:
 
-```ruby
+    gem 'lti'
 
-params = { user_id: '123', lti_message_type: IMS::LTI::Models::Messages::BasicLTILaunchRequest::MESSAGE_TYPE }
+And then execute:
 
-header = SimpleOAuth::Header.new(:post, 'https://yoursite.com', params, consumer_key: oauth_consumer_key, consumer_secret: secret)
+    $ bundle
 
-signed_params = header.signed_attributes.merge(params)
+Or install it yourself as:
 
-IMS::LTI::Services::MessageAuthenticator.new(launch_url, signed_params, secret)
+    $ gem install lti
 
-```
 
 ## Contributing
-Here is an example of a simple TC Sinatra app using this gem:
-[LTI Tool Consumer](https://github.com/instructure/lti_tool_consumer_example)
+
+1. Fork it ( http://github.com/instructure/lti/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 new Pull Request

data/lib/ims/lti/converters/time_json_converter.rb

@@ -0,0 +1,13 @@
+module IMS::LTI::Converters
+  class TimeJSONConverter
+
+    def self.to_json_value(time)
+      time
+    end
+
+    def self.from_json_value(json_val)
+      Time.parse(json_val)
+    end
+
+  end
+end

data/lib/ims/lti/converters.rb

@@ -0,0 +1,5 @@
+module IMS::LTI
+  module Converters
+    require_relative 'converters/time_json_converter'
+  end
+end

data/lib/ims/lti/models/base_url_choice.rb

@@ -0,0 +1,15 @@
+module IMS::LTI::Models
+  class BaseUrlChoice < LTIModel
+    add_attributes :default_base_url, :secure_base_url
+    add_attribute :selector, relation:'IMS::LTI::Models::BaseUrlSelector'
+
+    def default_message_url
+      if selector && selector.applies_to && selector.applies_to.include?('MessageHandler')
+        secure_base_url || default_base_url
+      else
+        ''
+      end
+    end
+
+  end
+end

data/lib/ims/lti/models/base_url_selector.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class BaseUrlSelector < LTIModel
+    add_attribute :applies_to
+  end
+end

data/lib/ims/lti/models/contact.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class Contact < LTIModel
+    add_attributes :email
+  end
+end

data/lib/ims/lti/models/icon_endpoint.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class IconEndpoint < LTIModel
+    add_attribute :path
+  end
+end

data/lib/ims/lti/models/icon_info.rb

@@ -0,0 +1,6 @@
+module IMS::LTI::Models
+  class IconInfo < LTIModel
+    add_attributes :key, :icon_style
+    add_attribute :default_location, relation: 'IMS::LTI::Models::IconEndpoint'
+  end
+end

data/lib/ims/lti/models/localized_name.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models
+  class LocalizedName < LTIModel
+    add_attributes :default_value, :key
+
+    def initialize(default_value = nil, key = nil)
+      @default_value = default_value
+      @key = key
+    end
+
+  end
+end

data/lib/ims/lti/models/localized_text.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models
+  class LocalizedText < LTIModel
+    add_attributes :default_value, :key
+
+    def initialize(default_value = nil, key = nil)
+      @default_value = default_value
+      @key = key
+    end
+
+  end
+end

data/lib/ims/lti/models/lti_model.rb

@@ -0,0 +1,169 @@
+module IMS::LTI::Models
+  class LTIModel
+    LTI_VERSION_2P0 = 'LTI-2p0'
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    def self.add_attributes(attribute, *attrs)
+      attrs.unshift(attribute)
+      self.attributes += attrs
+      attr_accessor(attrs.shift, *attrs)
+    end
+
+    def self.add_attribute(attribute, options = {})
+      @serialization_options ||= {}
+      options.each do |k, v|
+        @serialization_options[k] ||= {}
+        @serialization_options[k][attribute] = v
+      end
+      self.attributes += [attribute]
+      attr_accessor(attribute)
+    end
+
+    def self.inherit_attributes(attrs)
+      attributes ||= []
+      self.attributes += attrs
+    end
+
+    def self.inherited(subclass)
+      subclass.inherit_attributes(self.attributes)
+    end
+
+    def attributes
+      attrs = {}
+      self.class.attributes.each do |a|
+        value = instance_variable_get("@#{a.to_s}")
+        attrs[a.to_s] = value unless value == nil
+      end
+      attrs
+    end
+
+    def attributes=(attrs)
+      attrs.each do |k, v|
+        instance_variable_set("@#{k.to_s}", v)
+      end
+    end
+
+    def as_json(options = {})
+      json_hash = attributes
+      serialization_attrs_for(:json_key).each { |attr| json_hash.delete(attr.to_s) }
+      serialization_attrs_for(:relation).each do |attr|
+        val = attributes[attr.to_s]
+        json_hash[json_key(attr)] = val.as_json if val
+      end
+      json_hash.merge! to_json_conversions
+      json_hash.merge! to_json_keys
+      json_hash
+    end
+
+    def to_json
+      self.as_json.to_json
+    end
+
+    def from_json(json)
+      data = JSON.parse(json)
+      if data.is_a? Array
+        data.map { |hash| self.class.new.from_json(hash.to_json) }
+      else
+        process_json_hash(data)
+      end
+    end
+
+    private
+
+    def process_json_hash(hash)
+      change_json_keys_to_attrs!(hash)
+      hash.merge! from_json_conversions(hash)
+      deserialize_json_relations!(hash)
+      self.attributes=(hash)
+      self
+    end
+
+    def serialization_attrs_for(*keys)
+      Array.new(serialization_options.keys & keys).map { |opt| serialization_options[opt].keys }.flatten.uniq
+    end
+
+    def to_json_conversions
+      result = {}
+      if converters = serialization_options[:json_converter]
+        converters.each do |attr, converter|
+          value = attributes[attr.to_s]
+          result[json_key(attr)] = get_constant(converter).to_json_value(value) if value
+        end
+      end
+      result
+    end
+
+    def to_json_keys
+      result = {}
+      if attrs = serialization_attrs_for(:json_key)
+        conversion_attrs = serialization_attrs_for(:json_converter)
+        attrs.each { |attr| result[json_key(attr)] = attributes[attr.to_s] unless conversion_attrs.include?(attr) || attributes[attr.to_s].nil? }
+      end
+      result
+    end
+
+    def change_json_keys_to_attrs!(json_hash)
+      if attrs = serialization_attrs_for(:json_key)
+        attrs.each do |attr|
+          key = json_key(attr)
+          json_hash[attr.to_s] = json_hash.delete(key) if json_hash.has_key?(key)
+        end
+      end
+    end
+
+    def from_json_conversions(hash)
+      result = {}
+      if converters = serialization_options[:json_converter]
+        converters.each do |attr, converter|
+          result[attr] = get_constant(converter).from_json_value(hash[attr.to_s]) if hash[attr.to_s]
+        end
+      end
+      result
+    end
+
+    def deserialize_json_relations!(hash)
+      if relations = serialization_options[:relation]
+        attrs = {}
+        relations.each do |attr, relation|
+          hash_val = hash.delete(attr.to_s)
+          attrs[attr.to_s] = get_constant(relation).new.from_json(hash_val.to_json) if hash_val
+        end
+        self.attributes = attrs
+      end
+    end
+
+    def json_key(attr)
+      if json_keys = serialization_options[:json_key]
+        json_keys[attr] || attr
+      else
+        attr
+      end.to_s
+    end
+
+    def self.attributes
+      @attributes || []
+    end
+
+    def self.attributes=(attribs)
+      @attributes = attribs
+    end
+
+    def self.serialization_options
+      @serialization_options ||= {}
+    end
+
+    def serialization_options
+      self.class.serialization_options
+    end
+
+    def get_constant(constant)
+      obj = Object
+      constant.split('::').each { |c| obj = obj.const_get(c) }
+      obj
+    end
+
+  end
+end

data/lib/ims/lti/models/message_handler.rb

@@ -0,0 +1,6 @@
+module IMS::LTI::Models
+  class MessageHandler < LTIModel
+    add_attributes :message_type, :path, :enabled_capability, :parameter
+    add_attribute :parameter, relation:'IMS::LTI::Models::Parameter'
+  end
+end

data/lib/ims/lti/models/messages/basic_lti_launch_request.rb

@@ -0,0 +1,8 @@
+module IMS::LTI::Models::Messages
+  class BasicLTILaunchRequest < IMS::LTI::Models::LTIModel
+
+    add_attributes :context_id, :context_type, :launch_presentation_return_url, :resource_link_id, :role_scope_mentor,
+                   :tool_consumer_instance_guid, :user_image
+
+  end
+end

data/lib/ims/lti/models/messages/message.rb

@@ -0,0 +1,43 @@
+module IMS::LTI::Models::Messages
+  class Message < IMS::LTI::Models::LTIModel
+    LAUNCH_TARGET_IFRAME = 'iframe'
+    LAUNCH_TARGET_WINDOW = 'window'
+
+    add_attributes :lti_message_type, :lti_version, :user_id, :roles, :launch_presentation_local,
+                   :launch_presentation_document_target, :launch_presentation_css_url, :launch_presentation_width,
+                   :launch_presentation_height
+
+    def initialize(attrs = {})
+      super(attrs)
+      @custom_params = {}
+      @ext_params = {}
+    end
+
+    def post_params
+      get_custom_params.merge(get_ext_params).merge(attributes)
+    end
+
+    def get_ext_params
+      params = {}
+      @ext_params.each { |k, v| params["ext_#{k}"] = v }
+      params
+    end
+
+    def get_custom_params
+      params = {}
+      @custom_params.each { |k, v| params["custom_#{k}"] = v }
+      params
+    end
+
+    def method_missing(meth, *args, &block)
+      if match = /^(custom|ext)_([^=$]*)/.match(meth)
+        param_type, key = match.captures
+        param_hash = instance_variable_get("@#{param_type}_params".to_sym)
+        meth =~ /=$/ ? param_hash[key] = args[0] : param_hash[key]
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/ims/lti/models/messages/registration_request.rb

@@ -0,0 +1,17 @@
+module IMS::LTI::Models::Messages
+  class RegistrationRequest < Message
+    add_attributes :reg_key, :reg_password, :tc_profile_url, :launch_presentation_return_url
+
+    REGISTRATION_REQUEST_MESSAGE_TYPE = 'ToolProxyRegistrationRequest'
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.lti_message_type = REGISTRATION_REQUEST_MESSAGE_TYPE
+    end
+
+    def generate_key_and_password
+      self.reg_key, self.reg_password = 2.times.map { SecureRandom.uuid }
+    end
+
+  end
+end

data/lib/ims/lti/models/messages.rb

@@ -0,0 +1,6 @@
+module IMS::LTI::Models
+  module Messages
+    require_relative 'messages/message'
+    require_relative 'messages/registration_request'
+  end
+end

data/lib/ims/lti/models/parameter.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class Parameter < LTIModel
+    add_attributes :name, :variable, :fixed
+  end
+end

data/lib/ims/lti/models/product_family.rb

@@ -0,0 +1,8 @@
+module IMS::LTI::Models
+  class ProductFamily < LTIModel
+    add_attributes :code
+    add_attribute :id, json_key: '@id'
+    add_attribute :vendor, relation: 'IMS::LTI::Models::Vendor'
+
+  end
+end

data/lib/ims/lti/models/product_info.rb

@@ -0,0 +1,19 @@
+module IMS::LTI::Models
+  class ProductInfo < LTIModel
+    add_attribute :product_version
+    add_attribute :product_family, relation: 'IMS::LTI::Models::ProductFamily'
+    add_attribute :description, relation: 'IMS::LTI::Models::LocalizedText'
+    add_attribute :product_name, relation: 'IMS::LTI::Models::LocalizedName'
+    add_attribute :technical_description, relation: 'IMS::LTI::Models::LocalizedText'
+
+    def create_product_name(name, key = 'product.name')
+      @product_name = LocalizedName.new(name, key)
+    end
+
+    def create_description(name, key = 'product.description')
+      @description = LocalizedText.new(name, key)
+    end
+
+
+  end
+end

data/lib/ims/lti/models/product_instance.rb

@@ -0,0 +1,10 @@
+module IMS::LTI::Models
+  class ProductInstance < LTIModel
+    add_attributes :guid
+    add_attribute :product_info, relation:'IMS::LTI::Models::ProductInfo'
+    add_attribute :service_owner, relation:'IMS::LTI::Models::ServiceOwner'
+    add_attribute :support, relation:'IMS::LTI::Models::ServiceProvider'
+    add_attribute :service_provider, relation:'IMS::LTI::Models::Contact'
+
+  end
+end

data/lib/ims/lti/models/resource_handler.rb

@@ -0,0 +1,18 @@
+module IMS::LTI::Models
+  class ResourceHandler < LTIModel
+    add_attribute :resource_type, relation: 'IMS::LTI::Models::ResourceType'
+    add_attribute :resource_name, relation: 'IMS::LTI::Models::LocalizedName'
+    add_attribute :description, relation: 'IMS::LTI::Models::LocalizedText'
+    add_attribute :message, relation: 'IMS::LTI::Models::MessageHandler'
+    add_attribute :icon_info, relation: 'IMS::LTI::Models::IconInfo'
+
+    def default_name
+      resource_name && resource_name.default_value
+    end
+
+    def default_description
+      description && description.default_value
+    end
+
+  end
+end

data/lib/ims/lti/models/resource_type.rb

@@ -0,0 +1,6 @@
+module IMS::LTI::Models
+  class ResourceType < LTIModel
+    add_attribute :code
+
+  end
+end

data/lib/ims/lti/models/rest_service.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models
+  class RestService < LTIModel
+    TYPE = 'RestService'
+
+    add_attributes :endpoint, :format, :action
+    add_attribute :id, json_key:'@id'
+    add_attribute :type, json_key: '@type'
+
+    def initialize
+      @type = TYPE
+    end
+
+  end
+end

data/lib/ims/lti/models/rest_service_profile.rb

@@ -0,0 +1,7 @@
+module IMS::LTI::Models
+  class RestServiceProfile < LTIModel
+    add_attributes :service, :action
+    add_attribute :type, json_key: '@type'
+
+  end
+end

data/lib/ims/lti/models/security_contract.rb

@@ -0,0 +1,9 @@
+module IMS::LTI::Models
+  class SecurityContract < LTIModel
+
+    add_attribute :shared_secret
+    add_attribute :tool_service, relation: 'IMS::LTI::Models::RestServiceProfile'
+    add_attribute :end_user_service, relation: 'IMS::LTI::Models::RestServiceProfile'
+
+  end
+end

data/lib/ims/lti/models/service_owner.rb

@@ -0,0 +1,8 @@
+module IMS::LTI::Models
+  class ServiceOwner < LTIModel
+    add_attribute :description, relation: 'IMS::LTI::Models::LocalizedText'
+    add_attribute :timestamp, json_converter:'IMS::LTI::Converters::TimeJSONConverter'
+    add_attribute :service_owner_name, relation: 'IMS::LTI::Models::LocalizedName'
+
+  end
+end

data/lib/ims/lti/models/service_provider.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models
+  class ServiceProvider < LTIModel
+    add_attribute :guid
+    add_attribute :id, json_key:'@id'
+    add_attribute :service_provider_name, relation:'IMS::LTI::Models::LocalizedName'
+    add_attribute :description, relation:'IMS::LTI::Models::LocalizedText'
+    add_attribute :support, relation:'IMS::LTI::Models::Contact'
+    add_attribute :timestamp, json_converter: 'IMS::LTI::Converters::TimeJSONConverter'
+
+  end
+end