ims-lti 1.2.4 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 224820ab40ce08a13bfda880f3107740a2b46cd31f672719b72d1d8e8cf3cc50
-  data.tar.gz: b0c4c73930312bd6a27c7d6c8ea74b9dd33d83fd8cf8d240db14ea2b3e27e29f
+SHA1:
+  metadata.gz: d9a9be3ac5b5acb2c58f5c961cb68be59accfa3f
+  data.tar.gz: d5dba5360e965a35e54fe010800735e4d087fe25
 SHA512:
-  metadata.gz: 4d787b098d9fe7b9dba586cf77eff9d3a76cb31697685f29d5cd9f8add1d2950a8ac55385d1419a27559e688f1629f11ce33e394bb24191e447d6876a3b692fd
-  data.tar.gz: 4f0b4d72b52cd2ad3b936da67d64709734194c6dd321f4883b91131a8625e33193b40ed804d3ea1d633bf254fb3c9656829d04450ad26ca250899dfaf43799de
+  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,116 +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
+LTI ruby implementation
 
-## 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).
-
-### 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
-```
+## Installation
 
-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.
+Add this line to your application's Gemfile:
 
-#### 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).
+    gem 'lti'
 
-You can check whether the TC is expecting a grade write-back:
+And then execute:
 
-```ruby
-if provider.outcome_service?
-  # ready for grade write-back
-else
-  # normal tool launch without grade write-back
-end
-```
+    $ bundle
 
-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:
+Or install it yourself as:
 
-```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
-```
+    $ gem install lti
 
-You can see the error code documentation
-[here](http://www.imsglobal.org/gws/gwsv1p0/imsgws_baseProfv1p0.html#1639667).
 
-### 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)
+## 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.rb

@@ -1 +1,3 @@
-require 'ims/lti'
+module IMS
+  require 'ims/lti'
+end

data/lib/ims/lti.rb

@@ -1,69 +1,11 @@
-require 'oauth'
-require 'builder'
-require "rexml/document"
-require 'cgi'
+require 'json'
 require 'securerandom'
+require 'oauth'
 
-module IMS # :nodoc:
-
-  # :main:IMS::LTI
-  # LTI is a standard defined by IMS for creating eduction Tool Consumers/Providers.
-  # LTI documentation: http://www.imsglobal.org/lti/index.html
-  #
-  # When creating these tools you will work primarily with the ToolProvider and
-  # ToolConsumer classes.
-  #
-  # For validating OAuth request be sure to require the necessary proxy request
-  # object. See IMS::LTI::RequestValidator#valid_request? for more documentation.
-  #
-  # == 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'
+module IMS
   module LTI
-
-    # The versions of LTI this library supports
-    VERSIONS = %w{1.0 1.1}
-
-    class InvalidLTIConfigError < StandardError
-    end
-
-    class XMLParseError < StandardError
-    end
-
-    # POST a signed oauth request with the given key/secret/data
-    def self.post_service_request(key, secret, url, content_type, body)
-      raise IMS::LTI::InvalidLTIConfigError, "" unless key && secret
-
-      consumer = OAuth::Consumer.new(key, secret)
-      token = OAuth::AccessToken.new(consumer)
-      token.post(
-              url,
-              body,
-              'Content-Type' => content_type
-      )
-    end
-
-    # Generates a unique identifier
-    def self.generate_identifier
-      SecureRandom.uuid
-    end
+    require_relative 'lti/models'
+    require_relative 'lti/converters'
+    require_relative 'lti/services'
   end
 end
-
-require 'ims/lti/extensions'
-require 'ims/lti/launch_params'
-require 'ims/lti/request_validator'
-require 'ims/lti/tool_base'
-require 'ims/lti/deprecated_role_checks'
-require 'ims/lti/role_checks'
-require 'ims/lti/tool_provider'
-require 'ims/lti/tool_consumer'
-require 'ims/lti/outcome_request'
-require 'ims/lti/outcome_response'
-require 'ims/lti/tool_config'

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/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/models.rb

@@ -0,0 +1,29 @@
+module IMS::LTI
+  module Models
+    require_relative 'models/lti_model'
+    require_relative 'models/contact'
+    require_relative 'models/localized_name'
+    require_relative 'models/localized_text'
+    require_relative 'models/product_family'
+    require_relative 'models/product_info'
+    require_relative 'models/product_instance'
+    require_relative 'models/rest_service'
+    require_relative 'models/service_owner'
+    require_relative 'models/service_provider'
+    require_relative 'models/tool_consumer_profile'
+    require_relative 'models/vendor'
+    require_relative 'models/messages'
+    require_relative 'models/tool_proxy'
+    require_relative 'models/tool_profile'
+    require_relative 'models/resource_handler'
+    require_relative 'models/resource_type'
+    require_relative 'models/message_handler'
+    require_relative 'models/parameter'
+    require_relative 'models/icon_info'
+    require_relative 'models/icon_endpoint'
+    require_relative 'models/security_contract'
+    require_relative 'models/rest_service_profile'
+    require_relative 'models/base_url_choice'
+    require_relative 'models/base_url_selector'
+  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