roku_builder 3.12.8 → 3.13.0

data/lib/roku_builder/config_validator.rb

@@ -1,118 +1,125 @@
 # ********** Copyright Viacom, Inc. Apache 2.0 **********
 
 module RokuBuilder
-
-  MISSING_DEVICES           = 1
-  MISSING_DEVICES_DEFAULT   = 2
-  DEVICE_DEFAULT_BAD        = 3
-  #                         = 4
-  MISSING_PROJECTS_DEFAULT  = 5
-  PROJECTS_DEFAULT_BAD      = 6
-  DEVICE_MISSING_IP         = 7
-  DEVICE_MISSING_USER       = 8
-  DEVICE_MISSING_PASSWORD   = 9
-  PROJECT_MISSING_APP_NAME  = 10
-  PROJECT_MISSING_DIRECTORY = 11
-  PROJECT_MISSING_FOLDERS   = 12
-  PROJECT_FOLDERS_BAD       = 13
-  PROJECT_MISSING_FILES     = 14
-  PROJECT_FILES_BAD         = 15
-  STAGE_MISSING_BRANCH      = 16
-  STAGE_MISSING_SCRIPT      = 17
-  PROJECT_STAGE_METHOD_BAD  = 18
-  KEY_MISSING_PATH          = 19
-  KEY_MISSING_PASSWORD      = 20
-  INVALID_MAPPING_INFO      = 21
-  MISSING_KEY               = 22
-
-  MISSING_STAGE_METHOD      = -1
-
-  # Validate Config File
   class ConfigValidator
 
-    # Validates the roku config
-    # @param config [Hash] roku config object
-    # @return [Array] error codes for valid config (see self.error_codes)
-    def self.validate_config(config:)
-      codes = []
-      validate_structure(codes: codes, config: config)
-      [:projects, :devices, :keys].each do |type|
-        if config[type]
-          config[type].each do |key, value|
-            next if [:default, :key_dir, :project_dir].include?(key)
-            method = "validate_#{type.to_s[0..-2]}".to_sym
-            attrs = {codes: codes}
-            attrs[type.to_s[0..-2].to_sym] = value
-            send(method, attrs)
-            if value[:stages]
-              value[:stages].each {|_stage, stage_config|
-                validate_stage(codes: codes, stage: stage_config, project: value, config: config)
-              }
-            end
-          end
+    VALID_CONFIG              = 0
+    MISSING_DEVICES           = 1
+    MISSING_DEVICES_DEFAULT   = 2
+    DEVICE_DEFAULT_BAD        = 3
+    #                         = 4
+    MISSING_PROJECTS_DEFAULT  = 5
+    PROJECTS_DEFAULT_BAD      = 6
+    DEVICE_MISSING_IP         = 7
+    DEVICE_MISSING_USER       = 8
+    DEVICE_MISSING_PASSWORD   = 9
+    PROJECT_MISSING_APP_NAME  = 10
+    PROJECT_MISSING_DIRECTORY = 11
+    PROJECT_MISSING_FOLDERS   = 12
+    PROJECT_FOLDERS_BAD       = 13
+    PROJECT_MISSING_FILES     = 14
+    PROJECT_FILES_BAD         = 15
+    STAGE_MISSING_BRANCH      = 16
+    STAGE_MISSING_SCRIPT      = 17
+    PROJECT_STAGE_METHOD_BAD  = 18
+    KEY_MISSING_PATH          = 19
+    KEY_MISSING_PASSWORD      = 20
+    INVALID_MAPPING_INFO      = 21
+    MISSING_KEY               = 22
+    MISSING_STAGE_METHOD      = 23
+
+    def initialize(config:)
+      @logger = Logger.instance
+      @config = config
+      validate_config
+    end
+
+    def print_errors
+      @codes.each do |code|
+        if code > 0
+          @logger.fatal error_codes[code]
+        end
+        if code < 0
+          @logger.warn error_codes[code]
         end
       end
-      if config[:input_mapping]
-        config[:input_mapping].each_value {|info| validate_mapping(codes: codes, mapping: info) }
+    end
+
+    def is_fatal?
+      !@codes.select{|code| code > 0}.empty?
+    end
+
+    def is_depricated?
+      !@codes.select{|code| code < 0}.empty?
+    end
+
+    def is_valid?
+      @codes.select{|code| code > 0}.empty?
+    end
+
+    private
+
+    def validate_config
+      @codes = []
+      validate_structure
+      [:projects, :devices, :keys, :input_mapping].each do |section|
+        validate_section(section: section) if @config[section]
       end
-      codes.uniq!
-      codes.push(0) if codes.empty?
-      codes
+      @codes.uniq!
+      @codes.push(VALID_CONFIG) if @codes.empty?
     end
 
-    # Error code messages for config validation
-    # @return [Array] error code messages
-    def self.error_codes()
-      [
-        #===============FATAL ERRORS===============#
-        "Valid Config.",
-        "Devices config is missing.",
-        "Devices default is missing.",
-        "Devices default is not a hash.",
-        "",
-        "Projects default is missing.", #5
-        "Projects default is not a hash.",
-        "A device config is missing its IP address.",
-        "A device config is missing its username.",
-        "A device config is missing its password.",
-        "A project config is missing its app_name.", #10
-        "A project config is missing its directorty.",
-        "A project config is missing its folders.",
-        "A project config's folders is not an array.",
-        "A project config is missing its files.",
-        "A project config's files is not an array.", #15
-        "A project stage is missing its branch.",
-        "A project stage is missing its script.",
-        "A project as an invalid stage method.",
-        "A key is missing its keyed package path.",
-        "A key is missing its password.", #20
-        "A input mapping is invalid",
-        "A key is missing from the keys section",
-        #===============WARNINGS===============#
-        "A project is missing its stage method."
-      ]
+    def validate_section(section:)
+      @config[section].each do |key, value|
+        next unless should_validate(key: key)
+        call_validate_method_for_section(section: section, content: value)
+        if has_stages(section_content: value)
+          validate_stages(project_content: value)
+        end
+      end
+    end
+
+    def should_validate(key:)
+      !([:default, :key_dir, :project_dir].include?(key))
+    end
+
+    def call_validate_method_for_section(section:, content:)
+      section_singular = singularize(section: section.to_s)
+      attrs = {}
+      attrs[section_singular] = content
+      method = "validate_#{section_singular}".to_sym
+      send(method, attrs)
+    end
+
+    def singularize(section:)
+      section = section[0..-2] if section.end_with?("s")
+      section.to_sym
+    end
+
+    def has_stages(section_content:)
+      section_content.class == Hash and section_content[:stages]
+    end
+
+    def validate_stages(project_content:)
+      project_content[:stages].each_value {|stage_config|
+        validate_stage(stage: stage_config, project: project_content)
+      }
     end
 
-    # Validates the roku config structure
-    # @param codes [Array] array of error codes
-    # @param config [Hash] roku config object
-    def self.validate_structure(codes:, config:)
+
+    def validate_structure
       errors = [
-        [MISSING_DEVICES, !config[:devices]],
-        [MISSING_DEVICES_DEFAULT, (config[:devices] and !config[:devices][:default])],
-        [DEVICE_DEFAULT_BAD, (config[:devices] and config[:devices][:default] and !config[:devices][:default].is_a?(Symbol))],
-        [MISSING_PROJECTS_DEFAULT, (config[:projects] and !config[:projects][:default])],
-        [MISSING_PROJECTS_DEFAULT, (config[:projects] and config[:projects][:default] == "<project id>".to_sym)],
-        [PROJECTS_DEFAULT_BAD, (config[:projects] and config[:projects][:default] and !config[:projects][:default].is_a?(Symbol))]
+        [MISSING_DEVICES, !@config[:devices]],
+        [MISSING_DEVICES_DEFAULT, (@config[:devices] and !@config[:devices][:default])],
+        [DEVICE_DEFAULT_BAD, (@config[:devices] and @config[:devices][:default] and !@config[:devices][:default].is_a?(Symbol))],
+        [MISSING_PROJECTS_DEFAULT, (@config[:projects] and !@config[:projects][:default])],
+        [MISSING_PROJECTS_DEFAULT, (@config[:projects] and @config[:projects][:default] == "<project id>".to_sym)],
+        [PROJECTS_DEFAULT_BAD, (@config[:projects] and @config[:projects][:default] and !@config[:projects][:default].is_a?(Symbol))]
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_structure
 
-    # Validates a roku config device
-    # @param codes [Array] array of error codes
-    # @param device [Hash] device config object
-    def self.validate_device(codes:, device:)
+    def validate_device(device:)
       errors = [
         [DEVICE_MISSING_IP, (!device[:ip])],
         [DEVICE_MISSING_IP, (device[:ip] == "xxx.xxx.xxx.xxx")],
@@ -124,14 +131,10 @@ module RokuBuilder
         [DEVICE_MISSING_PASSWORD, (device[:password] == "<password>")],
         [DEVICE_MISSING_PASSWORD, (device[:password] == "")]
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_device
 
-    # Validates a roku config project
-    # @param codes [Array] array of error codes
-    # @param project [Hash] project config object
-    def self.validate_project(codes:, project:)
+    def validate_project(project:)
       errors= [
         [PROJECT_MISSING_APP_NAME, (!project[:app_name])],
         [PROJECT_MISSING_DIRECTORY, (!project[:directory])],
@@ -142,49 +145,69 @@ module RokuBuilder
         [MISSING_STAGE_METHOD, ( !project[:stage_method])],
         [PROJECT_STAGE_METHOD_BAD, (![:git, :script, nil].include?(project[:stage_method]))]
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_project
 
-    # Validates a roku config project
-    # @param codes [Array] array of error codes
-    # @param project [Hash] project config object
-    def self.validate_stage(codes:, stage:, project:, config:)
+    def validate_stage(stage:, project:)
       errors= [
         [STAGE_MISSING_BRANCH, (!stage[:branch] and project[:stage_method] == :git)],
         [STAGE_MISSING_SCRIPT, (!stage[:script] and project[:stage_method] == :script)],
-        [MISSING_KEY, (!!stage[:key] and stage[:key].class == String and (!config[:keys] or !config[:keys][stage[:key].to_sym]))]
+        [MISSING_KEY, (!!stage[:key] and stage[:key].class == String and (!@config[:keys] or !@config[:keys][stage[:key].to_sym]))]
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_stage
 
-    # Validates a roku config project
-    # @param codes [Array] array of error codes
-    # @param project [Hash] project config object
-    def self.validate_key(codes:, key:)
+    def validate_key(key:)
       errors= [
         [KEY_MISSING_PATH, (!key[:keyed_pkg])],
         [KEY_MISSING_PATH, (key[:keyed_pkg] == "<path/to/signed/package>")],
         [KEY_MISSING_PASSWORD, (!key[:password])],
         [KEY_MISSING_PASSWORD, (key[:password] == "<password>")],
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_key
 
-    def self.validate_mapping(codes:, mapping:)
+    def validate_input_mapping(input_mapping:)
       errors=[
-        [INVALID_MAPPING_INFO, (mapping.count != 2)]
+        [INVALID_MAPPING_INFO, (input_mapping.count != 2)]
       ]
-      process_errors(codes: codes, errors: errors)
+      process_errors(errors: errors)
     end
-    private_class_method :validate_mapping
 
-    def self.process_errors(codes:, errors:)
+    def process_errors(errors:)
       errors.each do |error|
-        codes.push(error[0]) if error[1]
+        @codes.push(error[0]) if error[1]
       end
     end
+
+    def error_codes
+      [
+        #===============FATAL ERRORS===============#
+        "Valid Config.",
+        "Devices config is missing.",
+        "Devices default is missing.",
+        "Devices default is not a hash.",
+        "",
+        "Projects default is missing.", #5
+        "Projects default is not a hash.",
+        "A device config is missing its IP address.",
+        "A device config is missing its username.",
+        "A device config is missing its password.",
+        "A project config is missing its app_name.", #10
+        "A project config is missing its directorty.",
+        "A project config is missing its folders.",
+        "A project config's folders is not an array.",
+        "A project config is missing its files.",
+        "A project config's files is not an array.", #15
+        "A project stage is missing its branch.",
+        "A project stage is missing its script.",
+        "A project as an invalid stage method.",
+        "A key is missing its keyed package path.",
+        "A key is missing its password.", #20
+        "A input mapping is invalid",
+        "A key is missing from the keys section",
+        "A project is missing its stage method."
+      ]
+    end
   end
 end

data/lib/roku_builder/controller.rb

@@ -7,126 +7,46 @@ module RokuBuilder
 
     # Run the builder
     # @param options [Hash] The options hash
-    def self.run(options:, logger:)
-      if options[:debug]
-        logger.level = Logger::DEBUG
-      elsif options[:verbose]
-        logger.level = Logger::INFO
-      else
-        logger.level = Logger::WARN
-      end
-
-      # Validate Options
-      options_code = validate_options(options: options)
-      ErrorHandler.handle_options_codes(options_code: options_code, options: options, logger: logger)
+    def self.run(options:)
+      options = Options.new(options: options)
 
-      # Configure Gem
-      configure_code = configure(options: options, logger: logger)
-      ErrorHandler.handle_configure_codes(configure_code: configure_code, logger: logger)
+      initialize_logger(options: options)
 
       # Load Config
-      load_code, config, configs = ConfigManager.load_config(options: options, logger: logger)
-      ErrorHandler.handle_load_codes(options: options, load_code: load_code, logger: logger)
-
-      # Check Configs
-      configs_code = validate_configs(configs: configs)
-      ErrorHandler.handle_configs_codes(configs_code: configs_code, logger: logger)
+      config = Config.new(options: options)
+      config.configure
+      config.load
+      config.validate
+      config.parse
 
       # Check devices
-      device_code, configs = check_devices(options: options, config: config, configs: configs, logger: logger)
-      ErrorHandler.handle_device_codes(device_code: device_code, logger: logger)
+      device_code = check_devices(options: options, config: config)
+      ErrorHandler.handle_device_codes(device_code: device_code, logger: Logger.instance)
 
       # Run Commands
-      command_code = execute_commands(options: options, configs: configs, logger: logger)
-      ErrorHandler.handle_command_codes(command_code: command_code, logger: logger)
-    end
-
-    # Validates the user options
-    # @param options [Hash] The options hash
-    # @return [Integer] Status code for command validation
-    def self.validate_options(options:)
-      command_result = validate_command_options(options: options)
-      return command_result unless command_result == VALID
-      source_result = validate_source_options(options: options)
-      return source_result unless source_result == VALID
-      combination_result = validate_option_combinations(options: options)
-      return combination_result unless combination_result == VALID
-      return validate_depricated_commands(options: options)
-    end
-    private_class_method :validate_options
-
-    # Validates use of command options
-    # @param options [Hash] The options hash
-    # @return [Integer] Status code for command validation
-    def self.validate_command_options(options:)
-      all_commands = options.keys & commands
-      return EXTRA_COMMANDS if all_commands.count > 1
-      return NO_COMMANDS if all_commands.count < 1
-      VALID
-    end
-    private_class_method :validate_command_options
-
-    # Validates use of source options
-    # @param options [Hash] The options hash
-    # @return [Integer] Status code for command validation
-    def self.validate_source_options(options:)
-      all_sources = options.keys & sources
-      return EXTRA_SOURCES if all_sources.count > 1
-      if (options.keys & source_commands).count == 1
-        return NO_SOURCE unless all_sources.count == 1
-      end
-      VALID
-    end
-    private_class_method :validate_source_options
-
-    # Validates proper option combinations
-    # @param options [Hash] The options hash
-    # @return [Integer] Status code for command validation
-    def self.validate_option_combinations(options:)
-      all_sources = options.keys & sources
-      if all_sources.include?(:current)
-        return BAD_CURRENT unless options[:build] or options[:sideload]
-      end
-      if options[:in]
-        return BAD_IN_FILE unless options[:sideload]
-      end
-      VALID
-    end
-    private_class_method :validate_option_combinations
-
-    # Validate depricated options adn commands
-    # @param options [Hash] The Options hash
-    # @return [Integer] Status code for command validation
-    def self.validate_depricated_commands(options:)
-      depricated = options.keys & depricated_options.keys
-      if depricated.count > 0
-        return DEPRICATED
-      end
-      VALID
+      command_code = execute_commands(options: options, config: config)
+      ErrorHandler.handle_command_codes(command_code: command_code, logger: Logger.instance)
     end
-    private_class_method :validate_depricated_commands
 
-    # Validate config hash
-    # @param configs [Hash] The Configs hash
-    # @return [Integer] Status code for command validation
-    def self.validate_configs(configs:)
-      unless Dir.exist?(configs[:out][:folder])
-        return MISSING_OUT_FOLDER
+    def self.initialize_logger(options:)
+      if options[:debug]
+        Logger.set_debug
+      elsif options[:verbose]
+        Logger.set_info
+      else
+        Logger.set_warn
       end
-      VALID
     end
-    private_class_method :validate_configs
 
     # Run commands
     # @param options [Hash] The options hash
     # @return [Integer] Return code for options handeling
     # @param logger [Logger] system logger
-    def self.execute_commands(options:, configs:, logger:)
-      command = (commands & options.keys).first
+    def self.execute_commands(options:, config:)
+      command = options.command
       if ControllerCommands.simple_commands.keys.include?(command)
         params = ControllerCommands.simple_commands[command]
-        params[:configs] = configs
-        params[:logger] = logger
+        params[:config] = config
         ControllerCommands.simple_command(**params)
       else
         params = ControllerCommands.method(command.to_s).parameters.collect{|a|a[1]}
@@ -135,10 +55,8 @@ module RokuBuilder
           case key
           when :options
             args[:options] = options
-          when :configs
-            args[:configs] = configs
-          when :logger
-            args[:logger] = logger
+          when :config
+            args[:config] = config
           end
         end
         ControllerCommands.send(command, args)
@@ -149,95 +67,27 @@ module RokuBuilder
     # Ensure that the selected device is accessable
     # @param options [Hash] The options hash
     # @param logger [Logger] system logger
-    def self.check_devices(options:, config:, configs:, logger:)
-      command = (options.keys & commands).first
-      if device_commands.include?(command)
+    def self.check_devices(options:, config:)
+      if options.device_command?
         ping = Net::Ping::External.new
-        host = configs[:device_config][:ip]
-        return [GOOD_DEVICE, configs] if ping.ping? host, 1, 0.2, 1
-        return [BAD_DEVICE, nil] if options[:device_given]
-        config[:devices].each_pair {|key, value|
+        host = config.parsed[:device_config][:ip]
+        return GOOD_DEVICE if ping.ping? host, 1, 0.2, 1
+        return BAD_DEVICE if options[:device_given]
+        config.raw[:devices].each_pair {|key, value|
           unless key == :default
             host = value[:ip]
             if ping.ping? host, 1, 0.2, 1
-              configs[:device_config] = value
-              configs[:device_config][:logger] = logger
-              return [CHANGED_DEVICE, configs]
+              config.parsed[:device_config] = value
+              return CHANGED_DEVICE
             end
           end
         }
-        return [NO_DEVICES, nil]
+        return NO_DEVICES
       end
-      return [GOOD_DEVICE, configs]
+      return GOOD_DEVICE
     end
     private_class_method :check_devices
 
-    # List of command options
-    # @return [Array<Symbol>] List of command symbols that can be used in the options hash
-    def self.commands
-      [:sideload, :package, :test, :deeplink,:configure, :validate, :delete,
-        :navigate, :navigator, :text, :build, :monitor, :update, :screencapture,
-        :key, :genkey, :screen, :screens, :applist, :print, :profile, :dostage,
-        :dounstage]
-    end
-
-    # List of depricated options
-    # @return [Hash] Hash of depricated options and the warning message for each
-    def self.depricated_options
-      {deeplink_depricated: "-L and --deeplink are depricated. Use -o or --deeplink-options." }
-    end
-
-    # List of source options
-    # @return [Array<Symbol>] List of source symbols that can be used in the options hash
-    def self.sources
-      [:ref, :set_stage, :working, :current, :in]
-    end
-
-    # List of commands requiring a source option
-    # @return [Array<Symbol>] List of command symbols that require a source in the options hash
-    def self.source_commands
-      [:sideload, :package, :test, :build, :key, :update, :print]
-    end
-
-    # List of commands the activate the exclude files
-    # @return [Array<Symbol] List of commands the will activate the exclude files lists
-    def self.exclude_commands
-      [:build, :package]
-    end
-
-    # List of commands that require a device
-    # @return [Array<Symbol>] List of commands that require a device
-    def self.device_commands
-      [:sideload, :package, :test, :deeplink, :delete, :navigate, :navigator,
-        :text, :monitor, :screencapture, :applist, :profile, :key, :genkey ]
-    end
-
-
-    # Configure the gem
-    # @param options [Hash] The options hash
-    # @return [Integer] Success or failure code
-    # @param logger [Logger] system logger
-    def self.configure(options:, logger:)
-      if options[:configure]
-        source_config = File.expand_path(File.join(File.dirname(__FILE__), "..", '..', 'config.json.example'))
-        target_config = File.expand_path(options[:config])
-        if File.exist?(target_config)
-          unless options[:edit_params]
-            return CONFIG_OVERWRITE
-          end
-        else
-          ### Copy Config File ###
-          FileUtils.copy(source_config, target_config)
-        end
-        if options[:edit_params]
-          ConfigManager.edit_config(config: target_config, options: options, logger: logger)
-        end
-        return SUCCESS
-      end
-      nil
-    end
-    private_class_method :configure
-
     # Run a system command
     # @param command [String] The command to be run
     # @return [String] The output of the command