academic_benchmarks 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c13cf6be09fd07cb0109d047e350f67b5d4cbc26
+  data.tar.gz: 64e6b5f20059e2d4a3cb9fa80e2fb646368eb8bd
+SHA512:
+  metadata.gz: 3dd28dee3d000f68bedf3b0f096ad3373946fd908bb38ed0eec10d6900d8fc0851243df23eed7dca4354a4b4a698f5542d4eff0ce7158e58b3fb70840becb1d3
+  data.tar.gz: b9064ef02deddcef55face091a4212ce4e83a6b4f83189428ad5b9eb75b22d184404a43a17195ee463db3b7353701b98b07fe191dc7f1541ff2037b0cc10be48

data/lib/academic_benchmarks.rb

@@ -0,0 +1,13 @@
+require 'httparty'
+require 'json'
+require 'base64'
+require 'openssl'
+
+begin
+  require 'byebug'
+rescue LoadError => e
+end
+
+Gem.find_files("academic_benchmarks/**/*.rb").each do |path|
+  require path.gsub(/\.rb$/, '')
+end

data/lib/academic_benchmarks/api/auth.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/numeric/time'
+
+module AcademicBenchmarks
+  module Api
+    module Auth
+      def self.auth_query_params(partner_id:, partner_key:, expires:, user_id: "")
+        {
+          "partner.id" => partner_id,
+          "auth.signature" => signature_for(
+            partner_key: partner_key,
+            message: self.message(expires: expires, user_id: user_id)),
+          "auth.expires" => expires,
+          "user.id" => user_id
+        }
+      end
+
+      def self.signature_for(partner_key:, message:)
+        Base64.encode64(OpenSSL::HMAC.digest(
+          OpenSSL::Digest.new('sha256'),
+          partner_key,
+          message
+        )).chomp
+      end
+
+      def self.message(expires:, user_id: '')
+        if user_id.empty?
+          "#{expires}"
+        else
+          "#{expires}\n#{user_id}"
+        end
+      end
+
+      def self.expire_time_in_10_seconds
+        self.expire_time_in(10.seconds)
+      end
+
+      def self.expire_time_in_2_hours
+        self.expire_time_in(2.hours)
+      end
+
+      def self.expire_time_in(offset)
+        Time.now.to_i + offset
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/api/constants.rb

@@ -0,0 +1,43 @@
+module AcademicBenchmarks
+  module Api
+    module Constants
+      def self.base_url
+        'https://api.academicbenchmarks.com/rest/v3'
+      end
+
+      def self.api_version
+        '3'
+      end
+
+      def self.partner_id_env_var
+        'ACADEMIC_BENCHMARKS_PARTNER_ID'
+      end
+
+      def self.partner_key_env_var
+        'ACADEMIC_BENCHMARKS_PARTNER_KEY'
+      end
+
+      def self.user_id_env_var
+        'ACADEMIC_BENCHMARKS_USER_ID'
+      end
+
+      def self.standards_search_params
+        %w[
+          query
+          authority
+          subject
+          grade
+          subject_doc
+          course
+          document
+          parent
+          deepest
+          limit
+          offset
+          list
+          fields
+        ]
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/api/handle.rb

@@ -0,0 +1,92 @@
+require_relative 'constants'
+require_relative 'standards'
+
+module AcademicBenchmarks
+  module Api
+    class Handle
+      include HTTParty
+
+      attr_accessor :partner_id, :partner_key
+
+      attr_reader :user_id # user_id writer is defined below
+
+      base_uri AcademicBenchmarks::Api::Constants.base_url
+
+      # Allows the user to initialize from environment variables
+      def self.init_from_env
+        partner_id  = partner_id_from_env
+        partner_key = partner_key_from_env
+
+        if !partner_id.present? || !partner_key.present?
+          pidstr = !partner_id.present? ?
+            AcademicBenchmarks::Api::Constants.partner_id_env_var : ""
+          pkystr = !partner_key.present? ?
+            AcademicBenchmarks::Api::Constants.partner_key_env_var : ""
+          raise StandardError.new(
+            "Missing environment variable(s): #{[pidstr, pkystr].join(', ')}"
+          )
+        end
+
+        new(
+          partner_id: partner_id,
+          partner_key: partner_key,
+          user_id: user_id_from_env
+        )
+      end
+
+      def initialize(partner_id:, partner_key:, user_id: "")
+        @partner_id = partner_id
+        @partner_key = partner_key
+        @user_id = user_id.to_s
+      end
+
+      def user_id=(user_id)
+        @user_id = user_id.to_s
+      end
+
+      def related(guid:, fields: [])
+        raise StandardError.new("Sorry, not implemented yet!")
+      end
+
+      def standards
+        Standards.new(self)
+      end
+
+      def assets
+        raise StandardError.new("Sorry, not implemented yet!")
+      end
+
+      def alignments
+        raise StandardError.new("Sorry, not implemented yet!")
+      end
+
+      def topics
+        raise StandardError.new("Sorry, not implemented yet!")
+      end
+
+      def special
+        raise StandardError.new("Sorry, not implemented yet!")
+      end
+
+      private
+
+      def api_resp_to_array_of_standards(api_resp)
+        api_resp.parsed_response["resources"].inject([]) do |retval, resource|
+          retval.push(AcademicBenchmarks::Standards::Standard.new(resource["data"]))
+        end
+      end
+
+      def self.partner_id_from_env
+        ENV[AcademicBenchmarks::Api::Constants.partner_id_env_var]
+      end
+
+      def self.partner_key_from_env
+        ENV[AcademicBenchmarks::Api::Constants.partner_key_env_var]
+      end
+
+      def self.user_id_from_env
+        ENV[AcademicBenchmarks::Api::Constants.user_id_env_var]
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/api/standards.rb

@@ -0,0 +1,128 @@
+require 'active_support/hash_with_indifferent_access'
+
+require_relative 'auth'
+require_relative 'constants'
+
+module AcademicBenchmarks
+  module Api
+    class Standards
+      DEFAULT_PER_PAGE = 100
+
+      def initialize(handle)
+        @handle = handle
+      end
+
+      def search(opts = {})
+        # query: "", authority: "", subject: "", grade: "", subject_doc: "", course: "",
+        # document: "", parent: "", deepest: "", limit: -1, offset: -1, list: "", fields: []
+        invalid_params = invalid_search_params(opts)
+        if invalid_params.empty?
+          raw_search(opts).map do |standard|
+            AcademicBenchmarks::Standards::Standard.new(standard)
+          end
+        else
+          raise ArgumentError.new(
+            "Invalid search params: #{invalid_params.join(', ')}"
+          )
+        end
+      end
+
+      alias_method :where, :search
+
+      def guid(guid, fields: [])
+        query_params = if fields.empty?
+                         auth_query_params
+                       else
+                         auth_query_params.merge({
+                           fields: fields.join(",")
+                         })
+                       end
+        @handle.class.get(
+          "/standards/#{guid}",
+          query: query_params
+        ).parsed_response["resources"].map do |r|
+          AcademicBenchmarks::Standards::Standard.new(r["data"])
+        end
+      end
+
+      def all
+        request_search_pages_and_concat_resources(auth_query_params)
+      end
+
+      def authorities
+        raw_search(list: "authority").map{|a| a["data"]["authority"]}.map{|a| AcademicBenchmarks::Standards::Authority.from_hash(a)}
+      end
+
+      private
+
+      def raw_search(opts = {})
+        request_search_pages_and_concat_resources(opts.merge(auth_query_params))
+      end
+
+      def invalid_search_params(opts)
+        opts.keys.map(&:to_s) - AcademicBenchmarks::Api::Constants.standards_search_params
+      end
+
+      def auth_query_params
+        AcademicBenchmarks::Api::Auth.auth_query_params(
+          partner_id: @handle.partner_id,
+          partner_key: @handle.partner_key,
+          expires: AcademicBenchmarks::Api::Auth.expire_time_in_2_hours,
+          user_id: @handle.user_id
+        )
+      end
+
+      def request_search_pages_and_concat_resources(query_params)
+        query_params.reverse_merge!({limit: DEFAULT_PER_PAGE})
+
+        if !query_params[:limit] || query_params[:limit] <= 0
+          raise ArgumentError.new(
+            "limit must be specified as a positive integer"
+          )
+        end
+
+        first_page = request_page(
+          query_params: query_params,
+          limit: query_params[:limit],
+          offset: 0
+        ).parsed_response
+
+        resources = first_page["resources"]
+        count = first_page["count"]
+        offset = query_params[:limit]
+
+        while offset < count
+          page = request_page(
+            query_params: query_params,
+            limit: query_params[:limit],
+            offset: offset
+          )
+          offset += query_params[:limit]
+          resources.push(page.parsed_response["resources"])
+        end
+
+        resources.flatten
+      end
+
+      def request_page(query_params:, limit:, offset:)
+        query_params.merge!({
+          limit: limit,
+          offset: offset,
+        })
+        resp = @handle.class.get(
+          '/standards',
+          query: query_params.merge({
+            limit: limit,
+            offset: offset,
+          })
+        )
+        if resp.code != 200
+          raise RuntimeError.new(
+            "Received response '#{resp.code}: #{resp.message}' requesting standards from Academic Benchmarks:"
+          )
+        end
+        resp
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/lib/inst_vars_to_hash.rb

@@ -0,0 +1,14 @@
+
+module InstVarsToHash
+  def to_s
+    to_h.to_s
+  end
+
+  def to_h
+    retval = {}
+    instance_variables.each do |iv|
+      retval[iv.to_s.gsub('@', '').to_sym] = instance_variable_get(iv)
+    end
+    retval
+  end
+end

data/lib/academic_benchmarks/standards/authority.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Authority
+      include InstVarsToHash
+
+      attr_accessor :code, :guid, :description
+
+      alias_method :descr, :description
+
+      def self.from_hash(hash)
+        self.new(code: hash["code"], guid: hash["guid"], description: hash["descr"])
+      end
+
+      def initialize(code:, guid:, description:)
+        @code = code
+        @guid = guid
+        @description = description
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/course.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Course
+      include InstVarsToHash
+
+      attr_accessor :guid, :description
+
+      alias_method :descr, :description
+
+      def self.from_hash(hash)
+        self.new(description: hash["descr"], guid: hash["guid"])
+      end
+
+      def initialize(guid:, description:)
+        @guid = guid
+        @description = description
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/document.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Document
+      include InstVarsToHash
+
+      attr_accessor :title, :guid
+
+      def self.from_hash(hash)
+        self.new(title: hash["title"], guid: hash["guid"])
+      end
+
+      def initialize(title:, guid:)
+        @title = title
+        @guid = guid
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/grade.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Grade
+      include InstVarsToHash
+
+      attr_accessor :high, :low
+
+      def self.from_hash(hash)
+        self.new(high: hash["high"], low: hash["low"])
+      end
+
+      def initialize(high:, low:)
+        @high = high
+        @low = low
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/has_relations.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class HasRelations
+      include InstVarsToHash
+
+      attr_accessor :origin, :derivative, :related_derivative
+
+      def self.from_hash(hash)
+        self.new(derivative: hash["derivative"], origin: hash["origin"], related_derivative: hash["related_derivative"])
+      end
+
+      def initialize(origin: 0, derivative: 0, related_derivative: 0)
+        @origin = origin
+        @derivative = derivative
+        @related_derivative = related_derivative
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/parent.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Parent
+      include InstVarsToHash
+
+      attr_accessor :guid, :description, :number, :stem, :label, :deepest,
+                    :seq, :level, :status, :version
+
+      def self.from_hash(hash)
+        self.new(
+          guid: hash["guid"],
+          description: hash["description"],
+          number: hash["number"],
+          stem: hash["stem"],
+          label: hash["label"],
+          deepest: hash["deepest"],
+          seq: hash["seq"],
+          level: hash["level"],
+          status: hash["status"],
+          version: hash["version"]
+        )
+      end
+
+      def initialize(guid:, description:, number:, stem:, label:, deepest:,
+                     seq:, level:, status:, version:)
+        @guid = guid
+        @description = description
+        @number = number
+        @stem = stem
+        @label = label
+        @deepest = deepest
+        @seq = seq
+        @level = level
+        @status = status
+        @version = version
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/standard.rb

@@ -0,0 +1,96 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Standard
+      include InstVarsToHash
+
+      attr_reader :status, :deepest, :children
+      attr_accessor :guid, :description, :number, :stem, :label, :level,
+                    :version, :seq, :adopt_year, :authority, :course,
+                    :document, :grade, :has_relations, :subject,
+                    :subject_doc, :parent, :parent_guid
+
+      alias_method :descr, :description
+
+      def initialize(data)
+        data = data["data"] if data["data"]
+        @guid = data["guid"]
+        @grade = attr_to_val_or_nil(Grade, data, "grade")
+        @label = data["label"]
+        @level = data["level"]
+        @course = attr_to_val_or_nil(Course, data, "course")
+        @number = data["number"]
+        @status = data["status"]
+        @parent = nil
+        @subject = attr_to_val_or_nil(Subject, data, "subject")
+        @deepest = data["deepest"]
+        @version = data["version"]
+        @children = []
+        @document = attr_to_val_or_nil(Document, data, "document")
+        @authority = attr_to_val_or_nil(Authority, data, "authority")
+        @adopt_year = data["adopt_year"]
+        @description = data["descr"]
+        @subject_doc = attr_to_val_or_nil(SubjectDoc, data, "subject_doc")
+        @has_relations = attr_to_val_or_nil(HasRelations, data, "has_relations")
+
+        # Parent guid extraction can be a little more complicated. Thanks AB!
+        if data["parent"] && data["parent"].is_a?(String)
+          @parent_guid = data["parent"]
+        elsif data["parent"] && data["parent"].is_a?(Hash)
+          @parent_guid = data["parent"]["guid"]
+        end
+      end
+
+      def active?
+        status == "Active"
+      end
+
+      def obsolete?
+        status == "Obsolete"
+      end
+
+      def deepest?
+        deepest == 'Y'
+      end
+
+      def status=(status)
+        unless %w[Active Obsolete].include?(status)
+          raise ArgumentError.new(
+            "Standard status must be either 'Active' or 'Obsolete'"
+          )
+        end
+        @status = status
+      end
+
+      def deepest=(deepest)
+        unless %w[Y N].include?(deepest)
+          raise ArgumentError.new("Standard deepest must be either 'Y' or 'N'")
+        end
+        @deepest = deepest
+      end
+
+      def add_child(child)
+        unless child.is_a?(Standard)
+          raise ArgumentError.new("Tried to set child that isn't a Standard")
+        end
+        @children.push(child)
+      end
+
+      def remove_child(child)
+        @children.delete(child)
+      end
+
+      def has_children?
+        @children.count > 0
+      end
+
+      private
+
+      def attr_to_val_or_nil(klass, hash, attr)
+        return nil unless hash.has_key?(attr)
+        klass.from_hash(hash)
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/standards_forest.rb

@@ -0,0 +1,97 @@
+module AcademicBenchmarks
+  module Standards
+    class StandardsForest
+      attr_reader :trees, :data_hash
+
+      # The guid to standard hash can optionally be saved to permit speedily
+      # adding standards to the tree (since the tree is unordered,
+      # this would otherwise be an expensive operation).
+      #
+      # The initial data hash can also be optionally saved to
+      # permit testing and internal consistency checks
+
+      def initialize(
+        data_hash,
+        save_guid_to_standard_hash: true,
+        save_initial_data_hash: false
+      )
+        @data_hash = data_hash.dup.freeze if save_initial_data_hash
+        @guid_to_standard = {} # a hash of guids to standards
+        @trees = []
+        process_items(data_hash)
+
+        # upgrade the hash data to a StandardsTree object
+        @trees.map! do |item|
+          StandardsTree.new(item, build_item_hash: save_guid_to_standard_hash)
+        end
+
+        unless save_guid_to_standard_hash
+          remove_instance_variable('@guid_to_standard')
+        end
+      end
+
+      def add_standard(standard)
+        if standard.is_a?(Standard)
+          raise StandardError.new(
+            "adding standards is not currently implemented"
+          )
+        elsif standard.is_a?(Hash)
+          add_standard(Standard.new(standard))
+        else
+          raise ArgumentError.new(
+            "standard must be an 'AcademicBenchmarks::Standards::Standard' " \
+            "or a 'Hash' but was a #{standard.class.to_s}"
+          )
+        end
+      end
+
+      def single_tree?
+        @trees.count == 1
+      end
+
+      def empty?
+        @trees.empty?
+      end
+
+      private
+
+      def to_standard(item)
+        return item if item.is_a?(Standard)
+        Standard.new(item)
+      end
+
+      def process_items(data_hash)
+        build_guid_to_standard_hash(data_hash)
+        link_parent_and_children
+      end
+
+      def build_guid_to_standard_hash(data_hash)
+        data_hash.each do |item|
+          item = to_standard(item)
+          @guid_to_standard[item.guid] = item
+        end
+      end
+
+      def link_parent_and_children
+        @guid_to_standard.values.each do |child|
+          if child.parent_guid
+            present_in_hash_or_raise(child.parent_guid)
+            parent = @guid_to_standard[child.parent_guid]
+            parent.add_child(child)
+            child.parent = parent
+          else
+            @trees.push(child)
+          end
+        end
+      end
+
+      def present_in_hash_or_raise(guid)
+        unless @guid_to_standard.has_key?(guid)
+          raise StandardError.new(
+            "item missing from guid_to_standard hash"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/standards_tree.rb

@@ -0,0 +1,67 @@
+module AcademicBenchmarks
+  module Standards
+    class StandardsTree
+      attr_reader :root_standard
+
+      # The item hash can optionally be built to permit the speedy
+      # addition of standards to the tree. since the tree is unordered,
+      # adding to it can be expensive without this
+
+      def initialize(root_standard, build_item_hash: true)
+        @root_standard = root_standard
+        if build_item_hash
+          @item_hash = {}
+          go_ahead_and_build_item_hash
+        end
+      end
+
+      def add_standard(standard)
+        if standard.is_a?(Standard)
+          parent = @item_hash ? @item_hash[standard.parent_guid] : find_parent(standard)
+          unless parent
+            raise StandardError.new(
+              "Parent of standard not found in tree. Parent guid is " \
+              "'#{standard.parent_guid}' and child guid is '#{standard.guid}'"
+            )
+          end
+          parent.add_child(standard)
+          standard.parent = parent
+        elsif standard.is_a?(Hash)
+          add_standard(Standard.new(standard))
+        else
+          raise ArgumentError.new(
+            "standard must be an 'AcademicBenchmarks::Standards::Standard' " \
+            "or a 'Hash' but was a #{standard.class.to_s}"
+          )
+        end
+      end
+
+      private
+
+      def go_ahead_and_build_item_hash
+        @item_hash[@root_standard.guid] = @root_standard
+        add_children_to_item_hash(@root_standard)
+      end
+
+      def add_children_to_item_hash(parent)
+        parent.children.each do |child|
+          @item_hash[child.guid] = child
+          add_children_to_item_hash(child) if child.has_children?
+        end
+      end
+
+      def find_parent(standard)
+        return @root_standard if @root_standard.guid == standard.parent_guid
+        check_children_for_parent(standard.parent_guid, @root_standard)
+      end
+
+      # does a depth-first search
+      def check_children_for_parent(parent_guid, standard)
+        standard.children.each do |child|
+          return child if child.guid == parent_guid
+          check_children_for_parent(parent_guid, child) if child.has_children?
+        end
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/subject.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Subject
+      include InstVarsToHash
+
+      attr_accessor :code, :broad
+
+      def self.from_hash(hash)
+        self.new(code: hash["code"], broad: hash["broad"], )
+      end
+
+      def initialize(code:, broad:)
+        @code = code
+        @broad = broad
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/subject_doc.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class SubjectDoc
+      include InstVarsToHash
+
+      attr_accessor :guid, :description
+
+      alias_method :descr, :description
+
+      def self.from_hash(hash)
+        self.new(guid: hash["guid"], description: hash["descr"])
+      end
+
+      def initialize(guid:, description:)
+        @guid = guid
+        @description = description
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: academic_benchmarks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Benjamin Porter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: A ruby api for accessing the Academic Benchmarks API.  A valid subscription
+  with accompanying credentials will be required to access the API
+email: bporter@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/academic_benchmarks.rb
+- lib/academic_benchmarks/api/auth.rb
+- lib/academic_benchmarks/api/constants.rb
+- lib/academic_benchmarks/api/handle.rb
+- lib/academic_benchmarks/api/standards.rb
+- lib/academic_benchmarks/lib/inst_vars_to_hash.rb
+- lib/academic_benchmarks/standards/authority.rb
+- lib/academic_benchmarks/standards/course.rb
+- lib/academic_benchmarks/standards/document.rb
+- lib/academic_benchmarks/standards/grade.rb
+- lib/academic_benchmarks/standards/has_relations.rb
+- lib/academic_benchmarks/standards/parent.rb
+- lib/academic_benchmarks/standards/standard.rb
+- lib/academic_benchmarks/standards/standards_forest.rb
+- lib/academic_benchmarks/standards/standards_tree.rb
+- lib/academic_benchmarks/standards/subject.rb
+- lib/academic_benchmarks/standards/subject_doc.rb
+homepage: https://github.com/instructure/academic_benchmarks
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.3
+signing_key: 
+specification_version: 4
+summary: A ruby api for accessing the Academic Benchmarks API
+test_files: []
+has_rdoc: