thinreports 0.6.0.pre3

data/lib/thinreports/generator/pxd.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+require 'stringio'
+require 'tempfile'
+
+module ThinReports
+  module Generator
+    
+    class Pxd < Base
+      require 'thinreports/generator/pxd/helper'
+      
+      autoload :PageRenderer, 'thinreports/generator/pxd/page_renderer'
+      autoload :ListRenderer, 'thinreports/generator/pxd/list_renderer'
+      
+      include Helper
+      
+      # @param report (see ThinReports::Generator::Base#initialize)
+      # @param [Hash] options See http://www.pxdoc.com/tech/wiki.cgi?page=pxd
+      def initialize(report, options)
+        super
+        @renderers = {}
+      end
+      
+      # @see ThinReports::Generator::Base#generate
+      def generate
+        output = StringIO.new('', 'r+:UTF-8')
+        render_start_pxd(output)
+        
+        report.pages.each do |page|
+          render_page(output, page)
+        end
+        
+        render_end_pxd(output)
+        output.string
+      end
+      
+      # @see ThinReports::Generator::Base#generate_file
+      def generate_file(filename)
+        File.open(filename, 'w') {|f| f << generate }
+      end
+    
+    private
+    
+      def renderer(page)
+        @renderers[page.layout.format.identifier] ||=
+            PageRenderer.new(page.layout.format)
+      end
+      
+      def render_page(output, page)
+        output << unless page.blank?
+          content_tag(:page, renderer(page).render(page.manager), nil,
+                      :escape => false)
+        else
+          tag(:page)
+        end
+      end
+      
+      def render_start_pxd(output)
+        format = default_layout.format
+        attrs  = @options.merge('title'       => format.report_title,
+                                'paper-type'  => format.page_paper_type,
+                                'orientation' => format.page_orientation,
+                                'width'       => format.page_width,
+                                'height'      => format.page_height,
+                                'dpi'         => '72')
+        output << tag(:pxd, attrs, true)
+      end
+      
+      def render_end_pxd(output)
+        output << '</pxd>'
+      end
+    end
+    
+  end
+end

data/lib/thinreports/generator/pxd/helper.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+require 'erb'
+
+module ThinReports
+  module Generator
+    
+    # @private
+    module Pxd::Helper
+    private
+      
+      def content_tag(tag_name, content = nil, attrs = nil, options = {})
+        content = h(content) unless options[:escape] == false
+        tag(tag_name, attrs, true) << content.to_s << "</#{h(tag_name)}>"
+      end
+      
+      def tag(tag_name, attrs = nil, open = false)
+        attrs = tag_attributes(attrs)
+        attrs = ' ' + attrs unless attrs.blank?
+        "<#{h(tag_name)}#{attrs}#{open ? '' : ' /'}>"
+      end
+      
+      def tag_attributes(attrs)
+        attrs && attrs.map{|k, v| "#{h(k)}=\"#{h(v)}\"" }.join(' ')
+      end
+      
+      def h(s)
+        ERB::Util.html_escape(s)
+      end
+    end
+    
+  end
+end

data/lib/thinreports/generator/pxd/list_renderer.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module ThinReports
+  module Generator
+    
+    # @private
+    class Pxd::ListRenderer
+      include Pxd::Helper
+      
+      def initialize
+        @renderers = {}
+        @list      = nil
+      end
+
+      # @param [ThinReports::Core::Shape::List::PageState] list
+      def render(list)
+        @list = list
+        
+        result = String.new
+        render_section(result, list.header) if list.header
+        
+        list.rows.each do |row|
+          render_section(result, row)
+        end
+        result
+      end
+      
+    private
+
+      # @param [String] result
+      # @param [ThinReports::Core::Shape::List::SectionInterface] section
+      def render_section(result, section)
+        internal   = section.internal
+        attributes = internal.attributes
+        contents   = renderer(internal.section_name).render(section.manager)
+        
+        # Only for when older than Ver 0.6.0.pre2.
+        # Since 0.6.0.pre3, ignore this.
+        if internal.relative_top
+          attributes['transform'] =
+              "translate(#{internal.relative_position.join(',')})"
+        end
+        
+        result << content_tag(internal.svg_tag, contents, attributes,
+                              :escape => false)
+      end
+      
+      # @param [Symbol] section_name
+      # @return [ThinReports::Generator::Pxd::PageRenderer]
+      def renderer(section_name)
+        @renderers[section_name] ||=
+          Pxd::PageRenderer.new(@list.format.sections[section_name])
+      end
+      
+    end
+    
+  end
+end

data/lib/thinreports/generator/pxd/page_renderer.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+require 'erb'
+
+module ThinReports
+  module Generator
+    
+    # @private
+    class Pxd::PageRenderer
+      include Pxd::Helper
+      
+      def initialize(format)
+        @engine  = ERB.new(read_layout(format))
+        @manager = {}
+        @lists   = {}
+      end
+      
+      # @param [ThinReports::Core::Shape::Manager::Internal] manager
+      # @return [String]
+      def render(manager)
+        @manager = manager
+        @engine.result(binding)
+      end
+      
+      def render_shape(id)
+        return '' unless shape = @manager.final_shape(id)
+        
+        shape = shape.internal
+        case 
+        when shape.type_of?(:tblock)
+          render_tblock(shape)
+        when shape.type_of?(:list)
+          render_list(shape)
+        when shape.type_of?(:text)
+          render_text(shape)
+        else
+          render_basic(shape)
+        end
+      end
+      alias_method :r, :render_shape
+      
+    private
+    
+      def render_basic(shape)
+        tag(shape.svg_tag, shape.attributes)
+      end
+      
+      def render_text(shape)
+        content_tag(shape.svg_tag, shape.svg_content,
+                    shape.attribute, :escape => false)
+      end
+      
+      def render_tblock(shape)
+        value = h(shape.real_value)
+        value = if shape.multiple?
+          value.gsub(/\r\n|\n/, '<tBreak/>')
+        else
+          value.gsub(/\r\n|\n/, ' ')
+        end
+        content_tag(shape.svg_tag, value, shape.attributes, :escape => false)
+      end
+      
+      def render_list(shape)
+        renderer = @lists[shape.id] ||= Pxd::ListRenderer.new
+        renderer.render(shape)
+      end
+      
+      def read_layout(format)
+        format.layout.gsub(/ x\-[a-z\d\-]+?=".*?"/, '').
+                      gsub(/ class=".*?"/, '')
+      end
+    end
+    
+  end
+end

data/lib/thinreports/layout.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+module ThinReports
+  
+  module Layout
+    # @see ThinReports::Layout::Base#initialize
+    def self.new(filename, options = {})
+      Base.new(filename, options)
+    end
+  end
+  
+end
+
+require 'thinreports/layout/version'
+require 'thinreports/layout/base'
+require 'thinreports/layout/format'
+require 'thinreports/layout/configuration'

data/lib/thinreports/layout/base.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+module ThinReports
+  module Layout
+    
+    class Base
+      EXT_NAME = 'tlf'
+      
+      class << self
+        # @param [String] filename
+        # @return [ThinReports::Layout::Format]
+        # @raise [ThinReports::Errors::InvalidLayoutFormat]
+        # @raise [ThinReports::Errors::IncompatibleLayoutFormat]
+        # @private
+        def load_format(filename)
+          filename += ".#{EXT_NAME}" unless filename =~/\.#{EXT_NAME}$/
+          
+          unless File.exists?(filename)
+            raise ThinReports::Errors::LayoutFileNotFound
+          end
+          # Build format.
+          ThinReports::Layout::Format.build(filename)
+        end
+        
+        # @private
+        def Page
+          const_defined?(:Page) ? Page : Core::Page
+        end
+        
+      private
+        
+        # @private
+        def PageHelpers(&block)
+          const_set(:Page, ::Class.new(Core::Page, &block))
+        end
+      end
+      
+      # @private
+      attr_reader :format
+      
+      # @return [String]
+      attr_reader :filename
+      
+      # @return [Symbol]
+      attr_reader :id
+      
+      # @param [String] filename
+      # @param [Hash] options
+      # @option options [Symbol] :id (nil)
+      def initialize(filename, options = {})
+        @filename = filename
+        @format   = self.class.load_format(filename)
+        @id       = options[:id]
+      end
+      
+      # @return [Boolean] Return the true if is default layout.
+      def default?
+        @id.nil?
+      end
+      
+      # @yield [config]
+      # @yieldparam [List::Configuration] config
+      # @return [List::Configuration]
+      def config(&block)
+        @config ||= Layout::Configuration.new(self)
+        block_exec_on(@config, &block)
+      end
+      
+      # @param [ThinReports::Report::Base] parent
+      # @return [Page]
+      # @private
+      def init_new_page(parent)
+        self.class.Page.new(parent, self)
+      end
+    end
+    
+  end
+end

data/lib/thinreports/layout/configuration.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+module ThinReports
+  module Layout
+    
+    class Configuration
+      include Core::Shape::Manager::Target
+      
+      undef_method :items, :values
+      
+      # @param [ThinReports::Layout::Base]
+      def initialize(layout)
+        initialize_manager(layout.format) do |f|
+          Core::Shape::Configuration(f.type).new
+        end
+      end
+      
+      # @param [String, Symbol] shape_id
+      # @return [Object, nil]
+      # @private
+      def activate(shape_id)
+        (config = manager.shapes[shape_id.to_sym]) && config.copy
+      end
+    end
+    
+  end
+end

data/lib/thinreports/layout/format.rb

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+require 'digest/sha1'
+
+module ThinReports
+  module Layout
+    
+    # @private
+    class Format < Core::Shape::Manager::Format
+      config_reader :last_version        => %w( version )
+      config_reader :report_title        => %w( title )
+      config_reader :page_paper_type     => %w( config page paper-type ),
+                    :page_width          => %w( config page width ),
+                    :page_height         => %w( config page height ),
+                    :page_orientation    => %w( config page orientation ),
+                    :page_margin_top     => %w( config page margin-top ),
+                    :page_margin_bottom  => %w( config page margin-bottom ),
+                    :page_margin_left    => %w( config page margin-left ), 
+                    :page_margin_left    => %w( config page margin-right )
+      
+      config_checker 'user', :user_paper_type => %w( config page paper-type )
+      
+      class << self
+        
+      private
+        
+        # @param [String] filename
+        # @param [Hash] options
+        # @option options [Boolean] :force (false)
+        # @private
+        def build_internal(filename, options = {})
+          build_once(filename, options[:force]) do |content, id|
+            raw_format = parse_json(content)
+            
+            # Check the compatibility of specified layout file.
+            unless ThinReports::Layout::Version.compatible?(raw_format['version'])
+              info = [filename, raw_format['version'],
+                      ThinReports::Layout::Version.required_rules_inspect]
+              raise ThinReports::Errors::IncompatibleLayoutFormat.new(*info)
+            end
+            
+            # Build and initialize format.
+            new(raw_format, id) do |f|
+              build_layout(f) do |type, shape_format|
+                Core::Shape::Format(type).build(shape_format)
+              end
+              clean(f.layout)
+            end
+          end
+        end
+        
+        # @private
+        def build_once(filename, force = false, &block)
+          content = read_format_file(filename)
+          
+          if force
+            block.call(content, nil)
+          else
+            id = Digest::SHA1.hexdigest(content).to_sym
+            built_format_registry[id] ||= block.call(content, id)
+          end
+        end
+        
+        # @private
+        def read_format_file(filename)
+          File.open(filename, 'r:UTF-8') {|f| f.read }
+        end
+        
+        # @private
+        def built_format_registry
+          @built_format_registry ||= {}
+        end        
+      end
+    end
+    
+  end
+end