proxy_pac_rb 0.0.2 → 0.0.3

data/lib/proxy_pac_rb/runtimes/rubyrhino.rb

@@ -1,77 +1,87 @@
 module ProxyPacRb
-  module Runtimes
-    class RubyRhinoRuntime
-      class Context
-        def initialize(source = "")
-          source = source.encode("UTF-8") if source.respond_to?(:encode)
+  class RubyRhinoRuntime < Runtime
+    class Context < Runtime::Context
+      def initialize(runtime, source = "")
+        source = encode(source)
 
-          @rhino_context = Rhino::Context.new
-          fix_memory_limit! @rhino_context
-          @rhino_context.eval(source)
-        end
+        self.context = ::Rhino::Context.new
+        fix_memory_limit! context
+        context.eval(source)
+      end
 
-        def include(mod)
-          (mod.methods - Module.methods).each do |name|
-            @rhino_context[name] = mod.method(name)
-          end
+      def exec(source, options = {})
+        source = encode(source)
+
+        if /\S/ =~ source
+          eval "(function(){#{source}})()", options
         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 Exceptions::ProgramError, e.message
-          end
+      def eval(source, options = {})
+        source = encode(source)
+
+        if /\S/ =~ source
+          unbox context.eval("(#{source})")
+        end
+      rescue ::Rhino::JSError => e
+        if e.message =~ /^syntax error/
+          raise RuntimeError, e.message
+        else
+          raise Exceptions::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
+      def call(properties, *args)
+        unbox context.eval(properties).call(*args)
+      rescue ::Rhino::JSError => e
+        if e.message == "syntax error"
+          raise RuntimeError, e.message
+        else
+          raise Exceptions::ProgramError, e.message
         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
+      def unbox(value)
+        case value = ::Rhino::to_ruby(value)
+        when Java::OrgMozillaJavascript::NativeFunction
+          nil
+        when Java::OrgMozillaJavascript::NativeObject
+          value.inject({}) do |vs, (k, v)|
+            case v
+            when Java::OrgMozillaJavascript::NativeFunction, ::Rhino::JS::Function
+              nil
             else
-              context.instance_eval { @native.setOptimizationLevel(-1) }
+              vs[k] = unbox(v)
             end
+            vs
           end
+        when Array
+          value.map { |v| unbox(v) }
+        else
+          value
+        end
       end
 
-      def name
-        "therubyrhino (Rhino)"
-      end
+      private
+        # Disables bytecode compiling which limits you to 64K scripts
+        def fix_memory_limit!(cxt)
+          if cxt.respond_to?(:optimization_level=)
+            cxt.optimization_level = -1
+          else
+            cxt.instance_eval { @native.setOptimizationLevel(-1) }
+          end
+        end
+    end
 
-      def compile(source)
-        Context.new(source)
-      end
+    def name
+      "therubyrhino (Rhino)"
+    end
 
-      def available?
-        require "rhino"
-        true
-      rescue LoadError
-        false
-      end
+    def available?
+      require "rhino"
+      true
+    rescue LoadError
+      false
     end
   end
 end

data/lib/proxy_pac_rb/version.rb

@@ -1,4 +1,4 @@
 #main ProxyPacRb
 module ProxyPacRb
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/proxy_pac_rb.gemspec

@@ -23,4 +23,7 @@ DESC
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| ::File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'addressable'
+  spec.add_runtime_dependency 'activesupport'
 end

data/script/acceptance_test

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+bundle exec cucumber
+bundle exec rspec spec/features

data/script/bootstrap

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+echo "Bootstrapping development environment for application.." >&2
+
+gem install bundler && bundle install

data/script/ci

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+bundle exec rake test:coveralls

data/script/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
+
+# Pull in all of the gems including those in the `test` group
+require 'bundler'
+Bundler.require :default, :test, :development, :therubyracer
+
+require 'irb'
+require 'irb/completion'
+require 'proxy_pac_rb'
+
+ARGV.clear
+IRB.start

data/script/release

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+bundle exec rake gem:release

data/script/unit_test

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+bundle exec rspec

data/spec/environment_spec.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPacRb::Environment do
+  let(:environment) do
+    Environment.new(my_ip_address: '127.0.0.1', time: Time.now)
+  end
+
+  describe "#isResolvable()" do
+    it "should return true for localhost" do
+      expect(environment.isResolvable("localhost")).to be_true
+    end
+
+    it "should return false for awidhaowuhuiuhiuug" do
+      expect(environment.isResolvable('asdfasdfasdfasdf')).to be_false
+    end
+  end
+
+  describe '#isPlainHostName' do
+    it 'returns true for google' do
+      result = environment.isPlainHostName('google')
+      expect(result).to be_true
+    end
+
+    it 'returns false for google.com' do
+      result = environment.isPlainHostName('google.com')
+      expect(result).to be_false
+    end
+  end
+
+  describe '#dnsDomainIs' do
+    it 'returns true for maps.google.com' do
+      result = environment.dnsDomainIs('maps.google.com', '.google.com')
+      expect(result).to be_true
+    end
+
+    it 'returns false for maps.ms.com' do
+      result = environment.dnsDomainIs('maps.ms.com', '.google.com')
+      expect(result).to be_false
+    end
+  end
+
+  describe '#localHostOrDomainIs' do
+    it 'returns true for maps.google.com' do
+      result = environment.localHostOrDomainIs('maps.google.com', 'maps.google.com')
+      expect(result).to be_true
+    end
+
+    it 'returns true for maps' do
+      result = environment.localHostOrDomainIs('maps', 'maps.google.com')
+      expect(result).to be_true
+    end
+
+    it 'returns false for maps.ms.com' do
+      result = environment.dnsDomainIs('maps.ms.com', '.google.com')
+      expect(result).to be_false
+    end
+  end
+
+  describe '#isInNet' do
+    it 'returns true for 127.0.0.1' do
+      result = environment.isInNet('127.0.0.1', '127.0.0.0', '255.255.255.0')
+      expect(result).to be_true
+    end
+
+    it 'returns false for 10.0.0.1' do
+      result = environment.isInNet('10.0.0.1', '127.0.0.0', '255.255.255.0')
+      expect(result).to be_false
+    end
+  end
+
+  describe '#dnsResolve' do
+    it 'returns the ip address for domain' do
+      ip   = '8.8.8.8'
+      name =  'google-public-dns-a.google.com'
+      expect(environment.dnsResolve(name)).to eq(ip)
+    end
+  end
+
+  describe '#MyIpAddress ' do
+    it 'returns the given ip address' do
+      ip = '127.0.0.1'
+      environment = Environment.new(my_ip_address: ip, time: Time.now)
+
+      expect(environment.MyIpAddress).to eq(ip)
+    end
+  end
+
+  describe '#dnsDomainLevels' do
+    it 'returns the count of domain levels (dots)' do
+      result = environment.dnsDomainLevels('maps.google.com')
+      expect(result).to eq(2)
+    end
+  end
+
+  describe '#shExpMatch' do
+    it 'returns true for maps.google.com' do
+      result = environment.shExpMatch('maps.google.com', '*.com')
+      expect(result).to be_true
+    end
+
+    it 'returns false for maps.ms.com' do
+      result = environment.shExpMatch('maps.ms.com', '*.de')
+      expect(result).to be_false
+    end
+  end
+
+  describe '#weekdayRange' do
+    let(:environment) { Environment.new(my_ip_address: '127.0.0.1', time: Time.parse('1991-08-25 12:00')) }
+
+    it 'returns true for SUN - MON' do
+      result = environment.weekdayRange("SUN", "MON")
+      expect(result).to be_true
+    end
+
+    it 'returns false for FR' do
+      result = environment.weekdayRange("FRI")
+      expect(result).to be_false
+    end
+
+    it 'fails if wd1 or wd2 are not valid, e.g. German SO for Sunday' do
+      expect {
+        environment.weekdayRange("SO")
+      }.to raise_error Exceptions::InvalidArgument
+    end
+
+  end
+
+  describe '#dateRange' do
+    let(:environment) { Environment.new(my_ip_address: '127.0.0.1', time: Time.parse('1991-08-25 12:00')) }
+
+    it 'returns true for JUL - SEP' do
+      result = environment.dateRange("JUL", "SEP")
+      expect(result).to be_true
+    end
+
+    it 'returns false for MAR' do
+      result = environment.dateRange("MAR")
+      expect(result).to be_false
+    end
+
+    it 'fails if range is not valid' do
+      expect {
+        environment.dateRange("SEPT")
+      }.to raise_error Exceptions::InvalidArgument
+    end
+  end
+
+  describe '#timeRange' do
+    let(:environment) { Environment.new(my_ip_address: '127.0.0.1', time: Time.parse('1991-08-25 12:00')) }
+
+    it 'returns true for 8 - 18h' do
+      result = environment.timeRange(8, 18)
+      expect(result).to be_true
+    end
+
+    it 'returns false for MAR' do
+      result = environment.timeRange(13,14)
+      expect(result).to be_false
+    end
+
+    it 'fails if range is not valid' do
+      expect {
+        environment.timeRange("SEPT")
+      }.to raise_error Exceptions::InvalidArgument
+    end
+  end
+
+  describe '#alert' do
+    it 'outputs msg' do
+      result = capture(:stderr) do
+        environment.alert('message')
+      end
+
+      expect(result.chomp).to eq('message')
+    end
+  end
+
+  describe '#prepare' do
+    it 'adds neccessary functions to source file' do
+      string = ''
+      environment.prepare(string)
+
+      %w[
+      MyIpAddress
+      weekdayRange
+      dateRange
+      timeRange
+      ].each { |f| expect(string).to include(f) }
+      
+    end
+  end
+end

data/spec/file_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe File do
+  let(:simple) do 
+    <<-EOS.strip_heredoc
+      function FindProxyForURL(url, host) {
+        return "DIRECT";
+      }
+    EOS
+  end
+
+  let(:client_ip_pac) do 
+    <<-EOS.strip_heredoc
+      function FindProxyForURL(url, host) {
+        if ( MyIpAddress() == '127.0.0.2' ) {
+          return "DIRECT";
+        } else {
+          return "PROXY localhost:8080";
+        }
+      }
+    EOS
+  end
+
+  let(:time_pac) do 
+    <<-EOS.strip_heredoc
+      function FindProxyForURL(url, host) {
+        if ( timeRange(8, 18) ) {
+          return "PROXY localhost:8080";
+        } else {
+          return "DIRECT";
+        }
+      }
+    EOS
+  end
+
+  context '#find' do
+    it 'returns result of proxy.pac' do
+      javascript = double('javascript')
+      expect(javascript).to receive(:call).with("FindProxyForURL", "http://localhost", "localhost")
+
+      ProxyPacRb::File.new(javascript).find("http://localhost")
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ProxyPacRb::Parser do
+  let(:sample_pac) do 
+    create_file 'sample.pac', <<-EOS.strip_heredoc
+      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
+  end
+
+  context ".source" do
+    let(:source) do <<-JS.strip_heredoc
+        function FindProxyForURL(url, host) {
+          return "DIRECT";
+        }
+      JS
+    end
+
+    it "should load source" do
+      pac = ProxyPacRb::Parser.new.source(source)
+      expect(pac).not_to be_nil
+    end
+  end
+
+  context 'compile' do
+    it 'supports a changeable ip address' do
+      string = <<-EOS
+      function FindProxyForURL(url, host) {
+        if ( MyIpAddress() == '127.0.0.2' ) {
+          return "DIRECT";
+        } else {
+          return "PROXY localhost:8080";
+        }
+      }
+      EOS
+
+      environment = ProxyPacRb::Environment.new(my_ip_address: '127.0.0.1')
+      file = ProxyPacRb::Parser.new(environment).source(string)
+      expect(file.find('http://localhost')).to eq('PROXY localhost:8080')
+
+      environment = ProxyPacRb::Environment.new(my_ip_address: '127.0.0.2')
+      file = ProxyPacRb::Parser.new(environment).source(string)
+      expect(file.find('http://localhost')).to eq('DIRECT')
+    end
+
+    it 'supports a changeable date' do
+      string = <<-EOS
+      function FindProxyForURL(url, host) {
+        if (weekdayRange("FRI", "SAT")) {
+          return "PROXY localhost:8080";
+        } else {
+          return "DIRECT";
+        }
+      }
+      EOS
+
+      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')
+
+      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')
+    end
+
+    it 'supports time range' do
+      string = <<-EOS
+      function FindProxyForURL(url, host) {
+        if (timeRange(8, 18)) {
+          return "PROXY localhost:8080";                                                                                                          
+        } else {
+          return "DIRECT";
+        }
+      }
+      EOS
+      
+      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')
+      
+      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')
+    end
+
+    it 'supports a date range' do
+      string = <<-EOS
+      function FindProxyForURL(url, host) {
+        if (dateRange("JUL", "SEP")) {
+          return "PROXY localhost:8080";                                                                                                          
+        } else {
+          return "DIRECT";
+        }
+      }
+      EOS
+      
+      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')
+      
+      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')
+    end
+
+  end
+end