origami-docspring 2.2.0 → 2.3.0

data/lib/origami/array.rb

@@ -1,242 +1,238 @@
-=begin
+# frozen_string_literal: true
+
+#
+#     This file is part of Origami, PDF manipulation framework for Ruby
+#     Copyright (C) 2016	Guillaume Delugré.
+#
+#     Origami is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Lesser General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     Origami is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public License
+#     along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+#
 
-    This file is part of Origami, PDF manipulation framework for Ruby
-    Copyright (C) 2016	Guillaume Delugré.
+module Origami
+  class InvalidArrayObjectError < InvalidObjectError # :nodoc:
+  end
+
+  #
+  # Class representing an Array Object.
+  # Arrays contain a set of Object.
+  #
+  class Array < ::Array
+    include CompoundObject
+    using TypeConversion
+
+    TOKENS = %w{[ ]} # :nodoc:
+    @@regexp_open = Regexp.new(WHITESPACES + Regexp.escape(TOKENS.first) + WHITESPACES)
+    @@regexp_close = Regexp.new(WHITESPACES + Regexp.escape(TOKENS.last) + WHITESPACES)
+
+    #
+    # Creates a new PDF Array Object.
+    # _data_:: An array of objects.
+    #
+    def initialize(data = [], parser = nil, hint_type: nil)
+      raise TypeError, "Expected type Array, received #{data.class}." unless data.is_a?(::Array)
+      super()
+
+      data.each_with_index do |value, index|
+        value = value.to_o
+
+        if Origami::OPTIONS[:enable_type_guessing]
+          index_type = hint_type.is_a?(::Array) ? hint_type[index % hint_type.size] : hint_type
+          if index_type.is_a?(::Array) && !value.is_a?(Reference)
+            index_type = index_type.find { |type| type < value.class }
+          end
+
+          if index_type.is_a?(Class) && (index_type < value.class)
+            value = value.cast_to(index_type, parser)
+          end
+
+          if index_type && parser && Origami::OPTIONS[:enable_type_propagation]
+            if value.is_a?(Reference)
+              parser.defer_type_cast(value, index_type)
+            end
+          end
+        end
+
+        push(value)
+      end
+    end
 
-    Origami is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
+    def pre_build
+      map!(&:to_o)
 
-    Origami is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
+      super
+    end
 
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+    def self.parse(stream, parser = nil, hint_type: nil) # :nodoc:
+      scanner = Parser.init_scanner(stream)
+      offset = scanner.pos
+      data = []
 
-=end
+      if !scanner.skip(@@regexp_open)
+        raise InvalidArrayObjectError, "No token '#{TOKENS.first}' found"
+      end
 
+      while scanner.skip(@@regexp_close).nil?
+        type = Object.typeof(scanner)
+        raise InvalidArrayObjectError, "Bad embedded object format" if type.nil?
 
-module Origami
+        value = type.parse(scanner, parser)
+        data << value
+      end
 
-    class InvalidArrayObjectError < InvalidObjectError #:nodoc:
+      array = Array.new(data, parser, hint_type: hint_type)
+      array.file_offset = offset
+
+      array
     end
 
     #
-    # Class representing an Array Object.
-    # Arrays contain a set of Object.
+    # Converts self into a Ruby array.
     #
-    class Array < ::Array
-        include CompoundObject
-        using TypeConversion
-
-        TOKENS = %w{ [ ] } #:nodoc:
-        @@regexp_open = Regexp.new(WHITESPACES + Regexp.escape(TOKENS.first) + WHITESPACES)
-        @@regexp_close = Regexp.new(WHITESPACES + Regexp.escape(TOKENS.last) + WHITESPACES)
-
-        #
-        # Creates a new PDF Array Object.
-        # _data_:: An array of objects.
-        #
-        def initialize(data = [], parser = nil, hint_type: nil)
-            raise TypeError, "Expected type Array, received #{data.class}." unless data.is_a?(::Array)
-            super()
-
-            data.each_with_index do |value, index|
-                value = value.to_o
-
-                if Origami::OPTIONS[:enable_type_guessing]
-                    index_type = hint_type.is_a?(::Array) ? hint_type[index % hint_type.size] : hint_type
-                    if index_type.is_a?(::Array) and not value.is_a?(Reference)
-                        index_type = index_type.find {|type| type < value.class }
-                    end
-
-                    if index_type.is_a?(Class) and index_type < value.class
-                        value = value.cast_to(index_type, parser)
-                    end
-
-                    if index_type and parser and Origami::OPTIONS[:enable_type_propagation]
-                        if value.is_a?(Reference)
-                            parser.defer_type_cast(value, index_type)
-                        end
-                    end
-                end
-
-                self.push(value)
-            end
-        end
+    def to_a
+      super.map(&:value)
+    end
+    alias_method :value, :to_a
+
+    alias_method :each_value, :each
 
-        def pre_build
-            self.map!(&:to_o)
+    def to_s(eol: $/) # :nodoc:
+      content = TOKENS.first.dup
+      content << map { |entry|
+        entry = entry.to_o
 
-            super
+        case entry
+        when Dictionary # Do not indent dictionaries inside of arrays.
+          entry.to_s(indent: 0, eol: eol)
+        else
+          entry.to_s(eol: eol)
         end
+      }.join(' ')
+      content << TOKENS.last
 
-        def self.parse(stream, parser = nil, hint_type: nil) #:nodoc:
-            scanner = Parser.init_scanner(stream)
-            offset = scanner.pos
-            data = []
+      super(content, eol: eol)
+    end
 
-            if not scanner.skip(@@regexp_open)
-                raise InvalidArrayObjectError, "No token '#{TOKENS.first}' found"
-            end
+    def +(other)
+      a = Origami::Array.new(to_a + other.to_a)
+      a.no, a.generation = @no, @generation
 
-            while scanner.skip(@@regexp_close).nil? do
-                type = Object.typeof(scanner)
-                raise InvalidArrayObjectError, "Bad embedded object format" if type.nil?
+      a
+    end
 
-                value = type.parse(scanner, parser)
-                data << value
-            end
+    def <<(item)
+      super(link_object(item))
+    end
 
-            array = Array.new(data, parser, hint_type: hint_type)
-            array.file_offset = offset
+    def push(*items)
+      items.each { |item| self << item }
+    end
 
-            array
-        end
+    def []=(index, item)
+      super(index, link_object(item))
+    end
 
-        #
-        # Converts self into a Ruby array.
-        #
-        def to_a
-            super.map(&:value)
-        end
-        alias value to_a
+    def insert(index, *items)
+      items.reverse_each do |item|
+        super(index, link_object(item))
+      end
 
-        alias each_value each
+      self
+    end
 
-        def to_s(eol: $/) #:nodoc:
-            content = TOKENS.first.dup
-            content << self.map {|entry|
-                entry = entry.to_o
+    def concat(*arys)
+      push(*arys.flatten)
+    end
 
-                case entry
-                when Dictionary # Do not indent dictionaries inside of arrays.
-                    entry.to_s(indent: 0, eol: eol)
-                else
-                    entry.to_s(eol: eol)
-                end
-            }.join(' ')
-            content << TOKENS.last
+    #
+    # Parameterized Array class with additional typing information.
+    # Example: Array.of(Integer)
+    #
+    def self.of(klass, *klasses, length: nil)
+      Class.new(self) do
+        const_set('ARRAY_TYPE', (klasses.empty? && !klass.is_a?(::Array)) ? klass : [klass].concat(klasses))
+        const_set('STATIC_LENGTH', length)
 
-            super(content, eol: eol)
+        def initialize(data = [], parser = nil)
+          super(data, parser, hint_type: self.class.const_get('ARRAY_TYPE'))
         end
 
-        def +(other)
-            a = Origami::Array.new(self.to_a + other.to_a)
-            a.no, a.generation = @no, @generation
+        def pre_build # :nodoc:
+          do_type_check if Origami::OPTIONS[:enable_type_checking]
 
-            a
+          super
         end
 
-        def <<(item)
-            super link_object(item)
+        def self.parse(stream, parser = nil)
+          super(stream, parser, hint_type: const_get('ARRAY_TYPE'))
         end
 
-        def push(*items)
-            items.each {|item| self << item }
-        end
-
-        def []=(index, item)
-            super(index, link_object(item))
-        end
+        def do_type_check # :nodoc:
+          static_length = self.class.const_get('STATIC_LENGTH')
+          array_type = self.class.const_get('ARRAY_TYPE')
 
-        def insert(index, *items)
-            items.reverse_each do |item|
-                super(index, link_object(item))
-            end
+          if static_length && (self.length != static_length)
+            warn "Warning: object #{self.class.name} has unexpected length #{self.length} (should be #{static_length})"
+          end
 
-            self
-        end
+          each_with_index do |object, index|
+            index_type = array_type.is_a?(::Array) ? array_type[index % array_type.size] : array_type
 
-        def concat(*arys)
-            self.push(*arys.flatten)
-        end
+            begin
+              object_value = object.solve
+            rescue InvalidReferenceError
+              warn "Warning: in object #{self.class}, invalid reference at index #{index}"
+              next
+            end
 
-        #
-        # Parameterized Array class with additional typing information.
-        # Example: Array.of(Integer)
-        #
-        def self.of(klass, *klasses, length: nil)
-            Class.new(self) do
-                const_set('ARRAY_TYPE', (klasses.empty? and not klass.is_a?(::Array)) ? klass : [ klass ].concat(klasses))
-                const_set('STATIC_LENGTH', length)
-
-                def initialize(data = [], parser = nil)
-                    super(data, parser, hint_type: self.class.const_get('ARRAY_TYPE'))
-                end
-
-                def pre_build #:nodoc:
-                    do_type_check if Origami::OPTIONS[:enable_type_checking]
-
-                    super
-                end
-
-                def self.parse(stream, parser = nil)
-                    super(stream, parser, hint_type: const_get('ARRAY_TYPE'))
-                end
-
-                def do_type_check #:nodoc:
-                    static_length = self.class.const_get('STATIC_LENGTH')
-                    array_type = self.class.const_get('ARRAY_TYPE')
-
-                    if static_length and self.length != static_length
-                        STDERR.puts "Warning: object #{self.class.name} has unexpected length #{self.length} (should be #{static_length})"
-                    end
-
-                    self.each_with_index do |object, index|
-                        index_type = array_type.is_a?(::Array) ? array_type[index % array_type.size] : array_type
-
-                        begin
-                            object_value = object.solve
-                        rescue InvalidReferenceError
-                            STDERR.puts "Warning: in object #{self.class}, invalid reference at index #{index}"
-                            next
-                        end
-
-                        unless object_value.is_a?(index_type)
-                            STDERR.puts "Warning: object #{self.class.name || 'Array'} should be composed of #{index_type.name} at index #{index} (got #{object_value.type} instead)"
-                        end
-                    end
-                end
+            unless object_value.is_a?(index_type)
+              warn "Warning: object #{self.class.name || "Array"} should be composed of #{index_type.name} at index #{index} (got #{object_value.type} instead)"
             end
+          end
         end
+      end
     end
-
-    #
-    # Class representing a location on a page or a bounding box.
-    #
-    class Rectangle < Array.of(Number, length: 4)
-
-        def self.[](coords)
-            corners =
-                if [ :llx, :lly, :urx, :ury ].all? {|p| coords.include?(p)}
-                    coords.values_at(:llx, :lly, :urx, :ury)
-                elsif [ :width, :height ].all? {|p| coords.include?(p)}
-                    width, height = coords.values_at(:width, :height)
-                    x = coords.fetch(:x, 0)
-                    y = coords.fetch(:y, 0)
-                    [ x, y, x+width, y+height ]
-                else
-                    raise ArgumentError, "Bad arguments for #{self.class}: #{coords.inspect}"
-                end
-
-            unless corners.all? { |corner| corner.is_a?(Numeric) }
-                raise TypeError, "All coords must be numbers"
-            end
-
-            Rectangle.new(corners)
+  end
+
+  #
+  # Class representing a location on a page or a bounding box.
+  #
+  class Rectangle < Array.of(Number, length: 4)
+    def self.[](coords)
+      corners =
+        if [:llx, :lly, :urx, :ury].all? { |p| coords.include?(p) }
+          coords.values_at(:llx, :lly, :urx, :ury)
+        elsif [:width, :height].all? { |p| coords.include?(p) }
+          width, height = coords.values_at(:width, :height)
+          x = coords.fetch(:x, 0)
+          y = coords.fetch(:y, 0)
+          [x, y, x + width, y + height]
+        else
+          raise ArgumentError, "Bad arguments for #{self.class}: #{coords.inspect}"
         end
 
-        def width
-            self[2] - self[0]
-        end
+      unless corners.all? { |corner| corner.is_a?(Numeric) }
+        raise TypeError, "All coords must be numbers"
+      end
 
-        def height
-            self[3] - self[1]
-        end
+      Rectangle.new(corners)
     end
 
+    def width
+      self[2] - self[0]
+    end
+
+    def height
+      self[3] - self[1]
+    end
+  end
 end

data/lib/origami/boolean.rb

@@ -1,90 +1,86 @@
-=begin
-
-    This file is part of Origami, PDF manipulation framework for Ruby
-    Copyright (C) 2016	Guillaume Delugré.
-
-    Origami is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    Origami is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
-
-=end
+# frozen_string_literal: true
+
+#
+#     This file is part of Origami, PDF manipulation framework for Ruby
+#     Copyright (C) 2016	Guillaume Delugré.
+#
+#     Origami is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Lesser General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     Origami is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public License
+#     along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+#
 
 module Origami
+  class InvalidBooleanObjectError < InvalidObjectError # :nodoc:
+  end
 
-    class InvalidBooleanObjectError < InvalidObjectError #:nodoc:
-    end
+  #
+  # Class representing a Boolean Object.
+  # A Boolean Object can be *true* or *false*.
+  #
+  class Boolean
+    include Origami::Object
+
+    TOKENS = %w[true false] # :nodoc:
+    @@regexp = Regexp.new(WHITESPACES + "(?<value>#{Regexp.union(TOKENS)})")
 
     #
-    # Class representing a Boolean Object.
-    # A Boolean Object can be *true* or *false*.
+    # Creates a new Boolean value.
+    # _value_:: *true* or *false*.
     #
-    class Boolean
-        include Origami::Object
-
-        TOKENS = %w{ true false } #:nodoc:
-        @@regexp = Regexp.new(WHITESPACES + "(?<value>#{Regexp.union(TOKENS)})")
-
-        #
-        # Creates a new Boolean value.
-        # _value_:: *true* or *false*.
-        #
-        def initialize(value)
-            unless value.is_a?(TrueClass) or value.is_a?(FalseClass)
-                raise TypeError, "Expected type TrueClass or FalseClass, received #{value.class}."
-            end
+    def initialize(value)
+      unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        raise TypeError, "Expected type TrueClass or FalseClass, received #{value.class}."
+      end
 
-            super()
+      super()
 
-            @value = (value == true)
-        end
-
-        def to_s(eol: $/) #:nodoc:
-            super(@value.to_s, eol: eol)
-        end
+      @value = (value == true)
+    end
 
-        def self.parse(stream, _parser = nil) #:nodoc:
-            scanner = Parser.init_scanner(stream)
-            offset = scanner.pos
+    def to_s(eol: $/) # :nodoc:
+      super(@value.to_s, eol: eol)
+    end
 
-            if scanner.scan(@@regexp).nil?
-                raise InvalidBooleanObjectError
-            end
+    def self.parse(stream, _parser = nil) # :nodoc:
+      scanner = Parser.init_scanner(stream)
+      offset = scanner.pos
 
-            value = (scanner['value'] == "true")
+      if scanner.scan(@@regexp).nil?
+        raise InvalidBooleanObjectError
+      end
 
-            bool = Boolean.new(value)
-            bool.file_offset = offset
+      value = (scanner['value'] == "true")
 
-            bool
-        end
+      bool = Boolean.new(value)
+      bool.file_offset = offset
 
-        #
-        # Converts self into a Ruby boolean, that is TrueClass or FalseClass instance.
-        #
-        def value
-            @value
-        end
+      bool
+    end
 
-        def false?
-            @value == false
-        end
+    #
+    # Converts self into a Ruby boolean, that is TrueClass or FalseClass instance.
+    #
+    attr_reader :value
 
-        def true?
-            @value == true
-        end
+    def false?
+      @value == false
+    end
 
-        def ==(bool)
-            @value == bool
-        end
+    def true?
+      @value == true
     end
 
+    def ==(other)
+      @value == other
+    end
+  end
 end