roku_builder 3.12.8 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a562753d6f0b7fb5e05b78835ac660754faddda
-  data.tar.gz: 3c4fbf513f28f9f1c59b5776497be3b9ea626f65
+  metadata.gz: dd32080b9b4c8246240b9aaf4a7a2dae7d0e18e9
+  data.tar.gz: 421453a021d14e16253702b07d8dfb356a750a2c
 SHA512:
-  metadata.gz: a44be2123c1949593a9221855c8e7feb3b4df08d17c5ed4aa316de2c95d25b34e31ad165a947064dbf86c2d089379ce8005df2d899334ae20dffb87bbe9641ec
-  data.tar.gz: 55ca8895e575e0ffc84170920821430e03081c1388bc171310b920b9827f6676e0a6ae867e06e6b97e5afcf813977abfcb3a3d52ac4d280fe107a8f7686a5d78
+  metadata.gz: 70e119253bf7a0379f466070e0fd97e69d2c50c2f353d32cc7985e6e6a69841840674c831f0c1873c39920453d234dc0501b93218eb34c3fae541ad38ad36465
+  data.tar.gz: ee473164b0297a43f6034b25adb3e8d75e2dd275db33d2c3bf8fbd231cfb51720645569f0c2da1c96ef2f768a2cb67d53261c5f0342cbe2c79dca68375ed38fb

data/.rubocop.yml

@@ -221,9 +221,9 @@ Metrics/BlockNesting:
   Max: 4
 
 Metrics/ClassLength:
-  Description: 'Avoid classes longer than 250 lines of code.'
+  Description: 'Avoid classes longer than 350 lines of code.'
   Enabled: true
-  Max: 250
+  Max: 350
 
 Metrics/CyclomaticComplexity:
   Description: >-

data/CHANGELOG

@@ -1,3 +1,12 @@
+ = 3.13.0 =
+
+ - Windows combatability
+ - Save screenshot using correct ext
+ - Allow integer build version
+ - Update Dependencies
+ - Code refactor
+ - Fixes for Test Suite
+
  = 3.12.8 =
 
  - Always print password/path from genkey

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.12.8)
+    roku_builder (3.13.0)
       faraday (~> 0.12)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)
@@ -9,25 +9,28 @@ PATH
       net-telnet (~> 0.1)
       nokogiri (~> 1.7)
       rubyzip (~> 1.2)
+      win32-security (~> 0.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
     byebug (9.0.6)
     coderay (1.1.1)
-    coveralls (0.8.20)
+    coveralls (0.8.21)
       json (>= 1.8, < 3)
       simplecov (~> 0.14.1)
       term-ansicolor (~> 1.3)
       thor (~> 0.19.4)
       tins (~> 1.6)
     docile (1.1.5)
-    faraday (0.12.0.1)
+    faraday (0.12.1)
       multipart-post (>= 1.2, < 3)
     faraday-digestauth (0.2.1)
       faraday (~> 0.7)
       net-http-digest_auth (~> 1.4)
-    ffi (1.9.17)
+    ffi (1.9.18)
+    ffi-win32-extensions (1.0.3)
+      ffi
     formatador (0.2.5)
     git (1.3.0)
     guard (2.14.1)
@@ -43,18 +46,18 @@ GEM
     guard-minitest (2.4.6)
       guard-compat (~> 1.2)
       minitest (>= 3.0)
-    json (2.0.3)
+    json (2.1.0)
     listen (3.1.5)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
       ruby_dep (~> 1.2)
-    lumberjack (1.0.11)
+    lumberjack (1.0.12)
     m (1.5.0)
       method_source (>= 0.6.7)
       rake (>= 0.9.2.2)
     method_source (0.8.2)
     mini_portile2 (2.1.0)
-    minitest (5.10.1)
+    minitest (5.10.2)
     minitest-autotest (1.0.3)
       minitest-server (~> 1.0)
     minitest-server (1.0.4)
@@ -64,7 +67,7 @@ GEM
     net-http-digest_auth (1.4.1)
     net-ping (2.0.1)
     net-telnet (0.1.1)
-    nokogiri (1.7.1)
+    nokogiri (1.7.2)
       mini_portile2 (~> 2.1.0)
     notiffany (0.1.1)
       nenv (~> 0.1)
@@ -86,11 +89,14 @@ GEM
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
     slop (3.6.0)
-    term-ansicolor (1.5.0)
+    term-ansicolor (1.6.0)
       tins (~> 1.0)
     thor (0.19.4)
-    tins (1.13.2)
-    yard (0.9.8)
+    tins (1.14.0)
+    win32-security (0.5.0)
+      ffi
+      ffi-win32-extensions
+    yard (0.9.9)
 
 PLATFORMS
   ruby

data/bin/roku

@@ -12,10 +12,6 @@ options = {}
 options[:config] = '~/.roku_config.json'
 options[:update_manifest] = false
 
-logger = Logger.new(STDOUT)
-logger.formatter = proc {|severity, datetime, _progname, msg|
-  "[%s #%s] %5s: %s\n\r" % [datetime.strftime("%Y-%m-%d %H:%M:%S.%4N"), $$, severity, msg]
-}
 
 parser = OptionParser.new do |opts|
   opts.banner = "Usage: roku <command> [options]"
@@ -133,7 +129,7 @@ parser = OptionParser.new do |opts|
     options[:set_stage] = true
   end
 
-  opts.on("-M", "--manifest-update", "Update the manifest file while packaging") do
+  opts.on("-M", "--manifest-update", "Update the manifest file while building or packaging") do
     options[:update_manifest] = true
   end
 
@@ -199,8 +195,8 @@ end
 
 begin
   parser.parse!
-  RokuBuilder::Controller.run(options: options, logger: logger)
-rescue OptionParser::ParseError => e
-  logger.fatal e.message
+  RokuBuilder::Controller.run(options: options)
+rescue StandardError => e
+  RokuBuilder::Logger.instance.fatal e.message
 end
 

data/lib/roku_builder.rb

@@ -10,6 +10,7 @@ require "net/ping"
 require "net/telnet"
 require "fileutils"
 require "tempfile"
+require "tmpdir"
 require "zip"
 require "git"
 #config_manager
@@ -23,28 +24,13 @@ require 'io/console'
 #monitor
 require 'readline'
 
-require "roku_builder/controller"
-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"
-require "roku_builder/tester"
-require "roku_builder/scripter"
-require "roku_builder/profiler"
-require "roku_builder/manifest_manager"
-require "roku_builder/config_manager"
-require "roku_builder/config_validator"
-require "roku_builder/config_parser"
-require "roku_builder/error_handler"
-require "roku_builder/navigator"
-require "roku_builder/monitor"
-require "roku_builder/version"
-
-# Wrapping module for the Roku Builder Gem
+
+require 'roku_builder/util'
+Dir.glob(File.join(File.dirname(__FILE__), "roku_builder", "*")).each do |path|
+  file = "roku_builder/"+File.basename(path, ".rb")
+  require file unless file == "roku_builder/util"
+end
+
 module RokuBuilder
 
   ### Global Codes ###
@@ -159,13 +145,19 @@ module RokuBuilder
 end
 
 class ::String
-  def underscore
-    word = self.dup
+  def underscore!
+    word = self
     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!
+    nil
+  end
+
+  def underscore
+    word = self.dup
+    word.underscore!
     word
   end
 end

data/lib/roku_builder/config.rb

@@ -0,0 +1,213 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  # Load and validate config files.
+  class Config
+
+    attr_reader :parsed
+
+    def initialize(options:)
+      @options = options
+      @logger = Logger.instance
+      @config = nil
+      @parsed = nil
+    end
+
+    def raw
+      @config
+    end
+
+    def load
+      check_config_file
+      load_config
+    end
+
+    def parse
+      @parsed = ConfigParser.parse(options: @options, config: @config)
+    end
+
+    def validate
+      validator = ConfigValidator.new(config: @config)
+      validator.print_errors
+      raise InvalidConfig if validator.is_fatal?
+    end
+
+    def edit
+      load
+      apply_options
+      config_string = JSON.pretty_generate(@config)
+      file = File.open(@options[:config], "w")
+      file.write(config_string)
+      file.close
+    end
+
+    def update
+      if @options[:build_version]
+        update_package_config
+        update_build_config
+        update_sideload_config
+        update_inspect_config
+      end
+    end
+
+    def configure
+      if @options[:configure]
+        source_config = File.expand_path(File.join(File.dirname(__FILE__), "..", '..', 'config.json.example'))
+        target_config = File.expand_path(@options[:config])
+        if File.exist?(target_config)
+          unless @options[:edit_params]
+            raise InvalidOptions, "Not overwriting config. Add --edit options to do so."
+          end
+        end
+        FileUtils.copy(source_config, target_config)
+        edit if @options[:edit_params]
+      end
+    end
+
+    private
+
+    def check_config_file
+      config_file = File.expand_path(@options[:config])
+      raise ArgumentError, "Missing Config" unless File.exist?(config_file)
+    end
+
+
+    def load_config
+      @config = {parent_config: @options[:config]}
+      depth = 1
+      while @config[:parent_config]
+        parent_config_hash = get_parent_config
+        @config[:child_config] = @config[:parent_config]
+        @config.delete(:parent_config)
+        @config.merge!(parent_config_hash) {|_key, v1, _v2| v1}
+        depth += 1
+        raise InvalidConfig, "Parent Configs Too Deep." if depth > 10
+      end
+      fix_config_symbol_values
+    end
+
+    def get_parent_config
+      begin
+        JSON.parse(parent_io.read, {symbolize_names: true})
+      rescue JSON::ParserError
+        raise InvalidConfig, "Config file is not valid JSON"
+      end
+    end
+
+    def parent_io
+      expand_parent_file_path
+      File.open(@config[:parent_config])
+    end
+
+    def expand_parent_file_path
+      if @config[:child_config]
+        @config[:parent_config] = File.expand_path(@config[:parent_config], File.dirname(@config[:child_config]))
+      else
+        @config[:parent_config] = File.expand_path(@config[:parent_config])
+      end
+    end
+
+    def fix_config_symbol_values
+      if @config[:devices]
+        @config[:devices][:default] = @config[:devices][:default].to_sym
+      end
+      if @config[:projects]
+        fix_project_config_symbol_values
+        build_inhearited_project_configs
+      end
+    end
+
+    def fix_project_config_symbol_values
+      @config[:projects][:default] = @config[:projects][:default].to_sym
+      @config[:projects].each_pair do |key,value|
+        next if is_skippable_project_key? key
+        if value[:stage_method]
+          value[:stage_method] = value[:stage_method].to_sym
+        end
+      end
+    end
+
+    def build_inhearited_project_configs
+      @config[:projects].each_pair do |key,value|
+        next if is_skippable_project_key? key
+        while value[:parent] and @config[:projects][value[:parent].to_sym]
+          new_value = @config[:projects][value[:parent].to_sym]
+          value.delete(:parent)
+          new_value = new_value.deep_merge value
+          @config[:projects][key] = new_value
+          value = new_value
+        end
+      end
+    end
+
+    def is_skippable_project_key?(key)
+      [:project_dir, :default].include?(key)
+    end
+
+    def build_edit_state
+      {
+        project: get_key_for(:project),
+        device: get_key_for(:device),
+        stage: get_stage_key(project: get_key_for(:project))
+      }
+    end
+
+    def get_key_for(type)
+      project = @options[type].to_sym if @options[type]
+      project ||= @config[(type.to_s+"s").to_sym][:default]
+      project
+    end
+
+    def get_stage_key(project:)
+      stage = @options[:stage].to_sym if @options[:stage]
+      stage ||= @config[:projects][project][:stages].keys[0].to_sym
+      stage
+    end
+
+    # Apply the changes in the options string to the config object
+    def apply_options
+      state = build_edit_state
+      changes = Util.options_parse(options: @options[:edit_params])
+      changes.each {|key,value|
+        if [:ip, :user, :password].include?(key)
+          @config[:devices][state[:device]][key] = value
+        elsif [:directory, :app_name].include?(key) #:folders, :files
+          @config[:projects][state[:project]][key] = value
+        elsif [:branch].include?(key)
+          @config[:projects][state[:project]][:stages][state[:stage]][key] = value
+        end
+      }
+    end
+
+    def update_package_config
+      if @parsed[:package_config]
+        @parsed[:package_config][:app_name_version] = "#{@parsed[:project_config][:app_name]} - #{@parsed[:stage]} - #{@options[:build_version]}"
+        @parsed[:package_config][:out_file] = out_file_path
+      end
+    end
+
+    def update_build_config
+      @parsed[:build_config][:out_file] = out_file_path if @parsed[:build_config]
+    end
+
+    def update_sideload_config
+      if @parsed[:sideload_config] and @options[:out]
+        @parsed[:sideload_config][:out_file] = out_file_path
+      end
+    end
+
+    def update_inspect_config
+      if @parsed[:inspect_config] and @parsed[:package_config]
+        @parsed[:inspect_config][:pkg] = @parsed[:package_config][:out_file]
+      end
+    end
+
+    def out_file_path
+      unless @parsed[:out][:file]
+        @parsed[:out][:file] = "#{@parsed[:project_config][:app_name]}_#{@parsed[:stage]}_#{@options[:build_version]}"
+      end
+      File.join(@parsed[:out][:folder], @parsed[:out][:file])
+    end
+  end
+end

data/lib/roku_builder/config_parser.rb

@@ -2,312 +2,349 @@
 
 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 = {init_params: {}}
-      #expand in
-      options[:in] = File.expand_path(options[:in]) if options[:in]
-      #set device
-      options[:device] = config[:devices][:default] unless options[:device]
-      #set project
-      setup_project(config: config, options: options) if project_required(options: options)
-      #set outfile
-      setup_outfile(options: options, configs: configs)
-      # 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 [project_config, nil, nil] unless project_config.class == Hash
-      configs[:project_config] = project_config
-      stage = setup_stage_config(configs: configs, options: options, logger: logger)[1]
-      return [UNKNOWN_STAGE, nil, nil] if stage.nil? and project_required(options: options)
-      setup_sideload_config(configs: configs, options: options)
-      code = setup_package_config(config: config, configs: configs, options: options, stage: stage)
-      return [code, nil, nil] unless code == SUCCESS
-      setup_active_configs(config: config, configs: configs, options: options)
-      setup_manifest_configs(configs: configs, options: options)
-      setup_simple_configs(config: config, configs: configs, options: options)
-      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:)
-      unless options[:project]
-        path = Pathname.pwd
-        project = nil
-        config[:projects].each_pair {|key,value|
-          if value.is_a?(Hash)
-            repo_path = ""
-            if config[:projects][:project_dir]
-              repo_path = Pathname.new(File.join(config[:projects][:project_dir], value[:directory])).realdirpath
-            else
-              repo_path = Pathname.new(value[:directory]).realdirpath
-            end
-            path.descend do |path_parent|
-              if path_parent == repo_path
-                project = key
-                break
-              end
-            end
-            break if project
-          end
-        }
+    attr_reader :parsed
+
+    def self.parse(options:, config:)
+      parser = new(options: options, config: config)
+      parser.parsed
+    end
+
+    def initialize(options:, config:)
+      @logger = Logger.instance
+      @options = options
+      @config = config
+      @parsed = {init_params: {}}
+      parse_config
+    end
+
+    def parse_config
+      process_in_argument
+      setup_device
+      setup_project
+      setup_outfile
+      setup_project_config
+      setup_stage_config
+      setup_sideload_config
+      setup_package_config
+      setup_monitor_configs
+      setup_navigate_configs
+      setup_manifest_config
+      setup_deeplink_configs
+      setup_text_configs
+      setup_test_configs
+      setup_screencapture_configs
+      setup_screen_config
+      setup_profiler_configs
+      setup_genkey_configs
+    end
+
+    def process_in_argument
+      @options[:in] = File.expand_path(@options[:in]) if @options[:in]
+    end
+
+    def setup_device
+      @options[:device] = @config[:devices][:default] unless @options[:device]
+      @parsed[:device_config] = @config[:devices][@options[:device].to_sym]
+      raise ArgumentError, "Unknown device: #{@options[:device]}" unless @parsed[:device_config]
+    end
+
+    def setup_project
+      if project_required and not @options[:project]
+        project = current_project
         if project
-          options[:project] = project
+          @options[:project] = project
         else
-          options[:project] = config[:projects][:default]
+          @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:, configs:)
-      configs[:out] = {file: nil, folder: nil}
-      if options[:out]
-        if options[:out].end_with?(".zip") or options[:out].end_with?(".pkg") or options[:out].end_with?(".jpg")
-          configs[:out][:folder], configs[:out][:file] = Pathname.new(options[:out]).split.map{|p| p.to_s}
-          if configs[:out][:folder] == "." and not options[:out].start_with?(".")
-            configs[:out][:folder] = nil
-          else
-            configs[:out][:folder] = File.expand_path(configs[:out][:folder])
-          end
+
+    def project_required
+      non_project_source = ([:current, :in] & @options.keys).count > 0
+      @options.source_command? and not non_project_source
+    end
+
+    def current_project
+      @config[:projects].each_pair do |key,value|
+        return key if is_current_project?(project_config: value)
+      end
+      nil
+    end
+
+    def is_current_project?(project_config:)
+      return false unless project_config.is_a?(Hash)
+      repo_path = get_repo_path(project_config: project_config)
+      Pathname.pwd.descend do |path_parent|
+        return true if path_parent == repo_path
+      end
+    end
+
+    def get_repo_path(project_config:)
+      if @config[:projects][:project_dir]
+        Pathname.new(File.join(@config[:projects][:project_dir], project_config[:directory])).realdirpath
+      else
+        Pathname.new(project_config[:directory]).realdirpath
+      end
+    end
+
+    def setup_outfile
+      @parsed[:out] = {file: nil, folder: nil}
+      if @options[:out]
+        if out_file_defined?
+          setup_outfile_and_folder
         else
-          configs[:out][:folder] = options[:out]
+          @parsed[:out][:folder] = @options[:out]
         end
       end
-      unless configs[:out][:folder]
-         configs[:out][:folder] = "/tmp"
+      set_default_outfile
+    end
+
+    def out_file_defined?
+      @options[:out].end_with?(".zip") or @options[:out].end_with?(".pkg") or @options[:out].end_with?(".jpg")
+    end
+
+    def setup_outfile_and_folder
+      @parsed[:out][:folder], @parsed[:out][:file] = Pathname.new(@options[:out]).split.map{|p| p.to_s}
+      if @parsed[:out][:folder] == "." and not @options[:out].start_with?(".")
+        @parsed[:out][:folder] = nil
+      else
+        @parsed[:out][:folder] = File.expand_path(@parsed[:out][:folder])
+      end
+    end
+
+    def set_default_outfile
+      unless @parsed[:out][:folder]
+        @parsed[:out][:folder] = Dir.tmpdir
       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 =  Pathname.pwd.to_s
-        return MISSING_MANIFEST unless File.exist?(File.join(pwd, "manifest"))
-        project_config = {
-          directory: pwd,
-          folders: nil,
-          files: nil,
-          stage_method: :current
-        }
-      elsif project_required(options: options)
-        project_config = config[:projects][options[:project].to_sym]
-        return UNKNOWN_PROJECT unless project_config
-        if config[:projects][:project_dir]
-          project_config[:directory] = File.join(config[:projects][:project_dir], project_config[:directory])
-        end
-        return BAD_PROJECT_DIR unless Dir.exist?(project_config[:directory])
-        project_config[:stage_method] = :working if options[:working]
+
+    def setup_project_config
+      if @options[:current]
+        stub_project_config_for_current
+      elsif  project_required
+        @parsed[:project_config] = @config[:projects][@options[:project].to_sym]
+        raise ParseError, "Unknown Project: #{@options[:project]}" unless @parsed[:project_config]
+        set_project_directory
+        check_for_working
       end
-      project_config
-    end
-    private_class_method :setup_project_config
-
-    # Determine whether a project is required
-    # @param options [Hash] The options hash
-    # @return [Boolean] Whether a project is required or not
-    def self.project_required(options:)
-      has_source_command = (Controller.source_commands & options.keys).count > 0
-      non_project_source = ([:current, :in] & options.keys).count > 0
-      has_source_command and not non_project_source
-    end
-    private_class_method :project_required
-
-    # 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_config[:method] = ([:in, :current] & options.keys).first
-      stage = options[:stage].to_sym if options[:stage]
-      if project_required(options: options)
-        project_config = configs[:project_config]
-        stage ||= project_config[:stages].keys[0].to_sym
-        options[:stage] = stage
-        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, nil] unless project_config[:stages][stage]
-            stage_config[:key] = project_config[:stages][stage][:branch]
-          end
-        when :script
-          return [nil, nil] unless project_config[:stages][stage]
-          stage_config[:key] = project_config[:stages][stage][:script]
-        end
+    end
+
+    def stub_project_config_for_current
+      pwd =  Pathname.pwd.to_s
+      raise ParseError, "Missing Manifest" unless File.exist?(File.join(pwd, "manifest"))
+      @parsed[:project_config] = {
+        directory: pwd,
+        folders: nil,
+        files: nil,
+        stage_method: :current
+      }
+    end
+
+    def set_project_directory
+      if @config[:projects][:project_dir]
+        @parsed[:project_config][:directory] = File.join(@config[:projects][:project_dir], @parsed[:project_config][:directory])
       end
-      configs[:stage_config] = stage_config
-      configs[:stage] = stage
-      [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:)
-      root_dir, content = nil, nil
-      if configs[:project_config]
-        root_dir = configs[:project_config][:directory]
-        content = {
-          folders: configs[:project_config][:folders],
-          files: configs[:project_config][:files],
-        }
-        all_commands = options.keys & Controller.commands
-        if options[:exclude] or Controller.exclude_commands.include?(all_commands.first)
-          content[:excludes] = configs[:project_config][:excludes]
+      unless Dir.exist?(@parsed[:project_config][:directory])
+        raise ParseError, "Missing project dirtectory: #{@parsed[:project_config][:dirtectory]}"
+      end
+    end
+
+    def check_for_working
+      @parsed[:project_config][:stage_method] = :working if @options[:working]
+    end
+
+
+    def setup_stage_config
+      setup_mininal_stage_configs
+      setup_project_stage_config if project_required
+    end
+
+    def setup_mininal_stage_configs
+      @parsed[:stage_config] = {}
+      @parsed[:stage_config][:method] = ([:in, :current] & @options.keys).first
+      @parsed[:stage] = @options[:stage].to_sym if @options[:stage]
+    end
+
+    def setup_project_stage_config
+      @parsed[:stage] ||= @parsed[:project_config][:stages].keys[0].to_sym
+      @parsed[:stage_config][:root_dir] = @parsed[:project_config][:directory]
+      raise ParseError, "Unknown Stage: #{@parsed[:stage]}" unless @parsed[:project_config][:stages][@parsed[:stage]]
+      setup_staging_method
+      setup_staging_key
+    end
+
+    def setup_staging_method
+      @parsed[:stage_config][:method] = @parsed[:project_config][:stage_method]
+      unless [:git, :script, :current, :working].include? @parsed[:stage_config][:method]
+        raise ParseError, "Unknown Stage Method: #{@parsed[:stage_config][:method]}"
+      end
+    end
+
+    def setup_staging_key
+      case @parsed[:stage_config][:method]
+      when :git
+        if @options[:ref]
+          @parsed[:stage_config][:key] = @options[:ref]
+        else
+          @parsed[:stage_config][:key] = @parsed[:project_config][:stages][@parsed[:stage]][:branch]
         end
+      when :script
+        @parsed[:stage_config][:key] = @parsed[:project_config][:stages][@parsed[:stage]][:script]
       end
+    end
+
+    def setup_sideload_config
+      root_dir, content = setup_project_values
       # Create Sideload Config
-      configs[:sideload_config] = {
-        update_manifest: options[:update_manifest],
-        infile: options[:in],
+      @parsed[:sideload_config] = {
+        update_manifest: @options[:update_manifest],
+        infile: @options[:in],
         content: content
       }
       # Create Build Config
-      configs[:build_config] = { content: content }
-      configs[:init_params][:loader] = { root_dir: root_dir }
-    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(config:, configs:, options:, stage:)
-      if options[:package] or options[:key]
-        # Create Key Config
-        configs[:key] = configs[:project_config][:stages][stage][:key]
-        if configs[:key].class == String
-          configs[:key] = config[:keys][configs[:key].to_sym]
-          if config[:keys][:key_dir]
-            configs[:key][:keyed_pkg] = File.join(config[:keys][:key_dir], configs[:key][:keyed_pkg])
-          end
-          return BAD_KEY_FILE unless File.exist?(configs[:key][:keyed_pkg])
-        end
-      end
-      if options[:package]
-        # Create Package Config
-        configs[:package_config] = {
-          password: configs[:key][:password],
-          app_name_version: "#{configs[:project_config][:app_name]} - #{stage}"
-        }
-        # Create Inspector Config
-        configs[:inspect_config] = {
-          password: configs[:key][:password]
+      @parsed[:build_config] = { content: content }
+      @parsed[:init_params][:loader] = { root_dir: root_dir }
+    end
+
+    def setup_project_values
+      if @parsed[:project_config]
+        root_dir = @parsed[:project_config][:directory]
+        content = {
+          folders: @parsed[:project_config][:folders],
+          files: @parsed[:project_config][:files],
         }
-        if configs[:out][:file]
-          configs[:package_config][:out_file] = File.join(configs[:out][:folder], configs[:out][:file])
-          configs[:inspect_config][:pkg] = File.join(configs[:out][:folder], configs[:out][:file])
-        end
+        content[:excludes] = @parsed[:project_config][:excludes] if add_excludes?
+        [root_dir, content]
+      else
+        [nil, nil]
+      end
+    end
+
+    def add_excludes?
+      @options[:exclude] or @options.exclude_command?
+    end
+
+    def setup_package_config
+      setup_key_config if @options[:package] or @options[:key]
+      if @options[:package]
+        setup_package_config_hashes
+        setup_package_config_out_files
+      end
+    end
+
+    def setup_key_config
+      @parsed[:key] = @parsed[:project_config][:stages][@parsed[:stage]][:key]
+      get_global_key_config if @parsed[:key].class == String
+    end
+
+    def get_global_key_config
+      raise ParseError, "Unknown Key: #{@parsed[:key]}" unless @config[:keys][@parsed[:key].to_sym]
+      @parsed[:key] = @config[:keys][@parsed[:key].to_sym]
+      if @config[:keys][:key_dir]
+        @parsed[:key][:keyed_pkg] = File.join(@config[:keys][:key_dir], @parsed[:key][:keyed_pkg])
       end
-      return SUCCESS
-    end
-    private_class_method :setup_package_config
-
-    # Setup configs for active methods, monitoring and navigating
-    # @param configs [Hash] The parsed configs hash
-    # @param options [Hash] The options hash
-    # @param logger [Logger] System logger
-    def self.setup_active_configs(config:, configs:, options:)
-      # Create Monitor Config
-      if options[:monitor]
-        configs[:monitor_config] = {type: options[:monitor].to_sym}
-        if options[:regexp]
-          configs[:monitor_config][:regexp] = /#{options[:regexp]}/
+      unless File.exist?(@parsed[:key][:keyed_pkg])
+        raise ParseError, "Bad key file: #{@parsed[:key][:keyed_pkg]}"
+      end
+    end
+
+    def setup_package_config_hashes
+      @parsed[:package_config] = {
+        password: @parsed[:key][:password],
+        app_name_version: "#{@parsed[:project_config][:app_name]} - #{@parsed[:stage]}"
+      }
+      @parsed[:inspect_config] = {
+        password: @parsed[:key][:password]
+      }
+    end
+
+    def setup_package_config_out_files
+      if @parsed[:out][:file]
+        @parsed[:package_config][:out_file] = File.join(@parsed[:out][:folder], @parsed[:out][:file])
+        @parsed[:inspect_config][:pkg] = File.join(@parsed[:out][:folder], @parsed[:out][:file])
+      end
+    end
+
+    def setup_monitor_configs
+      if @options[:monitor]
+        @parsed[:monitor_config] = {type: @options[:monitor].to_sym}
+        if @options[:regexp]
+          @parsed[:monitor_config][:regexp] = /#{@options[:regexp]}/
         end
       end
-      # Create Navigate Config
+    end
+
+    def setup_navigate_configs
+      @parsed[:init_params][:navigator] = {mappings: generate_maggings}
+      if @options[:navigate]
+        @parsed[:navigate_config] = {
+          commands: @options[:navigate].split(/, */).map{|c| c.to_sym}
+        }
+      end
+    end
+
+    def generate_maggings
       mappings = {}
-      if config[:input_mapping]
-        config[:input_mapping].each_pair {|key, value|
+      if @config[:input_mapping]
+        @config[:input_mapping].each_pair {|key, value|
           unless "".to_sym == key
             key = key.to_s.sub(/\\e/, "\e").to_sym
             mappings[key] = value
           end
         }
       end
-      configs[:init_params][:navigator] = {mappings: mappings}
-      if options[:navigate]
-        commands = options[:navigate].split(/, */).map{|c| c.to_sym}
-        configs[:navigate_config] = {commands: commands}
-      end
+      mappings
     end
-    private_class_method :setup_active_configs
-
-    # Setup manifest configs
-    # @param configs [Hash] The parsed configs hash
-    # @param options [Hash] The options hash
-    # @param logger [Logger] System logger
-    def self.setup_manifest_configs(configs:, options:)
-      # Create Manifest Config
-      root_dir = configs[:project_config][:directory] if configs[:project_config]
-      root_dir = options[:in] if options[:in]
-      root_dir = Pathname.pwd.to_s if options[:current]
-      configs[:manifest_config] = {
-        root_dir: root_dir
+
+    def setup_manifest_config
+      @parsed[:manifest_config] = {
+        root_dir: get_root_dir
       }
     end
-    private_class_method :setup_manifest_configs
-
-    # 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(config:, configs:, options:)
-      # Create Deeplink Config
-      configs[:deeplink_config] = {options: options[:deeplink]}
-      if options[:app_id]
-        configs[:deeplink_config][:app_id] = options[:app_id]
+
+    def get_root_dir
+      root_dir = @parsed[:project_config][:directory] if @parsed[:project_config]
+      root_dir = @options[:in] if @options[:in]
+      root_dir = Pathname.pwd.to_s if @options[:current]
+      root_dir
+    end if
+
+    def setup_deeplink_configs
+      @parsed[:deeplink_config] = {options: @options[:deeplink]}
+      if @options[:app_id]
+        @parsed[:deeplink_config][:app_id] = @options[:app_id]
       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: configs[:out][:folder],
-        out_file: configs[:out][:file]
+    end
+    def setup_text_configs
+      @parsed[:text_config] = {text: @options[:text]}
+    end
+    def setup_test_configs
+      @parsed[:test_config] = {sideload_config: @parsed[:sideload_config]}
+      @parsed[:init_params][:tester] = { root_dir: get_root_dir }
+    end
+    def setup_screencapture_configs
+      @parsed[:screencapture_config] = {
+        out_folder: @parsed[:out][:folder],
+        out_file: @parsed[:out][:file]
       }
-      if options[:screen]
-        configs[:screen_config] = {type: options[:screen].to_sym}
+    end
+    def setup_screen_config
+      if @options[:screen]
+        @parsed[:screen_config] = {type: @options[:screen].to_sym}
       end
-      #Create Profiler Config
-      if options[:profile]
-        configs[:profiler_config] = {command: options[:profile].to_sym}
+    end
+    def setup_profiler_configs
+      if @options[:profile]
+        @parsed[:profiler_config] = {command: @options[:profile].to_sym}
       end
-      #Create genkey config
-      configs[:genkey] = {}
-      if options[:out_file]
-        configs[:genkey][:out_file] = File.join(options[:out_folder], options[:out_file])
+    end
+    def setup_genkey_configs
+      @parsed[:genkey] = {}
+      if @options[:out_file]
+        @parsed[:genkey][:out_file] = File.join(@options[:out_folder], @options[:out_file])
       end
     end
-    private_class_method :setup_simple_configs
   end
 end