roku_builder 3.11.0 → 3.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6dbac3c0fec31e905833e19647dd92bb3d4864d
-  data.tar.gz: 321dd14fbb7e7f5e6a29112958e0c5c66834927d
+  metadata.gz: 24f62ca635f6a690606f53980f4b2de0d3206525
+  data.tar.gz: 1d061880ae44bd0764ed4ec22583f2402749a917
 SHA512:
-  metadata.gz: 55f1f1c4dd3b20aec47e227b28e4c69a028718c09adea8f068722129dc8ef03a3e467755c4f277cb7d5e6b8aa3c7d0fa081111fff9721fc72651600542fab1c5
-  data.tar.gz: d2d4f21e3ad6591a33bff630560b837086a385d5d882b1b060572ccc8af4515e4975c66906e82bef628302848934227549467ed513f1e405c9f13d1fbd68037c
+  metadata.gz: 8583f7c075a0fce0cc992d0f215b27e0145b147a88da14b4785887a84e70e60f85ecb0b91d5548081850c4347b2457c3bab4f1644fde1abbdbeb21832fb23960
+  data.tar.gz: afe84a4778c8ac21c3c97cf450e73ec5215d80f67d9dfba5a2dbc034f4637c7b9e7479b0d362ae775a21b5008be08dd21b58d6104fd7ed8a14efbde9ddcf3327

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.11.0)
-      faraday (~> 0.10)
+    roku_builder (3.11.1)
+      faraday (~> 0.11)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)
       net-ping (~> 2.0)
@@ -15,7 +15,7 @@ GEM
   specs:
     byebug (9.0.6)
     coderay (1.1.1)
-    coveralls (0.8.17)
+    coveralls (0.8.19)
       json (>= 1.8, < 3)
       simplecov (~> 0.12.0)
       term-ansicolor (~> 1.3)
@@ -26,12 +26,12 @@ GEM
       eventmachine (>= 0.12.9)
       http_parser.rb (~> 0.6.0)
     eventmachine (1.2.1)
-    faraday (0.10.1)
+    faraday (0.11.0)
       multipart-post (>= 1.2, < 3)
     faraday-digestauth (0.2.1)
       faraday (~> 0.7)
       net-http-digest_auth (~> 1.4)
-    ffi (1.9.14)
+    ffi (1.9.17)
     formatador (0.2.5)
     git (1.3.0)
     guard (2.14.0)
@@ -50,12 +50,12 @@ GEM
       guard-compat (~> 1.0)
       multi_json (~> 1.8)
     http_parser.rb (0.6.0)
-    json (2.0.2)
+    json (2.0.3)
     listen (3.1.5)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
       ruby_dep (~> 1.2)
-    lumberjack (1.0.10)
+    lumberjack (1.0.11)
     method_source (0.8.2)
     mini_portile2 (2.1.0)
     minitest (5.10.1)
@@ -80,7 +80,7 @@ GEM
       slop (~> 3.4)
     rake (12.0.0)
     rb-fsevent (0.9.8)
-    rb-inotify (0.9.7)
+    rb-inotify (0.9.8)
       ffi (>= 0.5.0)
     ruby_dep (1.5.0)
     rubyzip (1.2.0)
@@ -95,7 +95,7 @@ GEM
       tins (~> 1.0)
     thor (0.19.4)
     tins (1.13.0)
-    yard (0.9.6)
+    yard (0.9.8)
 
 PLATFORMS
   ruby
@@ -114,4 +114,4 @@ DEPENDENCIES
   yard (~> 0.9)
 
 BUNDLED WITH
-   1.13.6
+   1.13.7

data/README.md

@@ -75,8 +75,10 @@ configuration options:
 
  Each stage has the following options:
 
- * branch: name of the branch for the given stage (if stage_method = git)
- * script: scripts to use to stage the app (if stage_method = script)
+ * branch: name of the branch for the given stage (if stage_method = git). If
+    using stage_method = stage then this can be removed.
+ * script: scripts to use to stage the app (if stage_method = script). If using
+    stage_method = git this can be removed.
  * script -> stage: script run form the app root directory to stage app
  * script -> unstage: script run form the app root directory to unstage app
  * key: has of key options for signing a package

data/bin/roku

@@ -88,7 +88,7 @@ parser = OptionParser.new do |opts|
     options[:profile] = c
   end
 
-  opts.on("--do-stage", "Command: Run the stager. Used for scripting. Always run --do-unscript after") do
+  opts.on("--do-stage", "Command: Run the stager. Used for scripting. Always run --do-unstage after") do
     options[:dostage] = true
   end
 
@@ -124,7 +124,7 @@ parser = OptionParser.new do |opts|
     options[:working] = true
   end
 
-  opts.on("-c", "--current", "Use current directory to sideload or test. Overides any project config") do
+  opts.on("-c", "--current", "Use current directory to sideload or test. Overrides any project config") do
     options[:current] = true
   end
 
@@ -145,7 +145,7 @@ parser = OptionParser.new do |opts|
     options[:edit_params] = p
   end
 
-  opts.on("--config CONFIG", "Set a custom config file. Default: '~/.roku_config.rb'") do |c|
+  opts.on("--config CONFIG", "Set a custom config file. Default: '~/.roku_config.json'") do |c|
     options[:config] = c
   end
 

data/config.json.example

@@ -18,7 +18,8 @@
       "stage_method": "<git|script>",
       "stages":{
         "production": {
-          "branch": "production",
+          "branch": "<branch>",
+          "script": {"stage": "<command to stage>", "unstage": "<command to unstage, optional>"},
           "key": "key1"
         }
       }

data/lib/roku_builder.rb

@@ -124,6 +124,9 @@ module RokuBuilder
   # Unknown stage given
   UNKNOWN_STAGE      = 7
 
+  # Missing out folder
+  MISSING_OUT_FOLDER = 8
+
 
   ### Execute Codes ###
 
@@ -163,7 +166,7 @@ end
 
 class ::Hash
   def deep_merge(second)
-    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2  }
+    merger = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2  }
     self.merge(second, &merger)
   end
 end

data/lib/roku_builder/config_manager.rb

@@ -124,17 +124,16 @@ module RokuBuilder
     def self.update_configs(configs:, options:)
       if options[:build_version]
         configs[:package_config][:app_name_version] = "#{configs[:project_config][:app_name]} - #{configs[:stage]} - #{options[:build_version]}" if configs[:package_config]
-        unless options[:outfile]
-          pathname = File.join(options[:out_folder], "#{configs[:project_config][:app_name]}_#{configs[:stage]}_#{options[:build_version]}")
-          if options[:out]
-            configs[:package_config][:out_file] = File.join(options[:out_folder], options[:out_file]) if configs[:package_config]
-            configs[:build_config][:outfile]    = File.join(options[:out_folder], options[:out_file]) if configs[:build_config]
-          else
-            configs[:package_config][:out_file] = pathname+".pkg" if configs[:package_config]
-            configs[:build_config][:outfile]    = pathname+".zip" if configs[:build_config]
-          end
-          configs[:inspect_config][:pkg] = configs[:package_config][:out_file] if configs[:inspect_config] and configs[:package_config]
+        unless configs[:out][:file]
+          configs[:out][:file] = "#{configs[:project_config][:app_name]}_#{configs[:stage]}_#{options[:build_version]}"
+        end
+        pathname = File.join(configs[:out][:folder], configs[:out][:file])
+        configs[:package_config][:out_file] = pathname if configs[:package_config]
+        configs[:build_config][:out_file]   = pathname if configs[:build_config]
+        if configs[:sideload_config] and options[:out]
+          configs[:sideload_config][:out_file]   = pathname
         end
+        configs[:inspect_config][:pkg] = configs[:package_config][:out_file] if configs[:inspect_config] and configs[:package_config]
       end
       return configs
     end

data/lib/roku_builder/config_parser.rb

@@ -21,7 +21,7 @@ module RokuBuilder
       #set project
       setup_project(config: config, options: options)
       #set outfile
-      setup_outfile(options: options)
+      setup_outfile(options: options, configs: configs)
       # Create Device Config
       configs[:device_config] = config[:devices][options[:device].to_sym]
       return [UNKNOWN_DEVICE, nil, nil] unless configs[:device_config]
@@ -33,7 +33,8 @@ module RokuBuilder
       return [UNKNOWN_STAGE, nil, nil] unless stage
       setup_sideload_config(configs: configs, options: options)
       setup_package_config(config: config, configs: configs, options: options, stage: stage)
-      setup_simple_configs(config: config, configs: configs, options: options, logger: logger)
+      setup_active_configs(config: config, configs: configs, options: options)
+      setup_simple_configs(config: config, configs: configs, options: options)
       return [SUCCESS, configs]
     end
 
@@ -67,23 +68,22 @@ module RokuBuilder
 
     # Setup the out folder/file options
     # @param options [Hash] The options hash
-    def self.setup_outfile(options:)
-      options[:out_folder] = nil
-      options[:out_file] = nil
+    def self.setup_outfile(options:, configs:)
+      configs[:out] = {file: nil, folder: nil}
       if options[:out]
         if options[:out].end_with?(".zip") or options[:out].end_with?(".pkg") or options[:out].end_with?(".jpg")
-          options[:out_folder], options[:out_file] = Pathname.new(options[:out]).split.map{|p| p.to_s}
-          if options[:out_folder] = "." and not options[:out].start_with?(".")
-            options[:out_folder] = nil
+          configs[:out][:folder], configs[:out][:file] = Pathname.new(options[:out]).split.map{|p| p.to_s}
+          if configs[:out][:folder] == "." and not options[:out].start_with?(".")
+            configs[:out][:folder] = nil
           else
-            options[:out_folder] = File.expand_path(options[:out_folder])
+            configs[:out][:folder] = File.expand_path(configs[:out][:folder])
           end
         else
-          options[:out_folder] = options[:out]
+          configs[:out][:folder] = options[:out]
         end
       end
-      unless options[:out_folder]
-        options[:out_folder] = "/tmp"
+      unless configs[:out][:folder]
+         configs[:out][:folder] = "/tmp"
       end
     end
     private_class_method :setup_outfile
@@ -196,8 +196,8 @@ module RokuBuilder
           password: configs[:key][:password],
           app_name_version: "#{configs[:project_config][:app_name]} - #{stage}"
         }
-        if options[:out_file]
-          configs[:package_config][:out_file] = File.join(options[:out_folder], options[:out_file])
+        if configs[:out][:file]
+          configs[:package_config][:out_file] = File.join(configs[:out][:folder], configs[:out][:file])
         end
         # Create Inspector Config
         configs[:inspect_config] = {
@@ -208,20 +208,11 @@ module RokuBuilder
     end
     private_class_method :setup_package_config
 
-    # Setup other configs
+    # Setup configs for active methods, monitoring and navigating
     # @param configs [Hash] The parsed configs hash
     # @param options [Hash] The options hash
     # @param logger [Logger] System logger
-    def self.setup_simple_configs(config:, configs:, options:, logger:)
-      # Create Manifest Config
-      configs[:manifest_config] = {
-        root_dir: configs[:project_config][:directory]
-      }
-      # Create Deeplink Config
-      configs[:deeplink_config] = {options: options[:deeplink]}
-      if options[:app_id]
-        configs[:deeplink_config][:app_id] = options[:app_id]
-      end
+    def self.setup_active_configs(config:, configs:, options:)
       # Create Monitor Config
       if options[:monitor]
         configs[:monitor_config] = {type: options[:monitor].to_sym}
@@ -241,14 +232,31 @@ module RokuBuilder
         commands = options[:navigate].split(/, */).map{|c| c.to_sym}
         configs[:navigate_config] = {commands: commands}
       end
+    end
+    private_class_method :setup_active_configs
+
+    # Setup other configs
+    # @param configs [Hash] The parsed configs hash
+    # @param options [Hash] The options hash
+    # @param logger [Logger] System logger
+    def self.setup_simple_configs(config:, configs:, options:)
+      # Create Manifest Config
+      configs[:manifest_config] = {
+        root_dir: configs[:project_config][:directory]
+      }
+      # Create Deeplink Config
+      configs[:deeplink_config] = {options: options[:deeplink]}
+      if options[:app_id]
+        configs[:deeplink_config][:app_id] = options[:app_id]
+      end
       # Create Text Config
       configs[:text_config] = {text: options[:text]}
       # Create Test Config
       configs[:test_config] = {sideload_config: configs[:sideload_config]}
       #Create screencapture config
       configs[:screencapture_config] = {
-        out_folder: options[:out_folder],
-        out_file: options[:out_file]
+        out_folder: configs[:out][:folder],
+        out_file: configs[:out][:file]
       }
       if options[:screen]
         configs[:screen_config] = {type: options[:screen].to_sym}

data/lib/roku_builder/config_validator.rb

@@ -54,14 +54,10 @@ module RokuBuilder
         }
       end
       if config[:keys]
-        config[:keys].each {|key,key_config|
-          validate_key(codes: codes, key: key_config)
-        }
+        config[:keys].each {|_key,key_config| validate_key(codes: codes, key: key_config) }
       end
       if config[:input_mapping]
-        config[:input_mapping].each_value {|info|
-          validate_mapping(codes: codes, mapping: info)
-        }
+        config[:input_mapping].each_value {|info| validate_mapping(codes: codes, mapping: info) }
       end
       codes.uniq!
       codes.push(0) if codes.empty?
@@ -184,7 +180,6 @@ module RokuBuilder
 
     def self.validate_mapping(codes:, mapping:)
       errors=[
-        [INVALID_MAPPING_INFO, mapping.nil?],
         [INVALID_MAPPING_INFO, (mapping.count != 2)]
       ]
       process_errors(codes: codes, errors: errors)

data/lib/roku_builder/controller.rb

@@ -28,12 +28,16 @@ module RokuBuilder
       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)
+
       # 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)
 
       # Run Commands
-      command_code = execute_commands(options: options, config: config, configs: configs, logger: logger)
+      command_code = execute_commands(options: options, configs: configs, logger: logger)
       ErrorHandler.handle_command_codes(command_code: command_code, logger: logger)
     end
 
@@ -102,11 +106,22 @@ module RokuBuilder
     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
+      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:, config:, configs:, logger:)
+    def self.execute_commands(options:, configs:, logger:)
       command = (commands & options.keys).first
       if ControllerCommands.simple_commands.keys.include?(command)
         params = ControllerCommands.simple_commands[command]

data/lib/roku_builder/controller_commands.rb

@@ -48,6 +48,9 @@ module RokuBuilder
       success = nil
       if stager.stage
         loader = Loader.new(**config)
+        build_version = ManifestManager.build_version(**configs[:manifest_config])
+        options[:build_version] = build_version
+        configs = ConfigManager.update_configs(configs: configs, options: options)
         success = loader.sideload(**configs[:sideload_config])[0]
       end
       stager.unstage
@@ -68,14 +71,13 @@ module RokuBuilder
       stager = Stager.new(**configs[:stage_config])
       loader = Loader.new(**loader_config)
       packager = Packager.new(**configs[:device_config])
-      inspector = Inspector.new(**configs[:device_config])
       logger.warn "Packaging working directory" if options[:working]
       if stager.stage
         # Sideload #
         code, build_version = loader.sideload(**configs[:sideload_config])
-        return code unless code = SUCCESS
+        return code unless code == SUCCESS
         # Key #
-        success = keyer.rekey(**configs[:key])
+        _success = keyer.rekey(**configs[:key])
         # Package #
         options[:build_version] = build_version
         configs = ConfigManager.update_configs(configs: configs, options: options)
@@ -84,23 +86,30 @@ module RokuBuilder
         return FAILED_SIGNING unless success
         # Inspect #
         if options[:inspect]
-          info = inspector.inspect(configs[:inspect_config])
-          inspect_logger = Logger.new(STDOUT)
-          inspect_logger.formatter = proc {|_severity, _datetime, _progname, msg|
-            "%s\n\r" % [msg]
-          }
-          inspect_logger.unknown "=============================================================="
-          inspect_logger.unknown "App Name: #{info[:app_name]}"
-          inspect_logger.unknown "Dev ID: #{info[:dev_id]}"
-          inspect_logger.unknown "Creation Date: #{info[:creation_date]}"
-          inspect_logger.unknown "dev.zip: #{info[:dev_zip]}"
-          inspect_logger.unknown "=============================================================="
+          inspect_package(configs: configs)
         end
       end
       stager.unstage
       logger.info "App Packaged; staged using #{stager.method}"
       SUCCESS
     end
+
+    def self.inspect_package(configs:)
+      inspector = Inspector.new(**configs[:device_config])
+      info = inspector.inspect(configs[:inspect_config])
+      inspect_logger = Logger.new(STDOUT)
+      inspect_logger.formatter = proc {|_severity, _datetime, _progname, msg|
+        "%s\n\r" % [msg]
+      }
+      inspect_logger.unknown "=============================================================="
+      inspect_logger.unknown "App Name: #{info[:app_name]}"
+      inspect_logger.unknown "Dev ID: #{info[:dev_id]}"
+      inspect_logger.unknown "Creation Date: #{info[:creation_date]}"
+      inspect_logger.unknown "dev.zip: #{info[:dev_zip]}"
+      inspect_logger.unknown "=============================================================="
+    end
+    private_class_method :inspect_package
+
     # Run Build
     # @param options [Hash] user options
     # @param configs [Hash] parsed configs

data/lib/roku_builder/error_handler.rb

@@ -75,6 +75,19 @@ module RokuBuilder
       end
     end
 
+    # Handle codes returned from configuring
+    # @param configure_code [Integer] the error code returned by configure
+    # @param logger [Logger] system logger
+    def self.handle_configs_codes(configs_code:, logger:)
+      case configs_code
+      when MISSING_OUT_FOLDER
+        logger.fatal 'The folder passed in the command line options does not exist.'
+        abort
+      when VALID
+        logger.debug 'Configs OK'
+      end
+    end
+
     # Handle codes returned from checking devices
     # @param device_code [Integer] the error code returned by check_devices
     # @param logger [Logger] system logger