Replace open structs with structs

Author: steve-sullivan

config/config.rb

@@ -4,26 +4,113 @@
 require 'yaml'
 require 'json'
 require 'logger'
-require 'ostruct'
 require_relative '../lib/docker'
 
 # NOTE: dotenv/load must come after ../lib/docker
 require 'dotenv/load'
-# I think I need to only call this if we're NOT running in a container:
-# require 'dotenv/load' unless Docker.running_in_container?
 
 # Config class to hold/manage our configuration
 class Config
-  # Load the ENV vars
-  Docker::Secret.setup_environment!
+  # Define your Structs for Secrets:
+  Ucpath = Struct.new(:root, :id, :key, keyword_init: true)
+  Sis = Struct.new(:root, :id, :key, keyword_init: true)
+  Ldap = Struct.new(:host, :pass, keyword_init: true)
+  Secrets = Struct.new(:ucpath, :sis, :ldap, keyword_init: true)
 
-  # Secrets (passwords, api keys, etc...): Uses ERB for ENV variables
-  @secrets = JSON.parse(YAML.safe_load(ERB.new(File.read('config/secrets.yml')).result).to_json,
-                        object_class: OpenStruct)
+  class << self
+    attr_reader :secrets, :settings, :help
+
+    def load!
+      # Load the ENV vars
+      Docker::Secret.setup_environment!
+
+      load_settings!('config/settings.yml')
+      load_secrets!('config/secrets.yml')
+    end
+
+    # Returns specified field value from settings.yml
+    def setting(field)
+      @settings[field.to_sym]
+    end
+
+    def ucpath_employee_fields
+      @ucpath_fields['employee']['fields']
+    end
+
+    def sis_fields
+      @sis_fields['SIS']['fields']
+    end
+
+    def ucpath_job_fields
+      @ucpath_fields['job']['fields']
+    end
+
+    def student_affiated?(affiliation)
+      @ldap_fields['student_affiliation'].include? affiliation
+    end
+
+    def ldap_attributes
+      @ldap_fields['attributes']
+    end
+
+    def check_ucpath_code(type, value)
+      @ucpath_codes[type].include? value
+    end
+
+    private
+
+    def load_settings!(path)
+      raw = yaml_with_erb(path)
+
+      # Load those config settings from the yaml hash:
+      @settings = create_struct_from_hash(
+        name: 'Settings',
+        hash: raw.fetch('settings')
+      )
+
+      # keep help separate...it's just a string
+      @help = raw['help']
+    end
+
+    def load_secrets!(path)
+      raw = yaml_with_erb(path)
+
+      @secrets = Secrets.new(
+        ucpath: Ucpath.new(**symbolize(raw.fetch('ucpath'))),
+        sis: Sis.new(**symbolize(raw.fetch('sis'))),
+        ldap: Ldap.new(**symbolize(raw.fetch('ldap')))
+      )
+
+      # Over-ride the LDAP host if we're in CI land... JUST to make
+      # sure we don't hit the actual host when we're running rspec!
+      @secrets.ldap.host = 'ldap.fake.edu' if ENV['CI']
+    end
+
+    def symbolize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+
+    def yaml_with_erb(path)
+      YAML.safe_load(ERB.new(File.read(path)).result)
+    end
+
+    # Since settings isn't nested hash of hashes easy enough to create this struct dynamically:
+    def create_struct_from_hash(name:, hash:)
+      # Since Structs need symbols....
+      sym_hash = hash.transform_keys(&:to_sym)
+
+      struct_class = if const_defined?(name, false)
+                       const_get(name)
+                     else
+                       const_set(name, Struct.new(*sym_hash.keys, keyword_init: true))
+                     end
+
+      struct_class.new(**sym_hash)
+    end
+  end
 
-  # General Settings: Uses ERB for ENV variables
-  @settings = JSON.parse(YAML.safe_load(ERB.new(File.read('config/settings.yml')).result).to_json,
-                         object_class: OpenStruct)
+  # Let's do this!!!!
+  load!
 
   ucpath_contents = File.read('config/ucpath_fields.yml')
   @ucpath_fields = YAML.safe_load(ERB.new(ucpath_contents).result)
@@ -36,42 +123,4 @@ class Config
 
   sis_contents = File.read('config/sis_fields.yml')
   @sis_fields = YAML.safe_load(ERB.new(sis_contents).result)
-
-  # Over-ride the LDAP host if we're in CI land... JUST to make
-  # sure we don't hit the actual host when we're running rspec!
-  @secrets.ldap.host = 'ldap.fake.edu' if ENV['CI']
-
-  # Returns ostruct of the secrets yaml file
-  class << self
-    attr_reader :secrets
-  end
-
-  def self.ucpath_employee_fields
-    @ucpath_fields['employee']['fields']
-  end
-
-  def self.sis_fields
-    @sis_fields['SIS']['fields']
-  end
-
-  def self.ucpath_job_fields
-    @ucpath_fields['job']['fields']
-  end
-
-  def self.student_affiated?(affiliation)
-    @ldap_fields['student_affiliation'].include? affiliation
-  end
-
-  def self.check_ucpath_code(type, value)
-    @ucpath_codes[type].include? value
-  end
-
-  # Returns specified field value from settings.yml
-  def self.setting(field)
-    @settings.settings[field] || nil
-  end
-
-  def self.help
-    @settings.help
-  end
 end

config/ldap_fields.yml

@@ -1,28 +1,28 @@
 attributes:
-  - berkeleyEduExpDate
-  - berkeleyEduHCMID
-  - berkeleyEduAffID
-  - berkeleyEduAffiliations
-  - berkeleyEduBirthDay
-  - berkeleyEduBirthMonth
-  - berkeleyEduBirthYear
-  - berkeleyEduAlternateID
-  - berkeleyEduCSID
-  - berkeleyEduEmpTitleCode
-  - berkeleyEduEmpDeptUnitTitleCode
-  - berkeleyEduKerberosPrincipalString
-  - berkeleyEduStuID
-  - employeeNumber
-  - employeeType
+  - berkeleyeduexpdate
+  - berkeleyeduhcmid
+  - berkeleyeduaffid
+  - berkeleyeduaffiliations
+  - berkeleyedubirthday
+  - berkeleyedubirthmonth
+  - berkeleyedubirthyear
+  - berkeleyedualternateid
+  - berkeleyeducsid
+  - berkeleyeduemptitlecode
+  - berkeleyeduempdeptunittitlecode
+  - berkeleyedukerberosprincipalstring
+  - berkeleyedustuid
+  - employeenumber
+  - employeetype
   - uid
-  - berkeleyEduUnitHRDeptName
-  - givenName
+  - berkeleyeduunithrdeptname
+  - givenname
   - sn
-  - berkeleyEduOfficialEmail
-  - berkeleyEduPrimaryDeptUnit
-  - postalAddress
-  - postalCode
-  - telephoneNumber
+  - berkeleyeduofficialemail
+  - berkeleyeduprimarydeptunit
+  - postaladdress
+  - postalcode
+  - telephonenumber
   - mail
 
 student_affiliation:

config/settings.yml

@@ -6,7 +6,7 @@ settings:
   upload_host: "upload.lib.berkeley.edu"
   upload_user: "ssullivan"
   last_alma_purge: "2023-06-30"
-  application_version: "1.6.4"
+  application_version: "1.6.5"
 
 # TODO - flesh this out
 # http://docopt.org/

config/ucpath_fields.yml

@@ -91,16 +91,6 @@ job:
       dbdef: "VARCHAR(16)"
       status: OPTIONAL
 
-    - name: job_code
-      jpath: "$.position.jobCode.code.code"
-      dbdef: "VARCHAR(16)"
-      status: OPTIONAL
-
-    - name: dept_code
-      jpath: "$.department.code"
-      dbdef: "VARCHAR(16)"
-      status: OPTIONAL
-
     - name: dept_desc
       jpath: "$.department.description"
       dbdef: "VARCHAR(64)"

lib/ldap/api.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 require 'net/ldap'
 
 module LDAP
-  # Fetches an LDAP record by UID returns an ostruct
+  # Fetches an LDAP record by UID returns an struct
   module API
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def fetch_ldap_rec(id)
-      ldap_rec = OpenStruct.new
+      ldap_rec = ldap_struct_class.new
+
       filter = Net::LDAP::Filter.eq('uid', id)
 
       # Track number of attempts incase of a timeout or other temporary glitch
@@ -23,7 +23,12 @@ def fetch_ldap_rec(id)
         ldap.bind
         ldap.search(base: base, filter: filter) do |entry|
           entry.each do |attribute, values|
-            ldap_rec[attribute] = values
+
+            # Only grab the LDAP fields we care about....
+            attr_sym = attribute.to_sym
+            next unless ldap_rec.members.include?(attr_sym)
+
+            ldap_rec[attr_sym] = values
           end
         end
       rescue StandardError => e
@@ -63,5 +68,13 @@ def base
     def pass
       Config.secrets.ldap.pass
     end
+
+    # Define the LDAP Struct from the attributes we have in config > ldap_fields.yml[attributes]
+    def ldap_struct_class
+      return self.class::Ldap if self.class.const_defined?(:Ldap, false)
+
+      attribute_symbols = Config.ldap_attributes.map(&:to_sym)
+      self.class.const_set(:Ldap, Struct.new(*attribute_symbols, keyword_init: true))
+    end
   end
 end

lib/sis/student.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'ostruct'
 require 'date'
 
 # rubocop:disable Metrics/ClassLength
@@ -18,9 +17,15 @@ class Student
     Email = Struct.new(:preferred, :email_address, :email_types)
     Phone = Struct.new(:preferred, :preferred_sms, :phone_number, :phone_types)
 
+    Rec = Struct.new(:primary_id, :job_description, :expiry_date, :purge_date, :contact_info,
+                     :identifiers, :user_group, :full_name, :first_name, :middle_name, :last_name,
+                     :preferred_name, :pref_name_givenname, :pref_name_middlename, :pref_name_familyname,
+                     :campus_code, :account_type, :status,
+                     keyword_init: true)
+
     def initialize(user)
       @user = user
-      @rec = OpenStruct.new
+      @rec = Rec.new
       create_user_record
     end
 

lib/ucpath/jobs.rb

@@ -1,6 +1,5 @@
 require 'date'
 require 'json'
-require 'ostruct'
 require 'jsonpath'
 require 'nokogiri'
 require_relative '../alma'
@@ -101,12 +100,26 @@ def find_priority_jobs(job_list)
       end
     end
 
+    # Return the Job Struct class, creating it once using the
+    # field names defined in ucpath_fields.yml if it does not already exist.
+    def job_struct_class
+      return self.class::Job if self.class.const_defined?(:Job, false)
+
+      keys = Config.ucpath_job_fields.map { |f| f['name'].to_sym }
+      self.class.const_set(:Job, Struct.new(*keys, keyword_init: true))
+    end
+
+    # Extract the configured fields from the raw job JSON and
+    # instantiate a Job struct with the resulting values.
     def map_job_to_struct(job_hash)
-      OpenStruct.new(
-        Config.ucpath_job_fields.to_h do |field|
-          [field['name'], JsonPath.on(job_hash, field['jpath']).first || '']
-        end
-      )
+      attrs = Config.ucpath_job_fields.to_h do |field|
+        [
+          field['name'].to_sym,
+          JsonPath.on(job_hash, field['jpath']).first || ''
+        ]
+      end
+
+      job_struct_class.new(**attrs)
     end
 
     def fetch_jobs(id)