thinreports 0.6.0.pre3

data/lib/thinreports/generator.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+module ThinReports
+
+  module Generator
+    # @param [Symbol] type
+    # @param report (see ThinReports::Generator::Base#initialize)
+    # @param options (see ThinReports::Generator::Base#initialize)
+    def self.new(type, report, options = {})
+      unless generator = registry[type]
+        raise ThinReports::Errors::UnknownGeneratorType
+      end
+      generator.new(report, options)
+    end
+    
+    # @private
+    def self.register(type, generator)
+      registry[type] = generator
+    end
+    
+    # @private
+    def self.registry
+      @generators ||= {}
+    end
+  end
+end
+
+require 'thinreports/generator/base'
+require 'thinreports/generator/pxd'
+require 'thinreports/generator/pdf'

data/lib/thinreports/generator/base.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+module ThinReports
+  module Generator
+    
+    # @abstract
+    class Base
+      # @return [ThinReports::Report::Base]
+      # @private
+      attr_reader :report
+
+      # @return [Hash]
+      # @private
+      attr_reader :options
+      
+      # @private
+      def self.inherited(g)
+        Generator.register(g.name.split('::').last.downcase.to_sym, g);
+      end
+      
+      # @param [ThinReports::Report::Base] report
+      # @param [Hash] options
+      def initialize(report, options = {})
+        report.finalize
+        
+        @report  = report.internal
+        @options = options || {}
+      end
+      
+      # @return [String]
+      # @abstract
+      def generate
+        raise NotImplementedError
+      end
+      
+      # @param [String] filename
+      # @abstract
+      def generate_file(filename)
+        raise NotImplementedError
+      end
+      
+      # @private
+      def default_layout
+        report.default_layout
+      end      
+    end
+    
+  end
+end

data/lib/thinreports/generator/pdf.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'prawn'
+
+module ThinReports
+  module Generator
+    
+    class Pdf < Base
+      # @param report (see ThinReports::Generator::Base#initialize)
+      # @param [Hash] options
+      # @option options [Hash] :security (nil)
+      #   See Prawn::Document#encrypt_document
+      def initialize(report, options)
+        super
+        @pdf     = Document.new(options)
+        @drawers = {}
+        @current_format = nil
+      end
+      
+      # @see ThinReports::Generator::Base#generate
+      def generate
+        draw_report
+        @pdf.render
+      end
+      
+      # @see ThinReports::Generator::Base#generate_file
+      def generate_file(filename)
+        draw_report
+        @pdf.render_file(filename)
+      end
+      
+    private
+      
+      def draw_report
+        report.pages.each do |page|
+          draw_page(page)
+        end
+      end
+      
+      def draw_page(page)
+        return @pdf.add_blank_page if page.blank?
+        
+        format = page.layout.format
+        # On format change.
+        unless @current_format == format.identifier
+          @pdf.start_new_page(format)
+        else
+          @pdf.start_new_page
+        end
+        drawer(format).draw(page.manager)
+      end
+      
+      def drawer(format)
+        @drawers[format.identifier] ||= Drawer::Page.new(@pdf, format)
+      end      
+    end
+    
+  end
+end
+
+require 'thinreports/generator/pdf/prawn_ext'
+require 'thinreports/generator/pdf/document'
+require 'thinreports/generator/pdf/drawer'

data/lib/thinreports/generator/pdf/document.rb

@@ -0,0 +1,171 @@
+# coding: utf-8
+
+require 'thinreports/generator/pdf/document/font'
+require 'thinreports/generator/pdf/document/parse_color'
+require 'thinreports/generator/pdf/document/graphics'
+require 'thinreports/generator/pdf/document/draw_shape'
+require 'thinreports/generator/pdf/document/parse_svg'
+
+module ThinReports
+  module Generator
+    
+    # @private
+    class Pdf::Document
+      include Pdf::Font
+      include Pdf::ParseColor
+      include Pdf::Graphics
+      include Pdf::DrawShape
+      include Pdf::ParseSVG
+      
+      # @param options (see ThinReports::Generator::Pdf#initialize)
+      def initialize(options = {})
+        @pdf = Prawn::Document.new(
+          :skip_page_creation => true,
+          :margin => [0, 0],
+          :info   => {:Creator => 'ThinReports Generator for Ruby ' +
+                                  ThinReports::VERSION}
+        )
+        @format_stamp_registry = []
+        
+        # Setup to Prawn::Document.
+        setup_fonts
+        setup_custom_graphic_states
+        
+        # Encrypts the document.
+        if options[:security]
+          @pdf.encrypt_document(options[:security])
+        end
+      end
+      
+      # @param [ThinReports::Layout::Format] format (nil)
+      def start_new_page(format = nil)
+        options   = {}
+        format_id = format.identifier
+        
+        if format
+          options[:layout] = format.page_orientation.to_sym
+          options[:size]   = if format.user_paper_type?
+            [format.page_width.to_f, format.page_height.to_f]
+          else
+            format.page_paper_type
+          end
+        end
+        
+        pdf.start_new_page(options)
+        
+        # @note
+        #   The best way is to create a template for each layout.
+        #   However, in the latest Prawn library, because of problems handling
+        #   the template that you want supported by future releases.
+        # @see https://github.com/sandal/prawn/issues/199
+        unless format_stamp_registry.include?(format_id)
+          create_format_stamp(format)
+        end
+        # Apply the static shapes of current format.
+        stamp(format_id.to_s)
+      end
+      
+      def add_blank_page
+        pdf.start_new_page(pdf.page_count.zero? ? {:size => 'A4'} : {})
+      end
+      
+      # Delegate to Prawn::Document#render
+      # @see Prawn::Document#render
+      def render
+        result = pdf.render
+        finalize
+        result
+      end
+      
+      # Delegate to Prawn::Document#render_file
+      # @see Prawn::Document#render_file
+      def render_file(*args)
+        finalize
+        pdf.render_file(*args)
+      end
+      
+      # @param [Numeric, String] x
+      # @param [Numeric, String] y
+      def translate(x, y, &block)
+        x, y = rpos(x, y)
+        pdf.translate(x, y, &block)
+      end
+      
+      # @param [String] stamp_id
+      # @param [Array<Numeric>] at (nil)
+      def stamp(stamp_id, at = nil)
+        unless at.nil?
+          pdf.stamp_at(stamp_id, rpos(*at))
+        else
+          pdf.stamp(stamp_id)
+        end
+      end
+      
+      # Delegate to Prawn::Document#create_stamp
+      # @param [String] id
+      # @see Prawn::Document#create_stamp
+      def create_stamp(id, &block)
+        pdf.create_stamp(id, &block)
+      end
+      
+      # @private
+      # @see #pdf
+      def internal
+        @pdf
+      end
+      
+    private
+      
+      # @return [Prawn::Document]
+      attr_reader :pdf
+      
+      # @return [Array<Symbol>]
+      attr_reader :format_stamp_registry
+      
+      def finalize
+        clean_temp_images
+      end
+      
+      # @param [ThinReports::Layout::Format] format
+      def create_format_stamp(format)
+        create_stamp(format.identifier.to_s) do
+          parse_svg(format.layout, '/svg/g')
+        end
+        format_stamp_registry << format.identifier
+      end      
+      
+      # @param [Array<String, Numeric>] values
+      # @return [Numeric, Array<Numeric>, nil]
+      def s2f(*values)
+        return nil if values.empty?
+        
+        if values.size == 1
+          if value = values.first
+            value.is_a?(::Numeric) ? value : value.to_f
+          end
+        else
+          values.map {|v| s2f(v) }
+        end
+      end
+      
+      # @param [Numeric, String] x
+      # @param [Numeric, String] y
+      # @return [Array<Float>]
+      def map_to_upper_left_relative_position(x, y)
+        x, y = s2f(x, y)
+        [x, -y]
+      end
+      alias_method :rpos, :map_to_upper_left_relative_position
+      
+      # @param [Numeric, String] x
+      # @param [Numeric, String] y
+      # @return [Array<Float>]
+      def map_to_upper_left_position(x, y)
+        x, y = s2f(x, y)
+        [x, pdf.bounds.height - y]
+      end
+      alias_method :pos, :map_to_upper_left_position
+    end
+    
+  end
+end

data/lib/thinreports/generator/pdf/document/draw_shape.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+
+module ThinReports
+  module Generator
+    
+    # @private
+    module Pdf::DrawShape
+      # @param [ThinReports::Core::Shape::Tblock::Internal] shape
+      def draw_shape_tblock(shape)
+        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
+        
+        content = shape.real_value.to_s
+        unless shape.multiple?
+          content = content.gsub(/\n/, ' ')
+        end
+        text_box(content, x, y, w, h, common_text_attrs(shape.attributes))
+      end
+      
+      # @param [ThinReports::Core::Shape::Basic::Internal] shape
+      def draw_shape_image(shape)
+        x, y, w, h = shape.svg_attrs.values_at('x', 'y', 'width', 'height')
+        base64image(extract_base64_string(shape.svg_attrs['xlink:href']),
+                    x, y, w, h)
+      end
+      
+      # @param [ThinReports::Core::Shape::Text::Internal] shape
+      def draw_shape_text(shape)
+        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
+        text(shape.text.join("\n"), x, y, w, h, 
+             shape_text_attrs(shape))
+      end
+      
+      # @param [ThinReports::Core::Shape::Basic::Internal] shape
+      def draw_shape_ellipse(shape)
+        args = shape.svg_attrs.values_at('cx', 'cy', 'rx', 'ry')
+        args << common_graphic_attrs(shape.attributes)
+        ellipse(*args)
+      end
+      
+      # @param [ThinReports::Core::Shape::Basic::Internal] shape
+      def draw_shape_line(shape)
+        args = shape.svg_attrs.values_at('x1', 'y1', 'x2', 'y2')
+        args << common_graphic_attrs(shape.attributes)
+        line(*args)
+      end
+      
+      # @param [ThinReports::Core::Shape::Basic::Internal] shape
+      def draw_shape_rect(shape)
+        args = shape.svg_attrs.values_at('x', 'y', 'width', 'height')
+        args << common_graphic_attrs(shape.attributes) do |attrs|
+          attrs[:radius] = shape.svg_attrs['rx']
+        end
+        rect(*args)
+      end
+    
+    private
+      
+      # @param [ThinReports::Core::Shape::Text::Internal]
+      # @return [Hash]
+      def shape_text_attrs(shape)
+        format = shape.format
+        
+        common_text_attrs(shape.attributes) do |attrs|
+          # Set the :line_height option.
+          attrs[:line_height] = format.line_height unless format.line_height.blank?
+          # Set the :valign option.
+          attrs[:valign]      = text_valign(format.valign)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/thinreports/generator/pdf/document/font.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+
+module ThinReports
+  module Generator
+    
+    # @private
+    module Pdf::Font
+      FONT_STORE = File.join(ThinReports::ROOTDIR, 'resources', 'fonts')
+      
+      BUILTIN_FONTS = {
+        'IPAMincho'  => {:normal => File.join(FONT_STORE, 'ipam.ttf')},
+        'IPAPMincho' => {:normal => File.join(FONT_STORE, 'ipamp.ttf')},
+        'IPAGothic'  => {:normal => File.join(FONT_STORE, 'ipag.ttf')},
+        'IPAPGothic' => {:normal => File.join(FONT_STORE, 'ipagp.ttf')}
+      }
+      
+    private
+      
+      def setup_fonts
+        # Install built-in fonts.
+        pdf.font_families.update(BUILTIN_FONTS)
+        
+        # Install fall-back font that IPAMincho.
+        fallback_font = BUILTIN_FONTS['IPAMincho'][:normal]
+        pdf.font_families['FallbackFont'] = {:normal      => fallback_font,
+                                             :bold        => fallback_font,
+                                             :italic      => fallback_font,
+                                             :bold_italic => fallback_font}
+        # Setup fallback font.
+        pdf.fallback_fonts(['FallbackFont'])
+        
+        # Create aliases from the font list provided by Prawn.
+        pdf.font_families.update(
+          'Courier New'     => pdf.font_families['Courier'],
+          'Times New Roman' => pdf.font_families['Times-Roman']
+        )
+      end
+      
+      # @return [String]
+      def default_family
+        'Helvetica'
+      end
+      
+      # @param [String] family
+      # @return [String]
+      def default_family_if_missing(family)
+        pdf.font_families.key?(family) ? family : default_family
+      end
+      
+      # @param [String] font
+      # @param [Symbol] style
+      # @return [Boolean]
+      def font_has_style?(font, style)
+        (f = pdf.font_families[font]) && f.key?(style)
+      end      
+    end
+    
+  end
+end