class Bauxite::Context

# File lib/bauxite/core/context.rb, line 140
def initialize(options)
        @options = options
        @driver_name = (options[:driver] || :firefox).to_sym
        @variables = {
                '__TIMEOUT__'  => (options[:timeout] || 10).to_i,
                '__DEBUG__'    => false,
                '__SELECTOR__' => options[:selector] || 'sid'
        }
        @aliases = {}
        @tests = []
        
        client = Selenium::WebDriver::Remote::Http::Default.new
        client.timeout = (@options[:open_timeout] || 60).to_i
        @options[:driver_opt] = {} unless @options[:driver_opt]
        @options[:driver_opt][:http_client] = client

        _load_extensions(options[:extensions] || [])
        
        handle_errors do
                @logger = Context::load_logger(options[:logger], options[:logger_opt])
        end
        
        @parser = Parser.new(self)
end

# File lib/bauxite/core/context.rb, line 253
def debug
        exec_action('debug', false)
end

# File lib/bauxite/core/context.rb, line 242
def find(selector, &block) # yields: element
        with_timeout Selenium::WebDriver::Error::NoSuchElementError do
                Selector.new(self, @variables['__SELECTOR__']).find(selector, &block)
        end
end

# File lib/bauxite/core/context.rb, line 272
def get_value(element)
        if ['input','select','textarea'].include? element.tag_name.downcase
                element.attribute('value') 
        else
                element.text
        end
end

# File lib/bauxite/core/context.rb, line 197
def reset_driver
        @driver.quit
        _load_driver
end

# File lib/bauxite/core/context.rb, line 179
def start(actions = [])
        _load_driver
        return unless actions.size > 0
        begin
                actions.each do |action|
                        exec_action(action)
                end
        ensure
                stop
        end
end

# File lib/bauxite/core/context.rb, line 217
def stop
        Context::wait if @options[:wait]
        @driver.quit
end

# File lib/bauxite/core/context.rb, line 448
def self.load_logger(name, options)
        log_name = (name || 'null').downcase
        
        class_name = "#{log_name.capitalize}Logger"
        
        unless Loggers.const_defined? class_name.to_sym
                raise NameError,
                        "Invalid logger '#{log_name}'"
        end
        
        Loggers.const_get(class_name).new(options)
end

# File lib/bauxite/core/context.rb, line 470
def self.parse_action_default(text, file = '<unknown>', line = 0)
        data = text.split(' ', 2)
        begin
                args_text = data[1] ? data[1].strip : ''
                args = []
                
                unless args_text == ''
                        # col_sep must be a regex because String.split has a
                        # special case for a single space char (' ') that produced
                        # unexpected results (i.e. if line is '"a      b"' the
                        # resulting array contains ["a b"]).
                        #
                        # ...but... 
                        #
                        # CSV expects col_sep to be a string so we need to work
                        # some dark magic here. Basically we proxy the StringIO
                        # received by CSV to returns strings for which the split
                        # method does not fold the whitespaces.
                        #
                        args = CSV.new(StringIOProxy.new(args_text), { :col_sep => ' ' })
                        .shift
                        .select { |a| a != nil } || []
                end
                
                {
                        :action => data[0].strip.downcase,
                        :args   => args
                }
        rescue StandardError => e
                raise "#{file} (line #{line+1}): #{e.message}"
        end
end

# File lib/bauxite/core/context.rb, line 441
def self.wait
        Readline.readline("Press ENTER to continue\n")
end

# File lib/bauxite/core/context.rb, line 464
def add_alias(name, action, args)
        @aliases[name] = { :action => action, :args => args }
end

# File lib/bauxite/core/context.rb, line 293
def exec_action(text, log = true, file = '<unknown>', line = 0)
        data = Context::parse_action_default(text, file, line)
        exec_parsed_action(data[:action], data[:args], log, text, file, line)
end

# File lib/bauxite/core/context.rb, line 550
def exec_action_object(action)
        # Inject built-in variables
        file = action.file
        dir  = (File.exists? file) ? File.dirname(file) : Dir.pwd
        @variables['__FILE__'] = file
        @variables['__DIR__'] = File.absolute_path(dir)
        action.execute
end

# File lib/bauxite/core/context.rb, line 304
def exec_file(file)
        @parser.parse(file) do |action, args, text, file, line|
                exec_parsed_action(action, args, true, text, file, line)
        end
end

# File lib/bauxite/core/context.rb, line 323
def exec_parsed_action(action, args, log = true, text = nil, file = nil, line = nil)
        ret = handle_errors(true) do
                
                action =  get_action(action, args, text, file, line)
                
                if log
                        @logger.log_cmd(action) do
                                Readline::HISTORY << action.text
                                exec_action_object(action)
                        end
                else
                        exec_action_object(action)
                end
        end
        handle_errors(true) do
                ret.call if ret.respond_to? :call # delayed actions (after log_cmd)
        end
end

# File lib/bauxite/core/context.rb, line 510
def get_action(action, args, text = nil, file = nil, line = nil)
        while (alias_action = @aliases[action])
                action = alias_action[:action]
                args   = alias_action[:args].map do |a|
                        a.gsub(/\$\{(\d+)(\*q?)?\}/) do |match|
                                # expand ${1} to args[0], ${2} to args[1], etc.
                                # expand ${4*} to "#{args[4]} #{args[5]} ..."
                                # expand ${4*q} to "\"#{args[4]}\" \"#{args[5]}\" ..."
                                idx = $1.to_i-1
                                if $2 == nil
                                        args[idx] || ''
                                else
                                        range = args[idx..-1]
                                        range = range.map { |arg| '"'+arg.gsub('"', '""')+'"' } if $2 == '*q'
                                        range.join(' ')
                                end
                        end
                end
        end
        
        text = ([action] + args.map { |a| '"'+a.gsub('"', '""')+'"' }).join(' ') unless text
        file = @variables['__FILE__'] unless file
        line = @variables['__LINE__'] unless line
        
        Action.new(self, action, args, text, file, line)
end

# File lib/bauxite/core/context.rb, line 362
def handle_errors(break_into_debug = false, exit_on_error = true)
        yield
rescue StandardError => e
        if @logger
                @logger.log "#{e.message}\n", :error
        else
                puts e.message
        end
        if @options[:verbose]
                p e
                puts e.backtrace
        end
        unless @variables['__DEBUG__']
                if break_into_debug and @options[:debug]
                        debug
                elsif exit_on_error
                        if @variables['__RAISE_ERROR__']
                                raise
                        else
                                exit false
                        end
                end
        end
end

# File lib/bauxite/core/context.rb, line 572
def try_exec_action(action, args)
        action = get_action(action, args)
        
        with_timeout Bauxite::Errors::AssertionError do
                with_vars({ '__TIMEOUT__' => 0}) do
                        begin
                                ret = exec_action_object(action)
                                ret.call if ret.respond_to? :call
                                true
                        rescue Bauxite::Errors::AssertionError
                                false
                        end
                end
        end
end

# File lib/bauxite/core/context.rb, line 426
def with_driver_timeout(timeout)
        current = @driver_timeout
        @driver.manage.timeouts.implicit_wait = timeout
        yield
ensure
        @driver_timeout = current
        @driver.manage.timeouts.implicit_wait = current
end

# File lib/bauxite/core/context.rb, line 398
def with_timeout(*error_types)
        stime = Time.new
        timeout ||= stime + @variables['__TIMEOUT__']
        yield
rescue *error_types => e
        t = Time.new
        rem = timeout - t
        raise if rem < 0

        @logger.progress(rem.round)

        sleep(1.0/10.0) if (t - stime).to_i < 1
        retry
end

# File lib/bauxite/core/context.rb, line 609
def self.action_args(action)
        action += '_action' unless _action_methods.include? action
        Action.public_instance_method(action).parameters.map { |att, name| name.to_s }
end

# File lib/bauxite/core/context.rb, line 599
def self.actions
        _action_methods.map { |m| m.sub(/_action$/, '') }
end

# File lib/bauxite/core/context.rb, line 638
def self.loggers
        Loggers.constants.map { |l| l.to_s.downcase.sub(/logger$/, '') }
end

# File lib/bauxite/core/context.rb, line 662
def self.max_action_name_size
        actions.inject(0) { |s,a| a.size > s ? a.size : s }
end

# File lib/bauxite/core/context.rb, line 648
def self.parsers
        (Parser.public_instance_methods(false)                           - ParserModule.public_instance_methods(false))
        .map { |p| p.to_s }
end

# File lib/bauxite/core/context.rb, line 624
def self.selectors(include_standard_selectors = true)
        ret = Selector.public_instance_methods(false).map { |a| a.to_s.sub(/_selector$/, '') }
        if include_standard_selectors
                ret += Selenium::WebDriver::SearchContext::FINDERS.map { |k,v| k.to_s }
        end
        ret
end

# File lib/bauxite/core/context.rb, line 683
def expand(s)
        result = @variables.inject(s) do |s,kv|
                s = s.gsub(/\$\{#{kv[0]}\}/, kv[1].to_s)
        end
        result = expand(result) if result != s
        result
end

# File lib/bauxite/core/context.rb, line 706
def with_vars(vars)
        current = @variables
        @variables = @variables.merge(vars)
        yield
ensure
        @variables = current
end