proxy_pac_rb 0.3.8 → 0.4.0

data/lib/proxy_pac_rb/rack/proxy_pac_linter.rb

@@ -0,0 +1,66 @@
+require 'proxy_pac_rb'
+require 'rack'
+
+module ProxyPacRb
+  module Rack
+    # Rack Middleware to lint proxy pac
+    #
+    # @example Sinatra's <server>.rb
+    # require 'proxy_pac_rb/rack/proxy_pac_linter'
+    # use ProxyPacRb::Rack::ProxyPacLinter
+    #
+    # @example Rack's config.ru
+    # require 'proxy_pac_rb/rack/proxy_pac_linter'
+    # use ProxyPacRb::Rack::ProxyPacLinter
+    #
+    # @example Middleman's config.rb
+    # require 'proxy_pac_rb/rack/proxy_pac_linter'
+    # use ProxyPacRb::Rack::ProxyPacLinter
+    class ProxyPacLinter
+      private
+
+      attr_reader :linter, :loader, :enabled
+
+      public
+
+      def initialize(
+        app,
+        enabled: true
+      )
+        @app     = app
+        @linter  = ProxyPacRb::ProxyPacLinter.new(silent: true)
+        @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 }
+
+        proxy_pac = ProxyPacFile.new(source: content)
+
+        loader.load(proxy_pac)
+        linter.lint(proxy_pac)
+
+        if proxy_pac.valid?
+          content = proxy_pac.content
+        else
+          status  = 500
+          content = proxy_pac.message
+          headers['Content-Length'] = content.bytesize.to_s if headers['Content-Length']
+        end
+
+        [status, headers, [content]]
+      ensure
+        body.close if body.respond_to?(:close)
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/runtimes/rubyracer.rb

@@ -32,7 +32,7 @@ module ProxyPacRb
             if e.value['name'] == 'SyntaxError'
               raise e.value.to_s
             else
-              raise Exceptions::ProgramError, e.value.to_s
+              raise ProgramError, e.value.to_s
             end
           end
         end
@@ -46,7 +46,7 @@ module ProxyPacRb
             if e.value['name'] == 'SyntaxError'
               raise e.value.to_s
             else
-              raise Exceptions::ProgramError, e.value.to_s
+              raise ProgramError, e.value.to_s
             end
           end
         end

data/lib/proxy_pac_rb/runtimes/rubyrhino.rb

@@ -29,7 +29,7 @@ module ProxyPacRb
         if e.message =~ /^syntax error/
           raise e.message
         else
-          raise Exceptions::ProgramError, e.message
+          raise ProgramError, e.message
         end
       end
 
@@ -39,7 +39,7 @@ module ProxyPacRb
         if e.message == 'syntax error'
           raise e.message
         else
-          raise Exceptions::ProgramError, e.message
+          raise ProgramError, e.message
         end
       end
 

data/lib/proxy_pac_rb/runtimes.rb

@@ -7,7 +7,7 @@ module ProxyPacRb
     class << self
       def autodetect
         from_environment || best_available ||
-          fail(Exceptions::RuntimeUnavailable, 'Could not find a JavaScript runtime. ' \
+          fail(RuntimeUnavailableError, 'Could not find a JavaScript runtime. ' \
                 'See https://github.com/sstephenson/execjs for a list of available runtimes.')
       end
 
@@ -20,8 +20,8 @@ module ProxyPacRb
 
         runtime = const_get(ENV['JS_RUNTIME'])
 
-        fail Exceptions::RuntimeUnavailable, "#{ENV['JS_RUNTIME']} runtime is not defined" unless runtime
-        fail Exceptions::RuntimeUnavailable, "#{runtime.name} runtime is not available on this system" unless runtime.available?
+        fail RuntimeUnavailableError, "#{ENV['JS_RUNTIME']} runtime is not defined" unless runtime
+        fail RuntimeUnavailableError, "#{runtime.name} runtime is not available on this system" unless runtime.available?
 
         runtime
       end

data/lib/proxy_pac_rb/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 # ProxyPacRb
 module ProxyPacRb
-  VERSION = '0.3.8'
+  VERSION = '0.4.0'
 end

data/lib/proxy_pac_rb.rb

@@ -4,32 +4,39 @@ require 'addressable/uri'
 require 'ipaddr'
 require 'thor'
 require 'uglifier'
-require 'open-uri'
 require 'optparse'
 require 'ostruct'
 require 'resolv'
 require 'time'
 
 require 'proxy_pac_rb/version'
+require 'proxy_pac_rb/main'
+require 'proxy_pac_rb/errors'
 require 'proxy_pac_rb/encoding'
 require 'proxy_pac_rb/exceptions'
-require 'proxy_pac_rb/file'
 require 'proxy_pac_rb/environment'
 require 'proxy_pac_rb/runtime'
 require 'proxy_pac_rb/runtimes/rubyracer'
 require 'proxy_pac_rb/runtimes/rubyrhino'
 require 'proxy_pac_rb/runtimes'
 require 'proxy_pac_rb/parser'
+require 'proxy_pac_rb/javascript'
 require 'proxy_pac_rb/proxy_pac_js'
 require 'proxy_pac_rb/proxy_pac'
 require 'proxy_pac_rb/proxy_pac_file'
 require 'proxy_pac_rb/proxy_pac_template'
-require 'proxy_pac_rb/javascript_compressor'
+require 'proxy_pac_rb/proxy_pac_compressor'
+require 'proxy_pac_rb/proxy_pac_dumper'
+require 'proxy_pac_rb/proxy_pac_loader'
+require 'proxy_pac_rb/proxy_pac_linter'
+require 'proxy_pac_rb/proxy_pac_parser'
 
 require 'proxy_pac_rb/cli_validator'
 
 require 'proxy_pac_rb/cli/shared'
 require 'proxy_pac_rb/cli/find_proxy'
+require 'proxy_pac_rb/cli/lint_proxy_pac'
+require 'proxy_pac_rb/cli/lint'
 require 'proxy_pac_rb/cli/compress_proxy_pac'
 require 'proxy_pac_rb/cli/compress'
 require 'proxy_pac_rb/cli/show'

data/proxy_pac_rb.gemspec

@@ -26,4 +26,6 @@ DESC
   spec.add_runtime_dependency 'addressable'
   spec.add_runtime_dependency 'activesupport'
   spec.add_runtime_dependency 'uglifier'
+
+  spec.required_ruby_version = '~> 2.0'
 end

data/spec/api_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+RSpec.describe ProxyPacRb do
+  subject(:proxy_pac) { instance_double('ProxyPac::ProxyPacFile') }
+
+  let(:content) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  let(:source) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  before :each do
+    allow(proxy_pac).to receive(:content).and_return(content)
+    allow(proxy_pac).to receive(:valid).and_return(true)
+    allow(proxy_pac).to receive(:source).and_return(source)
+    allow(proxy_pac).to receive(:type?).with(:string).and_return(true)
+  end
+
+  describe ProxyPacCompressor do
+    let(:compressor) { described_class.new }
+    let(:modified_content) { %(function FindProxyForURL(){return"DIRECT"}) }
+
+    before :each do
+      expect(proxy_pac).to receive(:content=).with(modified_content)
+    end
+
+    describe '#modify' do
+      context 'when string contains white paces' do
+        it { compressor.compress(proxy_pac) }
+      end
+    end
+  end
+
+  describe ProxyPacDumper do
+    let(:dumper) { ProxyPacDumper.new }
+    let(:destination) { absolute_path('proxy.pac') }
+
+    describe '#dump' do
+      before :each do
+        allow(proxy_pac).to receive(:source).and_return(source)
+      end
+
+      context 'when proxy pac is string' do
+        before :each do
+          in_current_dir do
+            dumper.dump(proxy_pac, type: :string)
+          end
+        end
+
+        it { expect(destination).to be_existing_file }
+        it { expect(destination).to have_content proxy_pac.content }
+      end
+
+      context 'when proxy pac is file' do
+        let(:source) { 'proxy.pac.in' }
+
+        before :each do
+          write_file(source, content)
+        end
+
+        before :each do
+          in_current_dir do
+            dumper.dump(proxy_pac, type: :template)
+          end
+        end
+
+        around :example do |example|
+          in_current_dir { example.call }
+        end
+
+        it { expect(destination).to be_existing_file }
+        it { expect(destination).to have_content proxy_pac.content }
+      end
+    end
+  end
+
+  describe ProxyPacLoader do
+    let(:loader) { ProxyPacLoader.new }
+    let(:type) { :string }
+
+    before :each do
+      allow(proxy_pac).to receive(:source).and_return(source)
+      allow(proxy_pac).to receive(:type=).with(type)
+    end
+
+    before :each do
+      expect(proxy_pac).to receive(:content=).with(content)
+    end
+
+    describe '#load' do
+      context 'when proxy pac is string' do
+        it { loader.load(proxy_pac) }
+      end
+
+      context 'when proxy pac is file' do
+        let(:file) { 'proxy.pac' }
+        let(:type) { :file }
+
+        before(:each) { allow(proxy_pac).to receive(:source).and_return(absolute_path(file)) }
+        before(:each) { write_file(file, content) }
+
+        it { loader.load(proxy_pac) }
+      end
+
+      context 'when proxy pac is url' do
+        let(:uri) { 'http://example.com/proxy.pac' }
+        let(:type) { :url }
+
+        before(:each) { allow(proxy_pac).to receive(:source).and_return(uri) }
+        before(:each) { stub_request(:get, 'http://example.com/proxy.pac').to_return(body: content) }
+
+        it { loader.load(proxy_pac) }
+      end
+    end
+  end
+
+  describe ProxyPacParser do
+    describe '#parse' do
+      let(:pac) { ProxyPacParser.new.parse(proxy_pac) }
+
+      context 'when is valid' do
+        it { expect(pac).to be_kind_of ProxyPac }
+      end
+
+      context 'when is valid' do
+        let(:content) do
+          <<-EOS.strip_heredoc.chomp
+          function FindProxyForURL(url, host) {
+           asdfasf $$ SDF
+          }
+          EOS
+        end
+
+        it { expect { pac }.to raise_error ParserError }
+      end
+    end
+  end
+
+  describe ProxyPacLinter do
+    describe '#lint' do
+      let(:linter) {  ProxyPacLinter.new(silent: true) }
+      let(:result) { true }
+
+      before(:each) do
+        expect(proxy_pac).to receive(:valid=).with(result)
+        allow(proxy_pac).to receive(:message=)
+      end
+
+      context 'when is valid' do
+        it { linter.lint(proxy_pac) }
+      end
+
+      context 'when is proxy.pac does not contain FindProxyForURL' do
+        let(:result) { false }
+        let(:content) { '' }
+        it { linter.lint(proxy_pac) }
+      end
+
+      context 'when is proxy.pac cannot be compiled' do
+        let(:result) { false }
+        let(:content) do
+          <<-EOS.strip_heredoc.chomp
+          function FindProxyForURL(url, host) {
+           asdfasf $$ SDF
+          }
+          EOS
+        end
+
+        it { linter.lint(proxy_pac) }
+      end
+    end
+  end
+end
+
+RSpec.describe ProxyPacFile do
+  subject(:proxy_pac) { ProxyPacFile.new source: source }
+
+  let(:source) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  describe '#valid?' do
+    context 'when is invalid' do
+      it { expect(proxy_pac).not_to be_valid }
+    end
+
+    context 'when is valid' do
+      before(:each) { proxy_pac.valid = true }
+
+      it { expect(proxy_pac).to be_valid }
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -2,41 +2,40 @@
 require 'spec_helper'
 
 describe ProxyPacRb::Parser do
-  before :each do
-    write_file 'sample.pac', <<-EOS.strip_heredoc
+  subject(:proxy_pac) { Parser.new(environment: environment).parse(source) }
+
+  let(:environment) { Environment.new }
+
+  let(:content) do
+    <<-EOS.strip_heredoc.chomp
       function FindProxyForURL(url, host) {
         return "DIRECT";
       }
     EOS
   end
 
-  let(:sample_pac) { absolute_path('sample.pac') }
+  let(:source) do
+    <<-EOS.strip_heredoc.chomp
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
 
-  context '.read' do
-    it 'should load a file from a path' do
-      pac = ProxyPacRb::Parser.new.read(sample_pac)
-      expect(pac).not_to be_nil
-    end
+  context 'when string is given' do
+    it { expect(proxy_pac).not_to be_nil }
   end
 
-  context '.source' do
-    let(:source) do
-      <<-JS.strip_heredoc
-        function FindProxyForURL(url, host) {
-          return "DIRECT";
-        }
-      JS
-    end
+  context 'when path is given' do
+    let(:source) { absolute_path('proxy.pac') }
+    before(:each) { write_file(source, content) }
 
-    it 'should load source' do
-      pac = ProxyPacRb::Parser.new.source(source)
-      expect(pac).not_to be_nil
-    end
+    it { expect(proxy_pac).not_to be_nil }
   end
 
-  context 'compile' do
-    it 'supports a changeable ip address' do
-      string = <<-EOS
+  context 'when ip address is given' do
+    let(:source) do
+      <<-EOS
       function FindProxyForURL(url, host) {
         if ( myIpAddress() == '127.0.0.2' ) {
           return "DIRECT";
@@ -45,18 +44,22 @@ describe ProxyPacRb::Parser do
         }
       }
       EOS
+    end
 
-      environment = ProxyPacRb::Environment.new(client_ip: '127.0.0.1')
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('PROXY localhost:8080')
+    context 'when ip is 127.0.0.1' do
+      let(:environment) { Environment.new(client_ip: '127.0.0.1') }
+      it { expect(proxy_pac.find('http://localhost')).to eq('PROXY localhost:8080') }
+    end
 
-      environment = ProxyPacRb::Environment.new(client_ip: '127.0.0.2')
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('DIRECT')
+    context 'when ip is  127.0.0.2' do
+      let(:environment) { Environment.new(client_ip: '127.0.0.2') }
+      it { expect(proxy_pac.find('http://localhost')).to eq('DIRECT') }
     end
+  end
 
-    it 'supports a changeable date' do
-      string = <<-EOS
+  context 'when date is given' do
+    let(:source) do
+      <<-EOS
       function FindProxyForURL(url, host) {
         if (weekdayRange("FRI", "SAT")) {
           return "PROXY localhost:8080";
@@ -65,18 +68,22 @@ describe ProxyPacRb::Parser do
         }
       }
       EOS
+    end
 
-      environment = Environment.new(time: Time.parse('2014-03-08 12:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('PROXY localhost:8080')
+    context 'when time is 2014-03-08 12:00' do
+      let(:environment) { Environment.new(time: Time.parse('2014-03-08 12:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('PROXY localhost:8080') }
+    end
 
-      environment = Environment.new(time: Time.parse('2014-03-06 12:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('DIRECT')
+    context 'when time is 2014-03-06 12:0' do
+      let(:environment) { Environment.new(time: Time.parse('2014-03-06 12:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('DIRECT') }
     end
+  end
 
-    it 'supports time range' do
-      string = <<-EOS
+  context 'when time range is used' do
+    let(:source) do
+      <<-EOS
       function FindProxyForURL(url, host) {
         if (timeRange(8, 18)) {
           return "PROXY localhost:8080";
@@ -85,18 +92,22 @@ describe ProxyPacRb::Parser do
         }
       }
       EOS
+    end
 
-      environment = ProxyPacRb::Environment.new(time: Time.parse('2014-03-06 12:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('PROXY localhost:8080')
+    context 'when time is 2014-03-06 12:00' do
+      let(:environment) { ProxyPacRb::Environment.new(time: Time.parse('2014-03-06 12:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('PROXY localhost:8080') }
+    end
 
-      environment = ProxyPacRb::Environment.new(time: Time.parse('2014-03-08 6:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('DIRECT')
+    context 'when time is 2014-03-08 6:00' do
+      let(:environment) { ProxyPacRb::Environment.new(time: Time.parse('2014-03-08 6:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('DIRECT') }
     end
+  end
 
-    it 'supports a date range' do
-      string = <<-EOS
+  context 'when date range is used' do
+    let(:source) do
+      <<-EOS
       function FindProxyForURL(url, host) {
         if (dateRange("JUL", "SEP")) {
           return "PROXY localhost:8080";
@@ -105,14 +116,16 @@ describe ProxyPacRb::Parser do
         }
       }
       EOS
+    end
 
-      environment = ProxyPacRb::Environment.new(time: Time.parse('2014-07-06 12:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('PROXY localhost:8080')
+    context 'when time is 2014-07-06 12:00' do
+      let(:environment) { ProxyPacRb::Environment.new(time: Time.parse('2014-07-06 12:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('PROXY localhost:8080') }
+    end
 
-      environment = ProxyPacRb::Environment.new(time: Time.parse('2014-03-08 6:00'))
-      file = ProxyPacRb::Parser.new(environment).source(string)
-      expect(file.find('http://localhost')).to eq('DIRECT')
+    context 'when time is 2014-03-08 6:00' do
+      let(:environment) { ProxyPacRb::Environment.new(time: Time.parse('2014-03-08 6:00')) }
+      it { expect(proxy_pac.find('http://localhost')).to eq('DIRECT') }
     end
   end
 end

data/spec/rack/proxy_pac_compressor_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'proxy_pac_rb/rack/proxy_pac_compressor'
+
+RSpec.describe ProxyPacRb::Rack::ProxyPacCompressor, type: :rack_test do
+  let(:compressed_content) { %(function FindProxyForURL(){return\"DIRECT\"}) }
+
+  before(:each) { get '/' }
+  subject(:body) { last_response.body }
+
+  context 'when valid proxy pac is given' do
+    let(:app) do
+      a = Class.new(Sinatra::Base) do
+        before do
+          content_type 'application/x-ns-proxy-autoconfig'
+        end
+
+        get '/' do
+          <<-EOS.strip_heredoc.chomp
+          function FindProxyForURL(url, host) {
+            return "DIRECT";
+          }
+          EOS
+        end
+      end
+
+      a.use ProxyPacRb::Rack::ProxyPacCompressor
+
+      a.new
+    end
+
+    it { expect(body).to eq compressed_content }
+  end
+
+  context 'when invalid proxy pac is given' do
+    let(:compressed_content) { %{Unexpected token: string (§$ )} }
+
+    let(:app) do
+      a = Class.new(Sinatra::Base) do
+        before do
+          content_type 'application/x-ns-proxy-autoconfig'
+        end
+
+        get '/' do
+          <<-EOS.strip_heredoc.chomp
+          function FindProxyForURL(url, host) {
+            return $"§$ "DIRECT";
+          }
+          EOS
+        end
+      end
+
+      a.use ProxyPacRb::Rack::ProxyPacCompressor
+
+      a.new
+    end
+
+    it { expect(body).to include compressed_content }
+  end
+end