origami 1.1.2 → 1.2.0

data/README

@@ -12,12 +12,13 @@ DESCRIPTION
 
 VERSION
 
-  1.1
+  1.2
 
 OPTIONAL DEPENDENCIES
 
   - Ruby-GTK2 (only for GUI), http://ruby-gnome2.sourceforge.jp/
   - Ruby with OpenSSL support
+  - TheRubyRacer gem (only for JavaScript support)
 
 INSTALL
 

data/origami/dictionary.rb

@@ -166,7 +166,17 @@ module Origami
       end
       
       def [](key)
-        super(key.to_o)
+        #if key.is_a?(::Array) and key.size == 1
+        #  follow = true
+        #  key = key.first
+        #end
+
+        val = super(key.to_o)
+        #if follow and val.is_a?(Reference)
+        #  val.solve
+        #else
+        #  val
+        #end
       end
 
       def has_key?(key)

data/origami/filters/runlength.rb

@@ -97,7 +97,7 @@ module Origami
         result = ""
         until stream[i].ord == EOD do
         
-          length = stream[i]
+          length = stream[i].ord
           if length < EOD
             result << stream[i + 1, length + 1]
             i = i + length + 2

data/origami/javascript.rb

@@ -25,305 +25,686 @@
 
 module Origami
 
-  class PDF
+  begin
+    require 'v8'
+
+    class V8::Object
+      #def inspect
+      #  case self
+      #    when V8::Array,V8::Function then super
+      #    else
+      #      "{#{self.to_a.map{|k,v| "#{k}:#{v.inspect}"}.join(', ')}}"
+      #  end
+      #end
+    end
+
+    class PDF
   
-    module JavaScript
+      module JavaScript
 
-      module Platforms
-        WINDOWS = "WIN"
-        UNIX = "UNIX"
-        MAC = "MAC"
-      end
+        module Platforms
+          WINDOWS = "WIN"
+          UNIX = "UNIX"
+          MAC = "MAC"
+        end
 
-      module Viewers
-        ADOBE_READER = "Reader"
-      end
+        module Viewers
+          ADOBE_READER = "Reader"
+        end
 
-      class AcrobatObject
-        #def to_s
-        #  "[object #{self.class.to_s.split('::').last}]"
-        #end
-      end
+        class MissingArgError < Exception
+          def initialize; super("Missing required argument.") end
+        end
 
-      class Doc < AcrobatObject
-        attr_reader :info
-        attr_accessor :disclosed
-        attr_reader :hidden
-
-        class Info < AcrobatObject
-          def initialize(doc)
-            @doc = doc
-          end 
-
-          def title; @doc.title.to_s end
-          def author; @doc.author.to_s end
-          def subject; @doc.subject.to_s end
-          def keywords; @doc.keywords.to_s end
-          def creator; @doc.creator.to_s end
-          def creationDate; @doc.creation_date.to_s end
-          def modDate; @doc.mod_date.to_s end
+        class TypeError < Exception
+          def initialize; super("Incorrect argument type.") end
         end
 
-        def initialize(pdf)
-          @pdf = pdf
-          @disclosed = false
-          @hidden = false
-          @info = Info.new(pdf)
+        class InvalidArgsError < Exception
+          def initialize; super("Incorrect arguments.") end
         end
 
-        def numFields
-          fields = @pdf.fields
-          if fields.nil?
-            0
-          else
-            fields.size
-          end
+        class NotAllowedError < Exception
+          def initialize; super("Security settings prevent access to this property or method.") end
         end
 
-        def numPages; @pdf.pages.size end
+        class HelpError < Exception
+          def initialize; super("Help") end
+        end
+
+        class GeneralError < Exception
+          def initialize; super("Operation failed.") end
+        end
 
-        def title; @info.title end
-        def author; @info.author end
-        def subject; @info.subject end
-        def keywords; @info.keywords end
-        def creator; @info.creator end
-        def creationDate; @info.creationDate end
-        def modDate; @info.modDate end
+        class Arg
+          attr_reader :name, :type, :required, :default
 
-        def metadata
-          meta = @pdf.Catalog.Metadata
+          def initialize(declare = {})
+            @name = declare[:name]
+            @type = declare[:type]
+            @required = declare[:required]
+            @default = declare[:default]
+          end
 
-          (meta.data if meta.is_a?(Stream)).to_s
+          def self.[](declare = {})
+            self.new(declare)
+          end
+          
+          def self.inspect(obj)
+            case obj
+              when V8::Function then "function #{obj.name}"
+              when V8::Array then obj.to_a.inspect
+              when V8::Object
+                "{#{obj.to_a.map{|k,v| "#{k}:#{Arg.inspect(v)}"}.join(', ')}}"
+              else
+                obj.inspect
+            end
+          end
+          
         end
 
-        def filesize; @pdf.original_filesize end
-        def path; @pdf.original_filename end
-        def documentFileName; File.basename(self.path) end   
-        def URL; "file://#{self.path}" end
-        def baseURL; '' end
-
-        def dataObjects
-          data_objs = []
-          @pdf.ls_names(Names::Root::EMBEDDEDFILES).each do |name, file_desc|
-            if file_desc
-              ef = file_desc[:EF].solve
-              if ef
-                f = ef[:F].solve
-                data_objs.push Data.new(name, f.data.size) if f.is_a?(Stream)
+        class AcrobatObject
+          def initialize(engine)
+            @engine = engine
+          end
+
+          def self.check_method_args(args, def_args)
+            if args.first.is_a?(V8::Object)
+              args = args.first
+              members = args.entries.map{|k,v| k}
+              argv = []
+              def_args.each do |def_arg|
+                raise MissingArgError if def_arg.required and not members.include?(def_arg.name)
+
+                if members.include?(def_arg.name)
+                  arg = args[def_arg.name]
+                  raise TypeError if def_arg.type and not arg.is_a?(def_arg.type)
+                else
+                  arg = def_arg.default
+                end
+
+                argv.push(arg)
+              end
+
+              args = argv
+            else
+              i = 0
+              def_args.each do |def_arg|
+                raise MissingArgError if def_arg.required and i >= args.length
+                raise TypeError if def_arg.type and not args[i].is_a?(def_arg.type)
+
+                args.push(def_arg.default) if i >= args.length
+
+                i = i + 1
               end
             end
 
+            args
           end
-        
-          data_objs
-        end
+          
+          def self.acro_method(name, *def_args, &b)
+            define_method(name) do |*args| 
+              if @engine.options[:log_method_calls]
+                @engine.options[:console].puts(
+                  "LOG: #{self.class}.#{name}(#{args.map{|arg| Arg.inspect(arg)}.join(',')})"
+                )
+              end
+
+              args = AcrobatObject.check_method_args(args, def_args) 
+              self.instance_exec(*args, &b) if b
+            end
+          end
+
+          def self.acro_method_protected(name, *def_args, &b)
+            define_method(name) do |*args| 
+              if @engine.options[:log_method_calls]
+                @engine.options[:console].puts(
+                  "LOG: #{self.class}.#{name}(#{args.map{|arg| arg.inspect}.join(',')})"
+                )
+              end
 
-        def getDataObject(cName)
-          file_desc = @pdf.resolve_name(Names::Root::EMBEDDEDFILES, cName)
+              raise NotAllowedError
 
-          if file_desc
-            ef = file_desc[:EF].solve
-            if ef
-              f = ef[:F].solve
-              Data.new(cName, f.data.size) if f.is_a?(Stream)
+              args = AcrobatObject.check_method_args(args, def_args) 
+              self.instance_exec(*args, &b) if b
             end
           end
+          
+          def to_s
+            "[object #{self.class.to_s.split('::').last}]"
+          end
+          alias inspect to_s
+          
         end
 
-        def getDataObjectContents(cName, bAllowAuth = false)
-          file_desc = @pdf.resolve_name(Names::Root::EMBEDDEDFILES, cName)
+        class AcroTimer < AcrobatObject
+          def initialize(engine, timeout, code, repeat)
 
-          if file_desc
-            ef = file_desc[:EF].solve
-            if ef
-              f = ef[:F].solve
-              ReadStream.new(f.data) if f.is_a?(Stream)
+            @thr = Thread.start(engine, timeout, code, repeat) do
+              loop do
+                sleep(timeout / 1000.0)
+                engine.exec(code)
+                break if not repeat
+              end
             end
           end
         end
 
-        def getField(cName)
-          field = @pdf.get_field(cName)
+        class TimeOut < AcroTimer
+          def initialize(engine, timeout, code)
+            super(engine, timeout, code, false)
+          end
+        end
 
-          Field.new(field) if field
+        class Interval < AcroTimer
+          def initialize(engine, timeout, code)
+            super(engine, timeout, code, true)
+          end
         end
 
-        def getNthFieldName(nIndex)
-          fields = @pdf.fields
+        class ReadStream < AcrobatObject
+          def initialize(engine, data)
+            super(engine)
 
-          (Field.new(fields[nIndex]).name if fields and fields[nIndex]).to_s
+            @data = data
+          end
+
+          acro_method 'read',
+            Arg[:name => 'nBytes', :type => Numeric, :required => true] do |nBytes|
+              @data.slice!(0, nBytes)
+            end
         end
-      end
 
-      class App < AcrobatObject
-        attr_reader :platform, :viewerVariation, :viewerVersion
+        class Acrohelp < AcrobatObject; end
 
-        def initialize(platform, viewerVariation, viewerVersion)
-          @platform = platform
-          @viewerVariation, @viewerVersion = viewerVariation, viewerVersion
-        end
+        class Global < AcrobatObject
+          def initialize(engine)
+            super(engine)
 
-        def response(params)
-          puts params.class
-          gets
-        end
-      end
+            @vars = {}
+          end
+          
+          def []=(name, value)
+            @vars[name] ||= {:callbacks => []}
+            @vars[name][:value] = value
+            @vars[name][:callbacks].each do |callback|
+              callback.call(value)
+            end
+          end
 
-      class Console < AcrobatObject
-        def initialize(output = STDOUT)
-          @output = output
-        end
+          def [](name)
+            @vars[name][:value] if @vars.include?(name)
+          end
 
-        def println(msg)
-          @output.puts msg
-        end
-      end
+          acro_method 'setPersistent',
+            Arg[:name => 'cVariable', :required => true],
+            Arg[:name => 'bPersist', :required => true] do |cVariable, bPersist|
+              raise GeneralError unless @vars.include?(cVariable)
+            end
 
-      class Util < AcrobatObject
-        def streamFromString(cString, cCharset = 'utf-8')
-          ReadStream.new(cString.to_s)
+          acro_method 'subscribe',
+            Arg[:name => 'cVariable', :required => true],
+            Arg[:name => 'fCallback', :type => V8::Function, :required => true] do |cVariable, fCallback|
+              if @vars.include?(cVariable)
+                @vars[cVariable][:callbacks].push(fCallback)
+                fCallback.call(@vars[cVariable][:value])
+              end
+            end
         end
 
-        def stringFromStream(oStream, cCharset = 'utf-8')
-          if oStream.is_a?(ReadStream)
-            oStream.instance_variable_get(:@data).dup
+        class Doc < AcrobatObject
+          attr_reader :info
+          attr_accessor :disclosed
+          attr_reader :hidden
+
+          class Info < AcrobatObject
+            def initialize(engine, doc)
+              super(engine)
+
+              @doc = doc
+            end 
+
+            def title; @doc.title.to_s end
+            def author; @doc.author.to_s end
+            def subject; @doc.subject.to_s end
+            def keywords; @doc.keywords.to_s end
+            def creator; @doc.creator.to_s end
+            def creationDate; @doc.creation_date.to_s end
+            def modDate; @doc.mod_date.to_s end
           end
-        end
-      end
 
-      class Field < AcrobatObject
-        def initialize(field)
-          @field = field
-        end
+          def initialize(engine, pdf)
+            super(engine)
 
-        def doc; Doc.new(@field.pdf) end
-        def name
-          (@field[:T].solve.value if @field.has_key?(:T)).to_s
-        end
+            @pdf = pdf
+            @disclosed = false
+            @hidden = false
+            @info = Info.new(@engine, pdf)
+          end
+
+          ### PROPERTIES ###
+
+          def numFields
+            fields = @pdf.fields
+            if fields.nil?
+              0
+            else
+              fields.size
+            end
+          end
+
+          def numPages; @pdf.pages.size end
+
+          def title; @info.title end
+          def author; @info.author end
+          def subject; @info.subject end
+          def keywords; @info.keywords end
+          def creator; @info.creator end
+          def creationDate; @info.creationDate end
+          def modDate; @info.modDate end
+
+          def metadata
+            meta = @pdf.Catalog.Metadata
+
+            (meta.data if meta.is_a?(Stream)).to_s
+          end
+
+          def filesize; @pdf.original_filesize end
+          def path; @pdf.original_filename.to_s end
+          def documentFileName; File.basename(self.path) end   
+          def URL; "file://#{self.path}" end
+          def baseURL; '' end
+
+          def dataObjects
+            data_objs = []
+            @pdf.ls_names(Names::Root::EMBEDDEDFILES).each do |name, file_desc|
+              if file_desc
+                ef = file_desc[:EF].solve
+                if ef
+                  f = ef[:F].solve
+                  data_objs.push Data.new(@engine, name, f.data.size) if f.is_a?(Stream)
+                end
+              end
+
+            end
+          
+            data_objs
+          end
+
+          ### METHODS ###
         
-        def value
-          @field[:V].solve.value if @field.has_key?(:V)
-        end
+          acro_method 'closeDoc'
 
-        def valueAsString
-          self.value.to_s
-        end
+          acro_method 'getDataObject',
+            Arg[:name => 'cName', :type => ::String, :required => true] do |cName|
+              file_desc = @pdf.resolve_name(Names::Root::EMBEDDEDFILES, cName)
 
-        def type
-          (if @field.has_key?(:FT)
-            case @field[:FT].solve.value
-              when PDF::Field::Type::BUTTON
-                if @fields.has_key?(:Ff)
-                  flags = @fields[:Ff].solve.value
-
-                  if (flags & Origami::Annotation::Widget::Button::Flags::PUSHBUTTON) != 0
-                    'button'
-                  elsif (flags & Origami::Annotation::Widget::Button::Flags::RADIO) != 0
-                    'radiobox'
-                  else
-                    'checkbox'
-                  end
+              if file_desc
+                ef = file_desc[:EF].solve
+                if ef
+                  f = ef[:F].solve
+                else raise TypeError
                 end
-              when PDF::Field::Type::TEXT then 'text'
-              when PDF::Field::Type::SIGNATURE then 'signature'
-              when PDF::Field::Type::CHOICE
-                if @field.has_key?(:Ff)
-                  if (@field[:Ff].solve.value & Origami::Annotation::Widget::Choice::Flags::COMBO).zero?
-                    'listbox'
+              else raise TypeError
+              end
+
+              Data.new(@engine, cName, f.data.size) if f.is_a?(Stream)
+            end
+
+          acro_method 'getDataObjectContents',
+            Arg[:name => 'cName', :type => ::String, :required => true],
+            Arg[:name => 'bAllowAuth', :default => false] do |cName, bAllowAuth|
+              file_desc = @pdf.resolve_name(Names::Root::EMBEDDEDFILES, cName)
+
+              if file_desc
+                ef = file_desc[:EF].solve
+                if ef
+                  f = ef[:F].solve
+                else raise TypeError
+                end
+              else raise TypeError
+              end
+
+              ReadStream.new(@engine, f.data) if f.is_a?(Stream)
+            end
+
+          acro_method 'exportDataObject',
+            Arg[:name => 'cName', :type => ::String, :required => true],
+            Arg[:name => 'cDIPath' ],
+            Arg[:name => 'bAllowAuth'],
+            Arg[:name => 'nLaunch'] do |cName, cDIPath, bAllowAuth, nLaunch|
+              file_desc = @pdf.resolve_name(Names::Root::EMBEDDEDFILES, cName)
+
+              if file_desc
+                ef = file_desc[:EF].solve
+                if ef
+                  f = ef[:F].solve
+                else raise TypeError
+                end
+              else raise TypeError
+              end
+
+              raise TypeError if f.nil?
+            end
+
+          acro_method 'getField',
+            Arg[:name => 'cName', :type => ::Object, :required => true] do |cName|
+              field = @pdf.get_field(cName)
+
+              Field.new(@engine, field) if field
+            end
+
+          acro_method 'getNthFieldName',
+            Arg[:name => 'nIndex', :type => ::Object, :required => true] do |nIndex|
+              nIndex =
+                case nIndex
+                  when false then 0
+                  when true then 1
                   else
-                    'combobox'
-                  end
+                    @engine.parseInt.call(nIndex)
                 end
+
+              raise TypeError if (nIndex.is_a?(Float) and nIndex.nan?) or nIndex < 0
+              fields = @pdf.fields
+
+              (Field.new(@engine, fields[nIndex]).name if fields and fields[nIndex]).to_s
             end
-          end).to_s
         end
 
-      end
+        class App < AcrobatObject
+          attr_reader :platform, :viewerVariation, :viewerVersion
+
+          def platform; @engine.options[:platform] end
+          def viewerType; @engine.options[:viewerType] end
+          def viewerVariation; @engine.options[:viewerVariation] end
+          def viewerVersion; @engine.options[:viewerVersion] end
+
+          def activeDocs; [] end
+
+          ### METHODS ###
+          
+          acro_method 'setInterval',
+            Arg[:name => 'cExpr', :required => true],
+            Arg[:name => 'nMilliseconds', :type => Numeric, :required => true] do |cExpr, nMilliseconds|
+              cExpr = cExpr.is_a?(::String) ? cExpr : ''
+              Interval.new(@engine, nMilliseconds, cExpr)
+            end
 
-      class Data < AcrobatObject
-        attr_reader :name, :path, :size
-        attr_reader :creationDate, :modDate
-        attr_reader :description, :MIMEType
+          acro_method 'setTimeOut',
+            Arg[:name => 'cExpr', :required => true],
+            Arg[:name => 'nMilliseconds', :type => Numeric, :required => true] do |cExpr, nMilliseconds|
+              cExpr = cExpr.is_a?(::String) ? cExpr : ''
+              TimeOut.new(@engine, nMilliseconds, cExpr)
+            end
+
+          acro_method 'clearInterval',
+            Arg[:name => 'oInterval', :type => Interval, :required => true] do |oInterval|
+              oInterval.instance_variable_get(:@thr).terminate
+              nil
+            end
+
+          acro_method 'clearTimeOut',
+            Arg[:name => 'oInterval', :type => TimeOut, :required => true] do |oInterval|
+              oInterval.instance_variable_get(:@thr).terminate
+              nil
+            end
 
-        def initialize(name, size, path = nil, creationDate = nil, modDate = nil, description = nil, mimeType = nil)
-          @name, @path, @size = name, path, size
-          @creationDate, @modDate = creationDate, modDate
-          @description, @MIMEType = description, mimeType
+          acro_method_protected 'addMenuItem'
+          acro_method_protected 'addSubMenu'
+          acro_method           'addToolButton'
+          acro_method_protected 'beginPriv'
+          acro_method           'beep'
+          acro_method_protected 'browseForDoc'
+          acro_method_protected 'endPriv'
         end
-      end
 
-      class ReadStream < AcrobatObject
-        def initialize(data)
-          @data = data
+        class Console < AcrobatObject
+          def println(*args)
+            raise MissingArgError unless args.length > 0
+
+            @engine.options[:console].puts(args.first.to_s)
+          end
+
+          acro_method 'show'
+          acro_method 'clear'
+          acro_method 'hide'
         end
 
-        def read(n)
-          @data.slice!(0, n)
+        class Util < AcrobatObject
+          acro_method 'streamFromString',
+            Arg[:name => 'cString', :type => ::Object, :required => true],
+            Arg[:name => 'cCharset', :type => ::Object, :default => 'utf-8'] do |cString, cCharset|
+
+              ReadStream.new(@engine, cString.to_s)
+            end
+
+          acro_method 'stringFromStream',
+            Arg[:name => 'oStream', :type => ReadStream, :required => true],
+            Arg[:name => 'cCharset', :type => ::Object, :default => 'utf-8'] do |oStream, cCharset|
+
+              oStream.instance_variable_get(:@data).dup
+            end
         end
+
+        class Field < AcrobatObject
+          def initialize(engine, field)
+            super(engine)
+
+            @field = field
+          end
+
+          def doc; Doc.new(@field.pdf) end
+          def name
+            (@field[:T].solve.value if @field.has_key?(:T)).to_s
+          end
+          
+          def value
+            @field[:V].solve.value if @field.has_key?(:V)
+          end
+
+          def valueAsString
+            self.value.to_s
+          end
+
+          def type
+            (if @field.has_key?(:FT)
+              case @field[:FT].solve.value
+                when PDF::Field::Type::BUTTON
+                  if @fields.has_key?(:Ff)
+                    flags = @fields[:Ff].solve.value
+
+                    if (flags & Origami::Annotation::Widget::Button::Flags::PUSHBUTTON) != 0
+                      'button'
+                    elsif (flags & Origami::Annotation::Widget::Button::Flags::RADIO) != 0
+                      'radiobox'
+                    else
+                      'checkbox'
+                    end
+                  end
+                when PDF::Field::Type::TEXT then 'text'
+                when PDF::Field::Type::SIGNATURE then 'signature'
+                when PDF::Field::Type::CHOICE
+                  if @field.has_key?(:Ff)
+                    if (@field[:Ff].solve.value & Origami::Annotation::Widget::Choice::Flags::COMBO).zero?
+                      'listbox'
+                    else
+                      'combobox'
+                    end
+                  end
+              end
+            end).to_s
+          end
+
+        end
+
+        class Data < AcrobatObject
+          attr_reader :name, :path, :size
+          attr_reader :creationDate, :modDate
+          attr_reader :description, :MIMEType
+
+          def initialize(engine, name, size, path = nil, creationDate = nil, modDate = nil, description = nil, mimeType = nil)
+
+            super(engine)
+
+            @name, @path, @size = name, path, size
+            @creationDate, @modDate = creationDate, modDate
+            @description, @MIMEType = description, mimeType
+          end
+        end
+
       end
-    end
 
-    begin
-      require 'v8'
+      class JavaScript::EngineError < Exception; end
 
       class JavaScript::Engine
 
+        attr_reader :global
         attr_reader :context
+        attr_reader :options
+        attr_reader :parseInt
 
-        def initialize(pdf, params = {})
-          options = 
+        def initialize(pdf)
+          @options = 
           {
             :viewerVersion => JavaScript::Platforms::WINDOWS, 
+            :viewerType => JavaScript::Viewers::ADOBE_READER,
             :viewerVariation => JavaScript::Viewers::ADOBE_READER, 
-            :platform => 9
-          }.update(params)
-
-          doc = JavaScript::Doc.new(pdf)
-          app = JavaScript::App.new(options[:platform], options[:viewerVariation], options[:viewerVersion])
-          util = JavaScript::Util.new
-          console = JavaScript::Console.new
-
-          @context = V8::Context.new(:with => doc)
+            :platform => 9,
+            :console => STDOUT,
+            :log_method_calls => false
+          }
+
+          @global = JavaScript::Doc.new(self, pdf)
+          app = JavaScript::App.new(self)
+          acrohelp = JavaScript::Acrohelp.new(self)
+          global = JavaScript::Global.new(self)
+          console = JavaScript::Console.new(self)
+          util = JavaScript::Util.new(self)
+
+          @context = V8::Context.new(:with => @global)
           @context['app'] = app
+          @context['acrohelp'] = acrohelp
           @context['console'] = console
+          @context['global'] = global
           @context['util'] = util
+
+          @parseInt = @context['parseInt']
+          @hooks = {}
         end
 
+        #
+        # Evaluates a JavaScript code in the current context.
+        #
         def exec(script)
           @context.eval(script)
         end
-      end
 
-    rescue LoadError
-    end
-  end
+        #
+        # Set a hook on a JavaScript method.
+        #
+        def hook(name, &callback)
+          ns = name.split('.')
+          previous = @context
+
+          ns.each do |n|
+            raise JavaScript::EngineError, "#{name} does not exist" if previous.nil?
+            previous = previous[n]
+          end
+
+          case previous
+            when V8::Function, UnboundMethod, nil then
+              @context[name] = lambda do |*args|
+                callback[previous, *args]
+              end
+
+              @hooks[name] = [previous, callback]
+          else
+            raise JavaScript::EngineError, "#{name} is not a function"
+          end
+        end
+
+        #
+        # Removes an existing hook on a JavaScript method.
+        #
+        def unhook(name)
+          if @hooks.has_key?(name)
+            @context[name] = @hooks[name][0]
+          end
+        end
+
+        #
+        # Returns an Hash of all defined members in specified object name.
+        #
+        def members(obj)
+          members = {}
+          list = @context.eval <<-JS
+            (function(base){
+              var members = [];
+              for (var i in base) members.push([i, base[i]]);
+              return members;
+            })(#{obj})
+          JS
+
+          list.each do |var|
+            members[var[0]] = var[1]
+          end
+
+          members
+        end
+
+        #
+        # Returns all members in the global scope.
+        #
+        def scope
+          members('this')
+        end
 
-  if defined?(PDF::JavaScript::Engine)
+        #
+        # Binds the V8 remote debugging agent on the specified TCP _port_.
+        #
+        def enable_debugger(port)
+          V8::C::Debug.EnableAgent("Origami", port)
+        end
+      end
+    
+    end
+    
     module String
-      def eval_as_js(options = {})
-        runtime = options[:runtime] || PDF::JavaScript::Engine.new(self.pdf, options)
-        runtime.exec(self.value)
+      #
+      # Evaluates the current String as JavaScript.
+      #
+      def eval_js
+        self.pdf.eval_js(self.value)
       end
     end
 
     class Stream
-      def eval_as_js(options = {})
-        runtime = options[:runtime] || PDF::JavaScript::Engine.new(self.pdf, options)
-        runtime.exec(self.data)
+      #
+      # Evaluates the current Stream as JavaScript.
+      #
+      def eval_js
+        self.pdf.eval_js(self.data)
       end
     end
 
     class PDF
+
+      #
+      # Executes a JavaScript script in the current document context.
+      #
       def eval_js(code)
-        get_js_engine.exec(code) 
+        js_engine.exec(code) 
       end
 
-      private
-
-      def get_js_engine(options = {})
-        @js_engine ||= PDF::JavaScript::Engine.new(self, options)
+      #
+      # Returns the JavaScript engine (if JavaScript support is present).
+      #
+      def js_engine
+        @js_engine ||= PDF::JavaScript::Engine.new(self)
       end
     end
+
+  rescue LoadError
   end
-    
 end
+

data/origami/pdf.rb

@@ -54,11 +54,12 @@ require 'origami/encryption'
 require 'origami/linearization'
 require 'origami/obfuscation'
 require 'origami/xfa'
+require 'origami/javascript'
 
 module Origami
 
-  VERSION   = "1.1.2"
-  REVISION  = "$Revision: rev 122/, 2011/09/26 12:12:39 darko $" #:nodoc:
+  VERSION   = "1.2.0"
+  REVISION  = "$Revision: rev 125/, 2011/09/29 15:18:36 darko $" #:nodoc:
   
   #
   # Global options for Origami.
@@ -179,6 +180,7 @@ module Origami
       # Reads and parses a PDF file from disk.
       #
       def read(filename, options = {:verbosity => Parser::VERBOSE_INSANE})
+        filename = File.expand_path(filename) if filename.is_a?(::String)
         PDF::LinearParser.new(options).parse(filename)
       end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: origami
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 31
   prerelease: false
   segments: 
   - 1
-  - 1
   - 2
-  version: 1.1.2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - "Guillaume Delugr\xC3\xA9"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-26 00:00:00 +02:00
+date: 2011-09-29 00:00:00 +02:00
 default_executable: 
 dependencies: []