proxy_pac_rb 0.0.2 → 0.0.3

data/lib/proxy_pac_rb/proxy_pac_js.rb

@@ -0,0 +1,194 @@
+# encoding: utf-8
+module ProxyPacRb
+  class ProxyPacJs
+    class << self
+      def my_ip_address_template(value)
+        <<-EOS.strip_heredoc
+          function MyIpAddress() {
+            return "#{value}";
+          }
+        EOS
+      end
+
+
+      # taken from  releases-mozilla-release / netwerk / base / src / ProxyAutoConfig.cpp @ bitbucket.org
+      # https://bitbucket.org/mozilla/releases-mozilla-release/raw/dece38633cf1adcab2071d69fea264580d24cc9e/netwerk/base/src/ProxyAutoConfig.cpp
+      def time_variables
+        <<-EOS.strip_heredoc
+        var wdays = {SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6};
+        var months = {JAN: 0, FEB: 1, MAR: 2, APR: 3, MAY: 4, JUN: 5, JUL: 6, AUG: 7, SEP: 8, OCT: 9, NOV: 10, DEC: 11};
+        EOS
+      end
+
+      def week_day_range_template(value = nil)
+        value = %Q{"#{value}"} if value
+
+        <<-EOS.strip_heredoc
+        function weekdayRange() {
+            function getDay(weekday) {
+                if (weekday in wdays) {
+                    return wdays[weekday];
+                }
+                return -1;
+            }
+            var date = new Date(#{value});
+            var argc = arguments.length;
+            var wday;
+            if (argc < 1)
+                return false;
+            if (arguments[argc - 1] == 'GMT') {
+                argc--;
+                wday = date.getUTCDay();
+            } else {
+                wday = date.getDay();
+            }
+            var wd1 = getDay(arguments[0]);
+            var wd2 = (argc == 2) ? getDay(arguments[1]) : wd1;
+            return (wd1 == -1 || wd2 == -1) ? false
+                                            : (wd1 <= wday && wday <= wd2);
+        }
+        EOS
+      end
+
+      def date_range_template(value = nil)
+        value = %Q{"#{value}"} if value
+
+        <<-EOS.strip_heredoc
+        function dateRange() {
+            function getMonth(name) {
+                if (name in months) {
+                    return months[name];
+                }
+                return -1;
+            }
+            var date = new Date(#{value});
+            var argc = arguments.length;
+            if (argc < 1) {
+                return false;
+            }
+            var isGMT = (arguments[argc - 1] == 'GMT');
+
+            if (isGMT) {
+                argc--;
+            }
+            // function will work even without explict handling of this case
+            if (argc == 1) {
+                var tmp = parseInt(arguments[0]);
+                if (isNaN(tmp)) {
+                    return ((isGMT ? date.getUTCMonth() : date.getMonth()) ==
+                             getMonth(arguments[0]));
+                } else if (tmp < 32) {
+                    return ((isGMT ? date.getUTCDate() : date.getDate()) == tmp);
+                } else { 
+                    return ((isGMT ? date.getUTCFullYear() : date.getFullYear()) ==
+                             tmp);
+                }
+            }
+            var year = date.getFullYear();
+            var date1, date2;
+            date1 = new Date(year,  0,  1,  0,  0,  0);
+            date2 = new Date(year, 11, 31, 23, 59, 59);
+            var adjustMonth = false;
+            for (var i = 0; i < (argc >> 1); i++) {
+                var tmp = parseInt(arguments[i]);
+                if (isNaN(tmp)) {
+                    var mon = getMonth(arguments[i]);
+                    date1.setMonth(mon);
+                } else if (tmp < 32) {
+                    adjustMonth = (argc <= 2);
+                    date1.setDate(tmp);
+                } else {
+                    date1.setFullYear(tmp);
+                }
+            }
+            for (var i = (argc >> 1); i < argc; i++) {
+                var tmp = parseInt(arguments[i]);
+                if (isNaN(tmp)) {
+                    var mon = getMonth(arguments[i]);
+                    date2.setMonth(mon);
+                } else if (tmp < 32) {
+                    date2.setDate(tmp);
+                } else {
+                    date2.setFullYear(tmp);
+                }
+            }
+            if (adjustMonth) {
+                date1.setMonth(date.getMonth());
+                date2.setMonth(date.getMonth());
+            }
+            if (isGMT) {
+            var tmp = date;
+                tmp.setFullYear(date.getUTCFullYear());
+                tmp.setMonth(date.getUTCMonth());
+                tmp.setDate(date.getUTCDate());
+                tmp.setHours(date.getUTCHours());
+                tmp.setMinutes(date.getUTCMinutes());
+                tmp.setSeconds(date.getUTCSeconds());
+                date = tmp;
+            }
+            return ((date1 <= date) && (date <= date2));
+        }
+        EOS
+      end
+
+      def time_range_template(value = nil)
+        value = %Q{"#{value}"} if value
+
+        <<-EOS.strip_heredoc
+        function timeRange() {
+            var argc = arguments.length;
+            var date = new Date(#{value});
+            var isGMT= false;
+
+            if (argc < 1) {
+                return false;
+            }
+            if (arguments[argc - 1] == 'GMT') {
+                isGMT = true;
+                argc--;
+            }
+
+            var hour = isGMT ? date.getUTCHours() : date.getHours();
+            var date1, date2;
+            date1 = new Date();
+            date2 = new Date();
+
+            if (argc == 1) {
+                return (hour == arguments[0]);
+            } else if (argc == 2) {
+                return ((arguments[0] <= hour) && (hour <= arguments[1]));
+            } else {
+                switch (argc) {
+                case 6:
+                    date1.setSeconds(arguments[2]);
+                    date2.setSeconds(arguments[5]);
+                case 4:
+                    var middle = argc >> 1;
+                    date1.setHours(arguments[0]);
+                    date1.setMinutes(arguments[1]);
+                    date2.setHours(arguments[middle]);
+                    date2.setMinutes(arguments[middle + 1]);
+                    if (middle == 2) {
+                        date2.setSeconds(59);
+                    }
+                    break;
+                default:
+                  throw 'timeRange: bad number of arguments'
+                }
+            }
+
+            if (isGMT) {
+                date.setFullYear(date.getUTCFullYear());
+                date.setMonth(date.getUTCMonth());
+                date.setDate(date.getUTCDate());
+                date.setHours(date.getUTCHours());
+                date.setMinutes(date.getUTCMinutes());
+                date.setSeconds(date.getUTCSeconds());
+            }
+            return ((date1 <= date) && (date <= date2));
+        }
+        EOS
+      end
+    end
+  end
+end

data/lib/proxy_pac_rb/runtime.rb

@@ -0,0 +1,61 @@
+module ProxyPacRb
+  # Abstract base class for runtimes
+  class Runtime
+    class Context
+      include Encoding
+
+      attr_accessor :context
+
+      def include(environment)
+        environment.available_methods.each do |name| 
+          context[name] = environment.method(name)
+        end
+      end
+
+      def initialize(runtime, source = "")
+      end
+
+      def exec(source, options = {})
+        fail NotImplementedError
+      end
+
+      def eval(source, options = {})
+        fail NotImplementedError
+      end
+
+      def call(properties, *args)
+        fail NotImplementedError
+      end
+    end
+
+    def name
+      fail NotImplementedError
+    end
+
+    def context_class
+      self.class::Context
+    end
+
+    def exec(source)
+      context = context_class.new(self)
+      context.exec(source)
+    end
+
+    def eval(source)
+      context = context_class.new(self)
+      context.eval(source)
+    end
+
+    def compile(source)
+      context_class.new(self, source)
+    end
+
+    def deprecated?
+      false
+    end
+
+    def available?
+      fail NotImplementedError
+    end
+  end
+end

data/lib/proxy_pac_rb/runtimes.rb

@@ -5,7 +5,13 @@ module ProxyPacRb
 
     class << self
       def autodetect
-        from_environment || best_available || fail(Exceptions::RuntimeUnavailable, "Could not find a JavaScript runtime. See https://github.com/dg-vrnetze/proxy_pac_rb for a list of runtimes.")
+        from_environment || best_available ||
+          fail(Exceptions::RuntimeUnavailable, "Could not find a JavaScript runtime. " +
+                "See https://github.com/sstephenson/execjs for a list of available runtimes.")
+      end
+
+      def best_available
+        runtimes.reject(&:deprecated?).find(&:available?)
       end
 
       def from_environment
@@ -22,17 +28,20 @@ module ProxyPacRb
         end
       end
 
-      def best_available
-        runtimes.find(&:available?)
+      def names
+        @names ||= constants.inject({}) { |h, name| h.merge(const_get(name) => name) }.values
       end
 
       def runtimes
-        @runtimes ||= [RubyRacer, RubyRhino]
+        @runtimes ||= [
+          RubyRacer,
+          RubyRhino,
+        ]
       end
     end
-  end
 
-  def self.runtimes
-    Runtimes.runtimes
+    def runtimes
+      Runtimes.runtimes
+    end
   end
 end

data/lib/proxy_pac_rb/runtimes/rubyracer.rb

@@ -1,87 +1,103 @@
 module ProxyPacRb
-  module Runtimes
-    class RubyRacerRuntime
-      class Context
-        def initialize(source = "")
-          source = source.encode("UTF-8") if source.respond_to?(:encode)
+  class RubyRacerRuntime < Runtime
+    class Context < Runtime::Context
+      def initialize(runtime, source = "", environment = nil)
+        source = encode(source)
 
-          lock do
-            @v8_context = V8::Context.new
-            @v8_context.eval(source)
-          end
+        lock do
+          self.context = ::V8::Context.new
+          context.eval(source)
         end
+      end
 
-        def include(mod)
-          (mod.methods - Module.methods).each do |name|
-            @v8_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)
+      def eval(source, options = {})
+        source = encode(source)
+
+        if /\S/ =~ source
           lock do
             begin
-              unbox @v8_context.eval(properties).call(*args)
+              unbox context.eval("(#{source})")
             rescue ::V8::JSError => e
               if e.value["name"] == "SyntaxError"
-                raise RuntimeError, e.message
+                fail RuntimeError, e.value.to_s
               else
-                raise Exceptions::ProgramError, e.message
+                raise Exceptions::ProgramError, e.value.to_s
               end
             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
+      def call(properties, *args)
+        lock do
+          begin
+            unbox context.eval(properties).call(*args)
+          rescue ::V8::JSError => e
+            if e.value["name"] == "SyntaxError"
+              raise RuntimeError, e.value.to_s
+            else
+              raise Exceptions::ProgramError, e.value.to_s
             end
-          when String
-            value.respond_to?(:force_encoding) ? value.force_encoding("UTF-8") : value
-          else
-            value
           end
         end
+      end
 
-        private
-          def lock
-            result, exception = nil, nil
-            V8::C::Locker() do
-              begin
-                result = yield
-              rescue Exception => e
-                exception = e
-              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
 
-            if exception
-              raise exception
-            else
-              result
+      private
+        def lock
+          result, exception = nil, nil
+          V8::C::Locker() do
+            begin
+              result = yield
+            rescue Exception => e
+              exception = e
             end
           end
-      end
 
-      def name
-        "therubyracer (V8)"
-      end
+          if exception
+            raise exception
+          else
+            result
+          end
+        end
+    end
 
-      def compile(source)
-        Context.new(source)
-      end
+    def name
+      "therubyracer (V8)"
+    end
 
-      def available?
-        require "v8"
-        true
-      rescue LoadError
-        false
-      end
+    def available?
+      require "v8"
+      true
+    rescue LoadError
+      false
     end
   end
 end