academic_benchmarks 0.0.10 → 1.1.1

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,31 @@
 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
+      alias_method :description, :descr
 
       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,21 @@
+require 'academic_benchmarks/lib/inst_vars_to_hash'
+
+module AcademicBenchmarks
+  module Standards
+    class Number
+      include InstVarsToHash
+
+      attr_accessor :prefix_enhanced
+
+      def self.from_hash(hash)
+        self.new(
+          prefix_enhanced: hash["prefix_enhanced"]
+        )
+      end
+
+      def initialize(prefix_enhanced:)
+        @prefix_enhanced = prefix_enhanced
+      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,51 @@
+require 'academic_benchmarks/lib/attr_to_vals'
 require 'academic_benchmarks/lib/inst_vars_to_hash'
-require 'academic_benchmarks/lib/remove_obsolete_children'
 
 module AcademicBenchmarks
   module Standards
     class Standard
+      include AttrToVals
       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,
+                    :utilizations,
                     :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")
+        @utilizations = attr_to_vals(Utilizations, attributes["utilizations"])
+        @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 +65,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