ruby-jss 1.6.4 → 2.0.0b1

data/lib/{jss/api_object → jamf/api/classic/api_objects}/scopable/scope.rb

@@ -1,4 +1,4 @@
-# Copyright 2020 Pixar
+# Copyright 2022 Pixar
 
 #    Licensed under the Apache License, Version 2.0 (the "Apache License")
 #    with the following modification; you may not use this file except in
@@ -22,7 +22,7 @@
 #
 #
 
-module JSS
+module Jamf
 
   module Scopable
 
@@ -51,11 +51,11 @@ module JSS
     # of those bugs and how ruby-jss handles them.
     #
     # Targets/Inclusions
-    #  - 'Users' in the Scope UI can only be JSS::Users - No LDAP
+    #  - 'Users' in the Scope UI can only be Jamf::Users - No LDAP
     #    - BUG: They do not appear in API data (XML or JSON) and are
     #      NOT SUPPORTED in ruby-jss.
     #    - You must use the Web UI to work with them in a Scope.
-    #  - 'User Groups' in the Scope UI can only be JSS::UserGroups - No LDAP
+    #  - 'User Groups' in the Scope UI can only be Jamf::UserGroups - No LDAP
     #    - BUG: They do not appear in API data (XML or JSON) and are
     #      NOT SUPPORTED in ruby-jss.
     #    - You must use the Web UI to work with them in a Scope.
@@ -74,11 +74,11 @@ module JSS
     #      scope=>limitations=>user_groups
     #
     # Exclusions, combines the behavior of Inclusions & Limitations
-    #  - 'Users' in the Scope UI can only be JSS::Users - No LDAP
+    #  - 'Users' in the Scope UI can only be Jamf::Users - No LDAP
     #    - BUG: They do not appear in API data (XML or JSON) and are
     #      NOT SUPPORTED in ruby-jss.
     #    - You must use the Web UI to work with them in a Scope.
-    #  - 'User Groups' in the Scope UI can only be JSS::UserGroups - No LDAP
+    #  - 'User Groups' in the Scope UI can only be Jamf::UserGroups - No LDAP
     #    - BUG: They do not appear in API data (XML or JSON) and are
     #      NOT SUPPORTED in ruby-jss.
     #    - You must use the Web UI to work with them in a Scope.
@@ -102,7 +102,7 @@ module JSS
     #   - Methods #set_limitations, #add_limitation & #remove_limitation will accept:
     #     - :user, :ldap_user, or :jamf_ldap_user (and their plurals) for working
     #       with 'LDAP/Local Users'. When setting or adding, the provided
-    #       string(s) must exist as either a JSS::User or an LDAP user
+    #       string(s) must exist as either a Jamf::User or an LDAP user
     #     - :user_group or :ldap_user_group (and their plurals) for working with
     #       'LDAP User Groups'. When setting or adding, the provided string
     #       must exist as a group in LDAP.
@@ -110,7 +110,7 @@ module JSS
     #   - Methods #set_exclusions, #add_exclusion & #remove_exclusion will accept:
     #     - :user, :ldap_user, or :jamf_ldap_user (and their plurals) for working
     #       with 'LDAP/Local Users'. When setting or adding, the provided string(s)
-    #       must exist as either a JSS::User or an LDAP user.
+    #       must exist as either a Jamf::User or an LDAP user.
     #     - :user_group or :ldap_user_group (and their plurals) for working with
     #       'LDAP User Groups''. When setting or adding, the provided string
     #       must exist as a group in LDAP.
@@ -124,7 +124,7 @@ module JSS
     #    are in @limitations[:ldap_user_groups]  and @exclusions[:ldap_user_groups]
     #
     #
-    # @see JSS::Scopable
+    # @see Jamf::Scopable
     #
     class Scope
 
@@ -134,24 +134,24 @@ module JSS
       # These are the classes that Scopes can use for defining a scope,
       # keyed by appropriate symbols.
       # NOTE: All the user and group ones don't actually refer to
-      # JSS::User or JSS::UserGroup. See IMPORTANT discussion above.
+      # Jamf::User or Jamf::UserGroup. See IMPORTANT discussion above.
       SCOPING_CLASSES = {
-        computers: JSS::Computer,
-        computer: JSS::Computer,
-        computer_groups: JSS::ComputerGroup,
-        computer_group: JSS::ComputerGroup,
-        mobile_devices: JSS::MobileDevice,
-        mobile_device: JSS::MobileDevice,
-        mobile_device_groups: JSS::MobileDeviceGroup,
-        mobile_device_group: JSS::MobileDeviceGroup,
-        buildings: JSS::Building,
-        building: JSS::Building,
-        departments: JSS::Department,
-        department: JSS::Department,
-        network_segments: JSS::NetworkSegment,
-        network_segment: JSS::NetworkSegment,
-        ibeacon: JSS::IBeacon,
-        ibeacons: JSS::IBeacon,
+        computers: Jamf::Computer,
+        computer: Jamf::Computer,
+        computer_groups: Jamf::ComputerGroup,
+        computer_group: Jamf::ComputerGroup,
+        mobile_devices: Jamf::MobileDevice,
+        mobile_device: Jamf::MobileDevice,
+        mobile_device_groups: Jamf::MobileDeviceGroup,
+        mobile_device_group: Jamf::MobileDeviceGroup,
+        buildings: Jamf::Building,
+        building: Jamf::Building,
+        departments: Jamf::Department,
+        department: Jamf::Department,
+        network_segments: Jamf::NetworkSegment,
+        network_segment: Jamf::NetworkSegment,
+        ibeacon: Jamf::IBeacon,
+        ibeacons: Jamf::IBeacon,
         user: nil,
         users: nil,
         ldap_user: nil,
@@ -219,7 +219,7 @@ module JSS
       # Attributes
       ######################
 
-      # @return [JSS::APIObject subclass]
+      # @return [Jamf::APIObject subclass]
       #
       # A reference to the object that contains this Scope
       #
@@ -303,7 +303,7 @@ module JSS
       def initialize(target_key, raw_scope = nil)
         raw_scope ||= DEFAULT_SCOPE.dup
         unless TARGETS_AND_GROUPS.key?(target_key)
-          raise JSS::InvalidDataError, "The target class of a Scope must be one of the symbols :#{TARGETS_AND_GROUPS.keys.join(', :')}"
+          raise Jamf::InvalidDataError, "The target class of a Scope must be one of the symbols :#{TARGETS_AND_GROUPS.keys.join(', :')}"
         end
 
         @target_key = target_key
@@ -430,14 +430,14 @@ module JSS
       #
       def set_targets(key, list)
         key = pluralize_key(key)
-        raise JSS::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
+        raise Jamf::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
 
         # check the idents
         list.map! do |ident|
           item_id = validate_item(:target, key, ident)
 
           if @exclusions[key]&.include?(item_id)
-            raise JSS::AlreadyExistsError, \
+            raise Jamf::AlreadyExistsError, \
                   "Can't set #{key} target to '#{ident}' because it's already an explicit exclusion."
           end
 
@@ -476,7 +476,7 @@ module JSS
         item_id = validate_item(:target, key, item)
         return if @targets[key]&.include?(item_id)
 
-        raise JSS::AlreadyExistsError, "Can't set #{key} target to '#{item}' because it's already an explicit exclusion." if @exclusions[key]&.include?(item_id)
+        raise Jamf::AlreadyExistsError, "Can't set #{key} target to '#{item}' because it's already an explicit exclusion." if @exclusions[key]&.include?(item_id)
 
         @targets[key] << item_id
         @all_targets = false
@@ -524,13 +524,13 @@ module JSS
       #
       def set_limitation(key, list)
         key = pluralize_key(key)
-        raise JSS::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
+        raise Jamf::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
 
         # check the idents
         list.map! do |ident|
           item_id = validate_item(:limitation, key, ident)
           if @exclusions[key]&.include?(item_id)
-            raise JSS::AlreadyExistsError, "Can't set #{key} limitation for '#{name}' because it's already an explicit exclusion."
+            raise Jamf::AlreadyExistsError, "Can't set #{key} limitation for '#{name}' because it's already an explicit exclusion."
           end
 
           item_id
@@ -564,7 +564,7 @@ module JSS
         return nil if @limitations[key]&.include?(item_id)
 
         if @exclusions[key]&.include?(item_id)
-          raise JSS::AlreadyExistsError, "Can't set #{key} limitation for '#{name}' because it's already an explicit exclusion."
+          raise Jamf::AlreadyExistsError, "Can't set #{key} limitation for '#{name}' because it's already an explicit exclusion."
         end
 
         @limitations[key] << item_id
@@ -610,7 +610,7 @@ module JSS
       #
       def set_exclusion(key, list)
         key = pluralize_key(key)
-        raise JSS::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
+        raise Jamf::InvalidDataError, "List must be an Array of #{key} identifiers, it may be empty." unless list.is_a? Array
 
         # check the idents
         list.map! do |ident|
@@ -618,11 +618,11 @@ module JSS
           case key
           when *@target_keys
             if @targets[key] && @exclusions[key].include?(item_id)
-              raise JSS::AlreadyExistsError, "Can't exclude #{key} '#{ident}' because it's already explicitly included."
+              raise Jamf::AlreadyExistsError, "Can't exclude #{key} '#{ident}' because it's already explicitly included."
             end
           when *LIMITATIONS
             if @limitations[key] && @exclusions[key].include?(item_id)
-              raise JSS::AlreadyExistsError, "Can't exclude #{key} '#{ident}' because it's already an explicit limitation."
+              raise Jamf::AlreadyExistsError, "Can't exclude #{key} '#{ident}' because it's already an explicit limitation."
             end
           end
           item_id
@@ -652,9 +652,9 @@ module JSS
         item_id = validate_item(:exclusion, key, item)
         return if @exclusions[key]&.include?(item_id)
 
-        raise JSS::AlreadyExistsError, "Can't exclude #{key} scope to '#{item}' because it's already explicitly included." if @targets[key]&.include?(item)
+        raise Jamf::AlreadyExistsError, "Can't exclude #{key} scope to '#{item}' because it's already explicitly included." if @targets[key]&.include?(item)
 
-        raise JSS::AlreadyExistsError, "Can't exclude #{key} '#{item}' because it's already an explicit limitation." if @limitations[key]&.include?(item)
+        raise Jamf::AlreadyExistsError, "Can't exclude #{key} '#{item}' because it's already an explicit limitation." if @limitations[key]&.include?(item)
 
         @exclusions[key] << item_id
         @container&.should_update
@@ -775,7 +775,7 @@ module JSS
       ################
       def scoped_machines
         scoped_machines = {}
-        @target_class.all_objects(api: container.api).each do |machine|
+        @target_class.all_objects(cnx: container.cnx).each do |machine|
           scoped_machines[machine.id] = machine.name if in_scope? machine
         end
         scoped_machines
@@ -784,7 +784,7 @@ module JSS
       # is a given machine is in this scope?
       #
       # For a parameter you may pass either an instantiated
-      # JSS::MobileDevice or JSS::Computer, or an identifier for one.
+      # Jamf::MobileDevice or Jamf::Computer, or an identifier for one.
       # If an identifier is passed, it is not instantiated, but an API
       # request is made for just the required subsets of data, thus
       # speeding things up a bit when calling this method many times.
@@ -799,7 +799,7 @@ module JSS
       # If a scope contains iBeacon limitations or exclusions, it is up to
       # the user to be aware of that when evaluating the meaning of this result.
       #
-      # @param machine[Integer, String, JSS::MobileDevice, JSS::Computer]
+      # @param machine[Integer, String, Jamf::MobileDevice, Jamf::Computer]
       #   Either an identifier for the machine, or an instantiated object
       #
       # @return [Boolean]
@@ -811,6 +811,11 @@ module JSS
         a_target?(machine_data) && within_limitations?(machine_data) && !excluded?(machine_data)
       end
 
+      #####
+      def to_s
+        "Scope for #{container.class} id #{container.id}"
+      end
+
       # Private Instance Methods
       #####################################
       private
@@ -844,25 +849,25 @@ module JSS
 
         key = pluralize_key(key)
 
-        raise JSS::InvalidDataError, "#{realm} key must be one of :#{possible_keys.join(', :')}" \
+        raise Jamf::InvalidDataError, "#{realm} key must be one of :#{possible_keys.join(', :')}" \
           unless possible_keys.include? key
 
         id = nil
 
         # id will be a string
         if key == :jamf_ldap_users
-          id = ident if JSS::User.all_names(:refresh, api: container.api).include?(ident) || JSS::LDAPServer.user_in_ldap?(ident)
+          id = ident if Jamf::User.all_names(:refresh, cnx: container.cnx).include?(ident) || Jamf::LdapServer.user_in_ldap?(ident)
 
         # id will be a string
         elsif key == :ldap_user_groups
-          id = ident if JSS::LDAPServer.group_in_ldap? ident, api: container.api
+          id = ident if Jamf::LdapServer.group_in_ldap? ident, cnx: container.cnx
 
         # id will be an integer
         else
-          id = SCOPING_CLASSES[key].valid_id ident, api: container.api
+          id = SCOPING_CLASSES[key].valid_id ident, cnx: container.cnx
         end
 
-        raise JSS::NoSuchItemError, "No existing #{key} matching '#{ident}'" if error_if_not_found && id.nil?
+        raise Jamf::NoSuchItemError, "No existing #{key} matching '#{ident}'" if error_if_not_found && id.nil?
 
         id
       end # validate_item(type, key, ident)
@@ -886,15 +891,15 @@ module JSS
       #     location: the 'location' subset
       #     group_ids: an Array of the group ids to which the machine belongs.
       #
-      # @param machine[Integer, String, JSS::MobileDevice, JSS::Computer]
+      # @param machine[Integer, String, Jamf::MobileDevice, Jamf::Computer]
       #   Either an identifier for the machine, or an instantiated object
       #
       # @return
       #
       def fetch_machine_data(machine)
         case machine
-        when JSS::Computer
-          raise JSS::InvalidDataError, "Targets of this scope must be #{@target_class}" unless @target_class == JSS::Computer
+        when Jamf::Computer
+          raise Jamf::InvalidDataError, "Targets of this scope must be #{@target_class}" unless @target_class == Jamf::Computer
 
           general = machine.init_data[:general]
           location = machine.init_data[:location]
@@ -904,8 +909,8 @@ module JSS
           # MDevs already have this at general[:managed]
           general[:managed] = general[:remote_management][:managed]
 
-        when JSS::MobileDevice
-          raise JSS::InvalidDataError, "Targets of this scope must be #{@target_class}" unless @target_class == JSS::MobileDevice
+        when Jamf::MobileDevice
+          raise Jamf::InvalidDataError, "Targets of this scope must be #{@target_class}" unless @target_class == Jamf::MobileDevice
 
           general = machine.init_data[:general]
           location = machine.init_data[:location]
@@ -931,10 +936,10 @@ module JSS
       # @return [Array] the general, locacation, and parsed group IDs
       #
       def fetch_subsets(ident)
-        id = @target_class.valid_id ident, api: container.api
-        raise JSS::NoSuchItemError, "No #{@target_class} matching #{machine}" unless id
+        id = @target_class.valid_id ident, cnx: container.cnx
+        raise Jamf::NoSuchItemError, "No #{@target_class} matching #{machine}" unless id
 
-        if @target_class == JSS::MobileDevice
+        if @target_class == Jamf::MobileDevice
           grp_subset = 'MobileDeviceGroups'
           top_key = :mobile_device
         else
@@ -942,9 +947,9 @@ module JSS
           top_key = :computer
         end
         subset_rsrc = "#{@target_class::RSRC_BASE}/id/#{id}/subset/General&Location&#{grp_subset}"
-        data = container.api.get_rsrc(subset_rsrc)[top_key]
+        data = container.cnx.c_get(subset_rsrc)[top_key]
         grp_data =
-          if @target_class == JSS::MobileDevice
+          if @target_class == Jamf::MobileDevice
             data[:mobile_device_groups]
           else
             data[:groups_accounts][:computer_group_memberships]
@@ -961,7 +966,7 @@ module JSS
       # @return [Array] The ID's of the groups to which the machine belongs.
       #
       def group_ids(raw)
-        if @target_class == JSS::MobileDevice
+        if @target_class == Jamf::MobileDevice
           raw.map { |mdg| mdg[:id] }
         else
           names_to_ids = @group_class.map_all_ids_to(:name).invert
@@ -1047,7 +1052,7 @@ module JSS
         # false if no building for the machine - it isn't in any dept
         return false if machine_data[:location][:building].to_s.empty?
 
-        building_id = JSS::Building.map_all_ids_to(:name).invert[machine_data[:location][:building]]
+        building_id = Jamf::Building.map_all_ids_to(:name).invert[machine_data[:location][:building]]
         scope_list.include? building_id
       end
 
@@ -1063,7 +1068,7 @@ module JSS
         # false if no dept for the machine - it isn't in any dept
         return false if machine_data[:location][:department].to_s.empty?
 
-        dept_id = JSS::Department.map_all_ids_to(:name).invert[machine_data[:location][:department]]
+        dept_id = Jamf::Department.map_all_ids_to(:name).invert[machine_data[:location][:department]]
 
         scope_list.include? dept_id
       end
@@ -1078,11 +1083,11 @@ module JSS
         # nil if no netsegs in scope part
         return if scope_list.empty?
 
-        ip = @target_class == JSS::Computer ? machine_data[:general][:last_reported_ip] : machine_data[:general][:ip_address]
+        ip = @target_class == Jamf::Computer ? machine_data[:general][:last_reported_ip] : machine_data[:general][:ip_address]
         # false if no ip for machine - it isn't in a any of the segs
         return false if ip.to_s.empty?
 
-        mach_segs = JSS::NetworkSegment.network_segments_for_ip ip
+        mach_segs = Jamf::NetworkSegment.network_segments_for_ip ip
 
         # if the intersection is not empty, then the machine is in at least one of the net segs
         !(mach_segs & scope_list).empty?
@@ -1113,12 +1118,12 @@ module JSS
 
         # loop thru them checking to see if the user is a member
         scope_list.each do |ldapgroup|
-          server = JSS::LDAPServer.server_for_group ldapgroup
+          server = Jamf::LdapServer.server_for_group ldapgroup
           # if the group doesn't exist in any LDAP the user isn't a part of it
           next unless server
 
           # if the user name is in any group, return true
-          return true if JSS::LDAPServer.check_membership server, machine_data[:location][:username], ldapgroup
+          return true if Jamf::LdapServer.check_membership server, machine_data[:location][:username], ldapgroup
         end
 
         # if we're here, not in any group

data/lib/{jss/api_object → jamf/api/classic/api_objects}/scopable.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -24,7 +24,7 @@
 ###
 
 ###
-module JSS
+module Jamf
 
   #####################################
   ### Module Variables
@@ -45,8 +45,8 @@ module JSS
   ### that scoping. This module provides a consistant way to deal with scoping data
   ### via some instance methods and the {Scopable::Scope} class.
   ###
-  ### When this module is mixed in to a {JSS::APIObject} subclass, instances of the subclass
-  ### will have a @scope attribute containing a {JSS::Scopable::Scope} instance
+  ### When this module is mixed in to a {Jamf::APIObject} subclass, instances of the subclass
+  ### will have a @scope attribute containing a {Jamf::Scopable::Scope} instance
   ###
   ### Classes that mix in this module must:
   ### - Set a Constant SCOPE_TARGET_KEY that is either :computers or :mobile_devices
@@ -75,19 +75,19 @@ module JSS
     ### @return [void]
     ###
     def parse_scope
-      @scope = JSS::Scopable::Scope.new self.class::SCOPE_TARGET_KEY, @init_data[:scope]
+      @scope = Jamf::Scopable::Scope.new self.class::SCOPE_TARGET_KEY, @init_data[:scope]
       @scope.container = self
     end
 
     ### Change the scope
     ###
-    ### @param new_scope[JSS::Scopable::Scope] the new scope
+    ### @param new_scope[Jamf::Scopable::Scope] the new scope
     ###
     ### @return [void]
     ###
     def scope= (new_scope)
-      raise JSS::InvalidDataError, "JSS::Scopable::Scope instance required" unless new_criteria.kind_of?(JSS::Scopable::Scope)
-      raise JSS::InvalidDataError, "Scope object must have target_key of :#{self.class::SCOPE_TARGET_KEY}" unless self.class::SCOPE_TARGET_KEY == new_scope.target_key
+      raise Jamf::InvalidDataError, "Jamf::Scopable::Scope instance required" unless new_criteria.kind_of?(Jamf::Scopable::Scope)
+      raise Jamf::InvalidDataError, "Scope object must have target_key of :#{self.class::SCOPE_TARGET_KEY}" unless self.class::SCOPE_TARGET_KEY == new_scope.target_key
       @scope = new_scope
       @need_to_update = true
     end
@@ -105,15 +105,13 @@ module JSS
     #
     def update
       super
-    rescue JSS::ConflictError => conflict
+    rescue Jamf::ConflictError => conflict
       if scope.unable_to_verify_ldap_entries == true
-        raise JSS::InvalidDataError, "Potentially non-existant LDAP user or group in new scope values."
+        raise Jamf::InvalidDataError, "Potentially non-existant LDAP user or group in new scope values."
       else
         raise conflict
       end
     end # update
 
   end # module Scopable
-end # module JSS
-
-require "jss/api_object/scopable/scope"
+end # module Jamf

data/lib/{jss/api_object → jamf/api/classic/api_objects}/script.rb

@@ -1,4 +1,4 @@
-# Copyright 2020 Pixar
+# Copyright 2022 Pixar
 
 #
 #    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -24,7 +24,7 @@
 #
 
 #
-module JSS
+module Jamf
 
   # Module Constants
   #####################################
@@ -49,16 +49,16 @@ module JSS
   #
   # Use the {#run} method to run the script on the local machine.
   #
-  # @see JSS::APIObject
+  # @see Jamf::APIObject
   #
-  class Script < JSS::APIObject
+  class Script < Jamf::APIObject
 
     # Mix-Ins
     #####################################
 
-    include JSS::Creatable
-    include JSS::Updatable
-    include JSS::Categorizable
+    include Jamf::Creatable
+    include Jamf::Updatable
+    include Jamf::Categorizable
 
     # Class Methods
     #####################################
@@ -133,7 +133,7 @@ module JSS
     #####################################
 
     #
-    def initialize(args = {})
+    def initialize(**args)
       super
 
       @filename = @init_data[:filename] || @name
@@ -182,8 +182,8 @@ module JSS
       new_val = new_val.to_s
       return if new_val == @name
 
-      raise JSS::MissingDataError, "Name can't be empty" if new_val.empty?
-      raise JSS::AlreadyExistsError, "A script already exists with the name '#{new_val}'" if JSS::Script.all_names.include? new_val
+      raise Jamf::MissingDataError, "Name can't be empty" if new_val.empty?
+      raise Jamf::AlreadyExistsError, "A script already exists with the name '#{new_val}'" if Jamf::Script.all_names.include? new_val
 
       # if the filename matches the name, change that too.
       @filename = new_val if @filename == @name
@@ -226,7 +226,7 @@ module JSS
         new_val.flatten!
         new_val.uniq!
       else
-        raise JSS::InvalidDataError, 'os_requirements must be a String or an Array of strings'
+        raise Jamf::InvalidDataError, 'os_requirements must be a String or an Array of strings'
       end # case
 
       # get the array version
@@ -243,7 +243,7 @@ module JSS
     def priority=(new_val)
       return nil if new_val == @priority
       new_val = DEFAULT_PRIORITY if new_val.nil? || (new_val == '')
-      raise JSS::InvalidDataError, ":priority must be one of: #{PRIORITIES.join ', '}" unless PRIORITIES.include? new_val
+      raise Jamf::InvalidDataError, ":priority must be one of: #{PRIORITIES.join ', '}" unless PRIORITIES.include? new_val
       @priority = new_val
       @need_to_update = true
     end # priority=
@@ -289,10 +289,10 @@ module JSS
       new_val = {} if new_val.nil? || (new_val == '')
 
       # check the values
-      raise JSS::InvalidDataError, ':parameters must be a Hash with keys :parameter4 thru :parameter11' unless \
+      raise Jamf::InvalidDataError, ':parameters must be a Hash with keys :parameter4 thru :parameter11' unless \
         new_val.is_a?(Hash) && ((new_val.keys & PARAMETER_KEYS) == new_val.keys)
       new_val.each do |_k, v|
-        raise JSS::InvalidDataError, ':parameter values must be strings or nil' unless v.nil? || v.is_a?(String)
+        raise Jamf::InvalidDataError, ':parameter values must be strings or nil' unless v.nil? || v.is_a?(String)
       end
 
       @parameters = new_val
@@ -308,9 +308,9 @@ module JSS
     # @return [void]
     #
     def set_parameter(param_num, new_val)
-      raise JSS::NoSuchItemError, 'Parameter numbers must be from 4-11' unless (4..11).cover? param_num
+      raise Jamf::NoSuchItemError, 'Parameter numbers must be from 4-11' unless (4..11).cover? param_num
       pkey = "parameter#{param_num}".to_sym
-      raise JSS::InvalidDataError, 'parameter values must be strings or nil' unless new_val.nil? || new_val.is_a?(String)
+      raise Jamf::InvalidDataError, 'parameter values must be strings or nil' unless new_val.nil? || new_val.is_a?(String)
       return nil if new_val == @parameters[pkey]
       @parameters[pkey] = new_val
       @need_to_update = true
@@ -343,10 +343,10 @@ module JSS
                  when Pathname
                    new_val.read
                  else
-                   raise JSS::InvalidDataError, 'New code must be a String (path or code) or Pathname instance'
+                   raise Jamf::InvalidDataError, 'New code must be a String (path or code) or Pathname instance'
                  end # case
 
-      raise JSS::InvalidDataError, "Script contents must start with '#!'" unless new_code.start_with? '#!'
+      raise Jamf::InvalidDataError, "Script contents must start with '#!'" unless new_code.start_with? '#!'
 
       @script_contents = new_code
       @script_contents_encoded = Base64.encode64 @script_contents
@@ -385,12 +385,12 @@ module JSS
     #
     # @return [Array<(Integer,String)>] the exit status and stdout+stderr of the script
     #
-    def run(opts = {})
-      raise JSS::MissingDataError, 'script_contents does not start with #!' unless @script_contents.to_s.start_with? '#!'
+    def run(**opts)
+      raise Jamf::MissingDataError, 'script_contents does not start with #!' unless @script_contents.to_s.start_with? '#!'
 
       opts[:target] ||= '/'
-      opts[:computer_name] ||= JSS::Client.run_jamf('getComputerName')[/>(.)</, 1]
-      opts[:username] ||= JSS::Client.console_user
+      opts[:computer_name] ||= Jamf::Client.run_jamf('getComputerName')[/>(.*?)</, 1]
+      opts[:username] ||= Jamf::Client.console_user
 
       params = [opts[:target], opts[:computer_name], opts[:username]]
       params << opts[:p4]