prune 0.0.4

data/lib/prune/parsers/document/page_parser.rb

@@ -0,0 +1,91 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Parsers
+    # Parser for directive "page".
+    class PageParser < Base
+      attr_reader :page
+
+      # Initialize.
+      def initialize(document, size, options = {})
+        @document = document
+        # Check document size.
+        raise DocumenteSizeError unless DOCUMENT_SIZES.has_key?(size)
+        document_size = DOCUMENT_SIZES[size]
+        # Create a new page.
+        width, height = document_size.collect{|mm| mm_to_pt(mm)}
+        @page = Page.new(@document, [0.0, 0.0, width, height], options)
+        # Add page to pages.
+        @document.pages << @page
+      end
+
+      protected
+      # Draw rectangle.
+      def rect(x, y, width, height, options = {})
+        rect = Shapes::Rectangle.new(@page, [x, y, width, height], options)
+        rect.render
+        rect
+      end
+
+      # Div tag.
+      def div(string, options = {})
+        # Convert width and height.
+        if options[:width].nil?
+          options[:width] = @page.width
+        else
+          options[:width] = mm_to_pt(options[:width])
+        end
+        unless options[:height].nil?
+          options[:height] = mm_to_pt(options[:height])
+        end
+        div = Shapes::TextBox.new(@page, string, options)
+        div.render
+        @page.y -= div.height
+        div
+      end
+
+      # Span tag.
+      def span(string, options = {})
+        # Convert width and height.
+        unless options[:width].nil?
+          options[:width] = mm_to_pt(options[:width])
+        end
+        unless options[:height].nil?
+          options[:height] = mm_to_pt(options[:height])
+        end
+        span = Shapes::TextBox.new(@page, string, options)
+        span.render
+        @page.x += span.width
+        span
+      end
+
+      # Br tag.
+      def br
+        lf
+      end
+
+      # Goto tag(mm).
+      def goto(x, y)
+        @page.x = mm_to_pt(x)
+        @page.y = @page.height - mm_to_pt(y)
+      end
+
+      # Line feed.
+      def lf(feed = 1)
+        feed = 1 unless feed < 0
+        @page.x = @page.margin_left
+        font_size = @page.current_font[:size]
+        feed.times do
+          @page.y -= font_size + (font_size / 5)
+        end
+      end
+
+      # Table tag.
+      def table(options = {}, &block)
+        table_parser = TableParser.new(@page, options)
+        table_parser.instance_eval(&block)
+      end
+    end
+  end
+end
+

data/lib/prune/parsers/document/property_parser.rb

@@ -0,0 +1,45 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Parsers
+    # Parser for directive "property".
+    class PropertyParser < Base
+      # Initialize.
+      def initialize(document)
+        @document = document
+      end
+
+      protected
+      # Set title.
+      def title(title)
+        @document.info.title = title
+      end
+
+      # Set subject.
+      def subject(subject)
+        @document.info.subject = subject
+      end
+
+      # Set author.
+      def author(author)
+        @document.info.author = author
+      end
+
+      # Set PDF version.
+      def version(version)
+        valid_versions = %W[1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7]
+        raise PdfVersionError unless valid_versions.include?(version)
+        @document.version = version
+        @document.catalog.version = version
+      end
+
+      # Set language.
+      def language(language)
+        valid_langs = %W[en-US ja-JP]
+        raise PdfLanguageError unless valid_langs.include?(language)
+        @document.catalog.lang = pl(language)
+      end
+    end
+  end
+end
+

data/lib/prune/parsers/document_parser.rb

@@ -0,0 +1,26 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Parsers
+    # Parser for Prune DSL.
+    class DocumentParser < Base
+      def initialize(document)
+        @document = document
+      end
+
+      protected
+      def property(&block)
+        unless @property_parser
+          @property_parser = PropertyParser.new(@document)
+        end
+        @property_parser.instance_eval(&block)
+      end
+
+      def page(size = :A4, options = {}, &block)
+        @page_parser = PageParser.new(@document, size, options)
+        @page_parser.instance_eval(&block)
+      end
+    end
+  end
+end
+

data/lib/prune/shapes/base.rb

@@ -0,0 +1,52 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Shapes
+    class Base
+      include Errors
+      include Functions
+
+      attr_accessor :id
+      attr_accessor :x
+      attr_accessor :y
+      attr_accessor :width
+      attr_accessor :height
+
+      # Initialize.
+      def initialize(page)
+        @page = page
+        @document = @page.document
+        raise DuplicateIdError if @page.shape_ids.include?(id)
+        @id = "shape_#{@page.shape_ids.size}".to_sym
+        @x = 0.0
+        @y = 0.0
+        @width = 0.0
+        @height = 0.0
+      end
+
+      # Render shapes.
+      def render(stream)
+        stream.each{|line| @page.stream << line}
+        @page.shape_ids << @id
+        @page.shapes.update(@id => self)
+        self
+      end
+
+      private
+      # Convert to String.
+      def to_s
+        "Shape<#{@id}:#{self.class.to_s}>"
+      end
+
+      # Convert color string.
+      def convert_color_str(color_str)
+        raise ColorFormatError unless /\A#[0-9a-fA-F]{6}\z/ === color_str
+        r = color_str[1, 2].to_i(16) / 255.0
+        g = color_str[3, 2].to_i(16) / 255.0
+        b = color_str[5, 2].to_i(16) / 255.0
+        "%.2f %.2f %.2f" % [r, g, b]
+      end
+    end
+  end
+end
+

data/lib/prune/shapes/line.rb

@@ -0,0 +1,55 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Shapes
+    class Line < Base
+      STYLES = {
+        :solid => "[] 0 d",
+        :dashed => "[5 5] 0 d"
+      } unless const_defined?(:STYLES)
+
+      # Draw line.
+      def initialize(page, from_x, from_y, to_x, to_y, options = {})
+        super(page)
+        # Check arguments.
+        raise LineArgumentError unless from_x.is_a?(Numeric)
+        raise LineArgumentError unless from_y.is_a?(Numeric)
+        raise LineArgumentError unless to_x.is_a?(Numeric)
+        raise LineArgumentError unless to_y.is_a?(Numeric)
+        # Set instance variables.
+        @id = options[:id] if options.key?(:id)
+        @x = from_x
+        @y = from_y
+        @to_x = to_x
+        @to_y = to_y
+        @width = to_x - from_x
+        @height = -(to_y - from_y)
+        @options = options
+        # Parse options.
+        @style = options[:style] || :none
+        @width = options[:width] || 1.0
+        @color = options[:color] || "#000000"
+      end
+
+      # Render shape.
+      def render
+        return [] if @style == :none
+        return [] if @width <= 0.0
+        raise LineStyleError unless STYLES.include?(@style)
+        stream = []
+        stream << "q"
+        stream << "2 J"
+        stream << "0 j"
+        stream << STYLES[@style]
+        stream << "%s RG" % convert_color_str(@color)
+        stream << "%.2f w" % width
+        stream << "%.2f %.2f m" % [@x, @y]
+        stream << "%.2f %.2f l" % [@to_x, @to_y]
+        stream << "s"
+        stream << "Q"
+        super(stream)
+      end
+    end
+  end
+end
+

data/lib/prune/shapes/rectangle.rb

@@ -0,0 +1,64 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Shapes
+    class Rectangle < Base
+      STYLES = {
+        :solid => "[] 0 d",
+        :dashed => "[5 5] 0 d"
+      } unless const_defined?(:STYLES)
+
+      # Draw rectangle.
+      def initialize(page, x, y, width, height, options = {})
+        super(page)
+        # Check arguments.
+        raise RectangleArgumentError unless x.is_a?(Numeric)
+        raise RectangleArgumentError unless y.is_a?(Numeric)
+        raise RectangleArgumentError unless width.is_a?(Numeric)
+        raise RectangleArgumentError unless height.is_a?(Numeric)
+
+        # Set instance variables.
+        @id = options[:id] if options.key?(:id)
+        @x = x
+        @y = y
+        @width = width
+        @height = height
+        @options = options
+
+        # Parse options.
+        @style = options[:style] || :none
+        @border_width = options[:width] || 1.0
+        @border_color = options[:color] || "#000000"
+        @fill = options[:fill] || false
+        @fill_color = options[:fill_color] || "#000000"
+      end
+
+      # Render shape.
+      def render
+        stream = []
+        boundary = [@x, @y, @width, -@height]
+        stream << "q"
+        # Set fill color.
+        if @fill
+          stream << "%s rg" % convert_color_str(@fill_color)
+          stream << "%.2f %.2f %.2f %.2f re" % boundary
+          stream << "f"
+        end
+        # Draw boundary.
+        unless @style == :none
+          raise RectangleStyleError unless STYLES.include?(@style)
+          stream << "2 J"
+          stream << "0 j"
+          stream << STYLES[@style]
+          stream << "%s RG" % convert_color_str(@border_color)
+          stream << "%.2f w" % @border_width
+          stream << "%.2f %.2f %.2f %.2f re" % boundary
+          stream << "s"
+        end
+        stream << "Q"
+        super(stream)
+      end
+    end
+  end
+end
+

data/lib/prune/shapes/text_box.rb

@@ -0,0 +1,223 @@
+# -*- coding:utf-8 -*-
+
+module Prune
+  module Shapes
+    class TextBox < Base
+      attr_accessor :width
+      attr_accessor :height
+
+      # Initialize.
+      def initialize(page, string, options = {})
+        super(page)
+        # Set instance variables.
+        @id = options[:id] if options.key?(:id)
+        @x = @page.x
+        @y = @page.y
+        @options = options
+        # Erase "\r\n" and "\r" line feeds.
+        @string = string.gsub(/\r\n/, "\n").gsub(/\r/, "\n")
+        @string << "\n" unless /\n\z/ === @string
+        # Parse font options.
+        Elements::Page::FONT_OPTIONS.each do |sym|
+          @page.current_font[sym] = @page.default_font[sym]
+          if options.key?(:font) && options[:font].key?(sym)
+            @page.current_font[sym] = options[:font][sym]
+          end
+        end
+        # Get font.
+        @font = get_font(@page.current_font[:name],
+          :bold => @page.current_font[:bold],
+          :italic => @page.current_font[:italic])
+        raise FontNotSpecifiedError if @font.nil?
+        @font_size = @page.current_font[:size]
+        # Text align.
+        @text_align = options[:text_align] || :left
+        @width = get_width(@string, @font, @font_size, options[:width])
+        @height = get_height(@string, @font, @font_size, options[:height])
+      end
+
+      # Render shape.
+      def render
+        # Define local variables.
+        current_x = @x
+        current_y = @y
+        boundary = [@x, @y, @width, @height]
+
+        # Render background color.
+        render_background_color(boundary)
+        # Render borders.
+        render_rectangle_border(boundary)
+        render_top_border(boundary)
+        render_left_border(boundary)
+        render_right_border(boundary)
+        render_bottom_border(boundary)
+
+        # Render String.
+        stream = []
+        current_y -= @font_size
+        stream << "q"
+        # Set colors.
+        stroke_color = @page.current_font[:stroke_color]
+        fill_color = @page.current_font[:fill_color]
+        mode = font_mode(@page.current_font[:mode])
+        stream << "%s RG" % convert_color_str(stroke_color)
+        stream << "%s rg" % convert_color_str(fill_color)
+
+        # Write String.
+        x_before_align = current_x
+        @string.scan(/([^\n]*)\n/) do |token|
+          line = $1
+          line_width = @font.width(line, @font_size)
+          current_x =
+            x_of_text_align(line_width, @width, x_before_align, @text_align)
+          # Set to stream.
+          if line.size > 0
+            stream << "BT"
+            stream << "%s %d Tf" % [@font.name, @font_size]
+            stream << "%.2f %.2f Td" % [current_x, current_y]
+            stream << "%d Tr" % mode
+            stream << "%s Tj" % @font.decode(line)
+            stream << "ET"
+          end
+          current_y -= @font_size
+        end
+        stream << "Q"
+        super(stream)
+      end
+
+      private
+      # Get font from options.
+      def get_font(name, options)
+        raise UnexistingFontError if name.nil?
+        font_name = name.to_s
+        # Font name shold contain only lower case alphabets and underscores.
+        raise UnexistingFontError unless
+          /\A[a-z][a-z_]*[a-z]\z/ === font_name
+        # Font name should contain one underscore at a time.
+        raise UnexistingFontError if /_{2,}/ === font_name
+        # Constantize font.
+        font_class_name = font_name.gsub(/(?:^|_)(.)/){$1.upcase}
+        font_class = eval("Fonts::#{font_class_name}") rescue UnexistingFontError
+        # Find font instance in document.
+        font_key = font_class.key(options)
+        if @document.fonts.key?(font_key)
+          font = @document.fonts[font_key]
+        else
+          font = font_class.new(@document, options)
+          @document.fonts.update(font_key => font)
+        end
+        # Set font in page instance.
+        @page.set_font(font_key, font)
+        font
+      end
+
+      # Render background color.
+      def render_background_color(boundary)
+        color = @options[:background_color]
+        return unless color
+        x, y, width, height = boundary
+        fill_rect = Rectangle.new(@page, x, y, width, height,
+          :fill => true, :fill_color => color)
+        fill_rect.render
+      end
+
+      # Render rectangle border.
+      def render_rectangle_border(boundary)
+        return unless @options[:border]
+        return if @options[:border_top]
+        return if @options[:border_right]
+        return if @options[:border_left]
+        return if @options[:border_bottom]
+        x, y, width, height = boundary
+        border_rect = Rectangle.new(@page, x, y, width, height,
+          @options[:border])
+        border_rect.render
+      end
+
+      # Render top border.
+      def render_top_border(boundary)
+        return unless @options[:border_top]
+        x, y, width, height = boundary
+        line = Line.new(@page, x, y, x + width, y,
+          @options[:border_top])
+        line.render
+      end
+
+      # Render left border.
+      def render_left_border(boundary)
+        return unless @options[:border_left]
+        x, y, width, height = boundary
+        line = Line.new(@page, x, y, x, y - height,
+          @options[:border_left])
+        line.render
+      end
+
+      # Render right border.
+      def render_right_border(boundary)
+        return unless @options[:border_right]
+        x, y, width, height = boundary
+        line = Line.new(@page, x + width, y, x + width, y - height,
+          @options[:border_right])
+        line.render
+      end
+
+      # Render bottom border.
+      def render_bottom_border(boundary)
+        return unless @options[:border_bottom]
+        x, y, width, height = boundary
+        line = Line.new(@page, x, y - height, x + width, y - height,
+          @options[:border_bottom])
+        line.render
+      end
+
+      # Get width(mm).
+      def get_width(string, font, font_size, default_width)
+        return default_width unless default_width.nil?
+        width = 0.0
+        string.scan(/([^\n]*)\n/) do |token|
+          token_width = font.width(token[0], font_size)
+          width = token_width if token_width > width
+        end
+        width += font_size / 10.0
+      end
+
+      # Get height(mm).
+      def get_height(string, font, font_size, default_height)
+        return default_height unless default_height.nil?
+        height = string.count("\n") * font_size
+        height += font_size / 5.0
+      end
+
+      # Get font mode.
+      def font_mode(mode)
+        case mode
+        when :fill
+          0
+        when :stroke
+          1
+        when :fill_and_stroke
+          2
+        else
+          raise FontModeError
+        end
+      end
+
+      # Get text align.
+      def x_of_text_align(string_width, width, x, text_align)
+        return x if text_align == :left
+        return x if width.nil?
+        return x if width <= string_width
+        # Calculate x position.
+        case text_align
+        when :center
+          x + ((width - string_width) / 2.0)
+        when :right
+          x + (width - string_width)
+        else
+          raise TextAlignError
+        end
+      end
+    end
+  end
+end
+