proxy_pac_rb 0.3.8 → 0.4.0

data/lib/proxy_pac_rb/cli/lint_proxy_pac.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module ProxyPacRb
+  module Cli
+    # Find proxy for url
+    class LintProxyPac < Thor::Group
+      include Shared
+
+      class_option :proxy_pac, type: :array, desc: 'Proxy.pac-file(s)', aliases: '-p', required: true
+
+      def pre_init
+        enable_debug_mode
+      end
+
+      def set_variables
+        @proxy_pacs = options[:proxy_pac].map { |p| ProxyPacFile.new source: p }
+        @loader     = ProxyPacLoader.new
+        @linter     = ProxyPacLinter.new
+      end
+
+      def test_proxy_pac
+        @proxy_pacs.each do |p|
+          @loader.load(p)
+          @linter.lint(p)
+
+          if p.valid?
+            $stderr.puts %(proxy.pac "#{p.source}" is of type #{p.type} and is valid.)
+            true
+          else
+            $stderr.puts %(proxy.pac "#{p.source}" is of type #{p.type} and is invalid.)
+
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/cli/runner.rb

@@ -7,6 +7,8 @@ module ProxyPacRb
       map '-v' => :version
       map '--version' => :version
 
+      class_option :debug_mode, type: :boolean, default: false, desc: 'Enable debug mode'
+
       desc 'find', 'Find something'
       subcommand 'find', Find
 
@@ -16,6 +18,9 @@ module ProxyPacRb
       desc 'show', 'Show something'
       subcommand 'show', Show
 
+      desc 'lint', 'Lint something'
+      subcommand 'lint', Lint
+
       desc 'version', 'version', hide: true
       def version
         invoke 'proxy_pac_rb:cli:show:version'

data/lib/proxy_pac_rb/cli/shared.rb

@@ -3,6 +3,10 @@ module ProxyPacRb
   module Cli
     # Shared methods for all cli commands
     module Shared
+      # Enable debug mode
+      def enable_debug_mode
+        ProxyPacRb.enable_debug_mode if options[:debug_mode] == true
+      end
     end
   end
 end

data/lib/proxy_pac_rb/cli_validator.rb

@@ -14,10 +14,24 @@ module ProxyPacRb
     def validate
       exit_with_message 'You need to provide at least one url. Multiple urls need to be separated by a space.' if empty_url?
       exit_with_message 'You need to provide a proxy pac file.' if empty_pac_file?
+      exit_with_message %(You need to provide a path to an existing proxy pac file. The file "#{options[:proxy_pac]}" does not exist.) if non_existing_proxy_pac_file?
     end
 
     private
 
+    def proxy_pac_url?
+      url = Addressable::URI.parse(options[:proxy_pac])
+      return true if url.host
+
+      false
+    rescue StandardError
+      false
+    end
+
+    def non_existing_proxy_pac_file?
+      !proxy_pac_url? && !File.file?(options[:proxy_pac])
+    end
+
     def empty_url?
       options[:urls].blank?
     end

data/lib/proxy_pac_rb/errors.rb

@@ -0,0 +1,19 @@
+module ProxyPacRb
+  # Raised if proxy pac is invalid
+  class LinterError < StandardError; end
+
+  # raise on error
+  class ProgramError < StandardError; end
+
+  # raise on java script runtime error
+  class RuntimeUnavailableError < StandardError; end
+
+  # raise on invalid argument
+  class InvalidArgumentError < StandardError; end
+
+  # raise on invalid argument
+  class UrlInvalidError < StandardError; end
+
+  # raise if proxy pac could not be compiled
+  class ParserError < StandardError; end
+end

data/lib/proxy_pac_rb/javascript.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Parse Proxy pac to file system
+  class Javascript
+    private
+
+    attr_reader :context
+
+    public
+
+    def initialize(context)
+      @context = context
+    end
+
+    def method_missing(*args, &_block)
+      context.call(args.shift, *args)
+    end
+  end
+end

data/lib/proxy_pac_rb/main.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# Main
+module ProxyPacRb
+  @debug_mode = false
+
+  class << self
+    private
+
+    attr_accessor :debug_mode
+
+    public
+
+    def debug_mode_enabled?
+      debug_mode == true
+    end
+
+    def enable_debug_mode
+      self.debug_mode = true
+      %w(pry byebug).each { |l| require l }
+    end
+  end
+end

data/lib/proxy_pac_rb/parser.rb

@@ -13,42 +13,53 @@ module ProxyPacRb
   class Parser
     private
 
-    attr_reader :runtime, :environment
+    attr_reader :parser, :loader, :linter
 
     public
 
-    def initialize(environment = Environment.new, runtime = Runtimes.autodetect)
-      fail Exceptions::RuntimeUnavailable, "#{runtime.name} is unavailable on this system" unless runtime.available?
+    def initialize(*args)
+      if args.first.is_a? Hash
+        @parser = ProxyPacParser.new(**args.first)
+      else
+        $stderr.puts 'Deprecated: Use of positional parameters. Please use named parameters: environment: Environment.new.'
+        @parser = ProxyPacParser.new(environment: args.first)
+      end
 
-      @runtime     = runtime
-      @environment = environment
+      @loader = ProxyPacLoader.new
+      @linter = ProxyPacLinter.new
     end
 
-    def load(url, options = {})
-      create_file(open(url, { proxy: false }.merge(options)).read)
-    end
+    def parse(source)
+      pac_file = ProxyPacFile.new source: source
 
-    def read(file)
-      create_file(::File.read(file))
-    end
+      loader.load(pac_file)
+      linter.lint(pac_file)
+
+      unless pac_file.valid?
+        $stderr.puts %(proxy.pac "#{pac_file.source}" is invalid.)
+
+        return
+      end
 
-    def source(source)
-      create_file(source)
+      parser.parse(pac_file)
     end
 
-    private
+    def load(*args)
+      $stderr.puts 'Deprecated: #load. Please use #parse instead.'
 
-    def compile_javascript(source)
-      environment.prepare(source)
+      parse(*args)
+    end
 
-      context = runtime.compile(source)
-      context.include environment
+    def read(*args)
+      $stderr.puts 'Deprecated: #read. Please use #parse instead.'
 
-      context
+      parse(*args)
     end
 
-    def create_file(source)
-      File.new(compile_javascript(source))
+    def source(*args)
+      $stderr.puts 'Deprecated: #source. Please use #parse instead.'
+
+      parse(*args)
     end
   end
 end

data/lib/proxy_pac_rb/proxy_pac.rb

@@ -1,34 +1,24 @@
-# encoding: utf-8
 module ProxyPacRb
-  # ProxyPac
+  # Proxy pac file
   class ProxyPac
     private
 
-    attr_reader :path
+    attr_reader :javascript
 
     public
 
-    def initialize(path)
-      @path = path
-    end
+    attr_reader :file
 
-    def content
-      fail
+    def initialize(javascript:, file:)
+      @javascript = javascript
+      @file       = file
     end
 
-    private
-
-    def read_proxy_pac(path)
-      uri = Addressable::URI.parse(path)
-
-      uri.path = ::File.expand_path(uri.path) if uri.host.nil?
-
-      ENV.delete 'HTTP_PROXY'
-      ENV.delete 'HTTPS_PROXY'
-      ENV.delete 'http_proxy'
-      ENV.delete 'https_proxy'
+    def find(url)
+      uri = Addressable::URI.heuristic_parse(url)
+      fail UrlInvalidError, 'url is missing host' unless uri.host
 
-      open(uri, proxy: false).read
+      javascript.FindProxyForURL(url, uri.host)
     end
   end
 end

data/lib/proxy_pac_rb/proxy_pac_compressor.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Compress javascript files
+  class ProxyPacCompressor
+    def compress(proxy_pac)
+      proxy_pac.content = Uglifier.new.compile(proxy_pac.content)
+    end
+  end
+end

data/lib/proxy_pac_rb/proxy_pac_dumper.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Dump Proxy pac to file system
+  class ProxyPacDumper
+    private
+
+    attr_reader :type, :dumpers
+
+    public
+
+    def initialize
+      @dumpers = Hash.new { ProxyPacStringDumper.new }
+      @dumpers[:template] = ProxyPacTemplateDumper.new
+      @dumpers[:string] = ProxyPacStringDumper.new
+    end
+
+    def dump(proxy_pac, type:)
+      dumpers[type].dump(proxy_pac)
+    end
+  end
+
+  # Dump string to file
+  class ProxyPacStringDumper
+    private
+
+    attr_reader :default_file_name
+
+    public
+
+    def initialize
+      @default_file_name = 'proxy.pac'
+    end
+
+    def dump(proxy_pac)
+      ::File.write(default_file_name, proxy_pac.content)
+    end
+  end
+
+  # Dump proxy pac based on template
+  class ProxyPacTemplateDumper
+    def dump(proxy_pac)
+      ::File.write(output_path(proxy_pac.source), proxy_pac.content)
+    end
+
+    private
+
+    def in_extension
+      '.in'
+    end
+
+    def out_extension
+      '.out'
+    end
+
+    def output_path(path)
+      if ::File.exist?(path.gsub(/#{in_extension}*$/, '') + in_extension)
+        return path.gsub(/#{in_extension}*$/, '')
+      elsif ::File.exist? path
+        return path + out_extension
+      else
+        fail Errno::ENOENT, "Both paths \"#{path.gsub(/#{in_extension}*$/, '') + in_extension}\" and \"#{path}\" do not exist."
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/proxy_pac_file.rb

@@ -1,9 +1,26 @@
 # encoding: utf-8
 module ProxyPacRb
-  # Pac file not for parsing
-  class ProxyPacFile < ProxyPac
+  # Pac file
+  class ProxyPacFile
+    attr_accessor :valid, :type, :message
+    attr_reader :source
+    attr_writer :content
+
+    def initialize(source:)
+      @source = source
+      @valid  = false
+    end
+
     def content
-      read_proxy_pac(path)
+      @content.dup
+    end
+
+    def type?(t)
+      type == t
+    end
+
+    def valid?
+      valid == true
     end
   end
 end

data/lib/proxy_pac_rb/proxy_pac_linter.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Dump Proxy pac to file system
+  class ProxyPacLinter
+    private
+
+    attr_reader :rules, :silent
+
+    public
+
+    def initialize(silent: false)
+      @rules = []
+      @rules << Rules::ContainerProxyPacFunction.new
+      @rules << Rules::CanBeParsed.new
+
+      @silent = silent
+    end
+
+    # Load proxy pac
+    #
+    # @param [#source] proxy_pac
+    #   The proxy.pac
+    def lint(proxy_pac)
+      rules.each { |r| r.lint(proxy_pac) }
+
+      proxy_pac.valid = true
+    rescue LinterError => err
+      $stderr.puts err.message unless silent
+
+      proxy_pac.message = err.message
+      proxy_pac.valid = false
+    end
+  end
+
+  module Rules
+    # A proxy pac needs to contain FindProxyForURL
+    class ContainerProxyPacFunction
+      def lint(proxy_pac)
+        message = if proxy_pac.type? :string
+                    %(proxy.pac is only given as string "#{proxy_pac.source}" and does not contain "FindProxyForURL".)
+                  elsif proxy_pac.type? :url
+                    %(proxy.pac-url "#{proxy_pac.source}" does not contain "FindProxyForURL".)
+                  else
+                    %(proxy.pac-file "#{proxy_pac.source}" does not contain "FindProxyForURL".)
+                  end
+
+        fail LinterError, message unless proxy_pac.content.include?('FindProxyForURL')
+
+        self
+      end
+    end
+
+    # A proxy pac needs be parsable
+    class CanBeParsed
+      private
+
+      attr_reader :parser
+
+      public
+
+      def initialize
+        @parser = ProxyPacParser.new
+      end
+
+      def lint(proxy_pac)
+        parser.parse(proxy_pac)
+
+        self
+      rescue => err
+        message = if proxy_pac.type? :string
+                    %(proxy.pac is only given as string "#{proxy_pac.source}" cannot be parsed:\n#{err.message}".)
+                  elsif proxy_pac.type? :url
+                    %(proxy.pac-url "#{proxy_pac.source}" cannot be parsed:\n#{err.message}".)
+                  else
+                    %(proxy.pac-file "#{proxy_pac.source}" cannot be parsed:\n#{err.message}".)
+                  end
+
+        raise LinterError, message
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/proxy_pac_loader.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Dump Proxy pac to file system
+  class ProxyPacLoader
+    private
+
+    attr_reader :loaders, :default_loader
+
+    public
+
+    def initialize
+      @loaders = []
+      @loaders << ProxyPacStringLoader.new
+      @loaders << ProxyPacFileLoader.new
+      @loaders << ProxyPacUriLoader.new
+
+      @default_loader = -> { ProxyPacStringLoader.new }
+    end
+
+    # Load proxy pac
+    #
+    # @param [#source] proxy_pac
+    #   The proxy.pac
+    def load(proxy_pac)
+      loaders.find(default_loader) { |l| l.suitable_for? proxy_pac }.load(proxy_pac)
+    end
+  end
+
+  # Load proxy pac from string
+  class ProxyPacStringLoader
+    def load(proxy_pac)
+      proxy_pac.content = proxy_pac.source.to_s
+      proxy_pac.type = :string
+
+      self
+    end
+
+    def suitable_for?(proxy_pac)
+      proxy_pac.source.include? 'FindProxyForURL'
+    end
+  end
+
+  # Load proxy pac from file
+  class ProxyPacFileLoader
+    def load(proxy_pac)
+      proxy_pac.content = ::File.read(proxy_pac.source).chomp
+      proxy_pac.type    = :file
+    end
+
+    def suitable_for?(proxy_pac)
+      ::File.file? proxy_pac.source
+    end
+  end
+
+  # Load proxy pac from url
+  class ProxyPacUriLoader
+    def load(proxy_pac)
+      proxy_pac.content = Net::HTTP.get(URI(proxy_pac.source))
+      proxy_pac.type = :url
+    end
+
+    def suitable_for?(proxy_pac)
+      uri = Addressable::URI.parse(proxy_pac.source)
+
+      return true unless uri.host.blank?
+
+      false
+    rescue StandardError
+      false
+    end
+
+    private
+
+    def with_proxy_environment_variables
+      backup = []
+
+      %w(
+        http_proxy
+        https_proxy
+        HTTP_PROXY
+        HTTPS_PROXY
+      ).each do |v|
+        backup << ENV.delete(v)
+      end
+
+      yield
+    ensure
+      %w(
+        http_proxy
+        https_proxy
+        HTTP_PROXY
+        HTTPS_PROXY
+      ).each do |v|
+        ENV[v] = backup.shift
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/proxy_pac_parser.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module ProxyPacRb
+  # Parse Proxy pac to file system
+  class ProxyPacParser
+    private
+
+    attr_reader :environment, :runtime
+
+    public
+
+    def initialize(
+      environment: Environment.new,
+      runtime: Runtimes.autodetect
+    )
+      @runtime     = runtime
+      @environment = environment
+    end
+
+    def parse(proxy_pac)
+      fail Exceptions::RuntimeUnavailable, "#{runtime.name} is unavailable on this system" unless runtime.available?
+
+      ProxyPac.new(
+        javascript: compile_javascript(proxy_pac.content),
+        file: proxy_pac
+      )
+    end
+
+    private
+
+    def compile_javascript(content)
+      environment.prepare(content)
+
+      context = runtime.compile(content)
+      context.include environment
+
+      Javascript.new(context)
+    rescue StandardError => err
+      raise ParserError, err.message
+    end
+  end
+end

data/lib/proxy_pac_rb/rack/proxy_pac_compressor.rb

@@ -0,0 +1,68 @@
+require 'proxy_pac_rb'
+require 'rack'
+
+module ProxyPacRb
+  module Rack
+    # Rack Middleware to compress proxy pac
+    #
+    # @example Sinatra's <server>.rb
+    # require 'proxy_pac_rb/rack/proxy_pac_compressor'
+    # use ProxyPacRb::Rack::ProxyPacCompressor
+    #
+    # @example Rack's config.ru
+    # require 'proxy_pac_rb/rack/proxy_pac_compressor'
+    # use ProxyPacRb::Rack::ProxyPacCompressor
+    #
+    # @example Middleman's config.rb
+    # require 'proxy_pac_rb/rack/proxy_pac_compressor'
+    # use ProxyPacRb::Rack::ProxyPacCompressor
+    #
+    class ProxyPacCompressor
+      private
+
+      attr_reader :compressor, :loader, :enabled
+
+      public
+
+      def initialize(
+        app,
+        enabled: true
+      )
+        @app        = app
+        @compressor = ProxyPacRb::ProxyPacCompressor.new
+        @loader     = ProxyPacRb::ProxyPacLoader.new
+        @enabled    = enabled
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        return [status, headers, body] if enabled == false
+        # rubocop:disable Style/CaseEquality
+        return [status, headers, body] unless headers.key?('Content-Type') \
+                                              && %r{application/x-ns-proxy-autoconfig} === headers['Content-Type']
+        # rubocop:enable Style/CaseEquality
+
+        content = [body].flatten.each_with_object('') { |e, a| a << e.to_s }
+
+        begin
+          proxy_pac = ProxyPacFile.new(source: content)
+
+          loader.load(proxy_pac)
+          compressor.compress(proxy_pac)
+
+          content = proxy_pac.content
+        rescue => err
+          status  = 500
+          content = err.message
+        end
+
+        headers['Content-Length'] = content.bytesize.to_s if headers['Content-Length']
+
+        [status, headers, [content]]
+      ensure
+        body.close if body.respond_to? :close
+      end
+    end
+  end
+end