prawnx 0.1.1

data/lib/prawnx/pdf_a.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "time"
+
+module PrawnX
+  module Errors
+    PdfAViolation = Class.new(StandardError)
+  end
+
+  # PDF/A-3b (ISO 19005-3), switched on with Prawn::Document.new(pdf_a: true): XMP metadata matching the
+  # document information, an sRGB output intent, a file identifier, and errors for what PDF/A forbids.
+  # Factur-X invoices (pdf.factur_x) embed their CII XML into such a document.
+  module PdfA
+    FACTUR_X_NAMESPACE = "urn:factur-x:pdfa:CrossIndustryDocument:invoice:1p0#"
+    FACTUR_X_FILENAME = "factur-x.xml"
+    # Profile names of the Factur-X specification, and the relationship it gives the XML of each (§ 6.2.2).
+    FACTUR_X_LEVEL_BY_PROFILE = {
+      minimum: "MINIMUM", basic_wl: "BASIC WL", basic: "BASIC", en16931: "EN 16931", extended: "EXTENDED",
+    }.freeze
+    RELATIONSHIP_BY_PROFILE = {
+      minimum: :Data, basic_wl: :Data, basic: :Alternative, en16931: :Alternative, extended: :Alternative,
+    }.freeze
+    # Annotation flag 3, Print: PDF/A requires printing every annotation (ISO 19005-2 §6.3.2).
+    PRINT_FLAG = 4
+    XMP_PROPERTY_BY_INFO_KEY = {
+      Title: "dc:title", Author: "dc:creator", Subject: "dc:description", Keywords: "pdf:Keywords",
+      Creator: "xmp:CreatorTool", Producer: "pdf:Producer", CreationDate: "xmp:CreateDate", ModDate: "xmp:ModifyDate",
+    }.freeze
+
+    def pdf_a?
+      @pdf_a == true
+    end
+
+    def factur_x(xml, profile: :en16931, filename: FACTUR_X_FILENAME, description: "Factur-X invoice")
+      raise Errors::PdfAViolation, "Factur-X invoices are PDF/A-3 documents: create this one with pdf_a: true" unless pdf_a?
+
+      level = FACTUR_X_LEVEL_BY_PROFILE.fetch(profile) { raise ArgumentError, "Unknown Factur-X profile #{profile.inspect}: #{FACTUR_X_LEVEL_BY_PROFILE.keys.join(", ")}" }
+      @factur_x = {xml: xml.b, level:, relationship: RELATIONSHIP_BY_PROFILE.fetch(profile), filename:, description:}
+    end
+
+    private
+
+    def finalize_pdf_a
+      min_version(1.7)
+      icc_profile = ref!({N: 3}, PdfA::SrgbProfile.bytes)
+      @root.data[:OutputIntents] = [{
+        Type: :OutputIntent, S: :GTS_PDFA1, OutputConditionIdentifier: PDF::LiteralString.new(SrgbProfile::DESCRIPTION),
+        Info: PDF::LiteralString.new(SrgbProfile::DESCRIPTION), DestOutputProfile: icc_profile,
+      }]
+      embed_factur_x if @factur_x
+      metadata = ref!({Type: :Metadata, Subtype: :XML}, xmp_packet)
+      metadata.uncompressed = true
+      @root.data[:Metadata] = metadata
+    end
+
+    def embed_factur_x
+      xml = @factur_x[:xml]
+      modification_date = @info.data[:ModDate] || @info.data[:CreationDate]
+      params = {Size: xml.bytesize}
+      params[:ModDate] = modification_date if modification_date
+      embedded_file = ref!({Type: :EmbeddedFile, Subtype: :"text/xml", Params: params}, xml)
+      file_specification = ref!(
+        Type: :Filespec, F: PDF::LiteralString.new(@factur_x[:filename]), UF: @factur_x[:filename],
+        Desc: @factur_x[:description], AFRelationship: @factur_x[:relationship], EF: {F: embedded_file, UF: embedded_file},
+      )
+      @root.data[:AF] = [file_specification]
+      (names.data[:EmbeddedFiles] ||= ref!(PDF::NameTree.new)).data.add(@factur_x[:filename], file_specification)
+    end
+
+    def xmp_packet
+      properties = XMP_PROPERTY_BY_INFO_KEY.filter_map do |key, property|
+        value = @info.data[key]
+        next unless value
+
+        text = value.is_a?(Time) ? value.iso8601 : escape_xml(value.to_s)
+        case property
+        when "dc:title", "dc:description" then "<#{property}><rdf:Alt><rdf:li xml:lang=\"x-default\">#{text}</rdf:li></rdf:Alt></#{property}>"
+        when "dc:creator" then "<#{property}><rdf:Seq><rdf:li>#{text}</rdf:li></rdf:Seq></#{property}>"
+        else "<#{property}>#{text}</#{property}>"
+        end
+      end
+      <<~XMP
+        <?xpacket begin="\u{FEFF}" id="W5M0MpCehiHzreSzNTczkc9d"?>
+        <x:xmpmeta xmlns:x="adobe:ns:meta/">
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="" xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:pdf="http://ns.adobe.com/pdf/1.3/" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
+        <pdfaid:part>3</pdfaid:part>
+        <pdfaid:conformance>B</pdfaid:conformance>
+        #{properties.join("\n")}
+        </rdf:Description>
+        #{factur_x_xmp}
+        </rdf:RDF>
+        </x:xmpmeta>
+        <?xpacket end="w"?>
+      XMP
+    end
+
+    # The Factur-X properties, and the PDF/A extension schema declaring them (Factur-X specification § 6.2.1).
+    def factur_x_xmp
+      return "" unless @factur_x
+
+      fields = {DocumentFileName: "name of the embedded XML invoice file", DocumentType: "INVOICE",
+                Version: "The actual version of the Factur-X XML schema", ConformanceLevel: "The conformance level of the embedded Factur-X data"}
+      described = fields.map do |name, description|
+        "<rdf:li rdf:parseType=\"Resource\"><pdfaProperty:name>#{name}</pdfaProperty:name><pdfaProperty:valueType>Text</pdfaProperty:valueType>" \
+          "<pdfaProperty:category>external</pdfaProperty:category><pdfaProperty:description>#{description}</pdfaProperty:description></rdf:li>"
+      end
+      <<~XMP
+        <rdf:Description rdf:about="" xmlns:fx="#{FACTUR_X_NAMESPACE}">
+        <fx:DocumentType>INVOICE</fx:DocumentType>
+        <fx:DocumentFileName>#{escape_xml(@factur_x[:filename])}</fx:DocumentFileName>
+        <fx:Version>1.0</fx:Version>
+        <fx:ConformanceLevel>#{@factur_x[:level]}</fx:ConformanceLevel>
+        </rdf:Description>
+        <rdf:Description rdf:about="" xmlns:pdfaExtension="http://www.aiim.org/pdfa/ns/extension/" xmlns:pdfaSchema="http://www.aiim.org/pdfa/ns/schema#" xmlns:pdfaProperty="http://www.aiim.org/pdfa/ns/property#">
+        <pdfaExtension:schemas><rdf:Bag><rdf:li rdf:parseType="Resource">
+        <pdfaSchema:schema>Factur-X PDFA Extension Schema</pdfaSchema:schema>
+        <pdfaSchema:namespaceURI>#{FACTUR_X_NAMESPACE}</pdfaSchema:namespaceURI>
+        <pdfaSchema:prefix>fx</pdfaSchema:prefix>
+        <pdfaSchema:property><rdf:Seq>#{described.join}</rdf:Seq></pdfaSchema:property>
+        </rdf:li></rdf:Bag></pdfaExtension:schemas>
+        </rdf:Description>
+      XMP
+    end
+
+    def escape_xml(text)
+      text.encode(xml: :text)
+    end
+  end
+end

data/lib/prawnx/pdf_core.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# The few PDF::Core helpers and constants code written for Prawn reaches for directly, prawn-svg among it.
+module PDF
+  module Core
+    PageGeometry = PrawnX::PageGeometry
+    LiteralString = PrawnX::PDF::LiteralString
+    ByteString = PrawnX::PDF::ByteString
+    Reference = PrawnX::PDF::Reference
+
+    module_function
+
+    def real(number)
+      PrawnX::PDF.real(number)
+    end
+
+    def real_params(numbers)
+      PrawnX::PDF.real_params(numbers)
+    end
+
+    def pdf_object(object, in_content_stream = false)
+      PrawnX::PDF.serialize(object, in_content_stream)
+    end
+  end
+end

data/lib/prawnx/repeater.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    def repeat(page_filter, options = {}, &block)
+      repeaters << Repeater.new(self, page_filter, options.fetch(:dynamic, false), &block)
+    end
+
+    def number_pages(string, options = {})
+      options = options.dup
+      start_count_at = options.delete(:start_count_at)
+      page_filter = options.key?(:page_filter) ? options.delete(:page_filter) : :all
+      total_pages = options.delete(:total_pages)
+      text_color = options.delete(:color)
+      options[:height] = 50 unless options.key?(:height)
+
+      counting = false
+      pseudo_page = 0
+      (1..page_count).each do |page_number|
+        unless counting
+          pseudo_page =
+            case start_count_at
+            when String then Integer(start_count_at, 10)
+            when (1..) then Integer(start_count_at)
+            else 1
+            end
+        end
+        if page_match?(page_filter, page_number)
+          go_to_page(page_number)
+          fill_color(text_color) unless text_color.nil?
+          total_pages = page_count if total_pages.nil?
+          text_box(string.gsub("<page>", pseudo_page.to_s).gsub("<total>", total_pages.to_s), options)
+          counting = true
+        end
+        pseudo_page += 1 if counting
+      end
+    end
+  end
+
+  # Content drawn on every page matching a filter when the document renders: stamped once, or drawn again on
+  # each page when dynamic.
+  class Repeater
+    class << self
+      attr_writer :count
+
+      def count
+        @count ||= 0
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(document, page_filter, dynamic = false, &block)
+      @document = document
+      @page_filter = page_filter
+      @dynamic = dynamic
+      @stamp_name = "prawn_repeater(#{document.repeaters.size})"
+      @document.create_stamp(@stamp_name, &block) unless dynamic
+      @block = block if dynamic
+      @graphic_state = document.page.graphic_state.dup
+      Repeater.count += 1
+    end
+
+    def match?(page_number)
+      @document.page_match?(@page_filter, page_number)
+    end
+
+    def run(page_number)
+      return unless match?(page_number)
+      return @document.stamp(@stamp_name) unless @dynamic
+      return unless @block
+
+      @document.save_graphics_state(@graphic_state) do
+        @document.__send__(:freeze_stamp_graphics)
+        @block.call
+      end
+    end
+  end
+end

data/lib/prawnx/security.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module PrawnX
+  class Document
+    # The standard security handler, revision 2: 40-bit RC4 (ISO 32000-1 §7.6.3).
+    module Security
+      PERMISSIONS_BITS = {print_document: 3, modify_contents: 4, copy_contents: 5, modify_annotations: 6}.freeze
+      FULL_PERMISSIONS = 0xFFFFFFFF
+      PASSWORD_PADDING = ["28BF4E5E4E758A4164004E56FFFA01082E2E00B6D0683E802F0CA9FE6453697A"].pack("H*").freeze
+      KEY_LENGTH_BYTES = 5
+      private_constant :PERMISSIONS_BITS, :FULL_PERMISSIONS
+
+      def encrypt_document(options = {})
+        raise Errors::PdfAViolation, "PDF/A forbids encryption" if pdf_a?
+
+        PrawnX.verify_options(%i[user_password owner_password permissions], options)
+        @user_password = options.delete(:user_password) || ""
+        @owner_password = options.delete(:owner_password) || @user_password
+        @owner_password = Random.bytes(32) if @owner_password == :random
+        self.permissions = options.delete(:permissions) || {}
+        @encryption = Encryption.new(user_password: @user_password, owner_password: @owner_password, permissions: permissions_value)
+      end
+
+      def self.encrypt_string(string, key, identifier, generation)
+        Arcfour.new(object_key(key, identifier, generation)).encrypt(string)
+      end
+
+      # The key of one object: the document key extended with its number and generation (algorithm 1).
+      def self.object_key(key, identifier, generation)
+        Digest::MD5.digest(key + [identifier].pack("V")[0, 3] + [generation].pack("V")[0, 2])[0, key.bytesize + 5]
+      end
+
+      def self.pad_password(password)
+        password = password.b[0, 32]
+        password + PASSWORD_PADDING[0, 32 - password.bytesize]
+      end
+
+      private
+
+      def permissions=(permissions = {})
+        @permissions ||= FULL_PERMISSIONS
+        permissions.each do |key, value|
+          raise ArgumentError, "Unknown permission :#{key}. Valid options: #{PERMISSIONS_BITS.keys.map(&:inspect).join(", ")}" unless PERMISSIONS_BITS[key]
+
+          bit = 1 << (PERMISSIONS_BITS[key] - 1)
+          @permissions = value ? @permissions | bit : @permissions & ~bit
+        end
+      end
+
+      def permissions_value
+        @permissions || FULL_PERMISSIONS
+      end
+    end
+
+    # The keys and dictionary of an encrypted document, which depend on its file identifier.
+    class Encryption
+      def initialize(user_password:, owner_password:, permissions:)
+        @user_password = user_password
+        @owner_password = owner_password
+        @permissions = permissions
+      end
+
+      def owner_password_hash
+        @owner_password_hash ||= begin
+          key = Digest::MD5.digest(Security.pad_password(@owner_password))[0, Security::KEY_LENGTH_BYTES]
+          Arcfour.new(key).encrypt(Security.pad_password(@user_password))
+        end
+      end
+
+      def key(file_identifier)
+        Digest::MD5.digest(Security.pad_password(@user_password) + owner_password_hash + [@permissions].pack("V") + file_identifier)[0, Security::KEY_LENGTH_BYTES]
+      end
+
+      def dictionary(file_identifier)
+        user_password_hash = Arcfour.new(key(file_identifier)).encrypt(Security::PASSWORD_PADDING)
+        {Filter: :Standard, V: 1, R: 2, O: PDF::ByteString.new(owner_password_hash), U: PDF::ByteString.new(user_password_hash),
+         P: [@permissions].pack("L").unpack1("l")}
+      end
+    end
+
+    # RC4, the stream cipher of the standard security handler's first revisions.
+    class Arcfour
+      def initialize(key)
+        @state = (0..255).to_a
+        j = 0
+        key_bytes = key.bytes
+        256.times do |i|
+          j = (j + @state[i] + key_bytes[i % key_bytes.size]) & 0xFF
+          @state[i], @state[j] = @state[j], @state[i]
+        end
+      end
+
+      def encrypt(string)
+        state = @state.dup
+        i = 0
+        j = 0
+        string.b.bytes.map do |byte|
+          i = (i + 1) & 0xFF
+          j = (j + state[i]) & 0xFF
+          state[i], state[j] = state[j], state[i]
+          byte ^ state[(state[i] + state[j]) & 0xFF]
+        end.pack("C*")
+      end
+    end
+  end
+end

data/lib/prawnx/stamp.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module PrawnX
+  # Content drawn once into a form XObject, then placed on any page by name.
+  module Stamp
+    def stamp(name)
+      dictionary_name, dictionary = stamp_dictionary(name)
+      add_content("/#{dictionary_name} Do")
+      annotations = dictionary.data[:Annots]
+      page.dictionary.data[:Annots] = (page.dictionary.data[:Annots] || []) | annotations if annotations&.any?
+      page.xobjects[dictionary_name] = dictionary
+    end
+
+    def stamp_at(name, point, &)
+      translate(point[0], point[1]) { stamp(name) }
+    end
+
+    def create_stamp(name, &)
+      page.stamp_stream(create_stamp_dictionary(name), &)
+    end
+
+    private
+
+    def stamp_dictionary_registry
+      @stamp_dictionary_registry ||= {}
+    end
+
+    def stamp_dictionary(name)
+      raise Errors::InvalidName if name.empty?
+      raise Errors::UndefinedObjectName unless stamp_dictionary_registry.key?(name)
+
+      stamp_dictionary_registry[name].values_at(:stamp_dictionary_name, :stamp_dictionary)
+    end
+
+    def create_stamp_dictionary(name)
+      raise Errors::InvalidName if name.empty?
+      raise Errors::NameTaken if stamp_dictionary_registry.key?(name)
+
+      _left, _bottom, width, height = page.dimensions
+      dictionary = ref!({Type: :XObject, Subtype: :Form, BBox: [0, 0, width, height]}, +"")
+      stamp_dictionary_registry[name] = {stamp_dictionary_name: "Stamp#{stamp_dictionary_registry.length + 1}", stamp_dictionary: dictionary}
+      dictionary
+    end
+
+    def freeze_stamp_graphics
+      update_colors
+      write_line_width
+      write_stroke_cap_style
+      write_stroke_join_style
+      write_stroke_dash
+    end
+  end
+
+  module SoftMask
+    def soft_mask(&)
+      min_version(1.4)
+      group_attributes = ref!(Type: :Group, S: :Transparency, CS: :DeviceRGB, I: false, K: false)
+      group = ref!({Type: :XObject, Subtype: :Form, BBox: page.dimensions, Group: group_attributes}, +"")
+      page.stamp_stream(group, &)
+      mask = ref!(Type: :Mask, S: :Luminosity, G: group)
+      graphic_state_dictionary = ref!(Type: :ExtGState, SMask: mask, AIS: false, BM: :Normal, OP: false, op: false, OPM: 1, SA: true)
+
+      registry_key = [page.dimensions, group.stream, page_count].hash
+      @soft_mask_registry ||= {}
+      unless @soft_mask_registry[registry_key]
+        masks = page.resources[:ExtGState] ||= {}
+        name = masks.empty? ? "GS1" : masks.keys.max.succ
+        masks[name] = graphic_state_dictionary
+        @soft_mask_registry[registry_key] = name
+      end
+      add_content("/#{@soft_mask_registry[registry_key]} gs")
+    end
+  end
+end

data/lib/prawnx/table/cell/kinds.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Table
+    class Cell
+      class Text < Cell
+        TextOptions = %i[inline_format kerning size align valign rotate rotate_around leading single_line skip_encoding overflow min_font_size].freeze
+
+        TextOptions.each do |option|
+          define_method(:"#{option}=") { |value| @text_options[option] = value }
+          define_method(option) { @text_options[option] }
+        end
+
+        attr_writer :font, :text_color
+
+        def initialize(pdf, point, options = {})
+          @text_options = {}
+          super
+        end
+
+        def font
+          with_font { @pdf.font }
+        end
+
+        def font_style=(style)
+          @text_options[:style] = style
+        end
+
+        def natural_content_width
+          @natural_content_width ||= [styled_width_of(@content), @pdf.bounds.width].min
+        end
+
+        def natural_content_height
+          with_font do
+            @laid_out_box = text_box(width: spanned_content_width + FPTolerance)
+            @laid_out_box.render(dry_run: true, keep_layout: true)
+            @layout_inputs = layout_inputs
+            @laid_out_box.height + @laid_out_box.line_gap
+          end
+        end
+
+        def draw_content
+          with_font do
+            @pdf.move_down((@pdf.font.line_gap + @pdf.font.descender) / 2)
+            with_text_color do
+              if laid_out_box_reusable?
+                @laid_out_box.render_laid_out([0, @pdf.cursor])
+              else
+                text_box(width: spanned_content_width + FPTolerance, height: spanned_content_height + FPTolerance, at: [0, @pdf.cursor]).render
+              end
+            end
+          end
+        end
+
+        def set_width_constraints
+          unless @min_width
+            @min_width = padding_left + padding_right + [natural_content_width, styled_width_of("M")].min
+            super
+          end
+        end
+
+        protected
+
+        def with_font
+          @pdf.save_font do
+            options = {}
+            options[:style] = @text_options[:style] if @text_options[:style]
+            options[:style] ||= @pdf.font.options[:style] if @pdf.font.options[:style]
+            @pdf.font(@font || @pdf.font.family, options)
+            yield
+          end
+        end
+
+        def with_text_color
+          return yield unless @text_color
+
+          begin
+            old_color = @pdf.fill_color || "000000"
+            @pdf.fill_color(@text_color)
+            yield
+          ensure
+            @pdf.fill_color(old_color)
+          end
+        end
+
+        def text_box(extra_options = {})
+          inline_format = @text_options[:inline_format]
+          if inline_format
+            options = @text_options.except(:inline_format).merge(extra_options).merge(document: @pdf)
+            array = @pdf.text_formatter.format(@content, *(inline_format.is_a?(Array) ? inline_format : []))
+            PrawnX::Text::Formatted::Box.new(array, options)
+          else
+            PrawnX::Text::Box.new(@content, @text_options.merge(extra_options).merge(document: @pdf))
+          end
+        end
+
+        def styled_width_of(text)
+          @pdf.width_of(text, @text_options)
+        end
+
+        private
+
+        # A cell is laid out while the table is sized, then drawn: the layout is drawn again unless
+        # before_rendering_page, the document or a truncating height changed what the cell would wrap.
+        def laid_out_box_reusable?
+          @laid_out_box&.layout_reusable? && @laid_out_box.height <= spanned_content_height + FPTolerance &&
+            @layout_inputs == layout_inputs
+        end
+
+        def layout_inputs
+          [@content.dup, spanned_content_width, @text_options.dup, @pdf.font, @pdf.font_size, @pdf.default_leading,
+            @pdf.character_spacing, @pdf.text_direction, @pdf.fallback_fonts, @pdf.default_kerning?]
+        end
+      end
+
+      class Subtable < Cell
+        attr_reader :subtable
+
+        def initialize(pdf, point, options = {})
+          super
+          @subtable = options[:content]
+          @padding = [0, 0, 0, 0]
+        end
+
+        def text_color=(color)
+          @subtable.cells.text_color = color
+        end
+
+        def natural_content_width
+          @subtable.cells.width
+        end
+
+        def min_width
+          @subtable.cells.min_width
+        end
+
+        def max_width
+          @subtable.cells.max_width
+        end
+
+        def natural_content_height
+          @subtable.cells.height
+        end
+
+        def draw_content
+          @subtable.draw
+        end
+      end
+
+      class Image < Cell
+        def initialize(pdf, point, options = {})
+          @image_options = {}
+          super
+          @pdf_object, @image_info = @pdf.build_image_object(@file)
+          @natural_width, @natural_height = @image_info.calc_image_dimensions(@image_options)
+        end
+
+        def image=(file)
+          @file = file
+        end
+
+        {scale: :scale, fit: :fit, image_height: :height, image_width: :width, position: :position, vposition: :vposition}.each do |setter, option|
+          define_method(:"#{setter}=") { |value| @image_options[option] = value }
+        end
+
+        def natural_content_width
+          @natural_width
+        end
+
+        def natural_content_height
+          @natural_height
+        end
+
+        def draw_content
+          @pdf.embed_image(@pdf_object, @image_info, @image_options)
+        end
+      end
+
+      # Stands in the place a spanning cell covers beyond its first row and column, passing on the styles of
+      # its right and bottom edges.
+      class SpanDummy < Cell
+        def initialize(pdf, master_cell)
+          super(pdf, [0, pdf.cursor])
+          @master_cell = master_cell
+          @padding = [0, 0, 0, 0]
+        end
+
+        def natural_content_height
+          0
+        end
+
+        def natural_content_width
+          0
+        end
+
+        def avg_spanned_min_width
+          @master_cell.avg_spanned_min_width
+        end
+
+        def draw_borders(_point)
+        end
+
+        def draw_bounded_content(_point)
+        end
+
+        def padding_right=(value)
+          @master_cell.padding_right = value if rightmost?
+        end
+
+        def padding_bottom=(value)
+          @master_cell.padding_bottom = value if bottommost?
+        end
+
+        def border_right_color=(value)
+          @master_cell.border_right_color = value if rightmost?
+        end
+
+        def border_bottom_color=(value)
+          @master_cell.border_bottom_color = value if bottommost?
+        end
+
+        def border_right_width=(value)
+          @master_cell.border_right_width = value if rightmost?
+        end
+
+        def border_bottom_width=(value)
+          @master_cell.border_bottom_width = value if bottommost?
+        end
+
+        def background_color
+          @master_cell.background_color
+        end
+
+        private
+
+        def rightmost?
+          @column == @master_cell.column + @master_cell.colspan - 1
+        end
+
+        def bottommost?
+          @row == @master_cell.row + @master_cell.rowspan - 1
+        end
+      end
+    end
+  end
+end