ruby-jss 1.5.1 → 1.5.2

data/lib/jss/api_object/computer.rb

@@ -1046,6 +1046,19 @@ module JSS
       @need_to_update = true
     end
 
+    # flush the logs for this computer in a given policy
+    # @see JSS::Policy.flush_logs
+    #
+    def flush_policy_logs(policy, older_than: 0, period: :days)
+      JSS::Policy.flush_logs(
+        policy,
+        older_than: older_than,
+        period: period,
+        computers: [@id],
+        api: @api
+      )
+    end
+
     def barcode1=(new_val)
       new_val = new_val.strip
       return nil if @barcode1 == new_val

data/lib/jss/api_object/configuration_profile.rb

@@ -55,6 +55,11 @@ module JSS
     # which DISTRIBUTION_METHODS means we're in self service?
     SELF_SERVICE_DIST_METHOD = 'Make Available in Self Service'.freeze
 
+    # when a change is made, which in-scope machines should get
+    # the changed profile?
+    REDEPLOY_NEWLY_ASSIGNED = 'Newly Assigned'.freeze
+    REDEPLOY_ALL = 'All'.freeze
+
     # Our SelfService deploys profiles
     SELF_SERVICE_PAYLOAD = :profile
 
@@ -76,7 +81,11 @@ module JSS
     # @return [String] the uuid of this profile. NOT Updatable
     attr_reader :uuid
 
-    # @return [Boolean] Should this profile be redeployed when an inventory update happens?
+    # @return [String] When a change is made to the profile, which scoped machines
+    #   should get the changes? This will always contain REDEPLOY_NEWLY_ASSIGNED
+    #   when fetched, but can be set to REDEPLOY_ALL via the redeploy_to_all:
+    #   parameter to #update & #save. After the update is complete, it reverts
+    #   to REDEPLOY_NEWLY_ASSIGNED
     attr_reader :redeploy_on_update
 
     # @return [String] the plist containing the payloads for this profile. NOT Updatable
@@ -154,11 +163,27 @@ module JSS
     end
 
     # clear flag after updating
-    def update
-      super
+    def update(redeploy_to_all: false)
+      @redeploy_on_update = redeploy_to_all ? REDEPLOY_ALL : REDEPLOY_NEWLY_ASSIGNED
+      super()
+      # always reset to newly assigned
+      @redeploy_on_update = REDEPLOY_NEWLY_ASSIGNED
       @update_payloads = nil
     end
 
+    # wrapper with param
+    def save(redeploy_to_all: false)
+      if @in_jss
+        raise JSS::UnsupportedError, 'Updating this object in the JSS is currently not supported by ruby-jss' unless updatable?
+
+        update redeploy_to_all: redeploy_to_all
+      else
+        raise JSS::UnsupportedError, 'Creating this object in the JSS is currently not supported by ruby-jss' unless creatable?
+
+        create
+      end
+    end
+
     # Private Instance Methods
     ###################################
     private

data/lib/jss/api_object/policy.rb

@@ -263,14 +263,14 @@ module JSS
     }.freeze
 
     LOG_FLUSH_INTERVAL_PERIODS = {
-      day: 'Day',
-      days: 'Day',
-      week: 'Week',
-      weeks: 'Week',
-      month: 'Month',
-      months: 'Month',
-      year: 'Year',
-      years: 'Year'
+      day: 'Days',
+      days: 'Days',
+      week: 'Weeks',
+      weeks: 'Weeks',
+      month: 'Months',
+      months: 'Months',
+      year: 'Years',
+      years: 'Years'
     }.freeze
 
     # the object type for this object in
@@ -287,6 +287,83 @@ module JSS
     # How is the category stored in the API data?
     CATEGORY_DATA_TYPE = Hash
 
+    # Class Methods
+    ######################
+
+    # Flush logs for a given policy older than some number of days, weeks,
+    # months or years, possibly limited to one or more computers.
+    #
+    # With no parameters, flushes all logs for the policy for all computers.
+    #
+    # NOTE: Currently the API doesn't have a way to flush only failed policies.
+    #
+    # WARNING: Log flushing can take a long time, and the API call doesnt return
+    # until its finished. The connection timeout will be temporarily raised to
+    # 30 minutes, unless it's already higher.
+    #
+    # @param policy[Integer,String] The id or name of the policy to flush
+    #
+    # @param older_than[Integer] 0, 1, 2, 3, or 6
+    #
+    # @param period[Symbol] :days, :weeks, :months, or :years
+    #
+    # @param computers[Array<Integer,String>] Identifiers of the target computers
+    #   either ids, names, SNs, macaddrs, or UDIDs. If omitted, flushes logs for
+    #   all computers
+    #
+    # @param api [JSS::APIConnection] the API  connection to use.
+    #
+    # @return [void]
+    #
+    def self.flush_logs(policy, older_than: 0, period: :days, computers: [], api: JSS.api)
+      orig_timeout = api.cnx.options.timeout
+      pol_id = valid_id policy
+      raise JSS::NoSuchItemError, "No Policy identified by '#{policy}'." unless pol_id
+
+      older_than = LOG_FLUSH_INTERVAL_INTEGERS[older_than]
+      raise JSS::InvalidDataError, "older_than must be one of these integers: #{LOG_FLUSH_INTERVAL_INTEGERS.keys.join ', '}" unless older_than
+
+      period = LOG_FLUSH_INTERVAL_PERIODS[period]
+      raise JSS::InvalidDataError, "period must be one of these symbols: :#{LOG_FLUSH_INTERVAL_PERIODS.keys.join ', :'}" unless period
+
+      computers = [computers] unless computers.is_a? Array
+
+      # log flushes can be really slow
+      api.timeout = 1800 unless orig_timeout > 1800
+
+      return api.delete_rsrc "#{LOG_FLUSH_RSRC}/policy/id/#{pol_id}/interval/#{older_than}+#{period}" if computers.empty?
+
+      flush_logs_for_specific_computers pol_id, older_than, period, computers, api
+    ensure
+      api.timeout = orig_timeout
+    end
+
+    # use an XML body in a DELETE request to flush logs for
+    # a list of computers - used by the flush_logs class method
+    def self.flush_logs_for_specific_computers(pol_id, older_than, period, computers, api)
+      # build the xml body for a DELETE request
+      xml_doc = REXML::Document.new JSS::APIConnection::XML_HEADER
+      lf = xml_doc.add_element 'logflush'
+      lf.add_element('log').text = 'policy'
+      lf.add_element('log_id').text = pol_id.to_s
+      lf.add_element('interval').text = "#{older_than} #{period}"
+      comps_elem = lf.add_element 'computers'
+      computers.each do |c|
+        id = JSS::Computer.valid_id c
+        next unless id
+
+        ce = comps_elem.add_element 'computer'
+        ce.add_element('id').text = id.to_s
+      end
+
+      # Do a DELETE request with a body.
+      api.cnx.delete(LOG_FLUSH_RSRC) do |req|
+        req.headers[JSS::APIConnection::HTTP_CONTENT_TYPE_HEADER] = JSS::APIConnection::MIME_XML
+        req.body = xml_doc.to_s
+      end
+    end
+    private_class_method :flush_logs_for_specific_computers
+
     # Attributes
     ######################
 
@@ -1715,34 +1792,37 @@ module JSS
     end
     alias execute run
 
-    # Flush all policy logs for this policy older than
-    # some number of days, weeks, months or years.
+    # Flush logs for this policy older than
+    # some number of days, weeks, months or years, possibly limited to
+    # one or more computers
+    #
+    # With no parameters, flushes all logs for all computers
     #
-    # With no parameters, flushes all logs
+    # NOTE: Currently the API doesn't have a way to flush only failed policies.
     #
-    # NOTE: Currently the API doesn't have a way to
-    # flush only failed policies.
+    # WARNING: Log flushing can take a long time, and the API call doesnt return
+    # until its finished. The connection timeout will be temporarily raised to
+    # 30 minutes, unless it's already higher.
     #
     # @param older_than[Integer] 0, 1, 2, 3, or 6
     #
     # @param period[Symbol] :days, :weeks, :months, or :years
     #
+    # @param computers[Array<Integer,String>] Identifiers of the target computers
+    #   either ids, names, SNs, macaddrs, or UDIDs
+    #
     # @return [void]
     #
-    def flush_logs(older_than: 0, period: :days)
+    def flush_logs(older_than: 0, period: :days, computers: [])
       raise JSS::NoSuchItemError, "Policy doesn't exist in the JSS. Use #create first." unless @in_jss
 
-      unless LOG_FLUSH_INTERVAL_INTEGERS.key?(older_than)
-        raise JSS::InvalidDataError, "older_than must be one of these integers: #{LOG_FLUSH_INTERVAL_INTEGERS.keys.join ', '}"
-      end
-
-      unless LOG_FLUSH_INTERVAL_PERIODS.key?(period)
-        raise JSS::InvalidDataError, "period must be one of these symbols: :#{LOG_FLUSH_INTERVAL_PERIODS.keys.join ', :'}"
-      end
-
-      interval = "#{LOG_FLUSH_INTERVAL_INTEGERS[older_than]}+#{LOG_FLUSH_INTERVAL_PERIODS[period]}"
-
-      @api.delete_rsrc "#{LOG_FLUSH_RSRC}/policy/id/#{@id}/interval/#{interval}"
+      JSS::Policy.flush_logs(
+        @id,
+        older_than: older_than,
+        period: period,
+        computers: computers,
+        api: @api
+      )
     end
 
     # Private Instance Methods

data/lib/jss/api_object/scopable/scope.rb

@@ -224,6 +224,7 @@ module JSS
       # A reference to the object that contains this Scope
       #
       # For telling it when a change is made and an update needed
+      # and for accessing its api connection
       attr_accessor :container
 
       # @return [Boolean] should we expect a potential 409 Conflict
@@ -246,7 +247,6 @@ module JSS
       attr_reader :all_targets
       alias all_targets? all_targets
 
-
       # The items which form the base scope of included targets
       #
       # This is the group of targets to which the limitations and exclusions apply.
@@ -408,7 +408,7 @@ module JSS
           @exclusions = {}
           @exclusion_keys.each { |k| @exclusions[k] = [] }
         end
-        @container.should_update if @container
+        @container&.should_update
       end
 
       # Replace a list of item names for as targets in this scope.
@@ -436,7 +436,7 @@ module JSS
         list.map! do |ident|
           item_id = validate_item(:target, key, ident)
 
-          if @exclusions[key] && @exclusions[key].include?(item_id)
+          if @exclusions[key]&.include?(item_id)
             raise JSS::AlreadyExistsError, \
                   "Can't set #{key} target to '#{ident}' because it's already an explicit exclusion."
           end
@@ -448,7 +448,7 @@ module JSS
 
         @targets[key] = list
         @all_targets = false
-        @container.should_update if @container
+        @container&.should_update
       end # sinclude_in_scope
       alias set_target set_targets
       alias set_inclusion set_targets
@@ -474,13 +474,13 @@ module JSS
       def add_target(key, item)
         key = pluralize_key(key)
         item_id = validate_item(:target, key, item)
-        return if @targets[key] && @exclusions[key].include?(item_id)
+        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] && @exclusions[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)
 
         @targets[key] << item_id
         @all_targets = false
-        @container.should_update if @container
+        @container&.should_update
       end
       alias add_inclusion add_target
 
@@ -499,10 +499,10 @@ module JSS
         key = pluralize_key(key)
         item_id = validate_item :target, key, item, error_if_not_found: false
         return unless item_id
-        return unless @targets[key] && @exclusions[key].include?(item_id)
+        return unless @targets[key]&.include?(item_id)
 
         @targets[key].delete item_id
-        @container.should_update if @container
+        @container&.should_update
       end
       alias remove_inclusion remove_target
 
@@ -529,7 +529,7 @@ module JSS
         # check the idents
         list.map! do |ident|
           item_id = validate_item(:limitation, key, ident)
-          if @exclusions[key] && @exclusions[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."
           end
 
@@ -539,7 +539,7 @@ module JSS
         return nil if list.sort == @limitations[key].sort
 
         @limitations[key] = list
-        @container.should_update if @container
+        @container&.should_update
       end # set_limitation
       alias set_limitations set_limitation
 
@@ -561,14 +561,14 @@ module JSS
       def add_limitation(key, item)
         key = pluralize_key(key)
         item_id = validate_item(:limitation, key, item)
-        return nil if @limitations[key] && @exclusions[key].include?(item_id)
+        return nil if @limitations[key]&.include?(item_id)
 
-        if @exclusions[key] && @exclusions[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."
         end
 
         @limitations[key] << item_id
-        @container.should_update if @container
+        @container&.should_update
       end
 
       # Remove a single item for limiting this scope.
@@ -588,10 +588,10 @@ module JSS
         key = pluralize_key(key)
         item_id = validate_item :limitation, key, item, error_if_not_found: false
         return unless item_id
-        return unless @limitations[key] && @exclusions[key].include?(item_id)
+        return unless @limitations[key]&.include?(item_id)
 
         @limitations[key].delete item_id
-        @container.should_update if @container
+        @container&.should_update
       end ###
 
       # Replace an exclusion list for this scope
@@ -617,7 +617,9 @@ module JSS
           item_id = validate_item(:exclusion, key, ident)
           case key
           when *@target_keys
-            raise JSS::AlreadyExistsError, "Can't exclude #{key} '#{ident}' because it's already explicitly included." if @targets[key] && @exclusions[key].include?(item_id)
+            if @targets[key] && @exclusions[key].include?(item_id)
+              raise JSS::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."
@@ -629,7 +631,7 @@ module JSS
         return nil if list.sort == @exclusions[key].sort
 
         @exclusions[key] = list
-        @container.should_update if @container
+        @container&.should_update
       end # limit scope
 
       # Add a single item for exclusions of this scope.
@@ -648,14 +650,14 @@ module JSS
       def add_exclusion(key, item)
         key = pluralize_key(key)
         item_id = validate_item(:exclusion, key, item)
-        return if @exclusions[key] && @exclusions[key].include?(item_id)
+        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] && @targets[key].include?(item)
+        raise JSS::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] && @limitations[key].include?(item)
+        raise JSS::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 if @container
+        @container&.should_update
       end
 
       # Remove a single item for exclusions of this scope
@@ -672,10 +674,10 @@ module JSS
       def remove_exclusion(key, item)
         key = pluralize_key(key)
         item_id = validate_item :exclusion, key, item, error_if_not_found: false
-        return unless @exclusions[key] && @exclusions[key].include?(item_id)
+        return unless @exclusions[key]&.include?(item_id)
 
         @exclusions[key].delete item_id
-        @container.should_update if @container
+        @container&.should_update
       end
 
       # @api private
@@ -773,7 +775,7 @@ module JSS
       ################
       def scoped_machines
         scoped_machines = {}
-        @target_class.all_objects.each do |machine|
+        @target_class.all_objects(api: container.api).each do |machine|
           scoped_machines[machine.id] = machine.name if in_scope? machine
         end
         scoped_machines
@@ -809,7 +811,6 @@ module JSS
         a_target?(machine_data) && within_limitations?(machine_data) && !excluded?(machine_data)
       end
 
-
       # Private Instance Methods
       #####################################
       private
@@ -850,15 +851,15 @@ module JSS
 
         # id will be a string
         if key == :jamf_ldap_users
-          id = ident if JSS::User.all_names(:refresh).include?(ident) || JSS::LDAPServer.user_in_ldap?(ident)
+          id = ident if JSS::User.all_names(:refresh, api: container.api).include?(ident) || JSS::LDAPServer.user_in_ldap?(ident)
 
         # id will be a string
         elsif key == :ldap_user_groups
-          id = ident if JSS::LDAPServer.group_in_ldap? ident
+          id = ident if JSS::LDAPServer.group_in_ldap? ident, api: container.api
 
         # id will be an integer
         else
-          id = SCOPING_CLASSES[key].valid_id ident
+          id = SCOPING_CLASSES[key].valid_id ident, api: container.api
         end
 
         raise JSS::NoSuchItemError, "No existing #{key} matching '#{ident}'" if error_if_not_found && id.nil?
@@ -930,7 +931,7 @@ module JSS
       # @return [Array] the general, locacation, and parsed group IDs
       #
       def fetch_subsets(ident)
-        id = @target_class.valid_id ident
+        id = @target_class.valid_id ident, api: container.api
         raise JSS::NoSuchItemError, "No #{@target_class} matching #{machine}" unless id
 
         if @target_class == JSS::MobileDevice

data/lib/jss/utility.rb

@@ -23,59 +23,157 @@
 #
 #
 
-#
 module JSS
 
   # A collection of useful utility methods. Mostly for
   # converting values between formats, parsing data, and
   # user interaction.
 
-  # Converts an OS Version into an Array of higher OS versions.
+  # Hash of 'minor' => 'maint'
+  # The maximum maint release for macOS 10.minor.maint
+  # e.g the highest release of 10.6 was 10.6.8, the highest release of
+  # 10.15 was 10.15.7
+  #
+  # 12 is the default for the current OS and higher
+  # (and hoping apple doesn't release 10.16.13)
+  OS_TEN_MAXS = {
+      2 => 8,
+      3 => 9,
+      4 => 11,
+      5 => 8,
+      6 => 8,
+      7 => 5,
+      8 => 5,
+      9 => 5,
+      10 => 5,
+      11 => 6,
+      12 => 6,
+      13 => 6,
+      14 => 6,
+      15 => 7,
+      16 => 12
+    }
+
+  # Hash of 'major' => 'minor'
+  # The maximum minor release for macOS major.minor
+  # e.g. the highest release of 11 is 11.12
+  #
+  # 12 is the default for the current OS and higher
+  # (and hoping apple doesn't release 11.13)
+  MAC_OS_MAXS = {
+    11 => 12,
+    12 => 12,
+    13 => 12,
+    14 => 12,
+    15 => 12,
+    16 => 12,
+    17 => 12,
+    18 => 12,
+    19 => 12,
+    20 => 12
+  }
+
+  # Converts an OS Version into an Array of equal or higher OS versions, up to
+  # some non-existant max, hopefully far in the future, currently 20.12
+  #
+  # This array can then be joined with commas and used as the value of the
+  # os_requirements for Packages and Scripts.
+  #
+  # It's unlikely that this method, as written, will still be in use by
+  # the release of macOS 20.12, but currently thats the upper limit.
+  #
+  # Hopefully well before then JAMF will implement a "minimum OS" in Jamf Pro
+  # itself, then we could avoid the inherant limitations in using a method like
+  # this.
   #
-  # It's unlikely that this library will still be in use as-is by the release of OS X 10.30.
-  # Hopefully well before then JAMF will implement a "minimum OS" in the JSS itself.
+  # When the highest maint. release of an OS version is not known, because its
+  # the currently released OS version or higher, then this method assumes '12'
+  # e.g. '10.16.12', '11.12', '12.12', etc.
   #
-  # @param min_os [String] the mimimum OS version to expand, e.g. ">=10.6.7"  or "10.6.7"
+  # Apple has never released more than 11 updates to a version of macOS
+  # (that being 10.4), so hopefully 12 is enough
   #
-  # @return [Array] Nearly all potential OS versions from the minimum to 10.19.x.
+  # Since Big Sur might report itself as either '10.16.x' or '11.x', this method
+  # will allow for both possibilities, and the array will contain whatever
+  # iterations needed for both version numbers
+  #
+  # @param min_os [String] the mimimum OS version to expand, e.g. ">=10.9.4"  or "11.1"
+  #
+  # @return [Array] Nearly all potential OS versions from the minimum to 20.12
   #
   # @example
-  #   JSS.expand_min_os ">=10.6.7" # => returns this array
-  #    # ["10.6.7",
-  #    #  "10.6.8",
+  #   JSS.expand_min_os ">=10.9.4" # => returns this array
+  #    # ["10.9.4",
+  #    #  "10.9.5",
+  #    #  "10.10.x"
   #    #  ...
-  #    #  "10.6.25",
-  #    #  "10.7.x",
-  #    #  "10.8.x",
+  #    #  "10.16.x",
+  #    #  "11.x",
+  #    #  "12.x",
   #    #  ...
-  #    #  "10.30.x"]
+  #    #  "20.x"]
   #
   #
   def self.expand_min_os(min_os)
     min_os = min_os.delete '>='
 
     # split the version into major, minor and maintenance release numbers
-    (maj, min, maint) = min_os.split('.')
+    major, minor, maint = min_os.split('.')
     maint = 'x' if maint.nil? || maint == '0'
 
-    # if the maint release number is an "x" just start the list of OK OS's with it
-    if maint == 'x'
-      ok_oses = [maj + '.' + min.to_s + '.x']
+    ok_oses = []
+
+    # if major == 11 e.g. big sur, e.g. 10.16,
+    # reset major & min so that we get coverage for both
+    # 10.16 and 11, since clients may report it as either
+    if major == '11'
+      major = '10'
+      maint = minor
+      minor = '16'
+    end
+
+    # Deal with 10.x.x up to 10.16
+    if major == '10'
+      # if the maint release number is an "x" just start the list of OK OS's with it
+      if maint == 'x'
+        ok_oses << min_os
+
+      # otherwise, start with it and explicitly add all maint releases for
+      # that maint version. if unknown because its a current or future OS,
+      # go as h
+      else
+        max_maint_for_minor = OS_TEN_MAXS[minor.to_i]
+        (maint.to_i..max_maint_for_minor).each do |m|
+          ok_oses << "#{major}.#{minor}.#{m}"
+        end # each m
+      end
+
+      # now account for all macOS versions starting with 10.
+      # up to 10.16.x
+      ((minor.to_i + 1)..16).each do |v|
+        ok_oses << "#{major}.#{v}.x"
+      end # each v
+
+      # now reset major to 11, so we can continue with BigSur and up
+      major = '11'
+      minor = minor == '16' ? maint : 'x'
+    end # if major == 10
 
-    # otherwise, start with it and explicitly add all maint releases up to 15
-    # (and hope apple doesn't do more than 15 maint releases for an OS)
+    # Now deal with Big Sur and higher, macOS 10.16/11
+    if minor == 'x'
+      ok_oses << "#{major}.#{minor}"
     else
-      ok_oses = []
-      (maint.to_i..25).each do |m|
-        ok_oses << maj + '.' + min + '.' + m.to_s
+      max_minor_for_major = MAC_OS_MAXS[major.to_i]
+      (minor.to_i..max_minor_for_major).each do |m|
+        ok_oses << "#{major}.#{m}"
       end # each m
-    end
+    end # if minor == x
 
-    # now account for all OS X versions starting with 10.
-    # up to 10.30.x
-    ((min.to_i + 1)..30).each do |v|
-      ok_oses << maj + '.' + v.to_s + '.x'
+    # now account for all macOS versions 11 and up
+    ((major.to_i + 1)..MAC_OS_MAXS.keys.max).each do |v|
+      ok_oses << "#{v}.x"
     end # each v
+
     ok_oses
   end
 
@@ -95,6 +193,7 @@ module JSS
   #
   def self.processor_ok?(requirement, processor = nil)
     return true if requirement.to_s.empty? || requirement =~ /none/i
+
     processor ||= `/usr/bin/uname -p`
     requirement == (processor.to_s.include?('86') ? 'x86' : 'ppc')
   end
@@ -115,6 +214,7 @@ module JSS
   def self.os_ok?(requirement, os_to_check = nil)
     return true if requirement.to_s =~ /none/i
     return true if requirement.to_s == 'n'
+
     requirement = JSS.to_s_and_a(requirement)[:arrayform]
     return true if requirement.empty?
 
@@ -187,6 +287,7 @@ module JSS
     case plist
     when String
       return Plist.parse_xml plist if plist.include? '</plist>'
+
       plist = Pathname.new plist
     when Pathname
       true
@@ -223,9 +324,7 @@ module JSS
 
     # if the UTC offset of the datetime is zero, make a new one with the correct local offset
     # (which might also be zero if we happen to be in GMT)
-    if the_dt.offset.zero?
-      the_dt = DateTime.new(the_dt.year, the_dt.month, the_dt.day, the_dt.hour, the_dt.min, the_dt.sec, JSS::TIME_ZONE_OFFSET)
-    end
+    the_dt = DateTime.new(the_dt.year, the_dt.month, the_dt.day, the_dt.hour, the_dt.min, the_dt.sec, JSS::TIME_ZONE_OFFSET) if the_dt.offset.zero?
     # now convert it to a Time and return it
     Time.at the_dt.strftime('%s').to_i, usec
   end # parse_time
@@ -247,6 +346,7 @@ module JSS
   #
   def self.epoch_to_time(epoch)
     return nil if NIL_DATES.include? epoch
+
     Time.at(epoch.to_i / 1000.0)
   end # parse_date
 
@@ -266,6 +366,7 @@ module JSS
   def self.api_object_class(name)
     klass = api_object_names[name.downcase.to_sym]
     raise JSS::InvalidDataError, "Unknown API Object Class: #{name}" unless klass
+
     klass
   end
 
@@ -283,11 +384,13 @@ module JSS
   #
   def self.api_object_names
     return @api_object_names if @api_object_names
+
     @api_object_names ||= {}
     JSS.constants.each do |const|
       klass = JSS.const_get const
       next unless klass.is_a? Class
       next unless klass.ancestors.include? JSS::APIObject
+
       @api_object_names[klass.const_get(:RSRC_LIST_KEY).to_sym] = klass if klass.constants.include? :RSRC_LIST_KEY
       @api_object_names[klass.const_get(:RSRC_OBJECT_KEY).to_sym] = klass if klass.constants.include? :RSRC_OBJECT_KEY
     end
@@ -324,6 +427,7 @@ module JSS
   #
   def self.array_to_rexml_array(element, list)
     raise JSS::InvalidDataError, 'Arg. must be an Array.' unless list.is_a? Array
+
     element = element.to_s
     list.map do |v|
       e = REXML::Element.new(element)
@@ -350,6 +454,7 @@ module JSS
   #
   def self.hash_to_rexml_array(hash)
     raise InvalidDataError, 'Arg. must be a Hash.' unless hash.is_a? Hash
+
     ary = []
     hash.each_pair do |k, v|
       el = REXML::Element.new k.to_s
@@ -428,11 +533,11 @@ module JSS
 
     {
       major: major.to_i,
-      minor:  minor.to_i,
-      revision:  revision.to_i,
-      maint:  revision.to_i,
-      patch:  revision.to_i,
-      build:  build,
+      minor: minor.to_i,
+      revision: revision.to_i,
+      maint: revision.to_i,
+      patch: revision.to_i,
+      build: build,
       version: Gem::Version.new("#{major}.#{minor}.#{revision}")
     }
   end
@@ -457,6 +562,7 @@ module JSS
     @stdin_lines ||= ($stdin.tty? ? [] : $stdin.read.lines.map { |l| l.chomp("\n") })
 
     return @stdin_lines.join("\n") if line <= 0
+
     idx = line - 1
     @stdin_lines[idx]
   end
@@ -489,10 +595,9 @@ module JSS
   # @return [Boolean] The new state of devmode
   #
   def self.devmode(setting)
-    @devmode = setting == :on ? true : false
+    @devmode = setting == :on
   end
 
-
   # is devmode currently on?
   #
   # @return [Boolean]