lti2 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7fb808b35c9fa1aa859277f7fbf6e7789a126cc
+  data.tar.gz: 58137b32270008ffd738b49b609b27997afd5c5b
+SHA512:
+  metadata.gz: c8ebbfa0b82662ebd64d16228ffcc11b68d697f595f4758cbf7841073df1971046b9696761c442300da34192420fbf95bd975fdff857d050fa55f1c654783d3c
+  data.tar.gz: d78b7a644c7b29e1a4298e6199b3a8edda475cf5d263e40b4483ab592384056c6acdc97cc90e96561d89b1893e1dce4c42af891ce41a92dbaabb2fda0a1a7fa6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+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.rdoc

@@ -0,0 +1,184 @@
+
+LTI2 -- Ruby/Rails reference implementation
+==============
+__John Tibbetts, Integration Architect, Vital Source Technologies__
+
+This is an LTI2 reference implementation.  A reference implementation is one that is intended to demonstrate working code based on an emerging standard.  However implementation provides than just exemplary code.  In 
+addition, it fulfills the following responsibilities:
+
+* It implements both sides of the LTI convesation; that is, Tool Consumer (often an LMS) and Tool Provider.  These two components will work (out-of-the-box) with one another.  Or the Tool Consumer can be aimed at an external Tool Provider (possibly in development) to test it.  Or the Tool Provider can be addressed by an external Tool Consumer (possibly in development) to test it.
+
+* As new facilities, messages, or services are added to LTI2 they will be added to this reference model.  The intent is to add them in while they are still in development so that the LTI Services Task Force can see them in early operation.
+
+* The actual LTI-specific TC and TP functionality are implemented as Rails moountable engines.  A mountable engine is a type of gem that is used for creating a Rails 'sub-application'; that is, an application within an application.  Each mountable engine has its own models, controller, etc.  Common behavior of both engines is abstracted into a third gem: lti2-commons.  A consequence of using this design modularity is that either one or both engines can also be mounted in real working production code.  In particular, the Vital Source BusinessCenter incorporates the Tool Consumer engine to provide launches appropriate for viewing e-textbooks.  It also incorporates the Tool Provider to allow new interactive e-textbooks to launch out of the book into other LTI tools, either provided by Vital Source, the book publisher, or anyone else.
+
+* The reference implementation contains sample applications that can either be run under sqlite3 or MySQL.  Sample data is provided for each type of database.
+
+For all the details of LTI, see the full [LTI2 online docs](http://www.imsglobal.org/lti/index.html).
+
+
+
+Prerequisites
+-------------
+
+* Ruby/Rails.  Follow online docs to install Ruby/Rails for your development platform.  This code is currently built on Ruby 1.9.3.
+
+* Github identity.  During the prototype period (pre-conformance test) this must be sent to Lisa Mattson )Lisa Mattson (lisa@imsglobal.org) all access to the repos.
+
+* With a valid Github identity, clone this repo.
+
+* Run bundler in subsdirectories tc_sample_app (the TC directory) and tp_sample_app (the TP directory).
+
+* This code has been tested with either MySQL or sqlite.  The default database load instructions will work for either of these databases. They would likely work with virtually any other Rails-compatible database.
+
+
+Structure of this repository
+-----------------------------
+The repository structure is as follows:
+
+  LTI2--
+    |
+    |
+    --closet      (database backups, common scripts, metadata artifacts)
+    |
+    |
+    --lti2_tc       (tool consumer engine)
+    |
+    |
+    --lti2_tp     (tool provider engine)
+    |
+    |
+    --lti2_commons    (library used by both TC and TP)
+    |
+    |
+    --tc_sample_app   (lightweight TC host based on active_admin gem)
+    |
+    |˙
+    --tp_sample_app   (lightweight TP and tool)
+    
+
+Getting it running
+==================
+
+1. Clone the repo onto your machine.  
+
+2. Create a command prompt for the tool consumer.  chdir into <lti_repo>/tc_sample_app.  
+
+3. [FIRST-TIME ONLY after clone of TC] 'rake init_task:backup'.  This will reset data to base state and ensure that sqlite3 is the current database.  (Instructions below for changing to MySQL.  Recommend running it first as sqlite3).
+
+4. Start a rails server for the Tool Consumer on port 4000: 'rails s -p 4000'.
+
+5. Create a command prompt for the tool provider.  chdir into <lti_repo>/tp_sample_app.
+
+6. [FIRST-TIME ONLY after clone of TP] 'rake init_task:backup'.  This will reset data to base state and ensure that sqlite3 is the current database.  (Instructions below for changing to MySQL.  Recommend running it first as sqlite3).
+
+7. Start a rails server for the Tool Provider on port 5000: 'rails s -p 5000'.
+
+8. Open a browser and go to: 'http://localhost:4000/admin'.  If you're prompted for a login, username is 'admin@lumos.org', password is 'password'.
+
+9. Note: from here on you can see this tool used at: [LTI2 webcast](https://www.youtube.com/watch?v=3zTbtTldeiA "LTI2 webcast").
+
+10. Dashboard: 'Admin Functions' -> 'Register New Tool'.  Enter: 'http://localhost:5000/lti2_tp/registrations'.
+
+11. This will invoke an LTI2 Registration request to the Tool Provider.  The screen with title Fabericious is the Tool Provider's dialog to gather information.  The only action is to add some unique string to the end of the 'Institution name'.  For example, put in the time 1113.  Doing this ensures it can be run repeatedly, since duplicate subsequent entries would be rejected if the value didn't change.  Click the "Update" button.
+
+12. This should return you to the Tool Actions page of the Tool Consumer.  Click on the "[enable now]" link in the column 'Enabled?'.  This will activate the newly registered tool.
+
+13. Return to admin menu.  Click 'My Courses'.  Pick SMPL101A.  Links to a number of resources (within the single tool) are available.  Try 'Echo' to see the Tool Provider's log of the LTI parameters.  Try other resources as you like.
+
+14. Return to Admin.  'Admin Functions' --> 'Show Wirelog'.  This will display a structured log with messages emanating from the Tool Consumer left-adjusted and messages emanating from the Tool Provider center-adjusted.
+
+Resetting the data
+------------------
+
+After running the demo, the data can be reset to its base state (eliminating any current registrations, links, etc.).  To reset the data for the Tool Consumer:
+
+1. Stop the server in the TC directory. 
+2. rake db:seed
+3. Restart the server
+
+The procedure is identical for the Tool Provider, except perform the operations in the TP directory.
+
+Changing your database configuration
+=============================
+
+__NOTE WELL: Default database choice has changed!  It is now sqlite3, not MySQL__
+
+sqlite3 is built in and the data is prebuilt in github.  This means that the TC and TP can be checked out and immediately run with no database prep.
+
+If you'd prefer to use MySQL it's easy to switch.  
+
+* To change the TC to MySQL, edit lti_tc/config/database.yml. To change the TP to MySQL, edit lti_tp/config/database.yml.  These are entirely independent.  There is no requirement that they use the same database configuration.
+
+* Follow the TC- or TP-appropriate instructions in the sections below.  For a MySQL database you'll need to load the database from the /backups directory.
+
+* There is no requirement that the TC and the TP need to use the same database configuration.  e.g. The TC might be using sqlite3 and the TP mysql.
+
+It's also possible to switch database configurations with a command line option rather than hard-wiring the choice using database.yml.  To accomplish this use the -e option on the relevant rails command.
+
+For example:
+
+* Start the TC server with mysql: rails s -p 4000 -e mysql
+
+* Start the TP server with sqlite: rails s -p 5000 -e sqlite3
+
+If using this method remember to apply these same environments to rake tasks:
+
+For example:
+
+* Reseed the mysql database: RAILS_ENV=mysql rake db:seed
+
+* Reseed the sqlite3 database: RAILS_ENV=sqlite3 rake db:seed
+
+
+Setting up MySQL databases
+-----------------------
+
+_If you choose a MySQL Database for TC_  
+
+1. Create the 'Lumos' database.
+2. Allow Lumos access to user: 'ltiuser' with password 'ltipswd'.
+3. Initialize the database: mysql Lumos -u ltiuser -p < backup/lti2_tc.sql
+
+_If you choose a MySQL Database for TP__ 
+
+1. Create the 'fabericious' database.
+2. Allow fabericious access to user: 'ltiuser' with password 'ltipswd'.
+3. mysql fabericious -u ltiuser -p < backup/lti2_tp.sql
+
+Using the Tool Consumer Engine with another host application
+=========================================
+As described above, this distribution uses tc_sample_app as a pseudo LMS.  All of the LTI-specific behavior is mounted into this app using the Rails mountable engine capability.  To use this same engine in another host application the following steps need to be followed.
+
+1. The Gemfile of the host application should access the gem from VST github by including the line:
+  * gem 'lti2_tc', :github => 'vitalsource/lti2_tc'
+
+2. At a rails command-line in the host, import the TC engine migrations into the db migrations of the host:
+  * rake lti2_tc:install:migrations
+  
+3. In the host application's routes.rb, specify the mount point of the TC engine:
+  * mount Lti2Tc::Engine, :at => '/lti2_tc'
+  
+4. Implement the host responsibilities of the engine.  The can be seen in exemplary code in the tc_sample_app.
+  * In the database table 'lti2_tc_registries': modify the tc_deployment_url to the base URL of your server.
+  * In the database table 'lti2_tc_registries': look for the field tool_consumer_profile_template.  This is
+    the tool_consumer_profile that your TC will serve.  Modify it to suit.
+  * Implement a user experience to gather a Tool Provider ToolRegistration.  cf. tc_sample_app/app/admin/deployment_requests.rb in member_action :request_product.
+  * Once the tool is registered it needs to be enabled.  Set up a UX to display tools and tool status.  Cf. tc_sample_app/app/admin/tool_actions.rb.  Enabling (or disabling) the tool is performed by changing 'is_enabled'.  cf. 'toggle' behavior in 'tool_actions'.
+  * Set up 'resolver' methods (Visitor pattern) in course, user, grade_result.  These are invoked by the callbacks in app/services/LtiLaunch.
+
+Using the Tool Provider Engine with another host application
+=========================================
+As described above, this distribution uses tp_sample_app as a pseudo tool provider.  All of the LTI-specific behavior is mounted into this app using the Rails mountable engine capability.  To use this same engine in another host application the following steps need to be followed.
+
+1. The Gemfile of the host application should access the gem from VST github by including the line:
+  * gem 'lti2_tp', :github => 'vitalsource/lti2_tp'
+
+2. At a rails command-line in the host, import the TP engine migrations into the db migrations of the host:
+  * rake lti2_tp:install:migrations
+
+3. In the host application's routes.rb, specify the mount point of the TP engine:
+  * mount Lti2Tp::Engine, :at => '/lti2_tp'
+
+4. Implement the host responsibilities of the engine:
+  * [to be added]

data/Rakefile

@@ -0,0 +1,23 @@
+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    = 'Lti2'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+

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

@@ -0,0 +1,13 @@
+// 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 vendor/assets/javascripts of plugins, if any, 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.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/lti2/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 vendor/assets/stylesheets of plugins, if any, 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 styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/lti2/application_controller.rb

@@ -0,0 +1,4 @@
+module Lti2
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/lti2/application_helper.rb

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

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

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Lti2</title>
+  <%= stylesheet_link_tag    "lti2/application", media: "all" %>
+  <%= javascript_include_tag "lti2/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,4 @@
+Lti2::Engine.routes.draw do
+  mount Lti2Tc::Engine => '/lti2_tc'
+  mount Lti2Tp::Engine => '/lti2_tp'
+end

data/lib/lti2.rb

@@ -0,0 +1,7 @@
+require 'lti2/engine'
+require_relative 'lti2_commons/lib/lti2_commons'
+require_relative '../lti2_tc/lib/lti2_tc/engine.rb'
+require_relative '../lti2_tp/lib/lti2_tp/engine.rb'
+
+module Lti2
+end

data/lib/lti2/engine.rb

@@ -0,0 +1,9 @@
+module Lti2
+  class Engine < ::Rails::Engine
+    isolate_namespace Lti2
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/lti2/version.rb

@@ -0,0 +1,3 @@
+module Lti2
+  VERSION = '0.0.1'
+end

data/lib/lti2_commons/lib/lti2_commons.rb

@@ -0,0 +1,9 @@
+require_relative 'lti2_commons/cache'
+require_relative 'lti2_commons/json_wrapper'
+require_relative 'lti2_commons/message_support'
+require_relative 'lti2_commons/oauth_request'
+require_relative 'lti2_commons/signer'
+require_relative 'lti2_commons/substitution_support'
+require_relative 'lti2_commons/utils'
+require_relative 'lti2_commons/version'
+require_relative 'lti2_commons/wire_log'

data/lib/lti2_commons/lib/lti2_commons/cache.rb

@@ -0,0 +1,29 @@
+require 'lrucache'
+
+module Lti2Commons
+  # Cache adapter. This adapter wraps a simple LRUCache gem.
+  # A more scalable and cluster-friendly cache solution such as Redis
+  # or Memcache # would probably be suitable in a production environment.
+  # This class is used to document the interface.  In this particular case
+  # the interface exactly matches the protocol of the supplied implementation.
+  # Consequently, this adapter is not really required.
+  class Cache
+    # create cache.
+    # @params options [Hash] Should include ttl: <expiry_time>
+    def initialize(options)
+      @cache = LRUCache.new options
+    end
+
+    def clear
+      @cache.clear
+    end
+
+    def fetch(name)
+      @cache.fetch(name)
+    end
+
+    def store(name, value)
+      @cache.store(name, value)
+    end
+  end
+end

data/lib/lti2_commons/lib/lti2_commons/json_wrapper.rb

@@ -0,0 +1,118 @@
+require 'rubygems'
+require 'json'
+require 'jsonpath'
+
+module Lti2Commons
+  class JsonWrapper
+    attr_accessor :root
+
+    def initialize(json_str_or_obj)
+      @root = JsonPath.new('$').on(json_str_or_obj).first
+    end
+
+    def at(path)
+      JsonPath.new(path).on(@root)
+    end
+
+    # Deep copy through reserialization. Only used to preserve immutability of source.
+    #
+    # @return [JsonObject] A full new version of self
+    def deep_copy
+      JsonWrapper.new(@root.to_json)
+    end
+
+    def each_leaf
+      JsonPath.new('$..*').on(@root).each do |node|
+        yield node if node.is_a? String
+      end
+    end
+
+    def first_at(path)
+      at(path).first
+    end
+
+    # Does this node, possibly repeating, match all elements of the constraint_hash
+    #
+    # @params candidate [Hash/Array] node or Array of nodes to match
+    # @params constraint_hash [Hash] Hash of value to match
+    # @return [TreeNode] Either self or immediate child that matches constraint_hash
+    def get_matching_node(candidate, constraint_hash)
+      if candidate.is_a? Hash
+        return candidate if is_hash_intersect(candidate, constraint_hash)
+      elsif candidate.is_a? Array
+        candidate.each do |child|
+          # are there extraneous keys in constraint_hash
+          return child if is_hash_intersect(child, constraint_hash)
+        end
+      end
+      nil
+    end
+
+    # Convenience method to find a particular node with matching attributes to constraint_hash
+    # and then return specific element of that node.
+    # e.g., search for 'path' within the 'resource_handler' with constraint_hash attributes.
+    #
+    # @params path [JsonPath] path to parent of candidate array of nodes
+    # @params constraint_hash [Hash] Hash of values which must match target
+    # @params return_path [JsonPath] Path of element within matching target
+    # @return [Object] result_path within matching node or nil
+    def search(path, constraint_hash, return_path)
+      candidate = JsonPath.new(path).on(@root)
+      candidate = get_matching_node(candidate.first, constraint_hash)
+      return nil unless candidate
+      JsonPath.new(return_path).on(candidate).first
+    end
+
+    # Convenience method to find a particular node with matching attributes to constraint_hash
+    # and then return specific element of that node.
+    # e.g., search for 'path' within the 'resource_handler' with constraint_hash attributes.
+    #
+    # @params path [JsonPath] path to parent of candidate array of nodes
+    # @params constraint_hash [Hash] Hash of values which must match target
+    # @params return_path [JsonPath] Path of element within matching target
+    # @return [Object] result_path within matching node or nil
+    def select(path, selector, value, return_path)
+      candidates = JsonPath.new(path).on(@root)
+      now_candidate = nil
+      candidates.each do |candidate|
+        now_candidate = candidate
+        selector_node = JsonPath.new(selector).on(candidate.first)
+        break if selector_node.include? value
+      end
+      if now_candidate
+        JsonPath.new(return_path).on(now_candidate.first).first
+      else
+        nil
+      end
+    end
+
+    def substitute_text_in_all_nodes(token_prefix, token_suffix, hash)
+      self.each_leaf do |v|
+        substitute_template_values_from_hash(v, token_prefix, token_suffix, hash)
+      end
+    end
+
+    def to_pretty_json
+      JSON.pretty_generate(root)
+    end
+
+    private
+
+    def is_hash_intersect(target_hash, constraint_hash)
+      # failed search if constraint_hash as invalid keys
+      return nil if (constraint_hash.keys - target_hash.keys).length > 0
+      target_hash.each_pair do |k, v|
+        if constraint_hash.key? k
+          return false unless v == constraint_hash[k]
+        end
+      end
+      true
+    end
+
+    def substitute_template_values_from_hash(source_string, prefix, suffix, hash)
+      hash.each do |k, v|
+        source_string.sub!(prefix + k + suffix, v)
+      end
+    end
+  end
+end