roku_builder 3.11.0 → 3.11.1

data/lib/roku_builder/keyer.rb

@@ -6,31 +6,7 @@ module RokuBuilder
   class Keyer < Util
 
     def genkey(out_file: nil)
-      telnet_config = {
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
-      connection = Net::Telnet.new(telnet_config)
-      connection.puts("genkey")
-      waitfor_config = {
-        'Match' => /./,
-        'Timeout' => false
-      }
-      password = nil
-      dev_id = nil
-      while password.nil? or dev_id.nil?
-        connection.waitfor(waitfor_config) do |txt|
-          while line = txt.slice!(/^.*\n/) do
-            words = line.split
-            if words[0] == "Password:"
-              password = words[1]
-            elsif words[0] == "DevID:"
-              dev_id = words[1]
-            end
-          end
-        end
-      end
-      connection.close
+      password, dev_id = generate_new_key()
       @logger.info("Password: "+password)
       @logger.info("DevID: "+dev_id)
 
@@ -93,5 +69,38 @@ module RokuBuilder
       dev_id ||= "none"
       dev_id
     end
+
+    private
+
+    # Uses the device to generate a new signing key
+    #  @return [Array<String>] Password and dev_id for the new key
+    def generate_new_key()
+      telnet_config = {
+        'Host' => @roku_ip_address,
+        'Port' => 8080
+      }
+      connection = Net::Telnet.new(telnet_config)
+      connection.puts("genkey")
+      waitfor_config = {
+        'Match' => /./,
+        'Timeout' => false
+      }
+      password = nil
+      dev_id = nil
+      while password.nil? or dev_id.nil?
+        connection.waitfor(waitfor_config) do |txt|
+          while line = txt.slice!(/^.*\n/) do
+            words = line.split
+            if words[0] == "Password:"
+              password = words[1]
+            elsif words[0] == "DevID:"
+              dev_id = words[1]
+            end
+          end
+        end
+      end
+      connection.close
+      return password, dev_id
+    end
   end
 end

data/lib/roku_builder/loader.rb

@@ -15,37 +15,34 @@ module RokuBuilder
     # @param root_dir [String] Path to the root directory of the roku app
     # @param content [Hash] Hash containing arrays for folder, files, and excludes. Default: nil
     # @return [String] Build version on success, nil otherwise
-    def sideload(update_manifest: false, content: nil, infile: nil)
+    def sideload(update_manifest: false, content: nil, infile: nil, out_file: nil)
       Navigator.new(**@device_config).nav(commands: [:home])
       result = FAILED_SIDELOAD
-      outfile = nil
       build_version = nil
       if infile
         build_version = ManifestManager.build_version(root_dir: infile)
-        return [MISSING_MANIFEST, nil] if outfile == MISSING_MANIFEST
-        outfile = infile
+        out_file = infile
       else
         # Update manifest
         if update_manifest
           build_version = ManifestManager.update_build(root_dir: @root_dir)
-          return [MISSING_MANIFEST, nil] if outfile == MISSING_MANIFEST
         else
           build_version = ManifestManager.build_version(root_dir: @root_dir)
-          return [MISSING_MANIFEST, nil] if outfile == MISSING_MANIFEST
         end
-        outfile = build(build_version: build_version, content: content)
-        return [MISSING_MANIFEST, nil] if outfile == MISSING_MANIFEST
+        @logger.info "Build: #{out_file}" if out_file
+        out_file = build(build_version: build_version, out_file: out_file, content: content)
       end
+      return [MISSING_MANIFEST, nil] if out_file == MISSING_MANIFEST
       path = "/plugin_install"
       # Connect to roku and upload file
       conn = multipart_connection
       payload =  {
         mysubmit: "Replace",
-        archive: Faraday::UploadIO.new(outfile, 'application/zip')
+        archive: Faraday::UploadIO.new(out_file, 'application/zip')
       }
       response = conn.post path, payload
       # Cleanup
-      File.delete(outfile) unless infile
+      File.delete(out_file) if infile.nil? and out_file.nil?
       result = SUCCESS if response.status==200 and response.body=~/Install Success/
       result = IDENTICAL_SIDELOAD if response.status==200 and response.body=~/Identical to previous version/
       [result, build_version]
@@ -55,23 +52,20 @@ module RokuBuilder
     # Build an app to sideload later
     # @param root_dir [String] Path to the root directory of the roku app
     # @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 out_file [String] Path for the output file. If nil will create a file in /tmp. Default: nil
     # @param content [Hash] Hash containing arrays for folder, files, and excludes. Default: nil
     # @return [String] Path of the build
-    def build(build_version: nil, outfile: nil, content: nil)
+    def build(build_version: nil, out_file: nil, content: nil)
       build_version = ManifestManager.build_version(root_dir: @root_dir) unless build_version
       return MISSING_MANIFEST if build_version == MISSING_MANIFEST
       content ||= {}
-      unless content and content[:folders]
-        content[:folders] = Dir.entries(@root_dir).select {|entry| File.directory? File.join(@root_dir, entry) and !(entry =='.' || entry == '..') }
-      end
-      unless content and content[:files]
-        content[:files] = Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
-      end
-      content[:excludes] = [] unless content and content[:excludes]
-      outfile = "/tmp/build_#{build_version}.zip" unless outfile
-      File.delete(outfile) if File.exist?(outfile)
-      io = Zip::File.open(outfile, Zip::File::CREATE)
+      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 = 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)
       # Add folders to zip
       content[:folders].each do |folder|
         base_folder = File.join(@root_dir, folder)
@@ -87,7 +81,7 @@ module RokuBuilder
       # Add file to zip
       writeEntries(@root_dir, content[:files], "", content[:excludes], io)
       io.close()
-      outfile
+      out_file
     end
 
     # Remove the currently sideloaded app

data/lib/roku_builder/monitor.rb

@@ -22,14 +22,8 @@ module RokuBuilder
     # Monitor a development log on the Roku device
     # @param type [Symbol] The log type to monitor
     def monitor(type:)
-      telnet_config = {
-        'Host' => @roku_ip_address,
-        'Port' => @ports[type]
-      }
-      waitfor_config = {
-        'Match' => /./,
-        'Timeout' => false
-      }
+      telnet_config = { 'Host' => @roku_ip_address, 'Port' => @ports[type] }
+      waitfor_config = { 'Match' => /./, 'Timeout' => false }
 
       thread = Thread.new(telnet_config, waitfor_config) {|telnet,waitfor|
         @logger.info "Monitoring #{type} console(#{telnet['Port']}) on #{telnet['Host'] }"
@@ -42,8 +36,16 @@ module RokuBuilder
           end
         end
       }
-      # setup readline
 
+      init_readline()
+
+      run_prompt(thread: thread)
+    end
+
+    private
+
+    # Setup tab completeion for Readline
+    def init_readline
       libedit = false
       begin
         Readline.vi_editing_mode
@@ -62,8 +64,10 @@ module RokuBuilder
 
       Readline.completion_append_character = " "
       Readline.completion_proc = comp
+    end
 
-
+    # Check if needs to display prompt, displays prompt, and processes input
+    def run_prompt(thread:)
       running = true
       @logger.unknown "Q to exit"
       while running
@@ -90,9 +94,7 @@ module RokuBuilder
       end
     end
 
-    private
-
-    # Handel text from telnet
+    # Handle text from telnet
     #  @param all_text [String] remaining partial line text
     #  @param txt [String] current string from telnet
     #  @return [String] remaining partial line text

data/lib/roku_builder/navigator.rb

@@ -8,34 +8,36 @@ module RokuBuilder
     # Setup navigation commands
     def init(mappings: nil)
       @commands = {
-        home: "Home",
-        rew: "Rev",
-        ff: "Fwd",
-        play: "Play",
-        select: "Select",
-        left: "Left",
-        right: "Right",
-        down: "Down",
-        up: "Up",
-        back: "Back",
-        replay: "InstantReplay",
-        info: "Info",
-        backspace: "Backspace",
-        search: "Search",
-        enter: "Enter",
-        volumedown: "VolumeDown",
-        volumeup: "VolumeUp",
-        mute: "VolumeMute",
-        channelup: "ChannelUp",
-        channeldown: "ChannelDown",
-        tuner: "InputTuner",
-        hdmi1: "InputHDMI1",
-        hdmi2: "InputHDMI2",
-        hdmi3: "InputHDMI3",
-        hdmi4: "InputHDMI4",
-        avi: "InputAVI"
+        home: "Home",             rew: "Rev",                 ff: "Fwd",
+        play: "Play",             select: "Select",           left: "Left",
+        right: "Right",           down: "Down",               up: "Up",
+        back: "Back",             replay: "InstantReplay",    info: "Info",
+        backspace: "Backspace",   search: "Search",           enter: "Enter",
+        volumedown: "VolumeDown", volumeup: "VolumeUp",       mute: "VolumeMute",
+        channelup: "ChannelUp",   channeldown: "ChannelDown", tuner: "InputTuner",
+        hdmi1: "InputHDMI1",      hdmi2: "InputHDMI2",        hdmi3: "InputHDMI3",
+        hdmi4: "InputHDMI4",      avi: "InputAVI"
       }
+      @screens = {
+        platform: [:home, :home, :home, :home, :home, :ff, :play, :rew, :play, :ff],
+        secret: [:home, :home, :home, :home, :home, :ff, :ff, :ff, :rew, :rew],
+        secret2: [:home, :home, :home, :home, :home, :up, :right, :down, :left, :up],
+        channels: [:home, :home, :home, :up, :up, :left, :right, :left, :right, :left],
+        developer: [:home, :home, :home, :up, :up, :right, :left, :right, :left, :right],
+        wifi: [:home, :home, :home, :home, :home, :up, :down, :up, :down, :up],
+        antenna: [:home, :home, :home, :home, :home, :ff, :down, :rew, :down, :ff],
+        bitrate: [:home, :home, :home, :home, :home, :rew, :rew, :rew, :ff, :ff],
+        network: [:home, :home, :home, :home, :home, :right, :left, :right, :left, :right],
+        reboot: [:home, :home, :home, :home, :home, :up, :rew, :rew, :ff, :ff]
+      }
+      @runable = [
+        :secret, :channels
+      ]
+      mappings_init(mappings: mappings)
+    end
 
+    # Init Mappings
+    def mappings_init(mappings: nil)
       @mappings = {
         "\e[1~": [ "home", "Home" ],
         "<": [ "rew", "<" ],
@@ -64,25 +66,7 @@ module RokuBuilder
         #"": [ "hdmi4", "" ],
         #"": [ "avi", "" ]
       }
-
       @mappings.merge!(mappings) if mappings
-
-      @screens = {
-        platform: [:home, :home, :home, :home, :home, :ff, :play, :rew, :play, :ff],
-        secret: [:home, :home, :home, :home, :home, :ff, :ff, :ff, :rew, :rew],
-        secret2: [:home, :home, :home, :home, :home, :up, :right, :down, :left, :up],
-        channels: [:home, :home, :home, :up, :up, :left, :right, :left, :right, :left],
-        developer: [:home, :home, :home, :up, :up, :right, :left, :right, :left, :right],
-        wifi: [:home, :home, :home, :home, :home, :up, :down, :up, :down, :up],
-        antenna: [:home, :home, :home, :home, :home, :ff, :down, :rew, :down, :ff],
-        bitrate: [:home, :home, :home, :home, :home, :rew, :rew, :rew, :ff, :ff],
-        network: [:home, :home, :home, :home, :home, :right, :left, :right, :left, :right],
-        reboot: [:home, :home, :home, :home, :home, :up, :rew, :rew, :ff, :ff]
-      }
-
-      @runable = [
-        :secret, :channels
-      ]
     end
 
     # Send a navigation command to the roku device
@@ -152,8 +136,7 @@ module RokuBuilder
         else
           @logger.unknown("Cannot run command automatically")
         end
-        display = []
-        count = []
+        display, count, string = [], [], ""
         @screens[type].each do |command|
           if display.count > 0 and  display[-1] == command
             count[-1] = count[-1] + 1
@@ -162,7 +145,6 @@ module RokuBuilder
             count.push(1)
           end
         end
-        string = ""
         display.each_index do |i|
           if count[i] > 1
             string = string + @commands[display[i]]+" x "+count[i].to_s+", "
@@ -170,7 +152,6 @@ module RokuBuilder
             string = string + @commands[display[i]]+", "
           end
         end
-
         if @runable.include?(type)
           @logger.info(string.strip)
         else
@@ -191,16 +172,16 @@ module RokuBuilder
       STDIN.echo = false
       STDIN.raw!
 
+
       input = STDIN.getc.chr
       if input == "\e" then
         input << STDIN.read_nonblock(3) rescue nil
         input << STDIN.read_nonblock(2) rescue nil
       end
+      input
     ensure
       STDIN.echo = true
       STDIN.cooked!
-
-      return input
     end
   end
 end

data/lib/roku_builder/packager.rb

@@ -35,7 +35,7 @@ module RokuBuilder
       end
       response = conn.get path
       return false if response.status != 200
-
+      out_file = out_file+".pkg" unless out_file.end_with?(".pkg")
       File.open(out_file, 'w+') {|fp| fp.write(response.body)}
       true
     end

data/lib/roku_builder/tester.rb

@@ -25,7 +25,7 @@ module RokuBuilder
       connection = Net::Telnet.new(telnet_config)
       code, _build_version = loader.sideload(**sideload_config)
 
-      if code = SUCCESS
+      if code == SUCCESS
         in_tests = false
         connection.waitfor(@end_reg) do |txt|
           in_tests = handle_text(txt: txt, in_tests: in_tests)

data/lib/roku_builder/version.rb

@@ -2,5 +2,5 @@
 
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "3.11.0"
+  VERSION = "3.11.1"
 end

data/roku_builder.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = "~> 2.3"
 
   spec.add_dependency "rubyzip",             "~> 1.2"
-  spec.add_dependency "faraday",             "~> 0.10"
+  spec.add_dependency "faraday",             "~> 0.11"
   spec.add_dependency "faraday-digestauth",  "~> 0.2"
   spec.add_dependency "git",                 "~> 1.3"
   spec.add_dependency "net-ping",            "~> 2.0"

data/tests/roku_builder/config_manager_test.rb

@@ -280,4 +280,62 @@ class ConfigManagerTest < Minitest::Test
     assert_equal 2, config[:projects][:p2][:folders].count
     File.delete(target_config) if File.exist?(target_config)
   end
+
+  def test_config_manager_update_configs
+    configs = {
+      project_config: { app_name: "<app_name>" },
+      package_config: {},
+      stage: "<stage>",
+      out: { file: nil, folder: "/tmp" }
+    }
+    options = {
+      build_version: "<build_version>"
+    }
+    configs = RokuBuilder::ConfigManager.update_configs(configs: configs, options: options)
+    assert_equal "<app_name> - <stage> - <build_version>", configs[:package_config][:app_name_version]
+    assert_equal "<app_name>_<stage>_<build_version>", configs[:out][:file]
+    assert_equal "/tmp/<app_name>_<stage>_<build_version>", configs[:package_config][:out_file]
+
+    configs = {
+      project_config: { app_name: "<app_name>" },
+      package_config: {},
+      stage: "<stage>",
+      out: { file: "file.pkg", folder: "/home/user" }
+    }
+    options = {
+      build_version: "<build_version>"
+    }
+    configs = RokuBuilder::ConfigManager.update_configs(configs: configs, options: options)
+    assert_equal "<app_name> - <stage> - <build_version>", configs[:package_config][:app_name_version]
+    assert_equal "file.pkg", configs[:out][:file]
+    assert_equal "/home/user/file.pkg", configs[:package_config][:out_file]
+
+    configs = {
+      project_config: { app_name: "<app_name>" },
+      build_config: {},
+      stage: "<stage>",
+      out: { file: nil, folder: "/tmp" }
+    }
+    options = {
+      build_version: "<build_version>"
+    }
+    configs = RokuBuilder::ConfigManager.update_configs(configs: configs, options: options)
+    assert_equal "<app_name>_<stage>_<build_version>", configs[:out][:file]
+    assert_equal "/tmp/<app_name>_<stage>_<build_version>", configs[:build_config][:out_file]
+
+    configs = {
+      project_config: { app_name: "<app_name>" },
+      inspect_config: {},
+      package_config: {},
+      stage: "<stage>",
+      out: { file: nil, folder: "/tmp" }
+    }
+    options = {
+      build_version: "<build_version>"
+    }
+    configs = RokuBuilder::ConfigManager.update_configs(configs: configs, options: options)
+    assert_equal "<app_name>_<stage>_<build_version>", configs[:out][:file]
+    assert_equal "/tmp/<app_name>_<stage>_<build_version>", configs[:package_config][:out_file]
+    assert_equal "/tmp/<app_name>_<stage>_<build_version>", configs[:inspect_config][:pkg]
+  end
 end