origami 2.0.0 → 2.0.1

data/lib/origami/extensions/fdf.rb

@@ -209,6 +209,7 @@ module Origami
             @header = FDF::Header.new
             @revisions = [ Revision.new(self) ]
             @revisions.first.trailer = Trailer.new
+            @parser = parser
 
             init if parser.nil?
         end
@@ -249,10 +250,10 @@ module Origami
         end
         alias root_objects indirect_objects
 
-        def cast_object(reference, type, parser = nil) #:nodoc:
+        def cast_object(reference, type) #:nodoc:
             @revisions.each do |rev|
                 if rev.body.include?(reference) and type < rev.body[reference].class
-                    rev.body[reference] = rev.body[reference].cast_to(type, parser)
+                    rev.body[reference] = rev.body[reference].cast_to(type, @parser)
 
                     rev.body[reference]
                 else

data/lib/origami/extensions/ppklite.rb

@@ -134,7 +134,7 @@ module Origami
             include StandardObject
             include Descriptor
 
-            add_type_info self, :ABEType, Descriptor::CERTIFICATE
+            add_type_signature :ABEType, Descriptor::CERTIFICATE
 
             module Flags
                 CAN_CERTIFY             = 1 << 1
@@ -160,7 +160,7 @@ module Origami
             include StandardObject
             include Descriptor
 
-            add_type_info self, :ABEType, Descriptor::USER
+            add_type_signature :ABEType, Descriptor::USER
 
             field   :ABEType,       :Type => Integer, :Default => Descriptor::USER, :Required => true
             field   :Name,          :Type => String, :Required => true
@@ -204,6 +204,7 @@ module Origami
             @header = PPKLite::Header.new
             @revisions = [ Revision.new(self) ]
             @revisions.first.trailer = Trailer.new
+            @parser = parser
 
             init if parser.nil?
         end
@@ -213,10 +214,10 @@ module Origami
         end
         alias root_objects indirect_objects
 
-        def cast_object(reference, type, parser = nil) #:nodoc:
+        def cast_object(reference, type) #:nodoc:
             @revisions.each do |rev|
                 if rev.body.include?(reference) and type < rev.body[reference].class
-                    rev.body[reference] = rev.body[reference].cast_to(type, parser)
+                    rev.body[reference] = rev.body[reference].cast_to(type, @parser)
 
                     rev.body[reference]
                 else
@@ -260,11 +261,6 @@ module Origami
             get_object(@revisions.first.trailer.Root)
         end
 
-        def indirect_objects
-            @revisions.inject([]) do |set, rev| set.concat(rev.objects) end
-        end
-        alias root_objects indirect_objects
-
         def save(path)
             bin = "".b
             bin << @header.to_s

data/lib/origami/filespec.rb

@@ -95,7 +95,7 @@ module Origami
             # Converts MacOS file path into PDF file path.
             #
             def Mac(file)
-                LiteralString.new("/" + file.gsub(":", "/"))
+                LiteralString.new("/" + file.tr(":", "/"))
             end
 
             #
@@ -109,7 +109,7 @@ module Origami
                     file.sub!(":","")
                 end
 
-                file.gsub!("\\", "/")
+                file.tr!("\\", "/")
                 LiteralString.new(path + file)
             end
         end

data/lib/origami/filters.rb

@@ -25,6 +25,24 @@ module Origami
     #
     module Filter
 
+        autoload :ASCIIHex,     "origami/filters/ascii"
+        autoload :AHx,          "origami/filters/ascii"
+        autoload :ASCII85,      "origami/filters/ascii"
+        autoload :A85,          "origami/filters/ascii"
+        autoload :CCITTFax,     "origami/filters/ccitt"
+        autoload :CCF,          "origami/filters/ccitt"
+        autoload :Crypt,        "origami/filters/crypt"
+        autoload :DCT,          "origami/filters/dct"
+        autoload :Flate,        "origami/filters/flate"
+        autoload :Fl,           "origami/filters/flate"
+        autoload :JBIG2,        "origami/filters/jbig2"
+        autoload :JPX,          "origami/filters/jpx"
+        autoload :LZW,          "origami/filters/lzw"
+        autoload :RunLength,    "origami/filters/runlength"
+        autoload :RL,           "origami/filters/runlength"
+        autoload :Predictor,    "origami/filters/predictors"
+
+
         #
         # Base class for filter Exceptions.
         #
@@ -59,7 +77,7 @@ module Origami
             #
             class BitWriter
                 def initialize
-                    @data = ''
+                    @data = ''.b
                     @last_byte = nil
                     @ptr_bit = 0
                 end
@@ -68,7 +86,7 @@ module Origami
                 # Writes _data_ represented as Fixnum to a _length_ number of bits.
                 #
                 def write(data, length)
-                    return BitWriterError, "Invalid data length" unless length > 0 and (1 << length) > data
+                    return BitWriterError, "Invalid data length" unless length > 0 and length >= data.bit_length
 
                     # optimization for aligned byte writing
                     if length == 8 and @last_byte.nil? and @ptr_bit == 0
@@ -76,30 +94,7 @@ module Origami
                         return self
                     end
 
-                    while length > 0
-                        if length >= 8 - @ptr_bit
-                            length -= 8 - @ptr_bit
-                            @last_byte ||= 0
-                            @last_byte |= (data >> length) & ((1 << (8 - @ptr_bit)) - 1)
-
-                            data &= (1 << length) - 1
-                            @data << @last_byte.chr
-                            @last_byte = nil
-                            @ptr_bit = 0
-                        else
-                            @last_byte ||= 0
-                            @last_byte |= (data & ((1 << length) - 1)) << (8 - @ptr_bit - length)
-                            @ptr_bit += length
-
-                            if @ptr_bit == 8
-                                @data << @last_byte.chr
-                                @last_byte = nil
-                                @ptr_bit = 0
-                            end
-
-                            length = 0
-                        end
-                    end
+                    write_bits(data, length)
 
                     self
                 end
@@ -128,6 +123,39 @@ module Origami
                 def to_s
                     @data.dup
                 end
+
+                private
+
+                #
+                # Write the bits into the internal data.
+                #
+                def write_bits(data, length)
+
+                    while length > 0
+                        if length >= 8 - @ptr_bit
+                            length -= 8 - @ptr_bit
+                            @last_byte ||= 0
+                            @last_byte |= (data >> length) & ((1 << (8 - @ptr_bit)) - 1)
+
+                            data &= (1 << length) - 1
+                            @data << @last_byte.chr
+                            @last_byte = nil
+                            @ptr_bit = 0
+                        else
+                            @last_byte ||= 0
+                            @last_byte |= (data & ((1 << length) - 1)) << (8 - @ptr_bit - length)
+                            @ptr_bit += length
+
+                            if @ptr_bit == 8
+                                @data << @last_byte.chr
+                                @last_byte = nil
+                                @ptr_bit = 0
+                            end
+
+                            length = 0
+                        end
+                    end
+                end
             end
 
             class BitReaderError < Error #:nodoc:
@@ -336,13 +364,3 @@ module Origami
     end
 
 end
-
-require 'origami/filters/ascii'
-require 'origami/filters/lzw'
-require 'origami/filters/flate'
-require 'origami/filters/runlength'
-require 'origami/filters/ccitt'
-require 'origami/filters/dct'
-require 'origami/filters/jbig2'
-require 'origami/filters/jpx'
-require 'origami/filters/crypt'

data/lib/origami/filters/ascii.rb

@@ -91,23 +91,14 @@ module Origami
                         addend = 0
                     end
 
-                    inblock = (input[i].ord * 256**3 +
-                               input[i+1].ord * 256**2 +
-                               input[i+2].ord * 256 +
-                               input[i+3].ord)
-                    outblock = ""
-
-                    5.times do |p|
-                        c = inblock / 85 ** (4 - p)
-                        outblock << ("!".ord + c).chr
-
-                        inblock -= c * 85 ** (4 - p)
-                    end
+                    # Encode the 4 bytes input value into a 5 character string.
+                    value = input[i, 4].unpack("L>")[0]
+                    outblock = encode_block(value)
 
                     outblock = "z" if outblock == "!!!!!" and addend == 0
 
                     if addend != 0
-                        outblock = outblock[0,(4 - addend) + 1]
+                        outblock = outblock[0, 4 - addend + 1]
                     end
 
                     code << outblock
@@ -123,60 +114,41 @@ module Origami
             # _string_:: The data to decode.
             #
             def decode(string)
-                input = (string.include?(EOD) ? string[0..string.index(EOD) - 1] : string).delete(" \f\t\r\n\0")
+                input = filter_input(string)
 
                 i = 0
-                result = "".b
-                while i < input.size do
+                result = ''.b
+
+                while i < input.size
 
                     outblock = ""
+                    value = 0
+                    addend = 0
 
                     if input[i] == "z"
-                        inblock = 0
                         codelen = 1
                     else
-                        inblock = 0
                         codelen = 5
 
-                        if input.length - i < 5
+                        if input.length - i < codelen
                             raise InvalidASCII85StringError.new("Invalid length", input_data: string, decoded_data: result) if input.length - i == 1
 
-                            addend = 5 - (input.length - i)
+                            addend = codelen - (input.length - i)
                             input << "u" * addend
-                        else
-                            addend = 0
                         end
 
-                        # Checking if this string is in base85
-                        5.times do |j|
-                            if input[i+j].ord > "u".ord or input[i+j].ord < "!".ord
-                                raise InvalidASCII85StringError.new(
-                                        "Invalid character sequence: #{input[i,5].inspect}",
-                                        input_data: string,
-                                        decoded_data: result
-                                )
-                            else
-                                inblock += (input[i+j].ord - "!".ord) * 85 ** (4 - j)
-                            end
+                        # Decode the 5 characters input block into a 32 bit integer.
+                        begin
+                            value = decode_block input[i, codelen]
+                        rescue InvalidASCII85StringError => error
+                            error.input_data = string
+                            error.decoded_data = result
+                            raise(error)
                         end
-
-                        raise InvalidASCII85StringError.new(
-                                "Invalid value (#{inblock}) for block #{input[i,5].inspect}",
-                                input_data: string,
-                                decoded_data: result
-                        ) if inblock >= 2**32
                     end
 
-                    4.times do |p|
-                        c = inblock / 256 ** (3 - p)
-                        outblock << c.chr
-
-                        inblock -= c * 256 ** (3 - p)
-                    end
-
-                    if addend != 0
-                        outblock = outblock[0, 4 - addend]
-                    end
+                    outblock = [ value ].pack "L>"
+                    outblock = outblock[0, 4 - addend]
 
                     result << outblock
 
@@ -186,6 +158,52 @@ module Origami
                 result
             end
 
+            private
+
+            def filter_input(string)
+                string = string[0, string.index(EOD)] if string.include?(EOD)
+                string.delete(" \f\t\r\n\0")
+            end
+
+            #
+            # Encodes an integer value into an ASCII85 block of 5 characters.
+            #
+            def encode_block(value)
+                block = "".b
+
+                5.times do |p|
+                    c = value / 85 ** (4 - p)
+                    block << ("!".ord + c).chr
+
+                    value -= c * 85 ** (4 - p)
+                end
+                
+                block
+            end
+
+            #
+            # Decodes a 5 character ASCII85 block into an integer value.
+            #
+            def decode_block(block)
+                value = 0
+
+                5.times do |i|
+                    byte = block[i].ord
+
+                    if byte > "u".ord or byte < "!".ord
+                        raise InvalidASCII85StringError, "Invalid character sequence: #{block.inspect}"
+                    else
+                        value += (byte - "!".ord) * 85 ** (4 - i)
+                    end
+                end
+
+                if value >= (1 << 32)
+                    raise InvalidASCII85StringError, "Invalid value (#{value}) for block #{block.inspect}"
+                end
+
+                value
+            end
+
         end
         A85 = ASCII85
 

data/lib/origami/filters/ccitt.rb

@@ -18,6 +18,8 @@
 
 =end
 
+require 'origami/filters/ccitt/tables'
+
 module Origami
 
     module Filter
@@ -47,243 +49,9 @@ module Origami
                 field   :DamagedRowsBeforeError,  :Type => :Integer, :Default => 0
             end
 
-            def self.codeword(str) #:nodoc:
-                [ str.to_i(2), str.length ]
-            end
-
             EOL = codeword('000000000001')
             RTC = codeword('000000000001' * 6)
 
-            WHITE_TERMINAL_ENCODE_TABLE =
-            {
-                0   => codeword('00110101'),
-                1   => codeword('000111'),
-                2   => codeword('0111'),
-                3   => codeword('1000'),
-                4   => codeword('1011'),
-                5   => codeword('1100'),
-                6   => codeword('1110'),
-                7   => codeword('1111'),
-                8   => codeword('10011'),
-                9   => codeword('10100'),
-                10  => codeword('00111'),
-                11  => codeword('01000'),
-                12  => codeword('001000'),
-                13  => codeword('000011'),
-                14  => codeword('110100'),
-                15  => codeword('110101'),
-                16  => codeword('101010'),
-                17  => codeword('101011'),
-                18  => codeword('0100111'),
-                19  => codeword('0001100'),
-                20  => codeword('0001000'),
-                21  => codeword('0010111'),
-                22  => codeword('0000011'),
-                23  => codeword('0000100'),
-                24  => codeword('0101000'),
-                25  => codeword('0101011'),
-                26  => codeword('0010011'),
-                27  => codeword('0100100'),
-                28  => codeword('0011000'),
-                29  => codeword('00000010'),
-                30  => codeword('00000011'),
-                31  => codeword('00011010'),
-                32  => codeword('00011011'),
-                33  => codeword('00010010'),
-                34  => codeword('00010011'),
-                35  => codeword('00010100'),
-                36  => codeword('00010101'),
-                37  => codeword('00010110'),
-                38  => codeword('00010111'),
-                39  => codeword('00101000'),
-                40  => codeword('00101001'),
-                41  => codeword('00101010'),
-                42  => codeword('00101011'),
-                43  => codeword('00101100'),
-                44  => codeword('00101101'),
-                45  => codeword('00000100'),
-                46  => codeword('00000101'),
-                47  => codeword('00001010'),
-                48  => codeword('00001011'),
-                49  => codeword('01010010'),
-                50  => codeword('01010011'),
-                51  => codeword('01010100'),
-                52  => codeword('01010101'),
-                53  => codeword('00100100'),
-                54  => codeword('00100101'),
-                55  => codeword('01011000'),
-                56  => codeword('01011001'),
-                57  => codeword('01011010'),
-                58  => codeword('01011011'),
-                59  => codeword('01001010'),
-                60  => codeword('01001011'),
-                61  => codeword('00110010'),
-                62  => codeword('00110011'),
-                63  => codeword('00110100')
-            }
-            WHITE_TERMINAL_DECODE_TABLE = WHITE_TERMINAL_ENCODE_TABLE.invert
-
-            BLACK_TERMINAL_ENCODE_TABLE =
-            {
-                0   => codeword('0000110111'),
-                1   => codeword('010'),
-                2   => codeword('11'),
-                3   => codeword('10'),
-                4   => codeword('011'),
-                5   => codeword('0011'),
-                6   => codeword('0010'),
-                7   => codeword('00011'),
-                8   => codeword('000101'),
-                9   => codeword('000100'),
-                10  => codeword('0000100'),
-                11  => codeword('0000101'),
-                12  => codeword('0000111'),
-                13  => codeword('00000100'),
-                14  => codeword('00000111'),
-                15  => codeword('000011000'),
-                16  => codeword('0000010111'),
-                17  => codeword('0000011000'),
-                18  => codeword('0000001000'),
-                19  => codeword('00001100111'),
-                20  => codeword('00001101000'),
-                21  => codeword('00001101100'),
-                22  => codeword('00000110111'),
-                23  => codeword('00000101000'),
-                24  => codeword('00000010111'),
-                25  => codeword('00000011000'),
-                26  => codeword('000011001010'),
-                27  => codeword('000011001011'),
-                28  => codeword('000011001100'),
-                29  => codeword('000011001101'),
-                30  => codeword('000001101000'),
-                31  => codeword('000001101001'),
-                32  => codeword('000001101010'),
-                33  => codeword('000001101011'),
-                34  => codeword('000011010010'),
-                35  => codeword('000011010011'),
-                36  => codeword('000011010100'),
-                37  => codeword('000011010101'),
-                38  => codeword('000011010110'),
-                39  => codeword('000011010111'),
-                40  => codeword('000001101100'),
-                41  => codeword('000001101101'),
-                42  => codeword('000011011010'),
-                43  => codeword('000011011011'),
-                44  => codeword('000001010100'),
-                45  => codeword('000001010101'),
-                46  => codeword('000001010110'),
-                47  => codeword('000001010111'),
-                48  => codeword('000001100100'),
-                49  => codeword('000001100101'),
-                50  => codeword('000001010010'),
-                51  => codeword('000001010011'),
-                52  => codeword('000000100100'),
-                53  => codeword('000000110111'),
-                54  => codeword('000000111000'),
-                55  => codeword('000000100111'),
-                56  => codeword('000000101000'),
-                57  => codeword('000001011000'),
-                58  => codeword('000001011001'),
-                59  => codeword('000000101011'),
-                60  => codeword('000000101100'),
-                61  => codeword('000001011010'),
-                62  => codeword('000001100110'),
-                63  => codeword('000001100111')
-            }
-            BLACK_TERMINAL_DECODE_TABLE = BLACK_TERMINAL_ENCODE_TABLE.invert
-
-            WHITE_CONFIGURATION_ENCODE_TABLE =
-            {
-                64    => codeword('11011'),
-                128   => codeword('10010'),
-                192   => codeword('010111'),
-                256   => codeword('0110111'),
-                320   => codeword('00110110'),
-                384   => codeword('00110111'),
-                448   => codeword('01100100'),
-                512   => codeword('01100101'),
-                576   => codeword('01101000'),
-                640   => codeword('01100111'),
-                704   => codeword('011001100'),
-                768   => codeword('011001101'),
-                832   => codeword('011010010'),
-                896   => codeword('011010011'),
-                960   => codeword('011010100'),
-                1024  => codeword('011010101'),
-                1088  => codeword('011010110'),
-                1152  => codeword('011010111'),
-                1216  => codeword('011011000'),
-                1280  => codeword('011011001'),
-                1344  => codeword('011011010'),
-                1408  => codeword('011011011'),
-                1472  => codeword('010011000'),
-                1536  => codeword('010011001'),
-                1600  => codeword('010011010'),
-                1664  => codeword('011000'),
-                1728  => codeword('010011011'),
-
-                1792  => codeword('00000001000'),
-                1856  => codeword('00000001100'),
-                1920  => codeword('00000001001'),
-                1984  => codeword('000000010010'),
-                2048  => codeword('000000010011'),
-                2112  => codeword('000000010100'),
-                2176  => codeword('000000010101'),
-                2240  => codeword('000000010110'),
-                2340  => codeword('000000010111'),
-                2368  => codeword('000000011100'),
-                2432  => codeword('000000011101'),
-                2496  => codeword('000000011110'),
-                2560  => codeword('000000011111')
-            }
-            WHITE_CONFIGURATION_DECODE_TABLE = WHITE_CONFIGURATION_ENCODE_TABLE.invert
-
-            BLACK_CONFIGURATION_ENCODE_TABLE =
-            {
-                64    => codeword('0000001111'),
-                128   => codeword('000011001000'),
-                192   => codeword('000011001001'),
-                256   => codeword('000001011011'),
-                320   => codeword('000000110011'),
-                384   => codeword('000000110100'),
-                448   => codeword('000000110101'),
-                512   => codeword('0000001101100'),
-                576   => codeword('0000001101101'),
-                640   => codeword('0000001001010'),
-                704   => codeword('0000001001011'),
-                768   => codeword('0000001001100'),
-                832   => codeword('0000001001101'),
-                896   => codeword('0000001110010'),
-                960   => codeword('0000001110011'),
-                1024  => codeword('0000001110100'),
-                1088  => codeword('0000001110101'),
-                1152  => codeword('0000001110110'),
-                1216  => codeword('0000001110111'),
-                1280  => codeword('0000001010010'),
-                1344  => codeword('0000001010011'),
-                1408  => codeword('0000001010100'),
-                1472  => codeword('0000001010101'),
-                1536  => codeword('0000001011010'),
-                1600  => codeword('0000001011011'),
-                1664  => codeword('0000001100100'),
-                1728  => codeword('0000001100101'),
-
-                1792  => codeword('00000001000'),
-                1856  => codeword('00000001100'),
-                1920  => codeword('00000001001'),
-                1984  => codeword('000000010010'),
-                2048  => codeword('000000010011'),
-                2112  => codeword('000000010100'),
-                2176  => codeword('000000010101'),
-                2240  => codeword('000000010110'),
-                2340  => codeword('000000010111'),
-                2368  => codeword('000000011100'),
-                2432  => codeword('000000011101'),
-                2496  => codeword('000000011110'),
-                2560  => codeword('000000011111')
-            }
-            BLACK_CONFIGURATION_DECODE_TABLE = BLACK_CONFIGURATION_ENCODE_TABLE.invert
-
             #
             # Creates a new CCITT Fax Filter.
             #
@@ -459,7 +227,7 @@ module Origami
                 end
             end
 
-            def encode_two_dimensional_line(input, output, columns, colors, prev_line) #:nodoc:
+            def encode_two_dimensional_line(_input, _output, _columns, _colors, _prev_line) #:nodoc:
                 raise NotImplementedError "CCITT two-dimensional encoding scheme not supported."
             end
 
@@ -486,7 +254,7 @@ module Origami
                 end
             end
 
-            def decode_two_dimensional_line(input, output, columns, colors, prev_line) #:nodoc:
+            def decode_two_dimensional_line(_input, _output, _columns, _colors, _prev_line) #:nodoc:
                 raise NotImplementedError, "CCITT two-dimensional decoding scheme not supported."
             end