academic_benchmarks 0.0.11 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3ecf3026a1b108596fe8a1d59915d6c3dff504e0cc1556bd9072e0cbfbf5882
-  data.tar.gz: 3177ee2135a7b5a005de63c40ef5854c40b8e4a7fea73d57ce40e21647491171
+  metadata.gz: '05582989c51ab88e71317ed23866a5dd9c34a956b96791faa86f775c8c09e227'
+  data.tar.gz: c5a713f96b930b2b914674fd57390dd68d0cc8fc9269e3b3503514637d07d746
 SHA512:
-  metadata.gz: 02b49c5ce790e0a0f4555800fd3b59e812c8baa56cac1ca7476273be0c70ae6e82ca02a73df8d908bb132a39f2b758f3e03bd1ac9279fa9a522fdf8ae7e2771d
-  data.tar.gz: a9e5de63ed5d1dc3e885212d38a97bc4a8874c8fbb6834c98708baae639ceddf08ed3ec419428e6c9b67eaf805a093952e71f51517e88c8fb589e40c7e5e00c9
+  metadata.gz: a1cf494c1bde537ad7c8f6f6755ad71196b8946b2087479cefe4c9d5c0fee7c7f4657c14853fd8d26b01c2cd864ed8bb99e931404bd1b7c12ee1d8786b30f087
+  data.tar.gz: bb5bfe960f0182139852c1bc27ccda0cce0ae150e81aa8682c1090390d0412b6326f0000a587d948acee8d05363a9233b5466d7c9686cf27ce6fb7e8ecf66ad0

data/lib/academic_benchmarks/api/auth.rb

@@ -8,10 +8,12 @@ module AcademicBenchmarks
           "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
-        }
+            message: self.message(expires: expires, user_id: user_id)
+          ),
+          "auth.expires" => expires
+        }.tap do |params|
+          params["user.id"] = user_id unless user_id.empty?
+        end
       end
 
       def self.signature_for(partner_key:, message:)

data/lib/academic_benchmarks/api/constants.rb

@@ -2,11 +2,11 @@ module AcademicBenchmarks
   module Api
     module Constants
       def self.base_url
-        'https://api.academicbenchmarks.com/rest/v3'
+        'https://api.abconnect.certicaconnect.com/rest/v4.1'
       end
 
       def self.api_version
-        '3'
+        '4.1'
       end
 
       def self.partner_id_env_var
@@ -20,24 +20,6 @@ module AcademicBenchmarks
       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

@@ -44,30 +44,10 @@ module AcademicBenchmarks
         @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)

data/lib/academic_benchmarks/api/standards.rb

@@ -8,92 +8,73 @@ module AcademicBenchmarks
     class Standards
       DEFAULT_PER_PAGE = 100
 
+      STANDARDS_FIELDS = %w[
+        guid
+        education_levels.grades.code
+        label
+        level
+        section.guid
+        section.descr
+        number.raw
+        number.enhanced
+        status
+        disciplines.subjects.code
+        document.guid
+        document.descr
+        document.adopt_year
+        document.publication.descr
+        document.publication.guid
+        document.publication.authorities
+        statement.descr
+        parent
+      ]
+
       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(', ')}"
-          )
+      # TODO: in the future, support OData filtering for flexible querying
+      def search(authority_guid: nil, publication_guid: nil)
+        raw_search(authority: authority_guid, publication: publication_guid).map do |standard|
+          AcademicBenchmarks::Standards::Standard.new(standard)
         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"])
+      def authorities
+        raw_facet("document.publication.authorities").map do |a|
+          AcademicBenchmarks::Standards::Authority.from_hash(a["data"])
         end
       end
 
-      def all
-        request_search_pages_and_concat_resources(auth_query_params)
-      end
-
-      def authorities(query_params = {})
-        raw_search({list: "authority"}.merge(query_params)).map do |a|
-          AcademicBenchmarks::Standards::Authority.from_hash(a["data"]["authority"])
+      def publications(authority_guid: nil)
+        raw_facet("document.publication", authority: authority_guid).map do |a|
+          AcademicBenchmarks::Standards::Publication.from_hash(a["data"])
         end
       end
 
-      def documents(query_params = {})
-        raw_search({list: "document"}.merge(query_params)).map do |a|
-          AcademicBenchmarks::Standards::Document.from_hash(a["data"]["document"])
-        end
-      end
-
-      def authority_documents(authority_or_auth_code_guid_or_desc)
+      def authority_publications(authority_or_auth_code_guid_or_desc)
         authority = auth_from_code_guid_or_desc(authority_or_auth_code_guid_or_desc)
-        documents(authority: authority.code)
+        publications(authority_guid: authority.guid)
       end
 
       def authority_tree(authority_or_auth_code_guid_or_desc, include_obsolete_standards: true)
         authority = auth_from_code_guid_or_desc(authority_or_auth_code_guid_or_desc)
-        auth_children = search(authority: authority.code)
+        auth_children = raw_search(authority: authority.guid, include_obsoletes: include_obsolete_standards)
         AcademicBenchmarks::Standards::StandardsForest.new(
-          auth_children,
-          include_obsoletes: include_obsolete_standards
+          auth_children
         ).consolidate_under_root(authority)
       end
 
-      def document_tree(document_or_guid, include_obsolete_standards: true)
-        document = doc_from_guid(document_or_guid)
-        doc_children = search(document: document.guid)
+      def publication_tree(publication_or_pub_code_guid_or_desc, include_obsolete_standards: true)
+        publication = pub_from_guid(publication_or_pub_code_guid_or_desc)
+        pub_children = raw_search(publication: publication.guid, include_obsoletes: include_obsolete_standards)
         AcademicBenchmarks::Standards::StandardsForest.new(
-          doc_children,
-          include_obsoletes: include_obsolete_standards
-        ).consolidate_under_root(document)
+          pub_children
+        ).consolidate_under_root(publication)
       end
 
       private
 
-      def doc_from_guid(document_or_guid)
-        if document_or_guid.is_a?(AcademicBenchmarks::Standards::Document)
-          document_or_guid
-        else
-          find_type(type: "document", data: document_or_guid)
-        end
-      end
-
       def auth_from_code_guid_or_desc(authority_or_auth_code_guid_or_desc)
         if authority_or_auth_code_guid_or_desc.is_a?(AcademicBenchmarks::Standards::Authority)
           authority_or_auth_code_guid_or_desc
@@ -102,6 +83,14 @@ module AcademicBenchmarks
         end
       end
 
+      def pub_from_guid(publication_or_pub_code_guid_or_desc)
+        if publication_or_pub_code_guid_or_desc.is_a?(AcademicBenchmarks::Standards::Publication)
+          publication_or_pub_code_guid_or_desc
+        else
+          find_type(type: "publication", data: publication_or_pub_code_guid_or_desc)
+        end
+      end
+
       def find_type(type:, data:)
         matches = send("match_#{type}", data)
         if matches.empty?
@@ -110,7 +99,7 @@ module AcademicBenchmarks
           )
         elsif matches.count > 1
           raise StandardError.new(
-            "Authority code, guid, or description matched more than one authority.  " \
+            "#{type.upcase} code, guid, or description matched more than one #{type}.  " \
             "matched '#{matches.map(&:to_json).join('; ')}'"
           )
         end
@@ -119,22 +108,26 @@ module AcademicBenchmarks
 
       def match_authority(data)
         authorities.select do |auth|
-          auth.code  == data ||
+          auth.acronym  == data ||
           auth.guid  == data ||
           auth.descr == data
         end
       end
 
-      def match_document(data)
-        documents.select { |doc| doc.guid == data }
+      def match_publication(data)
+        publications.select do |pub|
+          pub.acronym == data ||
+          pub.guid == data ||
+          pub.descr == data
+        end
       end
 
-      def raw_search(opts = {})
-        request_search_pages_and_concat_resources(opts.merge(auth_query_params))
+      def raw_facet(facet, query_params = {})
+        request_facet({facet: facet}.merge(query_params).merge(auth_query_params))
       end
 
-      def invalid_search_params(opts)
-        opts.keys.map(&:to_s) - AcademicBenchmarks::Api::Constants.standards_search_params
+      def raw_search(opts = {})
+        request_search_pages_and_concat_resources(opts.merge(auth_query_params))
       end
 
       def auth_query_params
@@ -146,7 +139,41 @@ module AcademicBenchmarks
         )
       end
 
+      def odata_filters(query_params)
+        if query_params.key? :authority
+          value = query_params.delete :authority
+          query_params['filter[standards]'] = "document.publication.authorities.guid eq '#{value}'" if value
+        end
+        if query_params.key? :publication
+          value = query_params.delete :publication
+          query_params['filter[standards]'] = "document.publication.guid eq '#{value}'" if value
+        end
+
+        if query_params.key? :include_obsoletes
+          unless query_params.delete :include_obsoletes
+            if query_params.key? 'filter[standards]'
+              query_params['filter[standards]'] += " and status eq 'active'"
+            else
+              query_params['filter[standards]'] = "status eq 'active'"
+            end
+          end
+        end
+      end
+
+      def request_facet(query_params)
+        odata_filters query_params
+        page = request_page(
+          query_params: query_params,
+          limit: 0, # return no standards since facets are separate
+          offset: 0
+        ).parsed_response
+
+        page.dig("meta", "facets", 0, "details")
+      end
+
       def request_search_pages_and_concat_resources(query_params)
+        query_params['fields[standards]'] = STANDARDS_FIELDS.join(',')
+        odata_filters query_params
         query_params.reverse_merge!({limit: DEFAULT_PER_PAGE})
 
         if !query_params[:limit] || query_params[:limit] <= 0
@@ -161,10 +188,9 @@ module AcademicBenchmarks
           offset: 0
         ).parsed_response
 
-        resources = first_page["resources"]
-        count = first_page["count"]
+        resources = first_page["data"]
+        count = first_page["meta"]["count"]
         offset = query_params[:limit]
-
         while offset < count
           page = request_page(
             query_params: query_params,
@@ -172,7 +198,7 @@ module AcademicBenchmarks
             offset: offset
           )
           offset += query_params[:limit]
-          resources.push(page.parsed_response["resources"])
+          resources.push(page.parsed_response["data"])
         end
 
         resources.flatten
@@ -183,19 +209,29 @@ module AcademicBenchmarks
           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:"
+        1.times do
+          resp = @handle.class.get(
+            '/standards',
+            query: query_params.merge({
+              limit: limit,
+              offset: offset,
+            })
           )
+          if resp.code == 429
+            sleep retry_after(resp)
+            redo
+          end
+          if resp.code != 200
+            raise RuntimeError.new(
+              "Received response '#{resp.code}: #{resp.message}' requesting standards from Academic Benchmarks:"
+            )
+          end
+          return resp
         end
-        resp
+      end
+
+      def retry_after(response)
+        ENV['ACADEMIC_BENCHMARKS_TOO_MANY_REQUESTS_RETRY']&.to_f || 5
       end
     end
   end

data/lib/academic_benchmarks/lib/attr_to_vals.rb

@@ -0,0 +1,7 @@
+module AttrToVals
+  def attr_to_vals(klass, arr)
+    return [] if arr.nil?
+
+    arr.map {|v| klass.from_hash(v)}
+  end
+end

data/lib/academic_benchmarks/lib/inst_vars_to_hash.rb

@@ -19,6 +19,8 @@ module InstVarsToHash
   def to_h(omit_parent: true, omit_empty_children: true)
     retval = {}
     instance_variables.each do |iv|
+      # Don't hashify these attributes, otherwise it can lead to infinite recursion
+      next if %w[@authority @document @publication @section].include? iv.to_s
       if !(skip_parent?(omit_parent, iv) || skip_children?(omit_empty_children, iv))
         retval[iv.to_s.delete('@').to_sym] = elem_to_h(instance_variable_get(iv))
       end

data/lib/academic_benchmarks/standards/authority.rb

@@ -1,30 +1,56 @@
 require 'academic_benchmarks/lib/inst_vars_to_hash'
-require 'academic_benchmarks/lib/remove_obsolete_children'
 
 module AcademicBenchmarks
   module Standards
     class Authority
       include InstVarsToHash
-      include RemoveObsoleteChildren
 
-      attr_accessor :code, :guid, :description, :children
+      attr_accessor :acronym, :descr, :guid, :children
 
-      alias_method :descr, :description
+      alias_method :code, :acronym
+      alias_method :description, :descr
 
       def self.from_hash(hash)
         self.new(
-          code: hash["code"],
+          acronym: hash["acronym"],
           guid: hash["guid"],
-          description: (hash["descr"] || hash["description"])
+          descr: hash["descr"]
         )
       end
 
-      def initialize(code:, guid:, description:, children: [])
-        @code = code
+      def initialize(acronym:, guid:, descr:, children: [])
+        @acronym = acronym
         @guid = guid
-        @description = description
+        @descr = descr
         @children = children
       end
+
+      # Children are standards, so rebranch them so we have
+      # the following structure:
+      #
+      #   Authority -> Publication -> Document -> Section -> Standard
+      def rebranch_children
+        @seen = Set.new()
+        @guid_to_obj = {}
+        new_children = []
+        @children.each do |child|
+          pub = reparent(child.document.publication, new_children)
+          doc = reparent(child.document, pub.children)
+          sec = reparent(child.section, doc.children)
+          sec.children.push(child)
+        end
+        @children.replace(new_children)
+        remove_instance_variable('@seen')
+        remove_instance_variable('@guid_to_obj')
+      end
+
+      private
+
+      def reparent(object, children)
+        cached_object = (@guid_to_obj[object.guid] ||= object)
+        children.push(cached_object) if @seen.add? cached_object.guid
+        cached_object
+      end
     end
   end
 end

data/lib/academic_benchmarks/standards/disciplines.rb

@@ -0,0 +1,21 @@
+require 'academic_benchmarks/lib/attr_to_vals'
+require 'academic_benchmarks/lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Disciplines
+      include AttrToVals
+      include InstVarsToHash
+
+      attr_accessor :subjects
+
+      def self.from_hash(hash)
+        self.new(subjects: hash["subjects"])
+      end
+
+      def initialize(subjects:)
+        @subjects = attr_to_vals(Subject, subjects)
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/document.rb

@@ -1,23 +1,30 @@
 require 'academic_benchmarks/lib/inst_vars_to_hash'
-require 'academic_benchmarks/lib/remove_obsolete_children'
 
 module AcademicBenchmarks
   module Standards
     class Document
       include InstVarsToHash
-      include RemoveObsoleteChildren
 
-      attr_accessor :title, :guid, :children
+      attr_accessor :guid, :descr, :publication, :adopt_year, :children
 
       def self.from_hash(hash)
-        self.new(title: hash["title"], guid: hash["guid"])
+        self.new(guid: hash["guid"], descr: hash["descr"], publication: hash["publication"], adopt_year: hash["adopt_year"])
       end
 
-      def initialize(title:, guid:, children: [])
-        @title = title
+      def initialize(guid:, descr:, publication:, adopt_year:, children: [])
         @guid = guid
+        @descr = descr
+        @publication = attr_to_val_or_nil(Publication, publication)
+        @adopt_year = adopt_year
         @children = children
       end
+
+      private
+
+      def attr_to_val_or_nil(klass, hash)
+        return nil if hash.nil?
+        klass.from_hash(hash)
+      end
     end
   end
 end

data/lib/academic_benchmarks/standards/education_levels.rb

@@ -0,0 +1,21 @@
+require 'academic_benchmarks/lib/attr_to_vals'
+require 'academic_benchmarks/lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class EducationLevels
+      include AttrToVals
+      include InstVarsToHash
+
+      attr_accessor :grades
+
+      def self.from_hash(hash)
+        self.new(grades: hash["grades"])
+      end
+
+      def initialize(grades:)
+        @grades = attr_to_vals(Grade, grades)
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/grade.rb

@@ -5,15 +5,14 @@ module AcademicBenchmarks
     class Grade
       include InstVarsToHash
 
-      attr_accessor :high, :low
+      attr_accessor :code
 
       def self.from_hash(hash)
-        self.new(high: hash["high"], low: hash["low"])
+        self.new(code: hash["code"])
       end
 
-      def initialize(high:, low:)
-        @high = high
-        @low = low
+      def initialize(code:)
+        @code = code
       end
     end
   end

data/lib/academic_benchmarks/standards/number.rb

@@ -0,0 +1,23 @@
+require 'academic_benchmarks/lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Number
+      include InstVarsToHash
+
+      attr_accessor :enhanced, :raw
+
+      def self.from_hash(hash)
+        self.new(
+          enhanced: hash["enhanced"],
+          raw: hash["raw"]
+        )
+      end
+
+      def initialize(enhanced:, raw:)
+        @enhanced = enhanced
+        @raw = raw
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/publication.rb

@@ -0,0 +1,59 @@
+require 'academic_benchmarks/lib/attr_to_vals'
+require 'academic_benchmarks/lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Publication
+      include AttrToVals
+      include InstVarsToHash
+
+      attr_accessor :acronym, :descr, :guid, :authorities, :children
+
+      alias_method :code, :acronym
+      alias_method :description, :descr
+
+      def self.from_hash(hash)
+        self.new(
+          acronym: hash["acronym"],
+          descr: hash["descr"],
+          guid: hash["guid"],
+          authorities: hash["authorities"]
+        )
+      end
+
+      def initialize(acronym:, descr:, guid:, authorities:, children: [])
+        @acronym = acronym
+        @descr = descr
+        @guid = guid
+        @authorities = attr_to_vals(Authority, authorities)
+        @children = children
+      end
+
+      # Children are standards, so rebranch them so we have
+      # the following structure:
+      #
+      #   Publication -> Document -> Section -> Standard
+      def rebranch_children
+        @seen = Set.new()
+        @guid_to_obj = {}
+        new_children = []
+        @children.each do |child|
+          doc = reparent(child.document, new_children)
+          sec = reparent(child.section, doc.children)
+          sec.children.push(child)
+        end
+        @children.replace(new_children)
+        remove_instance_variable('@seen')
+        remove_instance_variable('@guid_to_obj')
+      end
+
+      private
+
+      def reparent(object, children)
+        cached_object = (@guid_to_obj[object.guid] ||= object)
+        children.push(cached_object) if @seen.add? cached_object.guid
+        cached_object
+      end
+    end
+  end
+end

data/lib/academic_benchmarks/standards/section.rb

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

data/lib/academic_benchmarks/standards/standard.rb

@@ -1,80 +1,47 @@
 require 'academic_benchmarks/lib/inst_vars_to_hash'
-require 'academic_benchmarks/lib/remove_obsolete_children'
 
 module AcademicBenchmarks
   module Standards
     class Standard
       include InstVarsToHash
-      include RemoveObsoleteChildren
 
-      attr_reader :status, :deepest, :children
-      attr_writer :grade
-      attr_accessor :guid, :description, :number, :stem, :label, :level,
-                    :version, :seq, :adopt_year, :authority, :course,
-                    :document, :has_relations, :subject, :subject_doc,
+      attr_reader :status, :children
+      attr_writer :education_levels
+      attr_accessor :guid,
+                    :statement,
+                    :number, :stem, :label, :level,
+                    :seq,
+                    :section,
+                    :document, :disciplines,
                     :parent, :parent_guid
 
-      alias_method :descr, :description
-
+      # Before standards are rebranched in Authority#rebranch_children
+      # or Document#rebranch_children, they have the following structure.
+      #
+      # Standard
+      # |-> Document
+      # |   |-> Publication
+      # |       |-> Authority
+      # |-> Section
+      #
       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"]
+        attributes = data["attributes"]
+        @guid = attributes["guid"]
+        @education_levels = attr_to_val_or_nil(EducationLevels, attributes, "education_levels")
+        @label = attributes["label"]
+        @level = attributes["level"]
+        @section = attr_to_val_or_nil(Section, attributes, "section")
+        @number = attr_to_val_or_nil(Number, attributes, "number")
+        @status = attributes["status"]
+        @disciplines = attr_to_val_or_nil(Disciplines, attributes, "disciplines")
         @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
-        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
+        @document = attr_to_val_or_nil(Document, attributes, "document")
+        @statement = attr_to_val_or_nil(Statement, attributes, "statement")
+        @parent_guid = data.dig("relationships", "parent", "data", "id")
       end
 
       alias_method :from_hash, :initialize
 
-      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)
         raise StandardError.new("Tried to add self as a child") if self == child
 
@@ -94,17 +61,13 @@ module AcademicBenchmarks
         @children.count > 0
       end
 
-      def leaf?
-        !has_children?
-      end
-
-      def grade
-        return @grade if @grade
+      def education_levels
+        return @education_levels if @education_levels
 
-        # check to see if one of our parents has a grade.  Use that if so
+        # check to see if one of our parents has education levels.  Use that if so
         p = parent
         while p
-          return p.grade if p.grade
+          return p.education_levels if p.education_levels
           p = p.parent
         end
         nil

data/lib/academic_benchmarks/standards/standards_forest.rb

@@ -1,36 +1,17 @@
 module AcademicBenchmarks
   module Standards
     class StandardsForest
-      attr_reader :trees, :data_hash, :orphans
-
-      # 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,
-        include_obsoletes: true
-      )
-        @data_hash = data_hash.dup.freeze if save_initial_data_hash
+      attr_reader :trees, :orphans
+
+      def initialize(data_hash)
         @guid_to_standard = {} # a hash of guids to standards
         @trees = []
         @orphans = []
         process_items(data_hash)
 
-        @trees.delete_if(&:obsolete?) unless include_obsoletes
-
         # upgrade the hash data to a StandardsTree object
         @trees.map! do |item|
-          StandardsTree.new(
-            item,
-            build_item_hash: save_guid_to_standard_hash,
-            include_obsoletes: include_obsoletes
-          )
+          StandardsTree.new(item)
         end
 
         # We will still have the guid-to-standards saved at the Tree level,
@@ -47,21 +28,6 @@ module AcademicBenchmarks
         StandardsTree.new(root).tap{ |st| st.add_orphans(@orphans) }
       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}"
-          )
-        end
-      end
-
       def single_tree?
         @trees.count == 1
       end

data/lib/academic_benchmarks/standards/standards_tree.rb

@@ -6,40 +6,10 @@ module AcademicBenchmarks
       attr_reader :root, :orphans
       delegate :children, :to_s, :to_h, :to_json, to: :root
 
-      # 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, build_item_hash: true, include_obsoletes: true)
+      def initialize(root)
         @orphans = []
         @root = root
-        prune_obsolete_branches unless include_obsoletes
-
-        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}"
-          )
-        end
+        root.rebranch_children if root.is_a?(Authority) || root.is_a?(Publication)
       end
 
       def add_orphan(orphan)
@@ -53,37 +23,6 @@ module AcademicBenchmarks
       def has_orphans?
         @orphans.present?
       end
-
-      private
-
-      def go_ahead_and_build_item_hash
-        @item_hash[@root.guid] = @root
-        add_children_to_item_hash(@root)
-      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 if @root.guid == standard.parent_guid
-        check_children_for_parent(standard.parent_guid, @root)
-      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
-
-      def prune_obsolete_branches
-        root.remove_obsolete_children
-      end
     end
   end
 end

data/lib/academic_benchmarks/standards/statement.rb

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

data/lib/academic_benchmarks/standards/subject.rb

@@ -5,15 +5,14 @@ module AcademicBenchmarks
     class Subject
       include InstVarsToHash
 
-      attr_accessor :code, :broad
+      attr_accessor :code
 
       def self.from_hash(hash)
-        self.new(code: hash["code"], broad: hash["broad"], )
+        self.new(code: hash["code"])
       end
 
-      def initialize(code:, broad:)
+      def initialize(code:)
         @code = code
-        @broad = broad
       end
     end
   end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: academic_benchmarks
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 1.0.0
 platform: ruby
 authors:
 - Benjamin Porter
+- Augusto Callejas
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -44,6 +45,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: hash_dig_and_collect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,14 +121,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.22'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.22'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -158,7 +173,9 @@ dependencies:
         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
+email:
+- bporter@instructure.com
+- acallejas@instructure.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -168,19 +185,21 @@ files:
 - lib/academic_benchmarks/api/constants.rb
 - lib/academic_benchmarks/api/handle.rb
 - lib/academic_benchmarks/api/standards.rb
+- lib/academic_benchmarks/lib/attr_to_vals.rb
 - lib/academic_benchmarks/lib/inst_vars_to_hash.rb
-- lib/academic_benchmarks/lib/remove_obsolete_children.rb
 - lib/academic_benchmarks/standards/authority.rb
-- lib/academic_benchmarks/standards/course.rb
+- lib/academic_benchmarks/standards/disciplines.rb
 - lib/academic_benchmarks/standards/document.rb
+- lib/academic_benchmarks/standards/education_levels.rb
 - lib/academic_benchmarks/standards/grade.rb
-- lib/academic_benchmarks/standards/has_relations.rb
-- lib/academic_benchmarks/standards/parent.rb
+- lib/academic_benchmarks/standards/number.rb
+- lib/academic_benchmarks/standards/publication.rb
+- lib/academic_benchmarks/standards/section.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/statement.rb
 - lib/academic_benchmarks/standards/subject.rb
-- lib/academic_benchmarks/standards/subject_doc.rb
 homepage: https://github.com/instructure/academic_benchmarks
 licenses:
 - AGPL-3.0
@@ -200,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A ruby api for accessing the Academic Benchmarks API

data/lib/academic_benchmarks/lib/remove_obsolete_children.rb

@@ -1,10 +0,0 @@
-module RemoveObsoleteChildren
-  def remove_obsolete_children
-    @children.delete_if do |child|
-      unless child.obsolete?
-        child.remove_obsolete_children
-      end
-      child.obsolete?
-    end
-  end
-end

data/lib/academic_benchmarks/standards/course.rb

@@ -1,22 +0,0 @@
-require 'academic_benchmarks/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/has_relations.rb

@@ -1,21 +0,0 @@
-require 'academic_benchmarks/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

@@ -1,41 +0,0 @@
-require 'academic_benchmarks/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/subject_doc.rb

@@ -1,22 +0,0 @@
-require 'academic_benchmarks/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