roku_builder 3.4.1 → 3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8e0c79c1201bbf18531f0f2e95232efac96caf3
-  data.tar.gz: d4f003ef51e562e3ac405c81c2dabe023d065be0
+  metadata.gz: dc0d1c23db3b41b36ad688f25bd7cf265bace489
+  data.tar.gz: 8f480837cb1cbe27b24453a3b81c5606d65aa28d
 SHA512:
-  metadata.gz: e427943879a47693406ebdb84b3a503bca7b6eff5a1e80cf9bb7ac0e15698fb8b8f7e705cf0a99e6a4f109068deb1f25e3ad7a56fa2278e561584f920b0d0c02
-  data.tar.gz: 0db0e26b474643b8d19c3537b5c0de766a47c7b17a28f98311df21b2166ec32cb10943f35562a723136aa4a9350cb0594981042786b381bc0e11896bfb65f854
+  metadata.gz: 6f0472ac3122318632449e8f257312211867da471632d14f53bc1845bd3bd47f3ef3d55606f9273b4adaa19a1dd0039baab6666de91ff7cb207e1876a771a1d9
+  data.tar.gz: 2d130f6dd27005b871c4ea0c318f45fb5871feb615b92ec54af119a0f9a26701c773fcf36aaf42c7a728ef407dc5f43d725721da265a00d9df75e955993ddbca

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.4.1)
+    roku_builder (3.4.2)
       faraday (~> 0.9)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)

data/README.md

@@ -67,11 +67,15 @@ configuration options:
 
  * directory: full path of the git repository the houses the roku app
  * app_name: Name used when packaging the app
+ * stage_method: Which method to use for switching app stages (git or script)
  * stages: a hash of stage objects
 
  Each stage has the following options:
 
- * branch: name of the branch for the given stage
+ * 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)
+ * 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
  * key -> keyed_pkg: path to a pkg file that has been signed
  * key -> password: password for the signed pkg
@@ -240,9 +244,9 @@ This path will be expanded so you do not have to use the full path
 ## Projects
 
 The project used in the above examples is a smart default. If you are in a
-project directory then it will use that project. If you not then it will use
-the defualt that you have defined in your config. You can define what project
-you want the command to be run on using the --project option:
+project directory then it will use that project. If you are not then it will
+use the defualt that you have defined in your config. You can define what
+project you want the command to be run on using the --project option:
 
     $ roku -lw --project project1
 
@@ -250,6 +254,20 @@ or:
 
     $ roku -lw -P project1
 
+## Stages
+
+Each project can have any number of stages. stages can be defined in a number
+of ways. The default is to use git branches to define stages. You can setup a
+branch for each stage and the gem will automatically switch between them as
+needed. If using git stages then the gem will ensure to stash any change you
+currently have before checking out the required branch. When done it will
+switch back and unstash the changes. You can use the -w or --working options
+to avoid this.
+
+The other method of staging is script staging. This will run a script you
+define before and after performing any actions. This will let you stage your
+app anyway you like as long as it can be done via script.
+
 ## Devices
 
 In the examples above the default device is used. If you have multiple devices
@@ -273,7 +291,6 @@ directory:
 
 ## Improvements
 
- * Pull build number from correct stage
  * Don't require a device for non device tasks
  * Account for missing folders or files
  * Increase testing

data/lib/roku_builder.rb

@@ -1,6 +1,7 @@
 require "logger"
 require "faraday"
 require "faraday/digestauth"
+require "pathname"
 #controller
 require "net/ping"
 #loader

data/lib/roku_builder/config_parser.rb

@@ -25,11 +25,10 @@ module RokuBuilder
       return [UNKNOWN_DEVICE, nil, nil] unless configs[:device_config]
       configs[:device_config][:logger] = logger
       project_config = setup_project_config(config: config, options: options)
-      return [UNKNOWN_PROJECT, nil, nil] unless project_config
+      return [project_config, nil, nil] unless project_config.class == Hash
       configs[:project_config] = project_config
       stage_config, stage = setup_stage_config(configs: configs, options: options, logger: logger)
       return [UNKNOWN_STAGE, nil, nil] unless stage
-      configs[:stage_config] = stage_config
       setup_sideload_config(configs: configs, options: options)
       setup_package_config(configs: configs, options: options, stage: stage)
       setup_simple_configs(configs: configs, options: options, logger: logger)
@@ -88,7 +87,7 @@ module RokuBuilder
       project_config = {}
       if options[:current]
         pwd =  Controller.system(command: "pwd")
-        return [MISSING_MANIFEST, nil, nil] unless File.exist?(File.join(pwd, "manifest"))
+        return MISSING_MANIFEST unless File.exist?(File.join(pwd, "manifest"))
         project_config = {
           directory: pwd,
           folders: nil,
@@ -97,6 +96,7 @@ module RokuBuilder
         }
       else
         project_config = config[:projects][options[:project].to_sym]
+        return UNKNOWN_PROJECT unless project_config
         project_config[:stage_method] = :working if options[:working]
       end
       project_config
@@ -126,7 +126,8 @@ module RokuBuilder
         return nil unless project_config[:stages][stage]
         stage_config[:key] = project_config[:stages][stage][:script]
       end
-      configs[:stage] = stage_config
+      configs[:stage_config] = stage_config
+      configs[:stage] = stage
       [stage_config, stage]
     end
 
@@ -138,14 +139,12 @@ module RokuBuilder
       root_dir = configs[:project_config][:directory]
       # Create Sideload Config
       configs[:sideload_config] = {
-        stage: configs[:stage_config],
         update_manifest: options[:update_manifest],
         folders: configs[:project_config][:folders],
         files: configs[:project_config][:files]
       }
       # Create Build Config
       configs[:build_config] = {
-        stage: configs[:stage_config],
         folders: configs[:project_config][:folders],
         files: configs[:project_config][:files]
       }

data/lib/roku_builder/controller_commands.rb

@@ -8,8 +8,6 @@ module RokuBuilder
     # @return [Hash] options to run simple commands
     def self.simple_commands
       {
-        sideload: { klass: Loader, method: :sideload, config_key: :sideload_config,
-          failure: FAILED_SIDELOAD },
         deeplink: { klass: Linker, method: :link, config_key: :deeplink_config,
           failure: FAILED_DEEPLINKING },
         delete: { klass: Loader, method: :unload },
@@ -31,37 +29,61 @@ module RokuBuilder
     def self.validate()
       SUCCESS
     end
+    # Run Sideload
+    # @param options [Hash] user options
+    # @param configs [Hash] parsed configs
+    # @param logger [Logger] system logger
+    # @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])
+      success = false
+      if stager.stage
+        loader = Loader.new(**config)
+        success = loader.sideload(**configs[:sideload_config])
+      end
+      stager.unstage
+      return FAILED_SIDELOAD unless success
+      SUCCESS
+    end
     # Run Package
     # @param options [Hash] user options
     # @param configs [Hash] parsed configs
     # @param logger [Logger] system logger
     # @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])
-      loader = Loader.new(**configs[:device_config])
+      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]
-      # Sideload #
-      build_version = loader.sideload(**configs[:sideload_config])
-      return FAILED_SIGNING unless build_version
-      # Key #
-      success = keyer.rekey(**configs[:key])
-      logger.info "Key did not change" unless success
-      # 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
-      return FAILED_SIGNING unless success
-      # Inspect #
-      if options[:inspect]
-        info = inspector.inspect(configs[:inspect_config])
-        logger.unknown "App Name: #{info[:app_name]}"
-        logger.unknown "Dev ID: #{info[:dev_id]}"
-        logger.unknown "Creation Date: #{info[:creation_date]}"
-        logger.unknown "dev.zip: #{info[:dev_zip]}"
+      if stager.stage
+        # Sideload #
+        build_version = loader.sideload(**configs[:sideload_config])
+        return FAILED_SIGNING unless build_version
+        # Key #
+        success = keyer.rekey(**configs[:key])
+        logger.info "Key did not change" unless success
+        # 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
+        return FAILED_SIGNING unless success
+        # Inspect #
+        if options[:inspect]
+          info = inspector.inspect(configs[:inspect_config])
+          logger.unknown "App Name: #{info[:app_name]}"
+          logger.unknown "Dev ID: #{info[:dev_id]}"
+          logger.unknown "Creation Date: #{info[:creation_date]}"
+          logger.unknown "dev.zip: #{info[:dev_zip]}"
+        end
       end
+      stager.unstage
       SUCCESS
     end
     # Run Build
@@ -71,12 +93,18 @@ module RokuBuilder
     # @return [Integer] Success or Failure Code
     def self.build(options:, configs:, logger:)
       ### Build ###
-      loader = Loader.new(**configs[:device_config])
-      build_version = ManifestManager.build_version(**configs[: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}"
+      loader_config = configs[:device_config].dup
+      loader_config[:init_params] = configs[:init_params][:loader]
+      stager = Stager.new(**configs[:stage_config])
+      loader = Loader.new(**loader_config)
+      if stager.stage
+        build_version = ManifestManager.build_version(**configs[: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}"
+      end
+      stager.unstage
       SUCCESS
     end
     # Run update
@@ -85,9 +113,13 @@ module RokuBuilder
     # @return [Integer] Success or Failure Code
     def self.update(configs:, logger:)
       ### Update ###
-      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}"
+      stager = Stager.new(**configs[: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}"
+      end
+      stager.unstage
       SUCCESS
     end
 

data/lib/roku_builder/loader.rb

@@ -11,92 +11,81 @@ module RokuBuilder
 
     # Sideload an app onto a roku device
     # @param root_dir [String] Path to the root directory of the roku app
-    # @param stage [Hash] stage to use for sideloading.
-    # @param update_manifest [Boolean] Flag to update the manifest file before sideloading. Default: false
     # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
     # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
     # @return [String] Build version on success, nil otherwise
-    def sideload(stage:, update_manifest: false, folders: nil, files: nil)
+    def sideload(update_manifest: false, folders: nil, files: nil)
       result = nil
-      stager = Stager.new(**stage)
-      if stager.stage
-        # Update manifest
-        build_version = ""
-        if update_manifest
-          build_version = ManifestManager.update_build(root_dir: @root_dir)
-        else
-          build_version = ManifestManager.build_version(root_dir: @root_dir)
-        end
-        outfile = build(stage: stage, build_version: build_version, folders: folders, files: files)
-        path = "/plugin_install"
-        # Connect to roku and upload file
-        conn = multipart_connection
-        payload =  {
-          mysubmit: "Replace",
-          archive: Faraday::UploadIO.new(outfile, 'application/zip')
-        }
-        response = conn.post path, payload
-        # Cleanup
-        File.delete(outfile)
-        result = build_version if response.status==200 and response.body=~/Install Success/
+      # Update manifest
+      build_version = ""
+      if update_manifest
+        build_version = ManifestManager.update_build(root_dir: @root_dir)
+      else
+        build_version = ManifestManager.build_version(root_dir: @root_dir)
       end
-      stager.unstage
-      result
+      outfile = build(build_version: build_version, folders: folders, files: files)
+      path = "/plugin_install"
+      # Connect to roku and upload file
+      conn = multipart_connection
+      payload =  {
+        mysubmit: "Replace",
+        archive: Faraday::UploadIO.new(outfile, 'application/zip')
+      }
+      response = conn.post path, payload
+      # Cleanup
+      File.delete(outfile)
+      result = build_version if response.status==200 and response.body=~/Install Success/
+        result
     end
 
 
     # Build an app to sideload later
     # @param root_dir [String] Path to the root directory of the roku app
-    # @param stage [Hash] stage to use for sideloading.
     # @param build_version [String] Version to assigne to the build. If nil will pull the build version form the manifest. Default: nil
     # @param outfile [String] Path for the output file. If nil will create a file in /tmp. Default: nil
     # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
     # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
     # @return [String] Path of the build
-    def build(stage:, build_version: nil, outfile: nil, folders: nil, files: nil)
-      stager = Stager.new(**stage)
-      if stager.stage
-        build_version = ManifestManager.build_version(root_dir: @root_dir, logger: @logger) unless build_version
-        unless folders
-          folders = Dir.entries(@root_dir).select {|entry| File.directory? File.join(@root_dir, entry) and !(entry =='.' || entry == '..') }
-        end
-        unless files
-          files = Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
-        end
-        outfile = "/tmp/build_#{build_version}.zip" unless outfile
-        File.delete(outfile) if File.exist?(outfile)
-        io = Zip::File.open(outfile, Zip::File::CREATE)
-        # Add folders to zip
-        folders.each do |folder|
-          base_folder = File.join(@root_dir, folder)
-          entries = Dir.entries(base_folder)
-          entries.delete(".")
-          entries.delete("..")
-          writeEntries(@root_dir, entries, folder, io)
-        end
-        # Add file to zip
-        writeEntries(@root_dir, files, "", io)
-        io.close()
+    def build(build_version: nil, outfile: nil, folders: nil, files: nil)
+      build_version = ManifestManager.build_version(root_dir: @root_dir) unless build_version
+      unless folders
+        folders = Dir.entries(@root_dir).select {|entry| File.directory? File.join(@root_dir, entry) and !(entry =='.' || entry == '..') }
       end
-      stager.unstage
+      unless files
+        files = Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
+      end
+      outfile = "/tmp/build_#{build_version}.zip" unless outfile
+      File.delete(outfile) if File.exist?(outfile)
+      io = Zip::File.open(outfile, Zip::File::CREATE)
+      # Add folders to zip
+      folders.each do |folder|
+        base_folder = File.join(@root_dir, folder)
+        entries = Dir.entries(base_folder)
+        entries.delete(".")
+        entries.delete("..")
+        writeEntries(@root_dir, entries, folder, io)
+      end
+      # Add file to zip
+      writeEntries(@root_dir, files, "", io)
+      io.close()
       outfile
     end
 
     # Remove the currently sideloaded app
     def unload()
-        path = "/plugin_install"
+      path = "/plugin_install"
 
-        # Connect to roku and upload file
-        conn = multipart_connection
-        payload =  {
-          mysubmit: "Delete",
-          archive: ""
-        }
-        response = conn.post path, payload
-        if response.status == 200 and response.body =~ /Install Success/
-          return true
-        end
-        return false
+      # Connect to roku and upload file
+      conn = multipart_connection
+      payload =  {
+        mysubmit: "Delete",
+        archive: ""
+      }
+      response = conn.post path, payload
+      if response.status == 200 and response.body =~ /Install Success/
+        return true
+      end
+      return false
     end
 
     private

data/lib/roku_builder/version.rb

@@ -1,4 +1,4 @@
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "3.4.1"
+  VERSION = "3.4.2"
 end

data/tests/roku_builder/controller_commands_test.rb

@@ -5,31 +5,44 @@ class ControllerCommandsTest < Minitest::Test
   def test_controller_commands_sideload
     logger = Logger.new("/dev/null")
     loader = Minitest::Mock.new
+    stager = Minitest::Mock.new
 
     options = {sideload: true, stage: 'production', config: "~/.roku_config.rb"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     # Test Success
     loader.expect(:sideload, true, [configs[:sideload_config]])
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
+
     RokuBuilder::Loader.stub(:new, loader) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      RokuBuilder::Stager.stub(:new, stager) do
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      end
     end
     assert_equal RokuBuilder::SUCCESS, code
 
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
+
     # Test Failure
     loader.expect(:sideload, false, [configs[:sideload_config]])
     RokuBuilder::Loader.stub(:new, loader) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      RokuBuilder::Stager.stub(:new, stager) do
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      end
     end
     assert_equal RokuBuilder::FAILED_SIDELOAD, code
 
     loader.verify
+    stager.verify
   end
 
   def test_controller_commands_package
     logger = Logger.new("/dev/null")
     keyer = Minitest::Mock.new
     loader = Minitest::Mock.new
+    stager = Minitest::Mock.new
     packager = Minitest::Mock.new
     inspector = Minitest::Mock.new
 
@@ -42,13 +55,17 @@ class ControllerCommandsTest < Minitest::Test
     keyer.expect(:rekey, true, [configs[:key]])
     packager.expect(:package, true, [configs[:package_config]])
     inspector.expect(:inspect, info, [configs[:inspect_config]])
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
 
     code = nil
     RokuBuilder::Keyer.stub(:new, keyer) do
       RokuBuilder::Loader.stub(:new, loader) do
         RokuBuilder::Packager.stub(:new, packager) do
           RokuBuilder::Inspector.stub(:new, inspector) do
-            code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+            RokuBuilder::Stager.stub(:new, stager) do
+              code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+            end
           end
         end
       end
@@ -57,6 +74,7 @@ class ControllerCommandsTest < Minitest::Test
 
     keyer.verify
     loader.verify
+    stager.verify
     packager.verify
     inspector.verify
   end
@@ -65,6 +83,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     keyer = Minitest::Mock.new
     loader = Minitest::Mock.new
+    stager = Minitest::Mock.new
     packager = Minitest::Mock.new
     inspector = Minitest::Mock.new
 
@@ -77,13 +96,17 @@ class ControllerCommandsTest < Minitest::Test
     keyer.expect(:rekey, true, [configs[:key]])
     packager.expect(:package, true, [configs[:package_config]])
     inspector.expect(:inspect, info, [configs[:inspect_config]])
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
 
     code = nil
     RokuBuilder::Keyer.stub(:new, keyer) do
       RokuBuilder::Loader.stub(:new, loader) do
         RokuBuilder::Packager.stub(:new, packager) do
           RokuBuilder::Inspector.stub(:new, inspector) do
-            code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+            RokuBuilder::Stager.stub(:new, stager) do
+              code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+            end
           end
         end
       end
@@ -92,6 +115,7 @@ class ControllerCommandsTest < Minitest::Test
 
     keyer.verify
     loader.verify
+    stager.verify
     packager.verify
     inspector.verify
   end
@@ -99,36 +123,50 @@ class ControllerCommandsTest < Minitest::Test
   def test_controller_commands_build
     logger = Logger.new("/dev/null")
     loader = Minitest::Mock.new
+    stager = Minitest::Mock.new
 
     code = nil
     options = {build: true, stage: 'production', out_folder: "/tmp", config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     loader.expect(:build, "/tmp/build", [configs[:build_config]])
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
+
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::ManifestManager.stub(:build_version, "1") do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        RokuBuilder::Stager.stub(:new, stager) do
+          code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        end
       end
     end
     assert_equal RokuBuilder::SUCCESS, code
     loader.verify
+    stager.verify
   end
   def test_controller_commands_update
     logger = Logger.new("/dev/null")
     mock = Minitest::Mock.new
+    stager = Minitest::Mock.new
 
     code = nil
-    options = {update: true, stage: 'production', out_folder: "/tmp", config: ":execute_commands,/.roku_config.json"}
+    options = {update: true, stage: 'production', out_folder: "/tmp", config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     mock.expect(:call, "1", [configs[:manifest_config]])
     mock.expect(:call, "2", [configs[:manifest_config]])
+    stager.expect(:stage, true)
+    stager.expect(:unstage, true)
+
     RokuBuilder::ManifestManager.stub(:build_version, mock) do
       RokuBuilder::ManifestManager.stub(:update_build, mock) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        RokuBuilder::Stager.stub(:new, stager) do
+          code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        end
       end
     end
     mock.verify
+    stager.verify
     assert_equal RokuBuilder::SUCCESS, code
   end
 
@@ -137,7 +175,7 @@ class ControllerCommandsTest < Minitest::Test
     mock = Minitest::Mock.new
 
     code = nil
-    options = {deeplink: true, stage: 'production', deeplink_options: "a:b", config: ":execute_commands,/.roku_config.json"}
+    options = {deeplink: true, stage: 'production', deeplink_options: "a:b", config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     mock.expect(:link, "true", [configs[:deeplink_config]])
@@ -151,7 +189,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     loader = Minitest::Mock.new
 
-    options = {delete: true, stage: 'production', config: ":execute_commands,/.roku_config.json"}
+    options = {delete: true, stage: 'production', config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     loader.expect(:unload, nil)
@@ -168,7 +206,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     monitor = Minitest::Mock.new
 
-    options = {monitor: "main", stage: 'production', config: ":execute_commands,/.roku_config.json"}
+    options = {monitor: "main", stage: 'production', config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     monitor.expect(:monitor, nil, [configs[:monitor_config]])
@@ -260,7 +298,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     tester = Minitest::Mock.new
 
-    options = {test: true, stage: 'production', config: ":execute_commands,/.roku_config.json"}
+    options = {test: true, stage: 'production', config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     tester.expect(:run_tests, true, [configs[:test_config]])
@@ -275,7 +313,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     inspector = Minitest::Mock.new
 
-    options = {screencapture: true, stage: 'production', out: "/tmp/capture.jpg", config: ":execute_commands,/.roku_config.json"}
+    options = {screencapture: true, stage: 'production', out: "/tmp/capture.jpg", config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     inspector.expect(:screencapture, true, [configs[:screencapture_config]])
@@ -290,7 +328,7 @@ class ControllerCommandsTest < Minitest::Test
     logger = Logger.new("/dev/null")
     inspector = Minitest::Mock.new
 
-    options = {screencapture: true, stage: 'production', out: "/tmp", config: ":execute_commands,/.roku_config.json"}
+    options = {screencapture: true, stage: 'production', out: "/tmp", config: "~/.roku_config.json"}
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     inspector.expect(:screencapture, false, [configs[:screencapture_config]])

data/tests/roku_builder/loader_test.rb

@@ -17,7 +17,6 @@ class LoaderTest < Minitest::Test
       init_params: {root_dir: root_dir}
     }
     loader_config = {
-      stage: {method: :working, root_dir: root_dir, logger: logger},
       folders: ["source"],
       files: ["manifest"]
     }
@@ -77,7 +76,6 @@ class LoaderTest < Minitest::Test
       init_params: {root_dir: root_dir}
     }
     loader_config = {
-      stage: {method: :working, root_dir: root_dir, logger: logger},
       update_manifest: true,
       folders: ["source"],
       files: ["manifest"]
@@ -134,7 +132,6 @@ class LoaderTest < Minitest::Test
       init_params: {root_dir: root_dir}
     }
     build_config = {
-      stage: {method: :working, root_dir: root_dir, logger: logger},
       folders: ["source"],
       files: ["manifest"]
     }
@@ -160,7 +157,7 @@ class LoaderTest < Minitest::Test
       logger: logger,
       init_params: {root_dir: root_dir}
     }
-    build_config = {stage: {method: :working, root_dir: root_dir, logger: logger}}
+    build_config = {}
     loader = RokuBuilder::Loader.new(**device_config)
     outfile = nil
     RokuBuilder::ManifestManager.stub(:build_version, "build_version") do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.4.1
+  version: 3.4.2
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2016-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip