roku_builder 3.3.3 → 3.3.4

data/.travis.yml

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

data/Gemfile.lock

@@ -1,23 +1,24 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.3.3)
+    roku_builder (3.3.4)
       faraday (~> 0.9)
       faraday-digestauth (~> 0.2)
-      git (~> 1.2.9)
+      git (~> 1.3)
       net-ping (~> 1.7)
-      rubyzip (~> 1.1)
+      rubyzip (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    byebug (3.5.1)
-      columnize (~> 0.8)
-      debugger-linecache (~> 1.2)
-      slop (~> 3.6)
+    byebug (8.2.2)
     coderay (1.1.0)
-    columnize (0.9.0)
-    debugger-linecache (1.2.0)
+    coveralls (0.8.13)
+      json (~> 1.8)
+      simplecov (~> 0.11.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+      tins (~> 1.6.0)
     docile (1.1.5)
     em-websocket (0.5.1)
       eventmachine (>= 0.12.9)
@@ -30,7 +31,7 @@ GEM
       net-http-digest_auth (~> 1.4)
     ffi (1.9.10)
     formatador (0.2.5)
-    git (1.2.9.1)
+    git (1.3.0)
     guard (2.13.0)
       formatador (>= 0.2.4)
       listen (>= 2.7, <= 4.0)
@@ -70,11 +71,11 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rake (10.5.0)
+    rake (11.1.1)
     rb-fsevent (0.9.7)
     rb-inotify (0.9.7)
       ffi (>= 0.5.0)
-    rubyzip (1.1.7)
+    rubyzip (1.2.0)
     shellany (0.0.1)
     simplecov (0.11.2)
       docile (~> 1.1.0)
@@ -82,7 +83,10 @@ GEM
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
     slop (3.6.0)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
     thor (0.19.1)
+    tins (1.6.0)
     yard (0.8.7.6)
 
 PLATFORMS
@@ -90,12 +94,13 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.7)
-  byebug (~> 3.5)
+  byebug (~> 8.2)
+  coveralls (~> 0.8)
   guard-livereload (~> 2.5)
   minitest (~> 5.8)
   minitest-autotest (~> 1.0)
   minitest-server (~> 1.0)
-  rake (~> 10.0)
+  rake (~> 11.1)
   roku_builder!
   simplecov (~> 0.11)
   yard (~> 0.8.7)

data/README.md

@@ -1,6 +1,10 @@
 # RokuBuilder
 
 [![Gem Version](https://badge.fury.io/rb/roku_builder.svg)](https://badge.fury.io/rb/roku_builder)
+[![Dependency Status](https://gemnasium.com/ViacomInc/roku_builder.svg)](https://gemnasium.com/ViacomInc/roku_builder)
+[![Build Status](https://travis-ci.org/ViacomInc/roku_builder.svg?branch=master)](https://travis-ci.org/ViacomInc/roku_builder)
+[![Coverage Status](https://coveralls.io/repos/github/ViacomInc/roku_builder/badge.svg?branch=master)](https://coveralls.io/github/ViacomInc/roku_builder?branch=master)
+[![Code Climate](https://codeclimate.com/github/ViacomInc/roku_builder/badges/gpa.svg)](https://codeclimate.com/github/ViacomInc/roku_builder)
 
 A tool to help with Roku Development. Assists with the following roku
 development tasks:
@@ -271,6 +275,7 @@ directory:
 
  * Account for missing folders or files
  * Increase testing
+   * Config Unit Tests
    * Intergration Tests
  * Move RokuBuilder::Controller to RokuBuilder?
  * Allow start and end delimiter for tests to be configured

data/bin/roku

@@ -11,80 +11,79 @@ options = {}
 options[:config] = '~/.roku_config.json'
 options[:stage] = 'production'
 options[:update_manifest] = false
-options[:fetch] = false
 
 OptionParser.new do |opts|
   opts.banner = "Usage: roku <command> [options]"
 
-  opts.on("-l", "--sideload", "Command: Sideload an app") do |s|
-    options[:sideload] = s
+  opts.on("-l", "--sideload", "Command: Sideload an app") do
+    options[:sideload] = true
   end
 
-  opts.on("-p", "--package", "Command: Package an app") do |p|
-    options[:package] = p
+  opts.on("-p", "--package", "Command: Package an app") do
+    options[:package] = true
   end
 
-  opts.on("-t", "--test", "Command: Test an app") do |t|
-    options[:test] = t
+  opts.on("-t", "--test", "Command: Test an app") do
+    options[:test] = true
   end
 
-  opts.on("-L", "--deeplink", "Command: Deeplink into app. Requires mgid and type options.") do |d|
-    options[:deeplink] = d
+  opts.on("-L", "--deeplink", "Command: Deeplink into app. Requires mgid and type options.") do
+    options[:deeplink] = true
   end
 
-  opts.on("--configure", "Command: Copy base configuration file to the --config location. Default: '~/.roku_config.json'") do |c|
-    options[:configure] = c
+  opts.on("--configure", "Command: Copy base configuration file to the --config location. Default: '~/.roku_config.json'") do
+    options[:configure] = true
   end
 
-  opts.on("--validate", "Command: Validate configuration'") do |v|
-    options[:validate] = v
+  opts.on("--validate", "Command: Validate configuration'") do
+    options[:validate] = true
   end
 
-  opts.on("-d", "--delete", "Command: Delete the currently sideloaded app") do |d|
-    options[:delete] = d
+  opts.on("-d", "--delete", "Command: Delete the currently sideloaded app") do
+    options[:delete] = true
   end
 
   opts.on("-N", "--navigate CMD", "Command: send the given command to the roku") do |n|
     options[:navigate] = n
   end
 
-  opts.on("-S", "--screencapture", "Command: save a screencapture to the output file/folder") do |s|
-    options[:screencapture] = s
+  opts.on("-S", "--screencapture", "Command: save a screencapture to the output file/folder") do
+    options[:screencapture] = true
   end
 
   opts.on("-y", "--type TEXT", "Command: type the given text on the roku device") do |t|
     options[:text] = t
   end
 
-  opts.on("-b", "--build", "Command: build a zip to be sideloaded") do |b|
-    options[:build] = b
+  opts.on("-b", "--build", "Command: build a zip to be sideloaded") do
+    options[:build] = true
   end
 
   opts.on("--screen SCREEN", "Command: show a screen") do |s|
     options[:screen] = s
   end
 
-  opts.on("--screens", "Command: show possible screens") do |s|
-    options[:screens] = s
+  opts.on("--screens", "Command: show possible screens") do
+    options[:screens] = true
   end
 
   opts.on("-m", "--monitor TYPE", "Command: run telnet to monitor roku log") do |m|
     options[:monitor] = m
   end
 
-  opts.on("-u", "--update-manifest", "Command: update the manifest file") do |u|
-    options[:update] = u
+  opts.on("-u", "--update-manifest", "Command: update the manifest file") do
+    options[:update] = true
   end
 
   opts.on("-r", "--ref REF", "Git referance to use for sideloading") do |r|
     options[:ref] = r
   end
 
-  opts.on("-w", "--working", "Use working directory to sideload or test") do |w|
-    options[:working] = w
+  opts.on("-w", "--working", "Use working directory to sideload or test") do
+    options[:working] = true
   end
 
-  opts.on("-c", "--current", "Use current directory to sideload or test. Overides any project config") do |w|
+  opts.on("-c", "--current", "Use current directory to sideload or test. Overides any project config") do
     options[:current] = true
   end
 
@@ -93,18 +92,14 @@ OptionParser.new do |opts|
     options[:set_stage] = true
   end
 
-  opts.on("-M", "--manifest-update", "Update the manifest file while packaging") do |n|
+  opts.on("-M", "--manifest-update", "Update the manifest file while packaging") do
     options[:update_manifest] = true
   end
 
-  opts.on("-i", "--inspect", "Print inspection information while packaging") do |n|
+  opts.on("-i", "--inspect", "Print inspection information while packaging") do
     options[:inspect] = true
   end
 
-  opts.on("-f", "--fetch", "Preform a `git fetch --all` on the repository before building or sideloading.") do
-    options[:fetch] = true
-  end
-
   opts.on("-o", "--deeplink-options TYPE", "Additional deeplink options. (eg. a:b, c:d,e:f)") do |o|
     options[:deeplink_options] = o
   end
@@ -134,15 +129,15 @@ OptionParser.new do |opts|
     options[:in] = i
   end
 
-  opts.on("-V", "--verbose", "Print Info message") do |v|
-    options[:verbose] = v
+  opts.on("-V", "--verbose", "Print Info message") do
+    options[:verbose] = true
   end
 
-  opts.on("--debug", "Print Debug messages") do |d|
-    options[:debug] = d
+  opts.on("--debug", "Print Debug messages") do
+    options[:debug] = true
   end
 
-  opts.on("-h", "--help", "Show this message") do |h|
+  opts.on("-h", "--help", "Show this message") do
     puts opts
     exit
   end

data/config.json.example

@@ -1,7 +1,7 @@
 {
   "devices": {
-    "default": "roku",
-    "roku": {
+    "default": "<device_id>",
+    "<device_id>": {
       "ip": "xxx.xxx.xxx.xxx",
       "user": "<username>",
       "password": "<password>"

data/lib/roku_builder/config_manager.rb

@@ -1,25 +1,44 @@
 module RokuBuilder
 
-  MISSING_DEVICES = 1
-  MISSING_DEVICES_DEFAULT = 2
-  DEVICE_DEFAULT_BAD = 3
-  MISSING_PROJECTS = 4
-  MISSING_PROJECTS_DEFAULT = 5
-  PROJECTS_DEFAULT_BAD = 6
-  DEVICE_MISSING_IP = 7
-  DEVICE_MISSING_USER = 8
-  DEVICE_MISSING_PASSWORD = 9
-  PROJECT_MISSING_APP_NAME = 10
-  PROJECT_MISSING_DIRECTORY = 11
-  PROJECT_MISSING_FOLDERS = 12
-  PROJECT_FOLDERS_BAD = 13
-  PROJECT_MISSING_FILES = 14
-  PROJECT_FILES_BAD = 15
-  STAGE_MISSING_BRANCH = 16
-
   # Load and validate config files.
   class ConfigManager
 
+    # Load config file and generate intermeidate configs
+    # @param options [Hash] The options hash
+    # @param logger [Logger] system logger
+    # @return [Integer] Return code
+    # @return [Hash] Loaded config
+    # @return [Hash] Intermeidate configs
+    def self.load_config(options:, logger:)
+      config_file = File.expand_path(options[:config])
+      return MISSING_CONFIG unless File.exist?(config_file)
+      code = SUCCESS
+      config = ConfigManager.get_config(config: config_file, logger: logger)
+      return INVALID_CONFIG unless config
+      codes = ConfigValidator.validate_config(config: config)
+      fatal = false
+      warning = false
+      codes.each {|a_code|
+        if a_code > 0
+          logger.fatal "Invalid Config: "+ ConfigValidator.error_codes()[a_code]
+          fatal = true
+        elsif a_code < 0
+          logger.warn "Depricated Config: "+ ConfigValidator.error_codes()[a_code]
+          warning = true
+        elsif a_code == 0 and options[:validate]
+          logger.info "Config Valid"
+        end
+      }
+      return [INVALID_CONFIG, nil, nil] if fatal
+      code = DEPRICATED_CONFIG if warning
+
+      parse_code, configs = ConfigParser.parse_config(options: options, config: config, logger: logger)
+      unless parse_code == SUCCESS
+        return [parse_code, nil, nil]
+      end
+      [code, config, configs]
+    end
+
     # Loads the roku config from file
     # @param config [String] path for the roku config
     # @return [Hash] roku config object
@@ -35,75 +54,6 @@ module RokuBuilder
       end
     end
 
-    # Validates the roku config
-    # @param config [Hash] roku config object
-    # @return [Array] error codes for valid config (see self.error_codes)
-    def self.validate_config(config:, logger:)
-      codes = []
-      codes.push(MISSING_DEVICES) if not config[:devices]
-      codes.push(MISSING_DEVICES_DEFAULT) if config[:devices] and not config[:devices][:default]
-      codes.push(DEVICE_DEFAULT_BAD) if config[:devices] and config[:devices][:default] and not config[:devices][:default].is_a?(Symbol)
-      codes.push(MISSING_PROJECTS) if not config[:projects]
-      codes.push(MISSING_PROJECTS_DEFAULT) if config[:projects] and not config[:projects][:default]
-      codes.push(MISSING_PROJECTS_DEFAULT) if config[:projects] and config[:projects][:default] == "<project id>".to_sym
-      codes.push(PROJECTS_DEFAULT_BAD) if config[:projects] and config[:projects][:default] and not config[:projects][:default].is_a?(Symbol)
-      if config[:devices]
-        config[:devices].each {|k,v|
-          next if k == :default
-          codes.push(DEVICE_MISSING_IP) if not v[:ip]
-          codes.push(DEVICE_MISSING_IP) if v[:ip] == "xxx.xxx.xxx.xxx"
-          codes.push(DEVICE_MISSING_IP) if v[:ip] == ""
-          codes.push(DEVICE_MISSING_USER) if not v[:user]
-          codes.push(DEVICE_MISSING_USER) if v[:user] == "<username>"
-          codes.push(DEVICE_MISSING_USER) if v[:user] == ""
-          codes.push(DEVICE_MISSING_PASSWORD) if not v[:password]
-          codes.push(DEVICE_MISSING_PASSWORD) if v[:password] == "<password>"
-          codes.push(DEVICE_MISSING_PASSWORD) if v[:password] == ""
-        }
-      end
-      if config[:projects]
-        config[:projects].each {|k,v|
-          next if k == :default
-          codes.push(PROJECT_MISSING_APP_NAME) if not v[:app_name]
-          codes.push(PROJECT_MISSING_DIRECTORY) if not v[:directory]
-          codes.push(PROJECT_MISSING_FOLDERS) if not v[:folders]
-          codes.push(PROJECT_FOLDERS_BAD) if v[:folders] and not v[:folders].is_a?(Array)
-          codes.push(PROJECT_MISSING_FILES) if not v[:files]
-          codes.push(PROJECT_FILES_BAD) if v[:files] and not v[:files].is_a?(Array)
-          v[:stages].each {|k,v|
-            codes.push(STAGE_MISSING_BRANCH) if not v[:branch]
-          }
-        }
-      end
-      codes.push(0) if codes.empty?
-      codes
-    end
-
-    # Error code messages for config validation
-    # @return [Array] error code messages
-    def self.error_codes()
-      [
-        #===============FATAL ERRORS===============#
-        "Valid Config.",
-        "Devices config is missing.",
-        "Devices default is missing.",
-        "Devices default is not a hash.",
-        "Projects config is missing.",
-        "Projects default is missing.", #5
-        "Projects default is not a hash.",
-        "A device config is missing its IP address.",
-        "A device config is missing its username.",
-        "A device config is missing its password.",
-        "A project config is missing its app_name.", #10
-        "A project config is missing its directorty.",
-        "A project config is missing its folders.",
-        "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."
-        #===============WARNINGS===============#
-      ]
-    end
 
     # Edit the roku config
     # @param config [String] path for the roku config
@@ -112,46 +62,61 @@ module RokuBuilder
     # @param project [String] which project to use
     # @param stage[String] which stage to use
     # @return [Boolean] success
-    def self.edit_config(config:, options:, device:, project:, stage:, logger:)
+    def self.edit_config(config:, options:, logger:)
       config_object = get_config(config: config, logger: logger)
       return false unless config_object
-      unless project
-        project = config_object[:projects][:default]
-      else
-        project = project.to_sym
-      end
-      unless device
-        device = config_object[:devices][:default]
-      else
-        device = device.to_sym
-      end
-      unless stage
-        stage = :production
-      else
-        stage = stage.to_sym
-      end
-      changes = {}
-      opts = options.split(/,\s*/)
-      opts.each do |opt|
-        opt = opt.split(":")
-        key = opt.shift.to_sym
-        value = opt.join(":")
-        changes[key] = value
-      end
-      changes.each {|key,value|
-        if [:ip, :user, :password].include?(key)
-          config_object[:devices][device][key] = value
-        elsif [:directory, :app_name].include?(key) #:folders, :files
-          config_object[:projects][project][key] = value
-        elsif [:branch]
-          config_object[:projects][project][:stages][stage][key] = value
-        end
+      project = options[:project].to_sym if options[:project]
+      project = config_object[:projects][:default] unless options[:project]
+      device = options[:device].to_sym if options[:device]
+      device = config_object[:devices][:default] unless options[:device]
+      stage = options[:stage].to_sym if options[:stage]
+      stage = :production unless options[:stage]
+      state = {
+        project: project,
+        device: device,
+        stage: stage
       }
+      apply_options(config_object: config_object, options: options[:edit_params], state: state)
       config_string = JSON.pretty_generate(config_object)
       file = File.open(config, "w")
       file.write(config_string)
       file.close
       return true
     end
+
+    # Apply the changes in the options string to the config object
+    # @param config_object [Hash] The config loaded from file
+    # @param options [String] The string of options passed in by the user
+    # @param state [Hash] The state of the config the user is editing
+    def self.apply_options(config_object:, options:, state:)
+      changes = Util.options_parse(options: options)
+      changes.each {|key,value|
+        if [:ip, :user, :password].include?(key)
+          config_object[:devices][state[:device]][key] = value
+        elsif [:directory, :app_name].include?(key) #:folders, :files
+          config_object[:projects][state[:project]][key] = value
+        elsif [:branch].include?(key)
+          config_object[:projects][state[:project]][:stages][state[:stage]][key] = value
+        end
+      }
+    end
+    private_class_method :apply_options
+
+    # Update the intermeidate configs
+    # @param configs [Hash] Intermeidate configs hash
+    # @param options [Hash] Options hash
+    # @return [Hash] New intermeidate configs hash
+    def self.update_configs(configs:, options:)
+      if options[:build_version]
+        configs[:package_config][:app_name_version] = "#{configs[:project_config][:app_name]} - #{configs[:stage]} - #{options[:build_version]}" if configs[:package_config]
+        unless options[:outfile]
+          pathname = File.join(options[:out_folder], "#{configs[:project_config][:app_name]}_#{configs[:stage]}_#{options[:build_version]}")
+          configs[:package_config][:out_file] =  pathname+".pkg" if configs[:package_config]
+          configs[:build_config][:outfile]    = pathname+".zip" if configs[:build_config]
+          configs[:inspect_config][:pkg] = configs[:package_config][:out_file] if configs[:inspect_config] and configs[:package_config]
+        end
+      end
+      return configs
+    end
   end
 end

data/lib/roku_builder/config_parser.rb

@@ -0,0 +1,192 @@
+module RokuBuilder
+
+  # Contains methods that will parse the loaded config and generate
+  # intermeidate configs for each of the tools.
+  class ConfigParser
+
+    # Parse config and generate intermeidate configs
+    # @param options [Hash] The options hash
+    # @param config [Hash] The loaded config hash
+    # @param logger [Logger] system logger
+    # @return [Integer] Return code
+    # @return [Hash] Intermeidate configs
+    def self.parse_config(options:, config:, logger:)
+      configs = {}
+      #set device
+      unless options[:device]
+        options[:device] = config[:devices][:default]
+      end
+      #set project
+      setup_project(config: config, options: options)
+      #set outfile
+      setup_outfile(options: options)
+      # Create Device Config
+      configs[:device_config] = config[:devices][options[:device].to_sym]
+      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
+      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)
+      setup_package_config(configs: configs, options: options, stage: stage)
+      setup_simple_configs(configs: configs, options: options, logger: logger)
+      return [SUCCESS, configs]
+    end
+
+    # Pick or choose the project being used
+    # @param config [Hash] The loaded config hash
+    # @param options [Hash] The options hash
+    def self.setup_project(config:, options:)
+      if options[:current] or not options[:project]
+        path = Controller.system(command: "pwd")
+        project = nil
+        config[:projects].each_pair {|key,value|
+          if value.is_a?(Hash)
+            repo_path = Pathname.new(value[:directory]).realdirpath.to_s
+            if path.start_with?(repo_path)
+              project = key
+              break
+            end
+          end
+        }
+        if project
+          options[:project] = project
+        else
+          options[:project] = config[:projects][:default]
+        end
+      end
+    end
+    private_class_method :setup_project
+
+    # Setup the out folder/file options
+    # @param options [Hash] The options hash
+    def self.setup_outfile(options:)
+      options[:out_folder] = nil
+      options[:out_file] = nil
+      if options[:out]
+        if options[:out].end_with?(".zip") or options[:out].end_with?(".pkg") or options[:out].end_with?(".jpg")
+          options[:out_folder], options[:out_file] = Pathname.new(options[:out]).split.map{|p| p.to_s}
+        else
+          options[:out_folder] = options[:out]
+        end
+      end
+      unless options[:out_folder]
+        options[:out_folder] = "/tmp"
+      end
+    end
+    private_class_method :setup_outfile
+
+    # Setup the project config with the chosen project
+    # @param config [Hash] The loaded config hash
+    # @param options [Hash] The options hash
+    # @return [Hash] The project config hash
+    def self.setup_project_config(config:, options:)
+      #Create Project Config
+      project_config = {}
+      if options[:current]
+        pwd =  Controller.system(command: "pwd")
+        return [MISSING_MANIFEST, nil, nil] unless File.exist?(File.join(pwd, "manifest"))
+        project_config = {
+          directory: pwd,
+          folders: nil,
+          files: nil,
+          stages: { production: { branch: nil } }
+        }
+      else
+        project_config = config[:projects][options[:project].to_sym]
+      end
+      project_config
+    end
+    private_class_method :setup_project_config
+
+    # 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:)
+      root_dir = configs[:project_config][:directory]
+      # Create Sideload Config
+      configs[:sideload_config] = {
+        root_dir: root_dir,
+        branch: branch,
+        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,
+        folders: configs[:project_config][:folders],
+        files: configs[:project_config][:files]
+      }
+    end
+    private_class_method :setup_sideload_config
+
+    # Setup config hashes for packaging
+    # @param configs [Hash] The parsed configs hash
+    # @param options [Hash] The options hash
+    # @param stage [Symbol] The stage to package
+    def self.setup_package_config(configs:, options:, stage:)
+      if options[:package]
+        # Create Key Config
+        configs[:key] = configs[:project_config][:stages][stage][:key]
+        # Create Package Config
+        configs[:package_config] = {
+          password: configs[:key][:password],
+          app_name_version: "#{configs[:project_config][:app_name]} - #{stage}"
+        }
+        if options[:out_file]
+          configs[:package_config][:out_file] = File.join(options[:out_folder], options[:out_file])
+        end
+        # Create Inspector Config
+        configs[:inspect_config] = {
+          pkg: configs[:package_config][:out_file],
+          password: configs[:key][:password]
+        }
+      end
+    end
+    private_class_method :setup_package_config
+
+    # Setup other configs
+    # @param configs [Hash] The parsed configs hash
+    # @param options [Hash] The options hash
+    # @param logger [Logger] System logger
+    def self.setup_simple_configs(configs:, options:, logger:)
+      # Create Manifest Config
+      configs[:manifest_config] = {
+        root_dir: configs[:project_config][:directory]
+      }
+      # Create Deeplink Config
+      configs[:deeplink_config] ={options: options[:deeplink_options]}
+      # Create Monitor Config
+      if options[:monitor]
+        configs[:monitor_config] = {type: options[:monitor].to_sym}
+      end
+      # Create Navigate Config
+      if options[:navigate]
+        configs[:navigate_config] = {command: options[:navigate].to_sym}
+      end
+      # Create Text Config
+      configs[:text_config] = {text: options[:text]}
+      # Create Test Config
+      configs[:test_config] = {sideload_config: configs[:sideload_config]}
+      #Create screencapture config
+      configs[:screencapture_config] = {
+        out_folder: options[:out_folder],
+        out_file: options[:out_file]
+      }
+      if options[:screen]
+        configs[:screen_config] = {type: options[:screen].to_sym}
+      end
+    end
+    private_class_method :setup_simple_configs
+  end
+end