proxy_rb 0.4.0 → 0.5.0

data/lib/proxy_rb/colorizer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# ProxyRb
+module ProxyRb
+  # The ANSIColor module can be used for namespacing and mixed into your own
+  # classes.
+  module AnsiColor
+    # :stopdoc:
+    ATTRIBUTES = [
+      [:clear,   0],
+      [:reset,   0], # synonym for :clear
+      [:bold,   1],
+      [:dark,   2],
+      [:italic, 3], # not widely implemented
+      [:underline, 4],
+      [:underscore, 4], # synonym for :underline
+      [:blink, 5],
+      [:rapid_blink, 6], # not widely implemented
+      [:negative, 7], # no reverse because of String#reverse
+      [:concealed, 8],
+      [:strikethrough, 9], # not widely implemented
+      [:black, 30],
+      [:red, 31],
+      [:green, 32],
+      [:yellow, 33],
+      [:blue, 34],
+      [:magenta, 35],
+      [:cyan, 36],
+      [:white, 37],
+      [:on_black, 40],
+      [:on_red, 41],
+      [:on_green, 42],
+      [:on_yellow, 43],
+      [:on_blue, 44],
+      [:on_magenta, 45],
+      [:on_cyan, 46],
+      [:on_white, 47]
+    ].freeze
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+    # :startdoc:
+
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    def self.coloring?
+      @coloring
+    end
+
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  ProxyRb::Colorizer.coloring = STDOUT.isatty
+    def self.coloring=(val)
+      @coloring = val
+    end
+    self.coloring = true
+
+    ATTRIBUTES.each do |c, v|
+      define_method(c) do |string|
+        result = []
+        result << "\e[#{v}m" if ProxyRb::AnsiColor.coloring?
+        if block_given?
+          result << yield
+        elsif string
+          result << string
+        elsif respond_to?(:to_str)
+          result << to_str
+        else
+          return result # only switch on
+        end
+        result << "\e[0m" if ProxyRb::AnsiColor.coloring?
+
+        result.join
+      end
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+    def self.included(klass)
+      if klass == String
+        ATTRIBUTES.delete(:clear)
+        ATTRIBUTE_NAMES.delete(:clear)
+      end
+    end
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolored(string = nil) # :yields:
+      if block_given?
+        yield.gsub(COLORED_REGEXP, '')
+      elsif string
+        string.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all ProxyRb::Platforms::AnsiColor attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+  end
+end
+
+# ProxyRb
+module ProxyRb
+  # Colorize output
+  class Colorizer
+    include ProxyRb::AnsiColor
+  end
+end

data/lib/proxy_rb/configuration.rb

@@ -3,7 +3,6 @@ require 'contracts'
 
 require 'proxy_rb/version'
 require 'proxy_rb/basic_configuration'
-require 'proxy_rb/basic_configuration/in_config_wrapper'
 
 require 'proxy_rb/password_fetchers/basic_password_fetcher'
 require 'proxy_rb/password_fetchers/environment_password_fetcher'
@@ -18,6 +17,7 @@ module ProxyRb
   class Configuration < BasicConfiguration
     option_accessor :password_fetcher, contract: { PasswordFetchers::BasicPasswordFetcher => PasswordFetchers::BasicPasswordFetcher }, default: ProxyRb::PasswordFetchers::EnvironmentPasswordFetcher.new(prefix: 'SECRET')
     option_accessor :driver, contract: { Drivers::BasicDriver => Drivers::BasicDriver }, default: ProxyRb::Drivers::WebkitDriver.new
+    option_accessor :console_history_file, contract: { String => String }, default: '~/.proxy_rb_history'
   end
 end
 

data/lib/proxy_rb/configuration_wrapper.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module ProxyRb
+  # This wraps the current runtime configuration of proxy_rb.
+  # If an option is changed, it notifies the event queue.
+  #
+  # This class is not meant for direct use - ConfigWrapper.new - by normal
+  # users.
+  #
+  # @private
+  class ConfigurationWrapper
+    private
+
+    attr_reader :config, :event_bus
+
+    public
+
+    # Create proxy
+    #
+    # @param [Config] config
+    #   An proxy_rb config object.
+    #
+    # @param [#notify] event_bus
+    #   The event queue which should be notified.
+    def initialize(config, event_bus)
+      @config = config
+      @event_bus = event_bus
+    end
+
+    # Proxy all methods
+    #
+    # If one method ends with "=", e.g. ":option1=", then notify the event
+    # queue, that the user changes the value of "option1"
+    def method_missing(name, *args, &block)
+      event_bus.notify Events::ChangedConfiguration.new(changed: { name: name.to_s.gsub(/=$/, ''), value: args.first }) if name.to_s.end_with? '='
+
+      config.send(name, *args, &block)
+    end
+
+    # Pass on respond_to?-calls
+    def respond_to_missing?(name, _include_private)
+      config.respond_to? name
+    end
+
+    # Compare two configs
+    #
+    # The comparism is done based on their values. No hooks are compared.
+    #
+    # Somehow `#respond_to_missing?`, `method_missing?` and `respond_to?` don't
+    # help here.
+    def ==(other)
+      config == other
+    end
+
+    # Pass on respond_to?-calls
+    def respond_to?(m)
+      config.respond_to? m
+    end
+  end
+end

data/lib/proxy_rb/console/help.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'proxy_rb/api'
+
+# ProxyRb
+module ProxyRb
+  # Consule
+  class Console
+    # Helpers for ProxyRb::Console
+    module Help
+      # Output help information
+      def proxy_rb_help
+        puts 'ProxyRb Version: ' + ProxyRb::VERSION
+        puts 'Issue Tracker: ' + 'https://github.com/fedux-org/proxy_rb/issues'
+        puts "Documentation:\n" + %w(http://www.rubydoc.info/gems/proxy_rb).map { |d| format('* %s', d) }.join("\n")
+        puts
+
+        nil
+      end
+
+      # List available methods in proxy_rb
+      def proxy_rb_methods
+        ms = (ProxyRb::Api.instance_methods - Module.instance_methods).each_with_object([]) { |e, a| a << format('* %s', e) }.sort
+        puts "Available Methods:\n" + ms.join("\n")
+
+        nil
+      end
+    end
+  end
+end

data/lib/proxy_rb/console.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'irb'
+
+require 'proxy_rb/console/help'
+require 'proxy_rb/api'
+
+# ProxyRb
+module ProxyRb
+  # Consule
+  class Console
+    # Start the proxy_rb console
+    def start
+      # Start IRB with current context:
+      # http://stackoverflow.com/questions/4189818/how-to-run-irb-start-in-context-of-current-class
+      ARGV.clear
+      IRB.setup nil
+
+      IRB.conf[:IRB_NAME] = 'proxy_rb'
+
+      IRB.conf[:PROMPT] = {}
+      IRB.conf[:PROMPT][:PROXY_RB] = {
+        PROMPT_I: '%N:%03n:%i> ',
+        PROMPT_S: '%N:%03n:%i%l ',
+        PROMPT_C: '%N:%03n:%i* ',
+        RETURN: "# => %s\n"
+      }
+      IRB.conf[:PROMPT_MODE] = :PROXY_RB
+
+      IRB.conf[:RC] = false
+
+      require 'irb/completion'
+      require 'irb/ext/save-history'
+      IRB.conf[:READLINE] = true
+      IRB.conf[:SAVE_HISTORY] = 1000
+      IRB.conf[:HISTORY_FILE] = ProxyRb.config.console_history_file
+
+      context = Class.new do
+        include ProxyRb::Console::Help
+        include ProxyRb::Api
+
+        def inspect
+          'nil'
+        end
+      end
+
+      irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+
+      trap('SIGINT') do
+        irb.signal_handle
+      end
+
+      begin
+        catch(:IRB_EXIT) do
+          irb.eval_input
+        end
+      ensure
+        IRB.irb_at_exit
+      end
+    end
+  end
+end

data/lib/proxy_rb/credentials.rb

@@ -33,6 +33,17 @@ module ProxyRb
       !(user_name? && password?)
     end
 
+    # Convert to hash
+    #
+    # @return [Hash]
+    #   The credentials as hash
+    def to_hash
+      {
+        user_name: user_name,
+        password: password
+      }
+    end
+
     private
 
     def user_name?

data/lib/proxy_rb/drivers/poltergeist_driver.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
-require 'proxy_rb/drivers/basic_driver'
 require 'capybara'
 
+require 'proxy_rb/drivers/basic_driver'
+require 'proxy_rb/errors'
+
 begin
   require 'capybara/poltergeist'
 rescue LoadError => e
@@ -44,9 +46,13 @@ module ProxyRb
         ::Capybara.current_driver = proxy.to_ref
       end
 
-      def rescuable_errors
+      def timeout_errors
         [::Capybara::Poltergeist::TimeoutError]
       end
+
+      def failure_errors
+        [::Capybara::Poltergeist::StatusFailError]
+      end
     end
   end
 end

data/lib/proxy_rb/drivers/selenium_driver.rb

@@ -2,6 +2,7 @@
 require 'proxy_rb/drivers/basic_driver'
 require 'capybara'
 require 'selenium-webdriver'
+require 'proxy_rb/errors'
 
 # ProxyRb
 module ProxyRb
@@ -20,6 +21,7 @@ module ProxyRb
         end
 
         profile = Selenium::WebDriver::Firefox::Profile.new
+        # profile.proxy = Selenium::WebDriver::Proxy.new(http: proxy.full_url)
         profile.proxy = Selenium::WebDriver::Proxy.new(http: format('%s:%s', proxy.host, proxy.port))
 
         unless ::Capybara.drivers.key? proxy.to_ref
@@ -31,7 +33,11 @@ module ProxyRb
         ::Capybara.current_driver = proxy.to_ref
       end
 
-      def rescuable_errors
+      def timeout_errors
+        []
+      end
+
+      def failure_errors
         []
       end
     end

data/lib/proxy_rb/drivers/webkit_driver.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'proxy_rb/drivers/basic_driver'
+require 'proxy_rb/errors'
 
 begin
   require 'capybara/webkit'
@@ -48,9 +49,17 @@ module ProxyRb
         ::Capybara.current_driver = proxy.to_ref
       end
 
-      def rescuable_errors
+      def timeout_errors
         [::Capybara::Webkit::TimeoutError]
       end
+
+      def failure_errors
+        [
+          Capybara::Webkit::InvalidResponseError,
+          Capybara::Webkit::NoResponseError,
+          Capybara::Webkit::ConnectionError
+        ]
+      end
     end
   end
 end

data/lib/proxy_rb/errors.rb

@@ -2,4 +2,16 @@
 module ProxyRb
   # Raised if time out occured while fetch resource
   class UrlTimeoutError < StandardError; end
+
+  # Raised when resource cannot be downloaded
+  class ResourceNotDownloadableError < StandardError; end
+
+  # Raised if one tries to use an unknown configuration option
+  class UnknownOptionError < ArgumentError; end
+
+  # Raised if an event name cannot be resolved
+  class EventNameResolveError < StandardError; end
+
+  # Raised if given object is not an event
+  class NoEventError < StandardError; end
 end

data/lib/proxy_rb/event_bus/name_resolver.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+require 'proxy_rb/errors'
+
+# Event notification library
+module ProxyRb
+  # EventBus
+  class EventBus
+    # Resolve name to Event name
+    class NameResolver
+      # @private
+      # Helpers for Resolvers
+      module ResolveHelpers
+        def camel_case(underscored_name)
+          if RUBY_VERSION < '1.9.3'
+            underscored_name.to_s.split('_').map { |word| word.upcase.chars.to_a[0] + word.chars.to_a[1..-1].join }.join
+          else
+            underscored_name.to_s.split('_').map { |word| word.upcase[0] + word[1..-1] }.join
+          end
+        end
+
+        # Thanks ActiveSupport
+        # (Only needed to support Ruby 1.9.3 and JRuby)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(camel_cased_word) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+
+              next candidate if constant.const_defined?(name, false)
+
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              # rubocop:disable Style/EachWithObject
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+              # rubocop:enable Style/EachWithObject
+
+              # owner is in Object, so raise
+              constant.const_get(name, false)
+            end
+          end
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+
+      # @private
+      # Convert a class in to an event class
+      class ClassResolver
+        class << self
+          def match?(event_id)
+            event_id.is_a? Class
+          end
+
+          # Which types are supported
+          def supports
+            [Class]
+          end
+        end
+
+        def transform(_, event_id)
+          event_id
+        end
+      end
+
+      # @private
+      # Convert a string in to an event class
+      class StringResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? String
+          end
+
+          # Which types are supported
+          def supports
+            [String]
+          end
+        end
+
+        def transform(_, event_id)
+          constantize(event_id)
+        end
+      end
+
+      # @private
+      # Convert a symbol in to an event class
+      class SymbolResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? Symbol
+          end
+
+          # Which types are supported
+          def supports
+            [Symbol]
+          end
+        end
+
+        def transform(default_namespace, event_id)
+          constantize("#{default_namespace}::#{camel_case(event_id)}")
+        end
+      end
+
+      # @private
+      # Default failing resolver
+      #
+      # This comes into play if the user passes an invalid event type
+      class FailingResolver
+        class << self
+          def match?(event_id)
+            raise ArgumentError, %(Input type "#{event_id.class}" of event_id "#{event_id}" is invalid)
+          end
+
+          def supports
+            []
+          end
+        end
+      end
+
+      protected
+
+      attr_reader :resolvers, :default_namespace
+
+      public
+
+      def initialize(default_namespace)
+        @default_namespace = default_namespace
+
+        @resolvers = []
+        @resolvers << ClassResolver
+        @resolvers << StringResolver
+        @resolvers << SymbolResolver
+        @resolvers << FailingResolver
+      end
+
+      def transform(event_id)
+        resolvers.find { |r| r.match? event_id }.new.transform(default_namespace, event_id)
+      rescue => e
+        raise EventNameResolveError, %(Transforming "#{event_id}" into an event class failed. Supported types are: #{@resolvers.map(&:supports).flatten.join(', ')}. #{e.message}.\n\n#{e.backtrace.join("\n")})
+      end
+    end
+  end
+end

data/lib/proxy_rb/event_bus.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'proxy_rb/event_bus/name_resolver'
+require 'proxy_rb/errors'
+
+module ProxyRb
+  # Event bus
+  #
+  # Implements and in-process pub-sub events broadcaster allowing multiple observers
+  # to subscribe to different events that fire as your tests are executed.
+  #
+  class EventBus
+    # Create EventBus
+    #
+    # @param [#transform] resolver
+    #   A resolver which transforms Symbol, String, Class into an event Class.
+    def initialize(resolver)
+      @resolver = resolver
+      @handlers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Register for an event
+    #
+    # @param [String, Symbol, Class, Array] event_ids
+    #   If Array, register multiple events witht the same handler. If String,
+    #   Symbol, Class register handler for given event.
+    #
+    # @param [#call] handler_object
+    #   The handler object, needs to have method `#call`. Either
+    #   `handler_object` or `block` can be defined. The handler object gets the
+    #   event passed to `#call`.
+    #
+    # @yield
+    #   Handler block which gets the event passed as parameter.
+    def register(event_ids, handler_object = nil, &handler_proc)
+      handler = handler_proc || handler_object
+
+      raise ArgumentError, 'Please pass either an object#call or a handler block' if handler.nil? || !handler.respond_to?(:call)
+
+      Array(event_ids).flatten.each do |id|
+        @handlers[
+          @resolver.transform(id).to_s
+        ] << handler
+      end
+
+      nil
+    end
+
+    # Broadcast an event
+    #
+    # @param [Object] event
+    #   An object of registered event class. This object is passed to the event
+    #   handler.
+    #
+    def notify(event)
+      raise NoEventError, 'Please pass an event object, not a class' if event.is_a?(Class)
+
+      @handlers[event.class.to_s].each { |handler| handler.call(event) }
+    end
+  end
+end

data/lib/proxy_rb/events.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# ProxyRb
+module ProxyRb
+  # Events
+  module Events
+    # Basic event
+    #
+    # This is not meant for direct use - BasicEvent.new - by users. It is inherited by normal events
+    #
+    # @private
+    class BasicEvent
+      attr_reader :entity
+
+      def initialize(entity)
+        @entity = entity
+      end
+    end
+
+    # Proxy was set
+    class ProxySet < BasicEvent; end
+
+    # User was set
+    class ProxyUserSet < BasicEvent; end
+
+    # User was set
+    class ResourceUserSet < BasicEvent; end
+
+    # User was set
+    class ResourceSet < BasicEvent; end
+
+    # The configuration was changed
+    class ChangedConfiguration < BasicEvent; end
+  end
+end

data/lib/proxy_rb/http_proxy.rb

@@ -42,5 +42,13 @@ module ProxyRb
     def to_ref
       Shellwords.escape(*[host, port, user].compact.join('_')).to_sym
     end
+
+    # Return proxy as full url
+    #
+    # @return [ProxyUrl]
+    #   The proxy as url
+    def full_url
+      ProxyUrl.build url.to_hash.merge(credentials.to_hash)
+    end
   end
 end