machinery-tool 1.22.1 → 1.22.2

data/lib/export_task.rb

@@ -15,7 +15,7 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class ExportTask
+class Machinery::ExportTask
   def initialize(exporter)
     @exporter = exporter
   end

data/lib/exporter.rb

@@ -16,7 +16,7 @@
 # you may find current contact information at www.suse.com
 
 # Interface class for exporter
-class Exporter
+class Machinery::Exporter
   attr_reader :system_description
 
   abstract_method :write

data/lib/file_diff.rb

@@ -15,7 +15,7 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class FileDiff
+class Machinery::FileDiff
   def self.diff(description1, description2, scope, path)
     return nil if !description1.scope_extracted?(scope) || !description2.scope_extracted?(scope)
 

data/lib/file_scope.rb

@@ -15,7 +15,7 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class FileScope < Machinery::Array
+class Machinery::FileScope < Machinery::Array
   def compare_with(other)
     only_self, only_other, changed, common = super(other)
 

data/lib/file_validator.rb

@@ -15,7 +15,7 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class FileValidator
+class Machinery::FileValidator
   def initialize(json_hash, base_path)
     @json_hash = json_hash
     @base_path = base_path
@@ -39,7 +39,10 @@ class FileValidator
       next unless scope_extracted?(scope)
 
       expected_files = expected_files(scope)
-      file_errors = validate_scope(ScopeFileStore.new(@base_path, scope.to_s), expected_files)
+      file_errors = validate_scope(
+        Machinery::ScopeFileStore.new(@base_path, scope.to_s),
+        expected_files
+      )
 
       errors << "Scope '#{scope}':\n" + file_errors.join("\n") unless file_errors.empty?
     end
@@ -58,7 +61,7 @@ class FileValidator
 
   def scope_extracted?(scope)
     if @format_version == 1
-      @json_hash[scope] && ScopeFileStore.new(@base_path, scope.to_s).path
+      @json_hash[scope] && Machinery::ScopeFileStore.new(@base_path, scope.to_s).path
     elsif @format_version < 6
       @json_hash[scope] && @json_hash[scope]["extracted"]
     else
@@ -92,7 +95,7 @@ class FileValidator
       end.map { |file| file["name"] }
     end
 
-    store_base_path = ScopeFileStore.new(@base_path, scope.to_s).path
+    store_base_path = Machinery::ScopeFileStore.new(@base_path, scope.to_s).path
     expected_files.map { |file| File.join(store_base_path, file) }
   end
 

data/lib/filter.rb

@@ -43,129 +43,133 @@
 #
 # More details about how the filter work can be found at
 # https://github.com/SUSE/machinery/blob/master/docs/Filtering-Design.md
-class Filter
-  attr_accessor :element_filters
-
-  OPERATOR_EQUALS = "="
-  OPERATOR_EQUALS_NOT = "!="
-
-  def self.parse_filter_definitions(filter_definitions)
-    element_filters = {}
-    Array(filter_definitions).each do |definition|
-      path, operator, matcher_definition = definition.scan(/([a-zA-Z_\/]+)(.*=)(.*)/)[0]
-
-      raise Machinery::Errors::InvalidFilter.new("Invalid filter: '#{definition}'") unless operator
-      element_filters[path] ||= ElementFilter.new(path)
-      if matcher_definition.index(",")
-        matchers = matcher_definition.split(/(?<!\\),/)
-        matchers.map! { |matcher| matcher.gsub("\\,", ",") } # Unescape escaped commas
-
-        element_filters[path].add_matchers(operator, [matchers])
-      else
-        element_filters[path].add_matchers(operator, matcher_definition)
+module Machinery
+  class Filter
+    attr_accessor :element_filters
+
+    OPERATOR_EQUALS = "=".freeze
+    OPERATOR_EQUALS_NOT = "!=".freeze
+
+    def self.parse_filter_definitions(filter_definitions)
+      element_filters = {}
+      Array(filter_definitions).each do |definition|
+        path, operator, matcher_definition = definition.scan(/([a-zA-Z_\/]+)(.*=)(.*)/)[0]
+
+        raise Machinery::Errors::InvalidFilter.new(
+          "Invalid filter: '#{definition}'"
+        ) unless operator
+        element_filters[path] ||= ElementFilter.new(path)
+        if matcher_definition.index(",")
+          matchers = matcher_definition.split(/(?<!\\),/)
+          matchers.map! { |matcher| matcher.gsub("\\,", ",") } # Unescape escaped commas
+
+          element_filters[path].add_matchers(operator, [matchers])
+        else
+          element_filters[path].add_matchers(operator, matcher_definition)
+        end
       end
-    end
 
-    element_filters
-  end
+      element_filters
+    end
 
-  def self.from_default_definition(command)
-    filter = Filter.new
+    def self.from_default_definition(command)
+      filter = Filter.new
 
-    default_filters_file = File.join(Machinery::ROOT, "filters", "default_filters.json")
-    if File.exist?(default_filters_file)
-      default_filters = JSON.parse(File.read(default_filters_file))
-      if default_filters[command]
-        default_filters[command].each do |definition|
-          filter.add_element_filter_from_definition(definition)
+      default_filters_file = File.join(Machinery::ROOT, "filters", "default_filters.json")
+      if File.exist?(default_filters_file)
+        default_filters = JSON.parse(File.read(default_filters_file))
+        if default_filters[command]
+          default_filters[command].each do |definition|
+            filter.add_element_filter_from_definition(definition)
+          end
         end
       end
-    end
 
-    filter
-  end
+      filter
+    end
 
-  def initialize(definitions = [])
-    @element_filters = Filter.parse_filter_definitions(definitions)
-  end
+    def initialize(definitions = [])
+      @element_filters = Filter.parse_filter_definitions(definitions)
+    end
 
-  def add_element_filter_from_definition(filter_definition)
-    add_element_filters(Filter.parse_filter_definitions(filter_definition).values)
-  end
+    def add_element_filter_from_definition(filter_definition)
+      add_element_filters(Filter.parse_filter_definitions(filter_definition).values)
+    end
 
-  def add_element_filters(element_filters)
-    Array(element_filters).each do |element_filter|
-      path = element_filter.path
-      @element_filters[path] ||= ElementFilter.new(path)
+    def add_element_filters(element_filters)
+      Array(element_filters).each do |element_filter|
+        path = element_filter.path
+        @element_filters[path] ||= ElementFilter.new(path)
 
-      element_filter.matchers.each do |operator, matchers|
-        @element_filters[path].add_matchers(operator, matchers)
+        element_filter.matchers.each do |operator, matchers|
+          @element_filters[path].add_matchers(operator, matchers)
+        end
       end
     end
-  end
-
-  def element_filter_for(path)
-    element_filters[path]
-  end
 
-  def element_filters_for_scope(scope)
-    @element_filters.values.select do |element_filter|
-      element_filter.filters_scope?(scope)
+    def element_filter_for(path)
+      element_filters[path]
     end
-  end
 
-  def set_element_filters_for_scope(scope, element_filters)
-    @element_filters.reject! do |_path, element_filter|
-      element_filter.filters_scope?(scope)
+    def element_filters_for_scope(scope)
+      @element_filters.values.select do |element_filter|
+        element_filter.filters_scope?(scope)
+      end
     end
 
-    add_element_filters(element_filters)
-  end
+    def set_element_filters_for_scope(scope, element_filters)
+      @element_filters.reject! do |_path, element_filter|
+        element_filter.filters_scope?(scope)
+      end
+
+      add_element_filters(element_filters)
+    end
 
-  def to_array
-    @element_filters.flat_map do |path, element_filter|
-      element_filter.matchers.flat_map do |operator, matchers|
-        matchers.map do |matcher|
-          "#{path}#{operator}#{Array(matcher).join(",")}"
+    def to_array
+      @element_filters.flat_map do |path, element_filter|
+        element_filter.matchers.flat_map do |operator, matchers|
+          matchers.map do |matcher|
+            "#{path}#{operator}#{Array(matcher).join(",")}"
+          end
         end
       end
     end
-  end
 
-  def matches?(path, value)
-    filter = element_filter_for(path)
-    return false unless filter
+    def matches?(path, value)
+      filter = element_filter_for(path)
+      return false unless filter
 
-    filter.matches?(value)
-  end
+      filter.matches?(value)
+    end
 
-  def apply!(system_description)
-    element_filters.each do |path, element_filter|
-      steps = path.split("/").reject(&:empty?)
-      target = steps.pop
-
-      pointer = system_description
-      container = nil
-      steps.each do |step|
-        break unless pointer
-        pointer = pointer[step]
-        container ||= pointer if pointer.is_a?(Machinery::Array)
-      end
+    def apply!(system_description)
+      element_filters.each do |path, element_filter|
+        steps = path.split("/").reject(&:empty?)
+        target = steps.pop
+
+        pointer = system_description
+        container = nil
+        steps.each do |step|
+          break unless pointer
+          pointer = pointer[step]
+          container ||= pointer if pointer.is_a?(Machinery::Array)
+        end
 
-      next unless pointer
+        next unless pointer
 
-      begin
-        pointer.delete_if do |element|
-          element_filter.matches?(element[target])
+        begin
+          pointer.delete_if do |element|
+            element_filter.matches?(element[target])
+          end
+        rescue Machinery::Errors::ElementFilterTypeMismatch => e
+          Machinery::Ui.warn("Warning: Filter '#{e.failed_matcher}' tries to match an array, " \
+            "but the according element is not an array.")
         end
-      rescue Machinery::Errors::ElementFilterTypeMismatch => e
-        Machinery::Ui.warn("Warning: Filter '#{e.failed_matcher}' tries to match an array, " \
-          "but the according element is not an array.")
       end
     end
-  end
 
-  def empty?
-    element_filters.empty?
+    def empty?
+      element_filters.empty?
+    end
   end
 end

data/lib/filter_option_parser.rb

@@ -17,10 +17,10 @@
 
 # This class takes care of transforming the user-provided filter options into
 # actual Filter objects.
-class FilterOptionParser
+class Machinery::FilterOptionParser
   class <<self
     def parse(command, options)
-      filter = Filter.from_default_definition(command)
+      filter = Machinery::Filter.from_default_definition(command)
 
       definitions = skip_files_definitions(options.delete("skip-files"))
       definitions += exclude_definitions(options["exclude"])

data/lib/hint.rb

@@ -15,78 +15,83 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class Hint
-  class << self
-    def print(method, options = {})
-      return unless Machinery::Config.new.hints
+module Machinery
+  class Ui
+    class Hint
+      class << self
+        def print(method, options = {})
+          return unless Machinery::Config.new.hints
 
-      Machinery::Ui.puts to_string(method, options)
-    end
+          Machinery::Ui.puts to_string(method, options)
+        end
 
-    def to_string(method, options = {})
-      return "" unless Machinery::Config.new.hints
+        def to_string(method, options = {})
+          return "" unless Machinery::Config.new.hints
 
-      "\nHint: #{send(method, options)}\n"
-    end
+          "\nHint: #{send(method, options)}\n"
+        end
 
-    def program_name
-      if which_machinery == $PROGRAM_NAME
-        "machinery"
-      else
-        $PROGRAM_NAME
-      end
-    end
+        def program_name
+          if which_machinery == $PROGRAM_NAME
+            "machinery"
+          else
+            $PROGRAM_NAME
+          end
+        end
 
-    private
+        private
 
-    def which_machinery
-      `which machinery 2>/dev/null`.chomp
-    rescue Errno::EPIPE => e
-      Machinery.logger.debug "Command `which machinery 2>/dev/null` crashed. " \
-                             "Error was #{e.class}: #{e}"
-    end
+        def which_machinery
+          `which machinery 2>/dev/null`.chomp
+        rescue Errno::EPIPE => e
+          Machinery.logger.debug "Command `which machinery 2>/dev/null` crashed. " \
+                                 "Error was #{e.class}: #{e}"
+        end
 
-    def get_started(_options)
-      "You can get started by inspecting a system. Run:\n'#{program_name} inspect HOSTNAME'\n" \
-      "To inspect a system as a user with sudo rights instead of root run:\n" \
-      "'#{program_name} inspect --remote-user USER HOSTNAME'"
-    end
+        def get_started(_options)
+          "You can get started by inspecting a system. Run:\n'#{program_name} inspect HOSTNAME'\n" \
+          "To inspect a system as a user with sudo rights instead of root run:\n" \
+          "'#{program_name} inspect --remote-user USER HOSTNAME'"
+        end
 
-    def upgrade_format_force(options)
-      "To force an upgrade of system descriptions run:\n" \
-      "#{program_name} upgrade-format --force #{options[:name]}"
-    end
+        def upgrade_format_force(options)
+          "To force an upgrade of system descriptions run:\n" \
+          "#{program_name} upgrade-format --force #{options[:name]}"
+        end
 
-    def show_data(options)
-      "To show the data of the system you just inspected run:\n#{program_name} show #{options[:name]}"
-    end
+        def show_data(options)
+          "To show the data of the system you just inspected "\
+          "run:\n#{program_name} show #{options[:name]}"
+        end
 
-    def show_analyze_data(options)
-      "To show the config file diffs you just created run:\n" \
-        "#{program_name} show --scope changed-config-files --show-diffs #{options[:name]}"
-    end
+        def show_analyze_data(options)
+          "To show the config file diffs you just created run:\n" \
+            "#{program_name} show --scope changed-config-files --show-diffs #{options[:name]}"
+        end
 
-    def do_complete_inspection(options)
-      if options[:host]
-        "To do a full inspection containing all scopes and to extract files run:\n" \
-         "#{program_name} inspect #{options[:host]} --name #{options[:name]} --extract-files"
-      elsif options[:docker_container]
-        "To do a full inspection containing all scopes and to extract files run:\n" \
-         "#{program_name} inspect-container #{options[:docker_container]} " \
-         "--name #{options[:name]} --extract-files"
-      end
-    end
+        def do_complete_inspection(options)
+          if options[:host]
+            "To do a full inspection containing all scopes and to extract files run:\n" \
+             "#{program_name} inspect #{options[:host]} --name #{options[:name]} --extract-files"
+          elsif options[:docker_container]
+            "To do a full inspection containing all scopes and to extract files run:\n" \
+             "#{program_name} inspect-container #{options[:docker_container]} " \
+             "--name #{options[:name]} --extract-files"
+          end
+        end
 
-    def upgrade_system_description(_options)
-      "To upgrade all system descriptions run:\n" \
-       "#{program_name} upgrade-format --all"
-    end
+        def upgrade_system_description(_options)
+          "To upgrade all system descriptions run:\n" \
+           "#{program_name} upgrade-format --all"
+        end
 
-    def share_html_contents(options)
-      dir = options[:directory] || ""
-      index_file = File.join(dir, "index.html")
-      assets_dir = File.join(dir, "assets/")
-      "Share the file: '#{index_file}' and the directory: '#{assets_dir}' as needed."
+        def share_html_contents(options)
+          dir = options[:directory] || ""
+          index_file = File.join(dir, "index.html")
+          assets_dir = File.join(dir, "assets/")
+          "Share the file: '#{index_file}' and the directory: '#{assets_dir}' as needed."
+        end
+      end
     end
   end
 end