roku_builder 3.12.8 → 3.13.0

data/lib/roku_builder/controller_commands.rb

@@ -22,7 +22,6 @@ module RokuBuilder
         genkey: { klass: Keyer, method: :genkey, config_key: :genkey },
         screens: { klass: Navigator, method: :screens },
         text: { klass: Navigator, method: :type, config_key: :text_config },
-        test: { klass: Tester, method: :run_tests, config_key: :test_config },
         screencapture: { klass: Inspector, method: :screencapture, config_key: :screencapture_config,
           failure: FAILED_SCREENCAPTURE },
         applist: {klass: Linker, method: :list},
@@ -30,74 +29,86 @@ module RokuBuilder
       }
     end
     # Validate Config
-    # @param logger [Logger] system logger
     # @return [Integer] Success or Failure Code
-    def self.validate(logger:)
-      logger.info "Config validated"
+    def self.validate()
+      Logger.instance.info "Config validated"
       SUCCESS
     end
     # Run Sideload
     # @param options [Hash] user options
-    # @param configs [Hash] parsed configs
-    # @param logger [Logger] system logger
+    # @param config [Config] parsed config
     # @return [Integer] Success or Failure Code
-    def self.sideload(options:, configs:, logger:)
-      config = configs[:device_config].dup
-      config[:init_params] = configs[:init_params][:loader]
-      stager = Stager.new(**configs[:stage_config])
+    def self.sideload(options:, config:)
+      device_config = config.parsed[:device_config].dup
+      device_config[:init_params] = config.parsed[:init_params][:loader]
+      stager = Stager.new(**config.parsed[:stage_config])
       success = nil
       if stager.stage
-        loader = Loader.new(**config)
-        build_version = ManifestManager.build_version(**configs[:manifest_config])
+        loader = Loader.new(**device_config)
+        build_version = ManifestManager.build_version(**config.parsed[:manifest_config])
         options[:build_version] = build_version
-        configs = ConfigManager.update_configs(configs: configs, options: options)
-        success = loader.sideload(**configs[:sideload_config])[0]
+        config.update
+        success = loader.sideload(**config.parsed[:sideload_config])[0]
       end
       stager.unstage
       if success == SUCCESS
-        logger.info "App Sideloaded; staged using #{stager.method}"
+        Logger.instance.info "App Sideloaded; staged using #{stager.method}"
       end
       success
     end
     # Run Package
     # @param options [Hash] user options
-    # @param configs [Hash] parsed configs
-    # @param logger [Logger] system logger
+    # @param config [Conifg] config object
     # @return [Integer] Success or Failure Code
-    def self.package(options:, configs:, logger:)
-      loader_config = configs[:device_config].dup
-      loader_config[:init_params] = configs[:init_params][:loader]
-      keyer = Keyer.new(**configs[:device_config])
-      stager = Stager.new(**configs[:stage_config])
+    def self.package(options:, config:)
+      loader_config = config.parsed[:device_config].dup
+      loader_config[:init_params] = config.parsed[:init_params][:loader]
+      keyer = Keyer.new(**config.parsed[:device_config])
+      stager = Stager.new(**config.parsed[:stage_config])
       loader = Loader.new(**loader_config)
-      packager = Packager.new(**configs[:device_config])
-      logger.warn "Packaging working directory" if options[:working]
+      packager = Packager.new(**config.parsed[:device_config])
+      Logger.instance.warn "Packaging working directory" if options[:working]
       if stager.stage
         # Sideload #
-        code, build_version = loader.sideload(**configs[:sideload_config])
+        code, build_version = loader.sideload(**config.parsed[:sideload_config])
         return code unless code == SUCCESS
         # Key #
-        _success = keyer.rekey(**configs[:key])
+        _success = keyer.rekey(**config.parsed[:key])
         # Package #
         options[:build_version] = build_version
-        configs = ConfigManager.update_configs(configs: configs, options: options)
-        success = packager.package(**configs[:package_config])
-        logger.info "Signing Successful: #{configs[:package_config][:out_file]}" if success
+        config.update
+        success = packager.package(**config.parsed[:package_config])
+        Logger.instance.info "Signing Successful: #{config.parsed[:package_config][:out_file]}" if success
         return FAILED_SIGNING unless success
         # Inspect #
         if options[:inspect]
-          inspect_package(configs: configs)
+          inspect_package(config: config)
         end
       end
       stager.unstage
-      logger.info "App Packaged; staged using #{stager.method}"
+      Logger.instance.info "App Packaged; staged using #{stager.method}"
+      SUCCESS
+    end
+    # Run Sideload
+    # @param options [Hash] user options
+    # @param config [Config] parsed config
+    # @return [Integer] Success or Failure Code
+    def self.test(options:, config:)
+      device_config = config.parsed[:device_config].dup
+      device_config[:init_params] = config.parsed[:init_params][:tester]
+      stager = Stager.new(**config.parsed[:stage_config])
+      if stager.stage
+        tester = Tester.new(**device_config)
+        tester.run_tests(**config.parsed[:test_config])
+      end
+      stager.unstage
       SUCCESS
     end
 
-    def self.inspect_package(configs:)
-      inspector = Inspector.new(**configs[:device_config])
-      info = inspector.inspect(configs[:inspect_config])
-      inspect_logger = Logger.new(STDOUT)
+    def self.inspect_package(config:)
+      inspector = Inspector.new(**config.parsed[:device_config])
+      info = inspector.inspect(config.parsed[:inspect_config])
+      inspect_logger = ::Logger.new(STDOUT)
       inspect_logger.formatter = proc {|_severity, _datetime, _progname, msg|
         "%s\n\r" % [msg]
       }
@@ -112,37 +123,35 @@ module RokuBuilder
 
     # Run Build
     # @param options [Hash] user options
-    # @param configs [Hash] parsed configs
-    # @param logger [Logger] system logger
+    # @param config [Config] config object
     # @return [Integer] Success or Failure Code
-    def self.build(options:, configs:, logger:)
+    def self.build(options:, config:)
       ### Build ###
-      loader_config = configs[:device_config].dup
-      loader_config[:init_params] = configs[:init_params][:loader]
-      stager = Stager.new(**configs[:stage_config])
+      loader_config = config.parsed[:device_config].dup
+      loader_config[:init_params] = config.parsed[:init_params][:loader]
+      stager = Stager.new(**config.parsed[:stage_config])
       loader = Loader.new(**loader_config)
       if stager.stage
-        build_version = ManifestManager.build_version(**configs[:manifest_config])
+        build_version = ManifestManager.build_version(**config.parsed[:manifest_config])
         options[:build_version] = build_version
-        configs = ConfigManager.update_configs(configs: configs, options: options)
-        outfile = loader.build(**configs[:build_config])
-        logger.info "Build: #{outfile}"
+        config.update
+        outfile = loader.build(**config.parsed[:build_config])
+        Logger.instance.info "Build: #{outfile}"
       end
       stager.unstage
-      logger.info "App build; staged using #{stager.method}"
+      Logger.instance.info "App build; staged using #{stager.method}"
       SUCCESS
     end
     # Run update
-    # @param configs [Hash] parsed configs
-    # @param logger [Logger] system logger
+    # @param config [Config] config object
     # @return [Integer] Success or Failure Code
-    def self.update(configs:, logger:)
+    def self.update(config:)
       ### Update ###
-      stager = Stager.new(**configs[:stage_config])
+      stager = Stager.new(**config.parsed[:stage_config])
       if stager.stage
-        old_version = ManifestManager.build_version(**configs[:manifest_config])
-        new_version = ManifestManager.update_build(**configs[:manifest_config])
-        logger.info "Update build version from:\n#{old_version}\nto:\n#{new_version}"
+        old_version = ManifestManager.build_version(**config.parsed[:manifest_config])
+        new_version = ManifestManager.update_build(**config.parsed[:manifest_config])
+        Logger.instance.info "Update build version from:\n#{old_version}\nto:\n#{new_version}"
       end
       stager.unstage
       SUCCESS
@@ -150,17 +159,15 @@ module RokuBuilder
 
     # Run Deeplink
     # @param options [Hash] user options
-    # @param configs [Hash] parsed configs
-    # @param logger [Logger] system logger
-    def self.deeplink(options:, configs:, logger:)
-      sources = options.keys & Controller.sources
-      if sources.count > 0
-        sideload(options: options, configs: configs, logger:logger)
+    # @param config [Config] config object
+    def self.deeplink(options:, config:)
+      if options.has_source?
+        sideload(options: options, config: config)
       end
 
-      linker = Linker.new(configs[:device_config])
-      if linker.launch(configs[:deeplink_config])
-        logger.info "Deeplinked into app"
+      linker = Linker.new(config.parsed[:device_config])
+      if linker.launch(config.parsed[:deeplink_config])
+        Logger.instance.info "Deeplinked into app"
         return SUCCESS
       else
         return FAILED_DEEPLINKING
@@ -169,24 +176,24 @@ module RokuBuilder
 
     # Run Print
     # @param options [Hash] user options
-    # @param configs [Hash] parsed configs
-    def self.print(options:, configs:)
-      stager = Stager.new(**configs[:stage_config])
+    # @param config [Config] config object
+    def self.print(options:, config:)
+      stager = Stager.new(**config.parsed[:stage_config])
       code = nil
       if stager.stage
-        code = Scripter.print(attribute: options[:print].to_sym, configs: configs)
+        code = Scripter.print(attribute: options[:print].to_sym, configs: config.parsed)
       end
       stager.unstage
       code
     end
 
-    def self.dostage(configs:)
-      stager = Stager.new(**configs[:stage_config])
+    def self.dostage(config:)
+      stager = Stager.new(**config.parsed[:stage_config])
       stager.stage
     end
 
-    def self.dounstage(configs:)
-      stager = Stager.new(**configs[:stage_config])
+    def self.dounstage(config:)
+      stager = Stager.new(**config.parsed[:stage_config])
       stager.unstage
     end
 
@@ -194,24 +201,23 @@ module RokuBuilder
     # @param klass [Class] class of object to create
     # @param method [Symbol] methog to run on klass
     # @param config_key [Symbol] config to send from configs if not nil
-    # @param configs [Hash] parsed roku config
+    # @param config [Configs] config object
     # @param failure [Integer] failure code to return on failure if not nil
-    # @param logger [Logger] system logger
     # @return [Integer] Success of failure code
-    def self.simple_command(klass:, method:, config_key: nil, configs:, failure: nil, logger:)
-      config = configs[:device_config].dup
+    def self.simple_command(klass:, method:, config_key: nil, config:, failure: nil)
+      klass_config = config.parsed[:device_config].dup
       key = klass.to_s.split("::")[-1].underscore.to_sym
-      if configs[:init_params][key]
-        config[:init_params] = configs[:init_params][key]
+      if config.parsed[:init_params][key]
+        klass_config[:init_params] = config.parsed[:init_params][key]
       end
-      instance = klass.new(**config)
+      instance = klass.new(**klass_config)
       if config_key
-        success = instance.send(method, configs[config_key])
+        success = instance.send(method, config.parsed[config_key])
       else
         success = instance.send(method)
       end
       return failure unless failure.nil? or success
-      logger.debug "#{klass} call #{method} successfully"
+      Logger.instance.debug "#{klass} call #{method} successfully"
       SUCCESS
     end
   end

data/lib/roku_builder/error_handler.rb

@@ -138,16 +138,5 @@ module RokuBuilder
         abort
       end
     end
-
-    # Print Options Deprications
-    # @param options [Hash] The options hash.
-    # @param logger [Logger] system logger
-    def self.print_options_depricateions(options:, logger:)
-      depricated = Controller.depricated_options.keys & options.keys
-      depricated.each do |key|
-        logger.warn Controller.depricated_options[key]
-      end
-    end
-    private_class_method :print_options_depricateions
   end
 end

data/lib/roku_builder/errors.rb

@@ -0,0 +1,12 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+  class InvalidConfig < StandardError
+  end
+
+  class ParseError < StandardError
+  end
+
+  class InvalidOptions < StandardError
+  end
+end

data/lib/roku_builder/inspector.rb

@@ -54,7 +54,7 @@ module RokuBuilder
       payload =  {
         mysubmit: "Screenshot",
         passwd: @dev_password,
-        archive: Faraday::UploadIO.new("/dev/null", 'application/octet-stream')
+        archive: Faraday::UploadIO.new(File::NULL, 'application/octet-stream')
       }
       response = conn.post path, payload
 
@@ -62,15 +62,17 @@ module RokuBuilder
       return false unless path
       path = path[1]
       unless out_file
-        out_file = /time=([^"]*)">/.match(response.body)
-        out_file = "dev_#{out_file[1]}.jpg" if out_file
+        out_time = /time=([^"]*)">/.match(response.body)
+        out_ext = /dev.([^"]*)\?/.match(response.body)
+        out_file = "dev_#{out_time[1]}.#{out_ext[1]}" if out_time and out_ext
+        out_file = "dev.jpg" unless out_file
       end
 
       conn = simple_connection
 
       response = conn.get path
 
-      File.open(File.join(out_folder, out_file), "w") do |io|
+      File.open(File.join(out_folder, out_file), "wb") do |io|
         io.write(response.body)
       end
       @logger.info "Screen captured to #{File.join(out_folder, out_file)}"

data/lib/roku_builder/keyer.rb

@@ -11,7 +11,7 @@ module RokuBuilder
       @logger.info("DevID: "+dev_id)
 
       unless out_file
-        out_file = File.join("/tmp", "key_"+dev_id+".pkg")
+        out_file = File.join(Dir.tmpdir, "key_"+dev_id+".pkg")
       end
 
       Dir.mktmpdir { |dir|

data/lib/roku_builder/loader.rb

@@ -62,7 +62,7 @@ module RokuBuilder
       content[:folders] ||= Dir.entries(@root_dir).select {|entry| File.directory? File.join(@root_dir, entry) and !(entry =='.' || entry == '..') }
       content[:files] ||= Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
       content[:excludes] ||= []
-      out_file = "/tmp/#{build_version}" unless out_file
+      out_file = "#{Dir.tmpdir}/#{build_version}" unless out_file
       out_file = out_file+".zip" unless out_file.end_with?(".zip")
       File.delete(out_file) if File.exist?(out_file)
       io = Zip::File.open(out_file, Zip::File::CREATE)

data/lib/roku_builder/logger.rb

@@ -0,0 +1,32 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+  class Logger
+
+    @@instance = nil
+
+    def self.instance
+      unless @@instance
+        @@instance = ::Logger.new(STDOUT)
+        @@instance.formatter = proc {|severity, datetime, _progname, msg|
+          "[%s #%s] %5s: %s\n\r" % [datetime.strftime("%Y-%m-%d %H:%M:%S.%4N"), $$, severity, msg]
+        }
+      end
+      @@instance
+    end
+
+    def self.set_debug
+      instance.level = ::Logger::DEBUG
+    end
+    def self.set_info
+      instance.level = ::Logger::INFO
+    end
+    def self.set_warn
+      instance.level = ::Logger::WARN
+    end
+
+    def self.set_testing
+      @@instance = ::Logger.new(File::NULL)
+    end
+  end
+end

data/lib/roku_builder/manifest_manager.rb

@@ -17,8 +17,8 @@ module RokuBuilder
         build_version[1] = iteration
         build_version = build_version.join(".")
       else
-        #Use current date.
-        build_version = Time.now.strftime("%m%d%y")+".0001"
+        iteration = build_version[0].to_i + 1
+        build_version = iteration.to_s
       end
       self.update_manifest(root_dir: root_dir, attributes: {build_version: build_version})
       self.build_version(root_dir: root_dir)

data/lib/roku_builder/monitor.rb

@@ -59,7 +59,7 @@ module RokuBuilder
         "exit", "gc", "help", "last", "list", "next", "print", "p", "?", "step",
         "s", "t", "over", "out", "up", "u", "var", "q"
       ].sort
-      commands.collect { |i| i += ' '  } if libedit
+      commands.collect { |i| i + ' '  } if libedit
 
       comp = proc { |s| commands.grep( /^#{Regexp.escape(s)}/  )  }
 

data/lib/roku_builder/options.rb

@@ -0,0 +1,113 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+  class Options < Hash
+    def initialize(options:)
+      merge!(options)
+      @logger = Logger.instance
+      validate
+    end
+
+    def command
+      (keys & commands).first
+    end
+
+    def exclude_command?
+      exclude_commands.include?(command)
+    end
+
+    def source_command?
+      (source_commands & keys).count > 0
+    end
+
+    def device_command?
+      device_commands.include?(command)
+    end
+
+    def has_source?
+      !(keys & sources).empty?
+    end
+
+    private
+
+    def validate
+      validate_commands
+      validate_sources
+      validate_combinations
+      validate_deprivated
+    end
+
+    def validate_commands
+      all_commands = keys & commands
+      raise InvalidOptions, "Only specify one command" if all_commands.count > 1
+      raise InvalidOptions, "Specify at least one command" if all_commands.count < 1
+    end
+
+    def validate_sources
+      all_sources = keys & sources
+      raise InvalidOptions, "Only spefify one source" if all_sources.count > 1
+      if source_command? and !has_source?
+        raise InvalidOptions, "Must specify a source for that command"
+      end
+    end
+
+    def validate_combinations
+      all_sources = keys & sources
+      if all_sources.include?(:current) and not (self[:build] or self[:sideload])
+        raise InvalidOptions, "Current source onle works for build or sideload"
+      end
+      if self[:in] and not self[:sideload]
+        raise InvalidOptions, "In source only works for sideloading"
+      end
+    end
+
+    def validate_deprivated
+      depricated = keys & depricated_options.keys
+      if depricated.count > 0
+        depricated.each do |key|
+          @logger.warn depricated_options[key]
+        end
+      end
+    end
+
+    # List of command options
+    # @return [Array<Symbol>] List of command symbols that can be used in the options hash
+    def 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 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 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 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 exclude_commands
+      [:build, :package]
+    end
+
+    # List of commands that require a device
+    # @return [Array<Symbol>] List of commands that require a device
+    def device_commands
+      [:sideload, :package, :test, :deeplink, :delete, :navigate, :navigator,
+        :text, :monitor, :screencapture, :applist, :profile, :key, :genkey ]
+    end
+  end
+end