roku_builder 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01878e8347e002a0414b1bc0d3e21357cf9464ea
-  data.tar.gz: 693de68409f67d5c2139d3fa508db5206ae5979a
+  metadata.gz: 878733ac2055fcbfa7fb162abf1f36a3d8e200c7
+  data.tar.gz: ee4a6a97eb48e0befd1e9dd5ec8e542396411f9b
 SHA512:
-  metadata.gz: 63e7b063e4d4e89a916f2a8c6f107a4b6dc3a7eacdb5e9169a9e9a2b9c3d0d98ef729692731449fa6335bda460e3fea294f80ccf21c192b7743bbb981f3bb707
-  data.tar.gz: b3f570b04987f9dc83bb8342f953b49d4ce315bb2a2598be25931cf2db7eed40c129ab2d08266b147dede2bccdc859b01ba64844a0a78dc4f07fa10995dfb21b
+  metadata.gz: bb15a8cdf99cdf04716c9ca95c8b531a492f1eff3632f7a663d0e061f34dcc5e5951b10d182bca3fe0cec130201010f0dc32f7a8fbbbb13890666ba9c3918fbb
+  data.tar.gz: 5894aeed3e103c46480cce8061b3b2fbd1a469c3f2391d6e72420a6d4f8531485d4ef15692b158959a30fd3529ecf8479129e558d4a0f03700e09ae26feb0d17

data/.travis.yml

@@ -1,3 +1,3 @@
 language: ruby
 rvm:
-  - "2.2.1"
+  - "2.2.3"

data/Gemfile.lock

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

data/config.json.example

@@ -13,6 +13,7 @@
       "directory": "<path/to/repo>",
       "folders": ["resources","source"],
       "files": ["manifest"],
+      "excludes": [],
       "app_name": "<app name>",
       "stage_method": "<git|script>",
       "stages":{

data/lib/roku_builder/config_parser.rb

@@ -140,16 +140,24 @@ module RokuBuilder
     # @param branch [String] the branch to sideload
     def self.setup_sideload_config(configs:, options:)
       root_dir = configs[:project_config][:directory]
+      content = {
+        folders: configs[:project_config][:folders],
+        files: configs[:project_config][:files],
+      }
+      all_commands = options.keys & Controller.commands
+      if Controller.exclude_commands.include?(all_commands.first)
+        content[:excludes] = configs[:project_config][:excludes]
+      end
+
       # Create Sideload Config
       configs[:sideload_config] = {
         update_manifest: options[:update_manifest],
-        folders: configs[:project_config][:folders],
-        files: configs[:project_config][:files]
+        infile: options[:in],
+        content: content
       }
       # Create Build Config
       configs[:build_config] = {
-        folders: configs[:project_config][:folders],
-        files: configs[:project_config][:files]
+        content: content
       }
       configs[:init_params][:loader] = {
         root_dir: root_dir

data/lib/roku_builder/controller.rb

@@ -164,7 +164,6 @@ module RokuBuilder
         :navigate, :text, :build, :monitor, :update, :screencapture, :key, :screen,
         :screens]
     end
-    private_class_method :commands
 
     # List of depricated options
     # @return [Hash] Hash of depricated options and the warning message for each
@@ -175,7 +174,7 @@ module RokuBuilder
     # List of source options
     # @return [Array<Symbol>] List of source symbols that can be used in the options hash
     def self.sources
-      [:ref, :set_stage, :working, :current]
+      [:ref, :set_stage, :working, :current, :in]
     end
 
     # List of commands requiring a source option
@@ -183,7 +182,12 @@ module RokuBuilder
     def self.source_commands
       [:sideload, :package, :test, :build, :key]
     end
-    private_class_method :source_commands
+
+    # List of commands the activate the exclude files
+    # @return [Array<Symbol] List of commands the will activate the exclude files lists
+    def self.exclude_commands
+      [:build, :package]
+    end
 
 
     # Configure the gem

data/lib/roku_builder/controller_commands.rb

@@ -39,15 +39,16 @@ module RokuBuilder
       config = configs[:device_config].dup
       config[:init_params] = configs[:init_params][:loader]
       stager = Stager.new(**configs[:stage_config])
-      success = false
+      success = nil
       if stager.stage
         loader = Loader.new(**config)
-        success = loader.sideload(**configs[:sideload_config])
+        success, version = loader.sideload(**configs[:sideload_config])
       end
       stager.unstage
-      return FAILED_SIDELOAD unless success
-      logger.info "App Sideloaded; staged using #{stager.method}"
-      SUCCESS
+      unless success == FAILED_SIDELOAD
+        logger.info "App Sideloaded; staged using #{stager.method}"
+      end
+      success
     end
     # Run Package
     # @param options [Hash] user options
@@ -65,8 +66,8 @@ module RokuBuilder
       logger.warn "Packaging working directory" if options[:working]
       if stager.stage
         # Sideload #
-        build_version = loader.sideload(**configs[:sideload_config])
-        return FAILED_SIGNING unless build_version
+        code, build_version = loader.sideload(**configs[:sideload_config])
+        return code unless code = SUCCESS
         # Key #
         success = keyer.rekey(**configs[:key])
         logger.info "Key did not change" unless success

data/lib/roku_builder/loader.rb

@@ -11,19 +11,24 @@ module RokuBuilder
 
     # Sideload an app onto a roku device
     # @param root_dir [String] Path to the root directory of the roku app
-    # @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
+    # @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, folders: nil, files: nil)
-      result = nil
-      # Update manifest
-      build_version = ""
-      if update_manifest
-        build_version = ManifestManager.update_build(root_dir: @root_dir)
+    def sideload(update_manifest: false, content: nil, infile: nil)
+      result = FAILED_SIDELOAD
+      outfile = nil
+      build_version = nil
+      if infile
+        build_version = ManifestManager.build_version(root_dir: infile)
+        outfile = infile
       else
-        build_version = ManifestManager.build_version(root_dir: @root_dir)
+        # Update manifest
+        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(build_version: build_version, content: content)
       end
-      outfile = build(build_version: build_version, folders: folders, files: files)
       path = "/plugin_install"
       # Connect to roku and upload file
       conn = multipart_connection
@@ -33,9 +38,10 @@ module RokuBuilder
       }
       response = conn.post path, payload
       # Cleanup
-      File.delete(outfile)
-      result = build_version if response.status==200 and response.body=~/Install Success/
-        result
+      File.delete(outfile) unless infile
+      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]
     end
 
 
@@ -43,30 +49,31 @@ module RokuBuilder
     # @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 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
+    # @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, folders: nil, files: nil)
+    def build(build_version: nil, outfile: nil, content: 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 == '..') }
+      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 files
-        files = Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
+      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)
       # Add folders to zip
-      folders.each do |folder|
+      content[: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)
+        writeEntries(@root_dir, entries, folder, content[:excludes], io)
       end
       # Add file to zip
-      writeEntries(@root_dir, files, "", io)
+      writeEntries(@root_dir, content[:files], "", content[:excludes], io)
       io.close()
       outfile
     end
@@ -95,16 +102,18 @@ module RokuBuilder
     # @param entries [Array<String>] Array of file paths of files/directories to store in the zip archive
     # @param path [String] The path of the current directory starting at the root directory
     # @param io [IO] zip IO object
-    def writeEntries(root_dir, entries, path, io)
+    def writeEntries(root_dir, entries, path, excludes, io)
       entries.each { |e|
         zipFilePath = path == "" ? e : File.join(path, e)
         diskFilePath = File.join(root_dir, zipFilePath)
         if File.directory?(diskFilePath)
           io.mkdir(zipFilePath)
           subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
-          writeEntries(root_dir, subdir, zipFilePath, io)
+          writeEntries(root_dir, subdir, zipFilePath, excludes, io)
         else
-          io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read()) }
+          unless excludes.include?(zipFilePath)
+            io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read()) }
+          end
         end
       }
     end

data/lib/roku_builder/manifest_manager.rb

@@ -47,14 +47,23 @@ module RokuBuilder
     # @param root_dir [String] Path to the root directory for the app
     # @return [String] Build version on success, empty string otherwise
     def self.build_version(root_dir:)
-      path = File.join(root_dir, 'manifest')
       build_version = ""
-      File.open(path, 'r') do |file|
+      get_version = lambda  { |file|
         file.each_line do |line|
           if line.include?("build_version")
             build_version = line.split("=")[1].chomp
           end
         end
+      }
+      if File.directory?(root_dir)
+        path = File.join(root_dir, 'manifest')
+        build_version = ""
+        File.open(path, 'r', &get_version)
+      elsif File.extname(root_dir) == ".zip"
+        Zip::File.open(root_dir) do |zip_file|
+          entry = zip_file.glob("manifest").first
+          entry.get_input_stream(&get_version)
+        end
       end
       build_version
     end

data/lib/roku_builder/tester.rb

@@ -21,13 +21,15 @@ module RokuBuilder
 
       loader = Loader.new(**@device_config)
       connection = Net::Telnet.new(telnet_config)
-      loader.sideload(**sideload_config)
+      code, _build_version = loader.sideload(**sideload_config)
 
-      in_tests = false
-      connection.waitfor(@end_reg) do |txt|
-        in_tests = handle_text(txt: txt, in_tests: in_tests)
+      if code = SUCCESS
+        in_tests = false
+        connection.waitfor(@end_reg) do |txt|
+          in_tests = handle_text(txt: txt, in_tests: in_tests)
+        end
+        connection.puts("cont\n")
       end
-      connection.puts("cont\n")
     end
 
     private

data/lib/roku_builder/version.rb

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

data/lib/roku_builder.rb

@@ -129,6 +129,9 @@ module RokuBuilder
 
   # Failed to capture screen
   FAILED_SCREENCAPTURE = 12
+
+  # Did not sideload as content is identical
+  IDENTICAL_SIDELOAD = 13
 end
 
 class String

data/roku_builder.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = "~> 2.2"
+  spec.required_ruby_version = "~> 2.2.3"
 
   spec.add_dependency "rubyzip",             "~> 1.2"
   spec.add_dependency "faraday",             "~> 0.9"

data/tests/roku_builder/controller_commands_test.rb

@@ -11,7 +11,7 @@ class ControllerCommandsTest < Minitest::Test
     config = good_config
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     # Test Success
-    loader.expect(:sideload, true, [configs[:sideload_config]])
+    loader.expect(:sideload, [RokuBuilder::SUCCESS, "build_version"], [configs[:sideload_config]])
     stager.expect(:stage, true)
     stager.expect(:unstage, true)
     stager.expect(:method, :git)
@@ -27,7 +27,7 @@ class ControllerCommandsTest < Minitest::Test
     stager.expect(:unstage, true)
 
     # Test Failure
-    loader.expect(:sideload, false, [configs[:sideload_config]])
+    loader.expect(:sideload, [RokuBuilder::FAILED_SIDELOAD, "build_version"], [configs[:sideload_config]])
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::Stager.stub(:new, stager) do
         code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
@@ -52,7 +52,7 @@ class ControllerCommandsTest < Minitest::Test
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     info = {app_name: "app", dev_id: "id", creation_date: "date", dev_zip: ""}
 
-    loader.expect(:sideload, "build_version", [configs[:sideload_config]])
+    loader.expect(:sideload, [RokuBuilder::SUCCESS, "build_version"], [configs[:sideload_config]])
     keyer.expect(:rekey, true, [configs[:key]])
     packager.expect(:package, true, [configs[:package_config]])
     inspector.expect(:inspect, info, [configs[:inspect_config]])
@@ -94,7 +94,7 @@ class ControllerCommandsTest < Minitest::Test
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     info = {app_name: "app", dev_id: "id", creation_date: "date", dev_zip: ""}
 
-    loader.expect(:sideload, "build_version", [configs[:sideload_config]])
+    loader.expect(:sideload, [RokuBuilder::SUCCESS, "build_version"], [configs[:sideload_config]])
     keyer.expect(:rekey, true, [configs[:key]])
     packager.expect(:package, true, [configs[:package_config]])
     inspector.expect(:inspect, info, [configs[:inspect_config]])

data/tests/roku_builder/controller_test.rb

@@ -36,7 +36,6 @@ class ControllerTest < Minitest::Test
     assert_equal RokuBuilder::DEPRICATED, RokuBuilder::Controller.send(:validate_options, {options: options})
     options = {
       sideload: true,
-      in: "",
       current: true
     }
     assert_equal RokuBuilder::VALID, RokuBuilder::Controller.send(:validate_options, {options: options})
@@ -45,7 +44,7 @@ class ControllerTest < Minitest::Test
       in: "",
       set_stage: true
     }
-    assert_equal RokuBuilder::BAD_IN_FILE, RokuBuilder::Controller.send(:validate_options, {options: options})
+    assert_equal RokuBuilder::EXTRA_SOURCES, RokuBuilder::Controller.send(:validate_options, {options: options})
   end
   def test_controller_configure
     logger = Logger.new("/dev/null")

data/tests/roku_builder/loader_test.rb

@@ -17,8 +17,10 @@ class LoaderTest < Minitest::Test
       init_params: {root_dir: root_dir}
     }
     loader_config = {
-      folders: ["source"],
-      files: ["manifest"]
+      content: {
+        folders: ["source"],
+        files: ["manifest"]
+      }
     }
     payload = {
       mysubmit: "Replace",
@@ -38,22 +40,26 @@ class LoaderTest < Minitest::Test
     end
     response.expect(:status, 200)
     response.expect(:body, "Install Success")
+    response.expect(:status, 200)
+    response.expect(:body, "Install Success")
 
     loader = RokuBuilder::Loader.new(**device_config)
     result = nil
+    build_version = nil
     RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
       loader.stub(:build, "zip_file") do
         Faraday.stub(:new, connection, faraday) do
           Faraday::UploadIO.stub(:new, io) do
             File.stub(:delete, nil) do
-              result = loader.sideload(**loader_config)
+              result, build_version = loader.sideload(**loader_config)
             end
           end
         end
       end
     end
 
-    assert_equal "build_version", result
+    assert_equal "build_version", build_version
+    assert_equal RokuBuilder::SUCCESS, result
 
     connection.verify
     faraday.verify
@@ -77,8 +83,10 @@ class LoaderTest < Minitest::Test
     }
     loader_config = {
       update_manifest: true,
-      folders: ["source"],
-      files: ["manifest"]
+      content: {
+        folders: ["source"],
+        files: ["manifest"]
+      }
     }
     payload = {
       mysubmit: "Replace",
@@ -98,22 +106,26 @@ class LoaderTest < Minitest::Test
     end
     response.expect(:status, 200)
     response.expect(:body, "Install Success")
+    response.expect(:status, 200)
+    response.expect(:body, "Install Success")
 
     loader = RokuBuilder::Loader.new(**device_config)
     result = nil
+    build_version = nil
     RokuBuilder::ManifestManager.stub(:update_build, "build_version") do
       loader.stub(:build, "zip_file") do
         Faraday.stub(:new, connection, faraday) do
           Faraday::UploadIO.stub(:new, io) do
             File.stub(:delete, nil) do
-              result = loader.sideload(**loader_config)
+              result, build_version = loader.sideload(**loader_config)
             end
           end
         end
       end
     end
 
-    assert_equal "build_version", result
+    assert_equal "build_version", build_version
+    assert_equal RokuBuilder::SUCCESS, result
 
     connection.verify
     faraday.verify
@@ -132,8 +144,10 @@ class LoaderTest < Minitest::Test
       init_params: {root_dir: root_dir}
     }
     build_config = {
-      folders: ["source"],
-      files: ["manifest"]
+      content: {
+        folders: ["source"],
+        files: ["manifest"]
+      }
     }
     loader = RokuBuilder::Loader.new(**device_config)
     outfile = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-12 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -317,7 +317,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: 2.2.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="