roku_builder 3.3.4 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7a3925b7a80b6bf4d42aac1f30e5389150a6ce1
-  data.tar.gz: 8437573af545cf9e151e70dbc4345824460761ea
+  metadata.gz: 7a9d534271fdbd6b97dd36575bfd13e248af80d8
+  data.tar.gz: 1d250755fb3a741fd8887f9756c70f52648225c0
 SHA512:
-  metadata.gz: 063192d4dfd2193affd30539e270f9d7a64cc7d87d217a4c7822a91c998f46d4a18b46bb549f3fe5627f6d6b83e7a98b2b7f1034cfa225f1965520cd67e7e944
-  data.tar.gz: 8caf8c49315738d1e150e36589f24940f5e5049a5631a61a82301681ade6f3fb50f9cfe527dc1ffa2042b333aa1cc09e605e910e6b52ef5a57e9c1177713ad12
+  metadata.gz: 7460a08f88a3cc134bac6a47c29ae76bfb8810110a667d7498b9274db8a86b2d5b6cb4370206d55716fb31c5d822952d0f8d952aef8ccbb07b5ed5a7b20c1ffd
+  data.tar.gz: dfcb56377c93de06217de2cd359877ccdecd496de1c2b6cbc2014c95b6adc0e778e973767961c082fdde9d8dcb576887cd8fef7807cf9e317471733e35cfe5f2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.3.4)
+    roku_builder (3.4.0)
       faraday (~> 0.9)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)
@@ -11,8 +11,8 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    byebug (8.2.2)
-    coderay (1.1.0)
+    byebug (8.2.4)
+    coderay (1.1.1)
     coveralls (0.8.13)
       json (~> 1.8)
       simplecov (~> 0.11.0)
@@ -23,7 +23,7 @@ GEM
     em-websocket (0.5.1)
       eventmachine (>= 0.12.9)
       http_parser.rb (~> 0.6.0)
-    eventmachine (1.0.9.1)
+    eventmachine (1.2.0.1)
     faraday (0.9.2)
       multipart-post (>= 1.2, < 3)
     faraday-digestauth (0.2.1)
@@ -71,7 +71,7 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rake (11.1.1)
+    rake (11.1.2)
     rb-fsevent (0.9.7)
     rb-inotify (0.9.7)
       ffi (>= 0.5.0)

data/README.md

@@ -273,6 +273,8 @@ 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
    * Config Unit Tests

data/config.json.example

@@ -14,6 +14,7 @@
       "folders": ["resources","source"],
       "files": ["manifest"],
       "app_name": "<app name>",
+      "stage_method": "<git|script>",
       "stages":{
         "production": {
           "branch": "production",

data/lib/roku_builder.rb

@@ -17,6 +17,7 @@ require "roku_builder/controller_commands"
 require "roku_builder/util"
 require "roku_builder/keyer"
 require "roku_builder/inspector"
+require "roku_builder/stager"
 require "roku_builder/loader"
 require "roku_builder/packager"
 require "roku_builder/linker"
@@ -125,3 +126,15 @@ module RokuBuilder
   # Failed to capture screen
   FAILED_SCREENCAPTURE = 12
 end
+
+class String
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/roku_builder/config_manager.rb

@@ -47,6 +47,12 @@ module RokuBuilder
         config = JSON.parse(File.open(config).read, {symbolize_names: true})
         config[:devices][:default] = config[:devices][:default].to_sym
         config[:projects][:default] = config[:projects][:default].to_sym
+        config[:projects].each_pair do |key,value|
+          next if key == :default
+          if value[:stage_method]
+            value[:stage_method] = value[:stage_method].to_sym
+          end
+        end
         config
       rescue JSON::ParserError
         logger.fatal "Config file is not valid JSON"

data/lib/roku_builder/config_parser.rb

@@ -11,7 +11,7 @@ module RokuBuilder
     # @return [Integer] Return code
     # @return [Hash] Intermeidate configs
     def self.parse_config(options:, config:, logger:)
-      configs = {}
+      configs = {init_params: {}}
       #set device
       unless options[:device]
         options[:device] = config[:devices][:default]
@@ -27,14 +27,10 @@ module RokuBuilder
       project_config = setup_project_config(config: config, options: options)
       return [UNKNOWN_PROJECT, nil, nil] unless project_config
       configs[:project_config] = project_config
-      stage = options[:stage].to_sym
-      return [UNKNOWN_STAGE, nil, nil] unless project_config[:stages][stage]
-      configs[:stage] = stage
-      branch = project_config[:stages][stage][:branch]
-      branch = options[:ref] if options[:ref]
-      branch = nil if options[:current]
-      branch = nil if options[:working]
-      setup_sideload_config(configs: configs, options: options, branch: branch)
+      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)
       return [SUCCESS, configs]
@@ -97,36 +93,65 @@ module RokuBuilder
           directory: pwd,
           folders: nil,
           files: nil,
-          stages: { production: { branch: nil } }
+          stage_method: :current
         }
       else
         project_config = config[:projects][options[:project].to_sym]
+        project_config[:stage_method] = :working if options[:working]
       end
       project_config
     end
     private_class_method :setup_project_config
 
+    # Setup the project stage config
+    # @param configs [Hash] The loaded config hash
+    # @param options [Hash] The options hash
+    # @return [Hash] The stage config hash
+    def self.setup_stage_config(configs:, options:, logger:)
+      stage_config = {logger: logger}
+      stage = options[:stage].to_sym
+      project_config = configs[:project_config]
+      stage_config[:root_dir] = project_config[:directory]
+      stage_config[:method] = project_config[:stage_method]
+      stage_config[:method] ||= :git
+      case stage_config[:method]
+      when :git
+        if options[:ref]
+          stage_config[:key] = options[:ref]
+        else
+          return nil unless project_config[:stages][stage]
+          stage_config[:key] = project_config[:stages][stage][:branch]
+        end
+      when :script
+        return nil unless project_config[:stages][stage]
+        stage_config[:key] = project_config[:stages][stage][:script]
+      end
+      configs[:stage] = stage_config
+      [stage_config, stage]
+    end
+
     # Setup config hashes for sideloading
     # @param configs [Hash] The parsed configs hash
     # @param options [Hash] The options hash
     # @param branch [String] the branch to sideload
-    def self.setup_sideload_config(configs:, options:, branch:)
+    def self.setup_sideload_config(configs:, options:)
       root_dir = configs[:project_config][:directory]
       # Create Sideload Config
       configs[:sideload_config] = {
-        root_dir: root_dir,
-        branch: branch,
+        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] = {
-        root_dir: root_dir,
-        branch: branch,
+        stage: configs[:stage_config],
         folders: configs[:project_config][:folders],
         files: configs[:project_config][:files]
       }
+      configs[:init_params][:loader] = {
+        root_dir: root_dir
+      }
     end
     private_class_method :setup_sideload_config
 

data/lib/roku_builder/config_validator.rb

@@ -16,6 +16,11 @@ module RokuBuilder
   PROJECT_MISSING_FILES     = 14
   PROJECT_FILES_BAD         = 15
   STAGE_MISSING_BRANCH      = 16
+  STAGE_MISSING_SCRIPT      = 17
+  PROJECT_STAGE_METHOD_BAD  = 18
+
+
+  MISSING_STAGE_METHOD      = -1
 
   # Validate Config File
   class ConfigValidator
@@ -39,6 +44,7 @@ module RokuBuilder
           validate_project(codes: codes, project: v)
         }
       end
+      codes.uniq!
       codes.push(0) if codes.empty?
       codes
     end
@@ -64,8 +70,11 @@ module RokuBuilder
         "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 branch.",
+        "A project stage is missing its script.",
+        "A project as an invalid stage method.",
         #===============WARNINGS===============#
+        "A project is missing its stage method."
       ]
     end
 
@@ -116,8 +125,11 @@ module RokuBuilder
       codes.push(PROJECT_FOLDERS_BAD) if project[:folders] and not project[:folders].is_a?(Array)
       codes.push(PROJECT_MISSING_FILES) if not project[:files]
       codes.push(PROJECT_FILES_BAD) if project[:files] and not project[:files].is_a?(Array)
+      codes.push(MISSING_STAGE_METHOD) unless project[:stage_method]
+      codes.push(PROJECT_STAGE_METHOD_BAD) unless [:git, :script, nil].include?(project[:stage_method])
       project[:stages].each {|_stage,value|
-        codes.push(STAGE_MISSING_BRANCH) if not value[:branch]
+        codes.push(STAGE_MISSING_BRANCH) if not value[:branch] and project[:stage_method] == :git
+        codes.push(STAGE_MISSING_SCRIPT) if not value[:script] and project[:stage_method] == :script
       }
     end
     private_class_method :validate_project

data/lib/roku_builder/controller_commands.rb

@@ -99,7 +99,12 @@ module RokuBuilder
     # @param failure [Integer] failure code to return on failure if not nil
     # @return [Integer] Success of failure code
     def self.simple_command(klass:, method:, config_key: nil, configs:, failure: nil)
-      instance = klass.new(**configs[:device_config])
+      config = configs[:device_config].dup
+      key = klass.to_s.split("::")[-1].underscore.to_sym
+      if configs[:init_params][key]
+        config[:init_params] = configs[:init_params][key]
+      end
+      instance = klass.new(**config)
       if config_key
         success = instance.send(method, configs[config_key])
       else

data/lib/roku_builder/loader.rb

@@ -3,26 +3,31 @@ module RokuBuilder
   # Load/Unload/Build roku applications
   class Loader < Util
 
+
+    # Set the root directory
+    def init(root_dir: nil)
+      @root_dir = root_dir
+    end
+
     # Sideload an app onto a roku device
     # @param root_dir [String] Path to the root directory of the roku app
-    # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
+    # @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(root_dir:, branch: nil, update_manifest: false, folders: nil, files: nil)
-      @root_dir = root_dir
+    def sideload(stage:, update_manifest: false, folders: nil, files: nil)
       result = nil
-      begin
-        git_switch_to(branch: branch)
+      stager = Stager.new(**stage)
+      if stager.stage
         # Update manifest
         build_version = ""
         if update_manifest
-          build_version = ManifestManager.update_build(root_dir: root_dir)
+          build_version = ManifestManager.update_build(root_dir: @root_dir)
         else
-          build_version = ManifestManager.build_version(root_dir: root_dir)
+          build_version = ManifestManager.build_version(root_dir: @root_dir)
         end
-        outfile = build(root_dir: root_dir, branch: branch, build_version: build_version, folders: folders, files: files)
+        outfile = build(stage: stage, build_version: build_version, folders: folders, files: files)
         path = "/plugin_install"
         # Connect to roku and upload file
         conn = multipart_connection
@@ -34,35 +39,29 @@ module RokuBuilder
         # Cleanup
         File.delete(outfile)
         result = build_version if response.status==200 and response.body=~/Install Success/
-        git_switch_from(branch: branch)
-      rescue Git::GitExecuteError
-        git_rescue
-      ensure
-        @current_dir ||= Dir.pwd
-        Dir.chdir(@current_dir) unless @current_dir == Dir.pwd
       end
+      stager.unstage
       result
     end
 
 
     # Build an app to sideload later
     # @param root_dir [String] Path to the root directory of the roku app
-    # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
+    # @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(root_dir:, branch: nil, build_version: nil, outfile: nil, folders: nil, files: nil)
-      @root_dir = root_dir
-      begin
-        git_switch_to(branch: branch)
-        build_version = ManifestManager.build_version(root_dir: root_dir, logger: @logger) unless build_version
+    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 == '..') }
+          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)}
+          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)
@@ -78,13 +77,8 @@ module RokuBuilder
         # Add file to zip
         writeEntries(@root_dir, files, "", io)
         io.close()
-        git_switch_from(branch: branch)
-      rescue Git::GitExecuteError
-        git_rescue
-      ensure
-        @current_dir ||= Dir.pwd
-        Dir.chdir(@current_dir) unless @current_dir == Dir.pwd
       end
+      stager.unstage
       outfile
     end
 
@@ -125,37 +119,5 @@ module RokuBuilder
         end
       }
     end
-
-    # Switch to the correct branch
-    def git_switch_to(branch:)
-      if branch
-        @current_dir = Dir.pwd
-        @git ||= Git.open(@root_dir)
-        if branch != @git.current_branch
-          Dir.chdir(@root_dir)
-          @current_branch = @git.current_branch
-          @stash = @git.branch.stashes.save("roku-builder-temp-stash")
-          @git.checkout(branch)
-        end
-      end
-    end
-
-    # Switch back to the previous branch
-    def git_switch_from(branch:)
-      if branch
-        @git ||= Git.open(@root_dir)
-        if @git and @current_branch
-          @git.checkout(@current_branch)
-          @git.branch.stashes.apply if @stash
-        end
-      end
-    end
-
-    # Called if resuce from git exception
-    def git_rescue
-      @logger.error "Branch or ref does not exist"
-      @logger.error e.message
-      @logger.error e.backtrace
-    end
   end
 end

data/lib/roku_builder/manifest_manager.rb

@@ -58,5 +58,53 @@ module RokuBuilder
       end
       build_version
     end
+
+    # Update attributes in the app manifest
+    # It will add missing attributes but not remove them
+    # @param root_dir [String] The app root directory
+    # @param attributes [Hash] The new attributes for the app manifest
+    def self.update_manifest(root_dir:, attributes:)
+      temp_file = Tempfile.new('manifest')
+      path = File.join(root_dir, 'manifest')
+      new_params = attributes.dup
+      begin
+        if File.exist?(path)
+          File.open(path, 'r') do |file|
+            file.each_line do |line|
+              key = line.split("=")[0]
+              if new_params.include?(key.to_sym)
+                temp_file.puts("#{key}=#{new_params[key.to_sym]}")
+                new_params.delete(key)
+              else
+                temp_file.puts(line)
+              end
+            end
+          end
+        else
+          new_params = self.default_params().merge(new_params)
+        end
+        new_params.each_pair do |key, value|
+          temp_file.puts("#{key}=#{value}")
+        end
+        temp_file.rewind
+        FileUtils.cp(temp_file.path, path)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    # Returns the default manafest values
+    # @return [Hash] default manifest values
+    def self.default_params
+      {
+        title: "Default Title",
+        major_version: 1,
+        minor_version: 0,
+        build_version: "010101.0001",
+        mm_icon_focus_hd: "<insert hd focus icon url>",
+        mm_icon_focus_sd: "<insert sd focus icon url>"
+      }
+    end
   end
 end

data/lib/roku_builder/stager.rb

@@ -0,0 +1,86 @@
+module RokuBuilder
+
+  # Change stage of roku application
+  class Stager
+
+    def initialize(key: nil, method:, root_dir:, logger:)
+      @method = method
+      @key = key
+      @root_dir = root_dir
+      @logger = logger
+      @stage_success = true
+      @orginal_directory = Dir.pwd
+    end
+
+    def stage
+      Dir.chdir(@root_dir) unless @root_dir == @orginal_directory
+      case @method
+      when :current
+        # Do Nothing
+      when :working
+        # Do Nothing
+      when :git
+        begin
+          git_switch_to(branch: @key)
+        rescue Git::GitExecuteError
+          git_rescue
+          @stage_success = false
+        end
+      when :script
+        Controller.system(command: @key[:stage])
+      end
+      @stage_success
+    end
+
+    def unstage
+      unstage_success = true
+      case @method
+      when :current
+        # Do Nothing
+      when :working
+        # Do Nothing
+      when :git
+        begin
+          git_switch_from(branch: @key, checkout: @stage_success)
+        rescue Git::GitExecuteError
+          git_rescue
+          unstage_success = false
+        end
+      when :script
+        Controller.system(command: @key[:unstage])
+      end
+      Dir.chdir(@orginal_directory) unless @root_dir == @orginal_directory
+      unstage_success
+    end
+
+    private
+
+    # Switch to the correct branch
+    def git_switch_to(branch:)
+      if branch
+        @git ||= Git.open(@root_dir)
+        if branch != @git.current_branch
+          @current_branch = @git.current_branch
+          @stash = @git.branch.stashes.save("roku-builder-temp-stash")
+          @git.checkout(branch)
+        end
+      end
+    end
+
+    # Switch back to the previous branch
+    def git_switch_from(branch:, checkout: true)
+      if branch
+        @git ||= Git.open(@root_dir)
+        if @git and @current_branch
+          @git.checkout(@current_branch) if checkout
+          @git.branch.stashes.apply if @stash
+        end
+      end
+    end
+
+    # Called if resuce from git exception
+    def git_rescue
+      @logger.error "Branch or ref does not exist"
+    end
+  end
+end

data/lib/roku_builder/util.rb

@@ -9,7 +9,7 @@ module RokuBuilder
     # @param ip [String] IP address of roku device
     # @param user [String] Username for roku device
     # @param password [String] Password for roku device
-    def initialize(ip:, user:, password:, logger:)
+    def initialize(ip:, user:, password:, logger:, init_params: nil)
       @device_config = {
         ip: ip,
         user: user,
@@ -20,7 +20,11 @@ module RokuBuilder
       @dev_password = password
       @url = "http://#{@roku_ip_address}"
       @logger = logger
-      init()
+      if init_params
+        init(**init_params)
+      else
+        init
+      end
     end
 
     # Second initializer to be overwriten

data/lib/roku_builder/version.rb

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

data/tests/roku_builder/loader_test.rb

@@ -8,14 +8,16 @@ class LoaderTest < Minitest::Test
     response = Minitest::Mock.new
 
     root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
+    logger = Logger.new("/dev/null")
     device_config = {
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
+      logger: logger,
+      init_params: {root_dir: root_dir}
     }
     loader_config = {
-      root_dir: root_dir,
+      stage: {method: :working, root_dir: root_dir, logger: logger},
       folders: ["source"],
       files: ["manifest"]
     }
@@ -66,14 +68,16 @@ class LoaderTest < Minitest::Test
     response = Minitest::Mock.new
 
     root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
+    logger = Logger.new("/dev/null")
     device_config = {
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
+      logger: logger,
+      init_params: {root_dir: root_dir}
     }
     loader_config = {
-      root_dir: root_dir,
+      stage: {method: :working, root_dir: root_dir, logger: logger},
       update_manifest: true,
       folders: ["source"],
       files: ["manifest"]
@@ -121,14 +125,16 @@ class LoaderTest < Minitest::Test
 
   def test_loader_build_defining_folder_and_files
     root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
+    logger = Logger.new("/dev/null")
     device_config = {
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
+      logger: logger,
+      init_params: {root_dir: root_dir}
     }
     build_config = {
-      root_dir: root_dir,
+      stage: {method: :working, root_dir: root_dir, logger: logger},
       folders: ["source"],
       files: ["manifest"]
     }
@@ -146,15 +152,15 @@ class LoaderTest < Minitest::Test
   end
   def test_loader_build_all_contents
     root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
+    logger = Logger.new("/dev/null")
     device_config = {
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    build_config = {
-      root_dir: root_dir,
+      logger: logger,
+      init_params: {root_dir: root_dir}
     }
+    build_config = {stage: {method: :working, root_dir: root_dir, logger: logger}}
     loader = RokuBuilder::Loader.new(**device_config)
     outfile = nil
     RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
@@ -177,7 +183,8 @@ class LoaderTest < Minitest::Test
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
+      logger: Logger.new("/dev/null"),
+      init_params: {root_dir: "/dev/null"}
     }
     payload = {
       mysubmit: "Delete",
@@ -219,7 +226,8 @@ class LoaderTest < Minitest::Test
       ip: "111.222.333",
       user: "user",
       password: "password",
-      logger: Logger.new("/dev/null")
+      logger: Logger.new("/dev/null"),
+      init_params: {root_dir: "/dev/null"}
     }
     payload = {
       mysubmit: "Delete",

data/tests/roku_builder/manifest_manager_test.rb

@@ -31,4 +31,34 @@ class ManifestManagerTest < Minitest::Test
     assert_equal "010101.1", build_version
     FileUtils.rm(File.join(root_dir, "manifest"))
   end
+
+  def test_manifest_manager_update_manifest
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test")
+    FileUtils.cp(File.join(root_dir, "manifest_template"), File.join(root_dir, "manifest"))
+    attrs = {
+      title: "New Title",
+      major_version: 2,
+      minor_version: 2,
+      build_version: "020202.0002",
+      mm_icon_focus_hd: "pkg:/images/focus1.png",
+      mm_icon_focus_sd: "pkg:/images/focus2.png"
+    }
+    RokuBuilder::ManifestManager.update_manifest(root_dir: root_dir, attributes: attrs)
+    assert FileUtils.compare_file(File.join(root_dir, "manifest"), File.join(root_dir, "updated_title_manifest"))
+    FileUtils.rm(File.join(root_dir, "manifest"))
+  end
+  def test_manifest_manager_update_manifest
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test")
+    attrs = {
+      title: "New Title",
+      major_version: 2,
+      minor_version: 2,
+      build_version: "020202.0002",
+      mm_icon_focus_hd: "pkg:/images/focus1.png",
+      mm_icon_focus_sd: "pkg:/images/focus2.png"
+    }
+    RokuBuilder::ManifestManager.update_manifest(root_dir: root_dir, attributes: attrs)
+    assert FileUtils.compare_file(File.join(root_dir, "manifest"), File.join(root_dir, "updated_title_manifest"))
+    FileUtils.rm(File.join(root_dir, "manifest"))
+  end
 end

data/tests/roku_builder/stager_test.rb

@@ -0,0 +1,179 @@
+require_relative "test_helper.rb"
+
+class StagerTest < Minitest::Test
+  def test_stager_stage_working
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    stager_config = {
+      method: :working,
+      root_dir: root_dir,
+      logger: nil
+    }
+    stager = RokuBuilder::Stager.new(**stager_config)
+    assert stager.stage
+    assert stager.unstage
+  end
+
+  def test_stager_stage_current
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    stager_config = {
+      method: :current,
+      root_dir: root_dir,
+      logger: nil
+    }
+    stager = RokuBuilder::Stager.new(**stager_config)
+    assert stager.stage
+    assert stager.unstage
+  end
+
+  def test_stager_stage_git_stash
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    branch_name = 'branch'
+    git = Minitest::Mock.new
+    branch = Minitest::Mock.new
+    stashes = Minitest::Mock.new
+
+    stager_config = {
+      method: :git,
+      root_dir: root_dir,
+      key: branch_name,
+      logger: nil
+    }
+
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:branch, branch)
+    branch.expect(:stashes, stashes)
+    stashes.expect(:save, true, ["roku-builder-temp-stash"])
+    git.expect(:checkout, nil, [branch_name])
+    git.expect(:checkout, nil, ['other_branch'])
+    git.expect(:branch, branch)
+    branch.expect(:stashes, stashes)
+    stashes.expect(:apply, nil)
+
+    Git.stub(:open, git) do
+      stager = RokuBuilder::Stager.new(**stager_config)
+      assert stager.stage
+      assert stager.unstage
+    end
+    git.verify
+    branch.verify
+    stashes.verify
+  end
+
+  def test_stager_stage_git_no_stash
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    branch_name = 'branch'
+    git = Minitest::Mock.new
+    branch = Minitest::Mock.new
+    stashes = Minitest::Mock.new
+
+    stager_config = {
+      method: :git,
+      root_dir: root_dir,
+      key: branch_name,
+      logger: nil
+    }
+
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:branch, branch)
+    branch.expect(:stashes, stashes)
+    stashes.expect(:save, nil, ["roku-builder-temp-stash"])
+    git.expect(:checkout, nil, [branch_name])
+    git.expect(:checkout, nil, ['other_branch'])
+
+    Git.stub(:open, git) do
+      stager = RokuBuilder::Stager.new(**stager_config)
+      assert stager.stage
+      assert stager.unstage
+    end
+    git.verify
+    branch.verify
+    stashes.verify
+  end
+
+  def test_stager_stage_git_error_stage
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    branch_name = 'branch'
+    git = Minitest::Mock.new
+    branch = Minitest::Mock.new
+    stashes = Minitest::Mock.new
+    logger = Minitest::Mock.new
+
+    stager_config = {
+      method: :git,
+      root_dir: root_dir,
+      key: branch_name,
+      logger: logger
+    }
+
+    def git.checkout(branch)
+      raise Git::GitExecuteError.new
+    end
+
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:current_branch, 'other_branch')
+    git.expect(:branch, branch)
+    branch.expect(:stashes, stashes)
+    stashes.expect(:save, true, ["roku-builder-temp-stash"])
+    logger.expect(:error, nil, ["Branch or ref does not exist"])
+    git.expect(:branch, branch)
+    branch.expect(:stashes, stashes)
+    stashes.expect(:apply, nil)
+
+    Git.stub(:open, git) do
+      stager = RokuBuilder::Stager.new(**stager_config)
+      assert !stager.stage
+      assert stager.unstage
+    end
+    git.verify
+    branch.verify
+    stashes.verify
+    logger.verify
+  end
+
+  def test_stager_stage_git_error_unstage
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    branch_name = 'branch'
+    git = Minitest::Mock.new
+    branch = Minitest::Mock.new
+    stashes = Minitest::Mock.new
+    logger = Minitest::Mock.new
+
+    stager_config = {
+      method: :git,
+      root_dir: root_dir,
+      key: branch_name,
+      logger: logger
+    }
+
+    def git.checkout(branch)
+      raise Git::GitExecuteError.new
+    end
+
+    logger.expect(:error, nil, ["Branch or ref does not exist"])
+
+    Git.stub(:open, git) do
+      stager = RokuBuilder::Stager.new(**stager_config)
+      stager.instance_variable_set(:@current_branch, "branch")
+      assert !stager.unstage
+    end
+    logger.verify
+  end
+
+  def test_stager_stage_script
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    stager_config = {
+      method: :script,
+      key: {stage: "stage_script", unstage: "unstage_script"},
+      root_dir: root_dir,
+      logger: nil
+    }
+    RokuBuilder::Controller.stub(:system, nil) do
+      stager = RokuBuilder::Stager.new(**stager_config)
+      assert stager.stage
+      assert stager.unstage
+    end
+  end
+end
+

data/tests/roku_builder/test_files/manifest_manager_test/manifest_template

@@ -1,2 +1,6 @@
-build_version=010101.1
 title=Test
+major_version=1
+minor_version=0
+build_version=010101.1
+mm_icon_focus_hd=pkg:/images/focus.png
+mm_icon_focus_sd=pkg:/images/focus.png

data/tests/roku_builder/test_files/manifest_manager_test/manifest_template_2

@@ -1,2 +1,6 @@
-build_version=010101
 title=Test
+major_version=1
+minor_version=0
+build_version=010101
+mm_icon_focus_hd=pkg:/images/focus.png
+mm_icon_focus_sd=pkg:/images/focus.png

data/tests/roku_builder/test_files/manifest_manager_test/updated_title_manifest

@@ -0,0 +1,6 @@
+title=New Title
+major_version=2
+minor_version=2
+build_version=020202.0002
+mm_icon_focus_hd=pkg:/images/focus1.png
+mm_icon_focus_sd=pkg:/images/focus2.png

data/tests/roku_builder/test_helper.rb

@@ -29,6 +29,7 @@ def good_config
         folders: ["resources","source"],
         files: ["manifest"],
         app_name: "<app name>",
+        stage_method: :git,
         stages:{
           production: {
             branch: "production",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.3.4
+  version: 3.4.0
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2016-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -253,6 +253,7 @@ files:
 - lib/roku_builder/monitor.rb
 - lib/roku_builder/navigator.rb
 - lib/roku_builder/packager.rb
+- lib/roku_builder/stager.rb
 - lib/roku_builder/tester.rb
 - lib/roku_builder/util.rb
 - lib/roku_builder/version.rb
@@ -272,6 +273,7 @@ files:
 - tests/roku_builder/monitor_test.rb
 - tests/roku_builder/navigator_test.rb
 - tests/roku_builder/packager_test.rb
+- tests/roku_builder/stager_test.rb
 - tests/roku_builder/test_files/controller_config_test/valid_config.json
 - tests/roku_builder/test_files/controller_test/load_config_test.json
 - tests/roku_builder/test_files/controller_test/valid_config.json
@@ -281,6 +283,11 @@ files:
 - tests/roku_builder/test_files/loader_test/source/c/d
 - tests/roku_builder/test_files/manifest_manager_test/manifest_template
 - tests/roku_builder/test_files/manifest_manager_test/manifest_template_2
+- tests/roku_builder/test_files/manifest_manager_test/updated_title_manifest
+- tests/roku_builder/test_files/stager_test/a
+- tests/roku_builder/test_files/stager_test/manifest
+- tests/roku_builder/test_files/stager_test/source/b
+- tests/roku_builder/test_files/stager_test/source/c/d
 - tests/roku_builder/test_helper.rb
 - tests/roku_builder/tester_test.rb
 - tests/roku_builder/util_test.rb