pac 1.0.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Samuel Kadolph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# pac
+
+pac is a gem to parse [proxy auto-config](http://en.wikipedia.org/wiki/Proxy_auto-config) files.
+pac uses a JavaScript runtime to evaulate a proxy auto-config file the same way a browser does to determine what proxy (if
+any at all) should a program use to connect to a server. You must install on of the supported JavaScript runtimes:
+therubyracer, therubyrhino, johnson or mustang.
+
+Big thanks to [sstephenson](https://github.com/sstephenson)'s [execjs](https://github.com/sstephenson/execjs) for the
+runtime wrapper code.
+
+## Installing
+
+### Recommended
+
+```
+gem install pac
+```
+
+### Edge
+
+```
+git clone https://github.com/samuelkadolph/ruby-pac
+cd ruby-pac && rake install
+```
+
+## Requirements
+
+After installing the `pac` gem you must install a JavaScript runtime. Compatible runtimes include:
+
+* [therubyracer](https://rubygems.org/gems/therubyracer) Google V8 embedded within Ruby
+* [therubyrhino](https://rubygems.org/gems/therubyrhino/) Mozilla Rhino embedded within JRuby
+* [johnson](https://rubygems.org/gems/johnson/) Mozilla SpiderMonkey embedded within Ruby 1.8
+* [mustang](https://rubygems.org/gems/mustang/) Mustang V8 embedded within Ruby
+
+## Usage
+
+### Command Line
+
+```
+parsepac https://github.com/downloads/samuelkadolph/ruby-pac/sample.pac https://github.com # => "PROXY proxy:8080"
+parsepac https://github.com/downloads/samuelkadolph/ruby-pac/sample.pac http://ruby-lang.com # => "PROXY proxy:8080; DIRECT"
+parsepac https://github.com/downloads/samuelkadolph/ruby-pac/sample.pac http://samuel.kadolph.com # => "DIRECT"
+```
+
+### Ruby
+
+```ruby
+require "rubygems"
+require "pac"
+
+pac = PAC.load("https://github.com/downloads/samuelkadolph/ruby-pac/sample.pac")
+pac.find("https://github.com") # => "PROXY proxy:8080"
+pac.find("http://ruby-lang.com") # => "PROXY proxy:8080; DIRECT"
+pac.find("http://samuel.kadolph.com") # => "DIRECT"
+
+pac = PAC.read("sample.pac")
+
+pac = PAC.source <<-JS
+  function FindProxyForURL(url, host) {
+    return "DIRECT";
+  }
+JS
+pac.find("http://localhost") # => "DIRECT"
+```
+
+## Available JavaScript Functions
+
+* isPlainHostName(host)
+* dnsDomainIs(host, domain)
+* localHostOrDomainIs(host, hostdom)
+* isResolvable(host)
+* isInNet(host, pattern, mask)
+* dnsResolve(host)
+* myIpAddress()
+* dnsDomainLevels(host)
+* shExpMatch(str, shexp)
+* weekdayRange(wd1, wd2, gmt)
+* dateRange(*args)
+* timeRange(*args)
+
+## Developers
+
+### Contributing
+
+If you want to contribute: fork, branch & pull request.
+
+### Running Tests
+
+```
+bundle install
+rake test
+rake test:rubyracer
+```

data/bin/parsepac

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if ARGV.size < 2
+  puts "usage: parsepac pac-url-or-file url-to-test"
+  exit 1
+else
+  require "pac"
+  puts PAC.load(ARGV.shift).find(ARGV.shift)
+  exit 0
+end

data/lib/pac.rb

@@ -0,0 +1,40 @@
+require "rubygems"
+
+module PAC
+  require "pac/version"
+  require "pac/file"
+  require "pac/runtimes"
+
+  class Error < StandardError
+  end
+  class RuntimeError < Error
+  end
+  class ProgramError < Error
+  end
+  class RuntimeUnavailable < RuntimeError
+  end
+
+  class << self
+    attr_reader :runtime
+
+    def runtime=(runtime)
+      raise RuntimeUnavailable, "#{runtime.name} is unavailable on this system" unless runtime.available?
+      @runtime = runtime
+    end
+
+    def load(url, options = {})
+      require "open-uri"
+      File.new(open(url, { :proxy => false }.merge(options)).read)
+    end
+
+    def read(file)
+      File.new(::File.read(file))
+    end
+
+    def source(source)
+      File.new(source)
+    end
+  end
+
+  self.runtime = Runtimes.autodetect
+end

data/lib/pac/file.rb

@@ -0,0 +1,21 @@
+require "uri"
+
+module PAC
+  require "pac/functions"
+
+  class File
+    attr_reader :source, :context
+
+    def initialize(source)
+      @source = source.dup.freeze
+      @context = PAC.runtime.compile(@source)
+      @context.include Functions
+    end
+
+    def find(url)
+      uri = URI.parse(url)
+      raise ArgumentError, "url is missing host" unless uri.host
+      context.call("FindProxyForURL", url, uri.host)
+    end
+  end
+end

data/lib/pac/functions.rb

@@ -0,0 +1,132 @@
+require "ipaddr"
+require "resolv"
+require "time"
+
+module PAC
+  module Functions
+    DAYS = { "MON" => 1, "TUE" => 2, "WED" => 3, "THU" => 4, "FRI" => 5, "SAT" => 6, "SUN" => 7 }
+    MONTHS = { "JAN" => 1, "FEB" => 2, "MAR" => 3, "APR" => 4, "MAY" => 5, "JUN" => 6,
+               "JUL" => 7, "AUG" => 8, "SEP" => 9, "OCT" => 10, "NOV" => 11, "DEC" => 12 }
+
+    class << self
+      def isPlainHostName(host)
+        not host.include? "."
+      end
+
+      def dnsDomainIs(host, domain)
+        host.end_with? domain
+      end
+
+      def localHostOrDomainIs(host, hostdom)
+        host == hostdom or hostdom.include? host
+      end
+
+      def isResolvable(host)
+        !!resolve_host(host)
+      end
+
+      def isInNet(host, pattern, mask)
+        IPAddr.new(pattern).mask(mask).include? resolve_host(host)
+      end
+
+      def dnsResolve(host)
+        resolve_host(host)
+      end
+
+      def myIpAddress()
+        resolve_host(Socket.gethostname)
+      end
+
+      def dnsDomainLevels(host)
+        host.scan(".").size
+      end
+
+      def shExpMatch(str, shexp)
+        ::File.fnmatch(shexp, str)
+      end
+
+      def weekdayRange(wd1, wd2 = nil, gmt = nil)
+        time = Time.now
+        time = time.utc if gmt == "GMT"
+
+        (DAYS[wd1]..DAYS[wd2 || wd1]).include? time.wday
+      end
+
+      def dateRange(*args)
+        time = Time.now
+        time = time.utc if args.last == "GMT" and args.pop
+
+        case args.size
+        when 1
+          check_date_part(time, args[0])
+        when 2
+          check_date_part(time, args[0]..args[1])
+        when 4
+          check_date_part(time, args[0]..args[2]) and
+          check_date_part(time, args[1]..args[3])
+        when 6
+          check_date_part(time, args[0]..args[3]) and
+          check_date_part(time, args[1]..args[4]) and
+          check_date_part(time, args[2]..args[5])
+        else
+          raise ArgumentError, "wrong number of arguments"
+        end
+      end
+
+      def timeRange(*args)
+        time = Time.now
+        time = time.utc if args.last == "GMT" and args.pop
+
+        case args.size
+        when 1
+          time.hour == args[0]
+        when 2
+          (args[0]..args[1]).include? time.hour
+        when 4
+          (args[0]..args[2]).include? time.hour and
+          (args[1]..args[3]).include? time.min
+        when 6
+          (args[0]..args[3]).include? time.hour and
+          (args[1]..args[4]).include? time.min  and
+          (args[2]..args[5]).include? time.sec
+        else
+          raise ArgumentError, "wrong number of arguments"
+        end
+      end
+
+      private
+        def check_date_part(time, part, operation = :==)
+          case part
+          when String
+            time.month.send(operation, MONTHS[part])
+          when Integer
+            if part < 100
+              time.day.send(operation, part)
+            else
+              time.year.send(operation, part)
+            end
+          when Range
+            check_date_part(time, part.begin, :>=) and check_date_part(time, part.end, :<=)
+          else
+            raise ArgumentError, "wrong type"
+          end
+        end
+
+        def resolve_host(host)
+          Resolv.each_address(host) do |address|
+            begin
+              return address if IPAddr.new(address).ipv4?
+            rescue ArgumentError
+            end
+          end
+
+          # We couldn't find an IPv4 address for the host
+          nil
+        rescue Resolv::ResolvError, NoMethodError
+          # Have to rescue NoMethodError because jruby has a bug with non existant hostnames
+          # See http://jira.codehaus.org/browse/JRUBY-6054
+          nil
+        end
+    end
+  end
+end

data/lib/pac/runtimes.rb

@@ -0,0 +1,45 @@
+module PAC
+  module Runtimes
+    require "pac/runtimes/rubyracer"
+    require "pac/runtimes/rubyrhino"
+    require "pac/runtimes/johnson"
+    require "pac/runtimes/mustang"
+
+    RubyRacer = RubyRacerRuntime.new
+    RubyRhino = RubyRhinoRuntime.new
+    Johnson = JohnsonRuntime.new
+    Mustang = MustangRuntime.new
+
+    class << self
+      def autodetect
+        from_environment || best_available || raise(RuntimeUnavailable, "Could not find a JavaScript runtime. See https://github.com/samuelkadolph/ruby-pac for a list of runtimes.")
+      end
+
+      def from_environment
+        if name = ENV["JS_RUNTIME"]
+          if runtime = const_get(name)
+            if runtime.available?
+              runtime if runtime.available?
+            else
+              raise RuntimeUnavailable, "#{runtime.name} runtime is not available on this system"
+            end
+          elsif !name.empty?
+            raise RuntimeUnavailable, "#{name} runtime is not defined"
+          end
+        end
+      end
+
+      def best_available
+        runtimes.find(&:available?)
+      end
+
+      def runtimes
+        @runtimes ||= [RubyRacer, RubyRhino, Johnson, Mustang]
+      end
+    end
+  end
+
+  def self.runtimes
+    Runtimes.runtimes
+  end
+end

data/lib/pac/runtimes/johnson.rb

@@ -0,0 +1,86 @@
+module PAC
+  module Runtimes
+    class JohnsonRuntime
+      class Context
+        def initialize(source = "")
+          @runtime = ::Johnson::Runtime.new
+          @runtime.evaluate(source)
+        end
+
+        def include(mod)
+          (mod.methods - Module.methods).each do |name|
+            @runtime[name] = mod.method(name)
+          end
+        end
+
+        def call(properties, *args)
+          unbox @runtime.evaluate(properties).call(*args)
+        rescue Johnson::Error => e
+          if syntax_error?(e)
+            raise RuntimeError, e.message
+          else
+            raise ProgramError, e.message
+          end
+        end
+
+        def unbox(value)
+          case
+          when function?(value)
+            nil
+          when string?(value)
+            value.respond_to?(:force_encoding) ? value.force_encoding("UTF-8") : value
+          when array?(value)
+            value.map { |v| unbox(v) }
+          when object?(value)
+            value.inject({}) do |vs, (k, v)|
+              vs[k] = unbox(v) unless function?(v)
+              vs
+            end
+          else
+            value
+          end
+        end
+
+        private
+          def syntax_error?(error)
+            error.message =~ /^syntax error at /
+          end
+
+          def function?(value)
+            value.respond_to?(:function?) && value.function?
+          end
+
+          def string?(value)
+            value.is_a?(String)
+          end
+
+          def array?(value)
+            array_test.call(value)
+          end
+
+          def object?(value)
+            value.respond_to?(:inject)
+          end
+
+          def array_test
+            @array_test ||= @runtime.evaluate("(function(a) { return a instanceof [].constructor})")
+          end
+      end
+
+      def name
+        "Johnson (SpiderMonkey)"
+      end
+
+      def compile(source)
+        Context.new(source)
+      end
+
+      def available?
+        require "johnson"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/pac/runtimes/mustang.rb

@@ -0,0 +1,60 @@
+module PAC
+  module Runtimes
+    class MustangRuntime
+      class Context
+        def initialize(source = "")
+          source = source.encode("UTF-8") if source.respond_to?(:encode)
+
+          @v8_context = ::Mustang::Context.new
+          @v8_context.eval(source)
+        end
+
+        def include(mod)
+          (mod.methods - Module.methods).each do |name|
+            @v8_context[name] = mod.method(name)
+          end
+        end
+
+        def call(properties, *args)
+          unbox @v8_context.eval(properties).call(*args)
+        rescue NoMethodError => e
+          raise ProgramError, e.message
+        end
+
+        def unbox(value)
+          case value
+          when ::Mustang::V8::Array
+            value.map { |v| unbox(v) }
+          when ::Mustang::V8::Boolean
+            value.to_bool
+          when ::Mustang::V8::NullClass, ::Mustang::V8::UndefinedClass
+            nil
+          when ::Mustang::V8::Function
+            nil
+          when ::Mustang::V8::SyntaxError
+            raise RuntimeError, value.message
+          when ::Mustang::V8::Error
+            raise ProgramError, value.message
+          else
+            value.respond_to?(:delegate) ? value.delegate : value
+          end
+        end
+      end
+
+      def name
+        "Mustang (V8)"
+      end
+
+      def compile(source)
+        Context.new(source)
+      end
+
+      def available?
+        require "mustang"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/pac/runtimes/rubyracer.rb

@@ -0,0 +1,87 @@
+module PAC
+  module Runtimes
+    class RubyRacerRuntime
+      class Context
+        def initialize(source = "")
+          source = source.encode("UTF-8") if source.respond_to?(:encode)
+
+          lock do
+            @v8_context = V8::Context.new
+            @v8_context.eval(source)
+          end
+        end
+
+        def include(mod)
+          (mod.methods - Module.methods).each do |name|
+            @v8_context[name] = mod.method(name)
+          end
+        end
+
+        def call(properties, *args)
+          lock do
+            begin
+              unbox @v8_context.eval(properties).call(*args)
+            rescue ::V8::JSError => e
+              if e.value["name"] == "SyntaxError"
+                raise RuntimeError, e.message
+              else
+                raise ProgramError, e.message
+              end
+            end
+          end
+        end
+
+        def unbox(value)
+          case value
+          when ::V8::Function
+            nil
+          when ::V8::Array
+            value.map { |v| unbox(v) }
+          when ::V8::Object
+            value.inject({}) do |vs, (k, v)|
+              vs[k] = unbox(v) unless v.is_a?(::V8::Function)
+              vs
+            end
+          when String
+            value.respond_to?(:force_encoding) ? value.force_encoding("UTF-8") : value
+          else
+            value
+          end
+        end
+
+        private
+          def lock
+            result, exception = nil, nil
+            V8::C::Locker() do
+              begin
+                result = yield
+              rescue Exception => e
+                exception = e
+              end
+            end
+
+            if exception
+              raise exception
+            else
+              result
+            end
+          end
+      end
+
+      def name
+        "therubyracer (V8)"
+      end
+
+      def compile(source)
+        Context.new(source)
+      end
+
+      def available?
+        require "v8"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/pac/runtimes/rubyrhino.rb

@@ -0,0 +1,77 @@
+module PAC
+  module Runtimes
+    class RubyRhinoRuntime
+      class Context
+        def initialize(source = "")
+          source = source.encode("UTF-8") if source.respond_to?(:encode)
+
+          @rhino_context = Rhino::Context.new
+          fix_memory_limit! @rhino_context
+          @rhino_context.eval(source)
+        end
+
+        def include(mod)
+          (mod.methods - Module.methods).each do |name|
+            @rhino_context[name] = mod.method(name)
+          end
+        end
+
+        def call(properties, *args)
+          unbox @rhino_context.eval(properties).call(*args)
+        rescue ::Rhino::JavascriptError => e
+          if e.message == "syntax error"
+            raise RuntimeError, e.message
+          else
+            raise ProgramError, e.message
+          end
+        end
+
+        def unbox(value)
+          case value = ::Rhino::To.ruby(value)
+          when ::Rhino::NativeFunction
+            nil
+          when ::Rhino::NativeObject
+            value.inject({}) do |vs, (k, v)|
+              case v
+              when ::Rhino::NativeFunction, ::Rhino::J::Function
+                nil
+              else
+                vs[k] = unbox(v)
+              end
+              vs
+            end
+          when Array
+            value.map { |v| unbox(v) }
+          else
+            value
+          end
+        end
+
+        private
+          # Disables bytecode compiling which limits you to 64K scripts
+          def fix_memory_limit!(context)
+            if context.respond_to?(:optimization_level=)
+              context.optimization_level = -1
+            else
+              context.instance_eval { @native.setOptimizationLevel(-1) }
+            end
+          end
+      end
+
+      def name
+        "therubyrhino (Rhino)"
+      end
+
+      def compile(source)
+        Context.new(source)
+      end
+
+      def available?
+        require "rhino"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/pac/test_helper.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "pac"
+require "minitest/autorun"
+require "minitest/spec"

data/lib/pac/version.rb

@@ -0,0 +1,3 @@
+module PAC
+  VERSION = "1.0.0"
+end

data/test/pac/functions_test.rb

@@ -0,0 +1,13 @@
+require "pac/test_helper"
+
+describe PAC::Functions do
+  describe "isResolvable()" do
+    it "should return true for localhost" do
+      PAC::Functions.isResolvable("localhost").must_equal true
+    end
+
+    it "should return false for awidhaowuhuiuhiuug" do
+      PAC::Functions.isResolvable("awidhaowuhuiuhiuug").must_equal false
+    end
+  end
+end

data/test/pac_test.rb

@@ -0,0 +1,39 @@
+require "pac/test_helper"
+
+describe PAC do
+  describe "read" do
+    before do
+      @path = File.expand_path("../files/sample.pac", __FILE__)
+    end
+
+    it "should load a file from a path" do
+      pac = PAC.read(@path)
+      pac.wont_be_nil
+    end
+
+    it "should return DIRECT for a url" do
+      pac = PAC.read(@path)
+      pac.find("http://localhost").must_equal "DIRECT"
+    end
+  end
+
+  describe "source" do
+    before do
+      @source = <<-JS
+        function FindProxyForURL(url, host) {
+          return "DIRECT";
+        }
+      JS
+    end
+
+    it "should load source" do
+      pac = PAC.source(@source)
+      pac.wont_be_nil
+    end
+
+    it "should return DIRECT for a url" do
+      pac = PAC.source(@source)
+      pac.find("http://localhost").must_equal "DIRECT"
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: pac
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Kadolph
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70297018438300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *70297018438300
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70297018437400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :development
+  prerelease: false
+  version_requirements: *70297018437400
+description: ! 'pac uses a JavaScript runtime to evaulate a proxy auto-config file
+  the same way a browser does to determine what proxy (if
+
+  any at all) should a program use to connect to a server. You must install on of
+  the supported JavaScript runtimes:
+
+  therubyracer, therubyrhino, johnson or mustang.
+
+'
+email:
+- samuel@kadolph.com
+executables:
+- parsepac
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/parsepac
+- lib/pac/file.rb
+- lib/pac/functions.rb
+- lib/pac/runtimes/johnson.rb
+- lib/pac/runtimes/mustang.rb
+- lib/pac/runtimes/rubyracer.rb
+- lib/pac/runtimes/rubyrhino.rb
+- lib/pac/runtimes.rb
+- lib/pac/test_helper.rb
+- lib/pac/version.rb
+- lib/pac.rb
+- LICENSE
+- README.md
+- test/pac/functions_test.rb
+- test/pac_test.rb
+homepage: https://github.com/samuelkadolph/ruby-pac
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: pac is a gem to parse proxy auto-config files.
+test_files:
+- test/pac/functions_test.rb
+- test/pac_test.rb