lti2 0.0.1

data/lib/lti2_commons/lib/lti2_commons/signer.rb

@@ -0,0 +1,75 @@
+require 'uri'
+require 'oauth'
+require_relative 'oauth_request'
+
+module Lti2Commons
+  module Signer
+    # Creates an OAuth signed request using the OAuth Gem - https://github.com/oauth/oauth-ruby
+    #
+    # @param launch_url [String]  Endpoint of service to be launched
+    # @param http_method [String] Http method ('get', 'post', 'put', 'delete')
+    # @param consumer_key [String] OAuth consumer key
+    # @param consumer_secret [String] OAuth consumer secret
+    # @param params [Hash] Non-auth parameters or oauth parameter default values
+    #        oauth_timestamp => defaults to current time
+    #        oauth_nonce => defaults to random number
+    #        oauth_signature_method => defaults to HMAC-SHA1 (also RSA-SHA1 supported)
+    # @param body [String] Body content.  Usually would include this for body-signing of non form-encoded data.
+    # @param content_type [String] HTTP CONTENT-TYPE header; defaults: 'application/x-www-form-urlencoded'
+    # @return [Request] Signed request
+    def create_signed_request(launch_url, http_method, consumer_key, consumer_secret, params = {},
+        body = nil, content_type = nil, accept = nil)
+      params['oauth_consumer_key'] = consumer_key
+      params['oauth_nonce'] = (rand * 10E12).to_i.to_s unless params.key? 'oauth_nonce'
+      params['oauth_signature_method'] = 'HMAC-SHA1' unless params.key? 'oauth_signature_method'
+      params['oauth_timestamp'] = Time.now.to_i.to_s unless params.key? 'oauth_timestamp'
+      params['oauth_version'] = '1.0' unless params.key? 'oauth_version'
+      params['oauth_callback'] = 'about:blank'
+
+      content_type = 'application/x-www-form-urlencoded' unless content_type
+
+      launch_url = URI.unescape(launch_url)
+      uri = URI.parse(launch_url)
+
+      # flatten in query string arrays
+      if uri.query && uri.query != ''
+        CGI.parse(uri.query).each do |query_key, query_values|
+          params[query_key] = query_values.first unless params[query_key]
+        end
+      end
+
+      final_uri = uri
+      uri = URI.parse(launch_url.split('?').first)
+
+      unless content_type == 'application/x-www-form-urlencoded'
+        params['oauth_body_hash'] = compute_oauth_body_hash body if body
+      end
+
+      request = OAuth::OAuthProxy::OAuthRequest.new(
+        'method' => http_method.to_s.upcase,
+        'uri' => uri,
+        'parameters' => params,
+        'final_uri' => final_uri
+      )
+
+      request.body = body
+      request.content_type = content_type
+      request.accept = accept
+
+      request.sign!(consumer_secret: consumer_secret)
+
+      # puts "Sender secret: #{consumer_secret}"
+      request
+    end
+
+    private
+
+    # Creates the value of an OAuth body hash
+    #
+    # @param launch_url [String] Content to be body signed
+    # @return [String] Signature base string (useful for debugging signature problems)
+    def compute_oauth_body_hash(content)
+      Base64.encode64(Digest::SHA1.digest(content.chomp)).gsub(/\n/, '')
+    end
+  end
+end

data/lib/lti2_commons/lib/lti2_commons/substitution_support.rb

@@ -0,0 +1,87 @@
+module Lti2Commons
+  module SubstitutionSupport
+    # Resolver resolves values by name from a variety of object sources.
+    # It's useful for variable substitution.
+    #
+    # The supported object sources are:
+    #   Hash      ::= value by key
+    #   Proc      ::= single-argument block evaluation
+    #   Method    ::= single-argument method obect evaluation
+    #   Resolver  ::= a nested resolver.  useful for scoping resolvers;
+    #                 i.e. a constant, global inner resolver, but a one-time outer-resolver
+    #   Object    ::= value by dynamic instrospection of any object's accessor
+    #
+    #   See the accompanying tester for numerous examples
+    class Resolver
+      attr_accessor :resolvers
+
+      def initialize
+        @resolver_hash = Hash.new
+      end
+
+      # Add some type of resolver object_source to the Resolver
+      #
+      # @param key [String] A dotted name with the leading zone indicating the object category
+      # @param resolver [ObjectSource] a raw object_source for resolving
+      # @returns [String] value.  If no resolution, return the incoming name
+      #
+      def add_resolver(key, resolver)
+        if resolver.is_a? Resolver
+          # Resolvers themselves should always be generic
+          key_sym = :*
+        else
+          key_sym = key.to_sym
+        end
+        @resolver_hash[key_sym] = [] unless @resolver_hash.key? key_sym
+        @resolver_hash[key_sym] << resolver
+      end
+
+      def resolve(full_name)
+        full_name ||= ''
+        zones = full_name.split('.')
+        return full_name if zones[0].blank?
+        category = zones[0].to_sym
+        name = zones[1..-1].join('.')
+
+        # Find any hits within category
+        @resolver_hash.each_pair do |k, v|
+          if k == category
+            result = resolve_by_category(full_name, name, v)
+            return result if result
+          end
+        end
+
+        # Find any hits in global category
+        resolvers = @resolver_hash[:*]
+        result = resolve_by_category full_name, name, resolvers if resolvers
+        return result if result
+
+        "#{full_name}"
+      end
+
+      def to_s
+        "Resolver for [#{@resolver_hash.keys}]"
+      end
+
+      private
+
+      def resolve_by_category(full_name, name, resolvers)
+        resolvers.each do |resolver|
+          if resolver.is_a? Hash
+            value = resolver[name]
+          elsif resolver.is_a? Proc
+            value = resolver.call(name)
+          elsif resolver.is_a? Method
+            value = resolver.call(name)
+          elsif resolver.is_a? Resolver
+            value = resolver.resolve(full_name)
+          elsif resolver.is_a? Object
+            value = resolver.send(name)
+          end
+          return value if value
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/lti2_commons/lib/lti2_commons/utils.rb

@@ -0,0 +1,28 @@
+require 'digest'
+require 'uuid'
+
+module Lti2Commons
+  module Utils
+    def is_hash_intersect(node, constraint_hash)
+      # failed search if constraint_hash as invalid keys
+      return nil if (constraint_hash.keys - node.keys).length > 0
+      node.each_pair do |k, v|
+        if constraint_hash.key?(k)
+          return false unless v == constraint_hash[k]
+        end
+      end
+      true
+    end
+
+    def hash_to_query_string(hash)
+      hash.keys.inject('') do |query_string, key|
+        query_string << '&' unless key == hash.keys.first
+        query_string << "#{URI.encode(key.to_s)}=#{CGI.escape(hash[key])}"
+      end
+    end
+
+    def substitute_template_values_from_hash(source_string, prefix, suffix, hash)
+      hash.each { |k, v| source_string.sub!(prefix + k + suffix, v) }
+    end
+  end
+end

data/lib/lti2_commons/lib/lti2_commons/version.rb

@@ -0,0 +1,3 @@
+module Lti2Commons
+  VERSION = '0.0.8'
+end

data/lib/lti2_commons/lib/lti2_commons/wire_log.rb

@@ -0,0 +1,163 @@
+require 'stringio'
+
+module Lti2Commons
+  module WireLogSupport
+    class WireLog
+      STATUS_CODES = {
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',
+
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',
+        226 => 'IM Used',
+
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        422 => 'Unprocessable Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        426 => 'Upgrade Required',
+
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        507 => 'Insufficient Storage',
+        510 => 'Not Extended'
+      }
+
+      attr_accessor :is_logging, :output_file_name
+
+      def initialize(wire_log_name, output_file, is_html_output = true)
+        @output_file_name = output_file
+        @is_logging = true
+        @wire_log_name = wire_log_name
+        @log_buffer = nil
+        @is_html_output = is_html_output
+      end
+
+      def clear_log
+        output_file = File.open(@output_file_name, 'a+')
+        output_file.truncate(0)
+        output_file.close
+      end
+
+      def flush(options = {})
+        output_file = File.open(@output_file_name, 'a+')
+        @log_buffer.rewind
+        buffer = @log_buffer.read
+        if @is_html_output
+          oldbuffer = buffer.dup
+          buffer = ''
+          oldbuffer.each_char do |c|
+            if c == '<'
+              buffer << '&lt;'
+            elsif c == '>'
+              buffer << '&gt;'
+            else
+              buffer << c
+            end
+          end
+        end
+        if options.key? :css_class
+          css_class = options[:css_class]
+        else
+          css_class = "#{@wire_log_name}"
+        end
+        output_file.puts("<div class=\"#{css_class}\"><pre>") if @is_html_output
+        output_file.write(buffer)
+        output_file.puts("\n</div></pre>") if @is_html_output
+        output_file.close
+        @log_buffer = nil
+      end
+
+      def log(s)
+        timestamp
+        raw_log("#{s}")
+        flush
+      end
+
+      def log_response(response, title = nil)
+        timestamp
+        raw_log(title.nil? ? 'Response' : "Response: #{title}")
+        raw_log("Status: #{response.code} #{STATUS_CODES[response.code]}")
+        headers = response.headers
+        unless headers.blank?
+          raw_log('Headers:')
+          headers.each { |k, v| raw_log("#{k}: #{v}") if k.downcase =~ /^content/ }
+        end
+
+        if response.body
+          # the following is expensive so do only when needed
+          raw_log('Body:') if @is_logging
+          begin
+            json_obj = JSON.load(response.body)
+            raw_log(JSON.pretty_generate(json_obj))
+          rescue
+            raw_log("#{response.body}")
+          end
+        end
+        newline
+        flush(css_class: "#{@wire_log_name}Response")
+      end
+
+      def newline
+        raw_log("\n")
+      end
+
+      def log_buffer
+        # put in the css header if file doesn't exist
+        unless File.size? @output_file_name
+          @output_file = File.open(@output_file_name, 'a')
+          @output_file.puts '<link rel="stylesheet" type="text/css" href="wirelog.css" />'
+          @output_file.puts ''
+          @output_file.close
+        end
+        @log_buffer = StringIO.new unless @log_buffer
+        @log_buffer
+      end
+
+      def raw_log(s)
+        @log_buffer = log_buffer
+        @log_buffer.puts(s)
+      end
+
+      def timestamp
+        raw_log(Time.new)
+      end
+    end
+  end
+end

data/lib/lti2_commons/test/test_jsonpath.rb

@@ -0,0 +1,255 @@
+require 'test/unit'
+require 'rubygems'
+require 'json'
+require 'jsonpath'
+
+class TestTree < Test::Unit::TestCase
+  def setup
+    @json_str =
+<<PROXY
+{
+  "@context" : [
+      "http://www.imsglobal.org/imspurl/lti/v2/ctx/ToolProxy",
+      "http://purl.org/blackboard/ctx/v1/iconStyle"
+  ],
+  "@type" : "ToolProxy",
+  "@id" : "http://fabericious..com/ToolProxy/869e5ce5-214c-4e85-86c6-b99e8458a592",
+  "lti_version" : "LTI-2p0",
+  "tool_proxy_guid" : "869e5ce5-214c-4e85-86c6-b99e8458a592",
+  "tool_consumer_profile" : "http://lms.example.com/profile/b6ffa601-ce1d-4549-9ccf-145670a964d4",
+  "tool_profile" : {
+    "lti_version" : "LTI-2p0",
+    "product_instance" : {
+      "guid" : "fd75124a-140e-470f-944c-114d2d92bb40",
+      "product_info" : {
+        "product_name" : {
+          "default_value" : "Acme Assessments",
+          "key" : "tool.name"
+        },
+        "description" : {
+          "default_value" : "Acme Assessments provide an interactive test format.",
+          "key" : "tool.description"
+        },
+        "product_version" : "10.3",
+        "technical_description" : {
+          "default_value" : "Support provided for all LTI 1 extensions as well as LTI 2",
+          "key" : "tool.technical"
+        },
+        "product_family" : {
+          "code" : "assessment-tool",
+          "vendor" : {
+            "code" : "acme.com",
+            "name" : {
+              "default_value" : "Acme",
+              "key" : "tool.vendor.name"
+            },
+            "description" : {
+              "default_value" : "Acme is a leading provider of interactive tools for education",
+              "key" : "tool.vendor.description"
+            },
+            "website" : "http://acme.example.com",
+            "timestamp" : "2012-04-05T09:08:16-04:00",
+            "contact" : {
+              "email" : "info@example.com"
+            }
+          }
+        }
+      },
+      "support" : {
+        "email" : "helpdesk@example.com"
+      },
+      "service_provider" : {
+        "guid" : "18e7ea50-3d6d-4f6b-aff2-ed3ab577716c",
+        "provider_name" : {
+          "default_value" : "Acme Hosting",
+          "key" : "service_provider.name"
+        },
+        "description" : {
+          "default_value" : "Provider of high performance managed hosting environments",
+          "key" : "service_provider.description"
+        },
+        "support" : {
+          "email" : "support@acme-hosting.example.com"
+        },
+        "timestamp" : "2012-04-05T09:08:16-04:00"
+      }
+    },
+    "base_url_choice" : [
+       { "default_base_url" : "http://acme.example.com",
+         "secure_base_url" : "https://acme.example.com",
+         "selector" : {
+           "applies_to" : [
+             "IconEndpoint",
+             "MessageHandler"
+           ]
+         }
+       }
+     ],
+    "resource_handler" : [
+      {
+        "name" : {
+          "default_value" : "Acme Assessment",
+          "key" : "assessment.resource.name"
+        },
+        "description" : {
+          "default_value" : "An interactive assessment using the Acme scale.",
+          "key" : "assessment.resource.description"
+        },
+        "message" : {
+          "message_type" : "basic-lti-launch-request",
+          "path" : "/handler/launchRequest",
+          "capability" : [
+            "Result.autocreate",
+            "Result.sourcedGUID"
+          ],
+          "parameter" : [
+            { "name" : "result_id",
+              "variable" : "$Result.sourcedGUID"
+            },
+            { "name" : "discipline",
+              "fixed" : "chemistry"
+            }
+          ]
+        },
+        "icon_info" : [
+           {
+             "default_location" : {
+               "path" : "/images/bb/en/icon.png"
+             },
+             "key" : "iconStyle.default.path"
+           },
+           { "icon_style" : "BbListElementIcon",
+             "default_location" : {
+               "path" : "/images/bb/en/listElement.png"
+             },
+             "key" : "iconStyle.bb.listElement.path"
+           },
+           { "icon_style" : "BbPushButtonIcon",
+             "default_location" : {
+               "path" : "images/bb/en/pushButton.png"
+             },
+             "key" : "iconStyle.bb.pushButton.path"
+           }
+         ]
+      }
+    ]
+  },
+  "security_contract" : {
+    "shared_secret" : "ThisIsASecret!",
+    "tool_service" : [
+      { "@type" : "RestServiceProfile",
+        "service" : "http://lms.example.com/profile/b6ffa601-ce1d-4549-9ccf-145670a964d4#ToolProxy.collection",
+        "action" : "POST"
+      },
+      { "@type" : "RestServiceProfile",
+        "service" : "http://lms.example.com/profile/b6ffa601-ce1d-4549-9ccf-145670a964d4#ToolProxy.item",
+        "action" : [
+          "GET",
+          "PUT"
+        ]
+      },
+      { "@type" : "RestService",
+        "service" : "http://lms.example.com/profile/b6ffa601-ce1d-4549-9ccf-145670a964d4#Result.item",
+        "action" : [
+          "GET",
+          "PUT"
+        ]
+      }
+    ]
+  }
+}
+PROXY
+
+  @json_obj = JSON.parse(@json_str)
+  end
+
+  # asserts if expected_value is provided, else prints result
+  # useful for preparing new tests
+  def assert_node(jsonpath, expected_value=nil)
+    try_result = JsonPath.new(jsonpath).on(@json_obj)
+    if expected_value
+      assert_equal expected_value, try_result
+    else
+      puts "#{jsonpath}: #{try_result.inspect}"
+    end
+  end
+
+  # asserts if singleton expected_value is provided, else prints result
+  # useful for preparing new tests
+  def assert_first(jsonpath, expected_value=nil)
+    try_result = JsonPath.new(jsonpath).on(@json_obj).first
+    if expected_value
+      assert_equal expected_value, try_result
+    else
+      puts "#{jsonpath}: #{try_result.inspect}"
+    end
+  end
+
+  def test_path_on_json
+    # Note that same result for JSON string or loaded JSON object 
+    assert_equal ["869e5ce5-214c-4e85-86c6-b99e8458a592"], JsonPath.new('tool_proxy_guid').on(@json_str)
+    assert_equal ["869e5ce5-214c-4e85-86c6-b99e8458a592"], JsonPath.new('tool_proxy_guid').on(@json_obj)
+    # assert_node 'tool_proxy_guid'
+    assert_node 'tool_proxy_guid', ["869e5ce5-214c-4e85-86c6-b99e8458a592"]
+  end
+
+  def test_first
+    assert_equal "869e5ce5-214c-4e85-86c6-b99e8458a592", JsonPath.new('tool_proxy_guid').on(@json_str).first
+  end
+
+  def test_basics
+    assert_node 'tool_proxy_guid', ["869e5ce5-214c-4e85-86c6-b99e8458a592"]
+    assert_node 'security_contract.shared_secret', ["ThisIsASecret!"]
+    # 2 dots goes through array(s)
+    assert_node 'tool_profile.base_url_choice..default_base_url', ["http://acme.example.com"]
+    assert_node 'lti_version', ["LTI-2p0"]
+  end
+
+  def test_arrays
+    assert_node "tool_profile.resource_handler[0].message.path", ["/handler/launchRequest"]
+    assert_node 'tool_profile.resource_handler[0].message.message_type', ["basic-lti-launch-request"]
+  end
+
+  def test_filter0
+    # resource_handler = JsonPath.new('tool_profile.resource_handler').on(@json_obj)
+    # assert_node 'tool_profile.resource_handler[?(true)]'
+    # assert_node 'tool_profile.resource_handler.[?(@["message"]["message_type"]=="basic-lti-launch-request")]'
+    #find matching message_type and dig down to get message.path
+    assert_equal "/handler/launchRequest", 
+      JsonPath.new('tool_profile.resource_handler.[?(@["message"]["message_type"]=="basic-lti-launch-request")]').on(@json_obj).first['message']['path']
+
+    # do the same replying JsonPath
+    assert_equal "/handler/launchRequest", JsonPath.new('@..message..path').on(
+      JsonPath.new('tool_profile.resource_handler.[?(@["message"]["message_type"]=="basic-lti-launch-request")]').on(@json_obj)).first
+
+  end
+
+  def test_filter
+    assert_first 'security_contract.tool_service[0].action', "POST"
+    assert_first 'security_contract.tool_service[?(@["action"]=="POST")]', 
+      {"service"=>"http://lms.example.com/profile/b6ffa601-ce1d-4549-9ccf-145670a964d4#ToolProxy.collection", "action"=>"POST", "@type"=>"RestServiceProfile"}
+    # assert_first 'security_contract.tool_service[?(@["action"]=="POST")]'
+    assert_equal "POST", JsonPath.new('security_contract.tool_service[?(@["action"]=="POST")]').on(@json_obj).first['action']
+  end
+
+  def test_enumerate
+    enum = JsonPath.new("$..*")[@json_obj]
+    counter = 0
+    enum.each {|node| counter += 1}
+    assert_equal 114, counter
+  end
+
+  def test_enumerate
+    root = JsonPath.new("$").on(@json_str).first
+    assert_equal ["http://acme.example.com"], JsonPath.new('tool_profile.base_url_choice..default_base_url').on(root)
+  end
+
+  def test_print
+    root = JsonPath.new("$").on(@json_str).first
+    # puts root.to_json
+    puts JSON.pretty_generate root
+  end
+
+  ARGV = ['', "--name", "test_print"]
+  Test::Unit::AutoRunner.run(false, nil, ARGV)
+end