thinreports 0.9.1 → 0.11.0

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

@@ -1,147 +1,147 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
   module Generator
+    class PDF
+      module Graphics
+        # @param [Hash] style
+        # @yield [attrs]
+        # @yieldparam [Hash] attrs
+        # @return [Hash]
+        def build_graphic_attributes(style, &block)
+          graphic_attributes = {
+            stroke: style['border-color'],
+            stroke_width: style['border-width'],
+            stroke_type: style['border-style'],
+            fill: style['fill-color']
+          }
+          block.call(graphic_attributes) if block_given?
+          graphic_attributes
+        end
 
-    module PDF::Graphics
-      # @param [Hash] style
-      # @yield [attrs]
-      # @yieldparam [Hash] attrs
-      # @return [Hash]
-      def build_graphic_attributes(style, &block)
-        graphic_attributes = {
-          stroke: style['border-color'],
-          stroke_width: style['border-width'],
-          stroke_type: style['border-style'],
-          fill: style['fill-color']
-        }
-        block.call(graphic_attributes) if block_given?
-        graphic_attributes
-      end
-
-      # @param [Hash] style
-      # @yield [attrs]
-      # @yieldparam [Hash] attrs
-      # @return [Hash]
-      def build_text_attributes(style, &block)
-        text_attributes = {
-          font: font_family(style['font-family']),
-          size: style['font-size'],
-          color: style['color'],
-          align: text_align(style['text-align']),
-          valign: text_valign(style['vertical-align']),
-          styles: font_styles(style['font-style']),
-          letter_spacing: letter_spacing(style['letter-spacing']),
-          line_height: line_height(style['line-height']),
-          overflow: text_overflow(style['overflow']),
-          word_wrap: word_wrap(style['word-wrap'])
-        }
-        block.call(text_attributes) if block_given?
-        text_attributes
-      end
+        # @param [Hash] style
+        # @yield [attrs]
+        # @yieldparam [Hash] attrs
+        # @return [Hash]
+        def build_text_attributes(style, &block)
+          text_attributes = {
+            font: font_family(style['font-family']),
+            size: style['font-size'],
+            color: style['color'],
+            align: text_align(style['text-align']),
+            valign: text_valign(style['vertical-align']),
+            styles: font_styles(style['font-style']),
+            letter_spacing: letter_spacing(style['letter-spacing']),
+            line_height: line_height(style['line-height']),
+            overflow: text_overflow(style['overflow']),
+            word_wrap: word_wrap(style['word-wrap'])
+          }
+          block.call(text_attributes) if block_given?
+          text_attributes
+        end
 
-      # @param [Array<String>] font_names
-      # @return [String]
-      def font_family(font_names)
-        font_name = font_names.first
-        default_family_if_missing(font_name)
-      end
+        # @param [Array<String>] font_names
+        # @return [String]
+        def font_family(font_names)
+          font_name = font_names.first
+          default_family_if_missing(font_name)
+        end
 
-      # @param [Array<String>] styles
-      # @return [Array<Symbol>]
-      def font_styles(styles)
-        styles.map do |font_style|
-          case font_style
-          when 'bold' then :bold
-          when 'italic' then :italic
-          when 'underline' then :underline
-          when 'linethrough' then :strikethrough
+        # @param [Array<String>] styles
+        # @return [Array<Symbol>]
+        def font_styles(styles)
+          styles.map do |font_style|
+            case font_style
+            when 'bold' then :bold
+            when 'italic' then :italic
+            when 'underline' then :underline
+            when 'linethrough' then :strikethrough
+            end
           end
         end
-      end
 
-      # @param [Float, "", nil] spacing
-      # @return [Float, nil]
-      def letter_spacing(spacing)
-        blank_value?(spacing) ? nil : spacing
-      end
+        # @param [Float, "", nil] spacing
+        # @return [Float, nil]
+        def letter_spacing(spacing)
+          blank_value?(spacing) ? nil : spacing
+        end
 
-      # @param ["left", "center", "right", ""] align
-      # @return [:left, :center, :right]
-      def text_align(align)
-        case align
-        when 'left' then :left
-        when 'center' then :center
-        when 'right' then :right
-        when '' then :left
-        else :left
+        # @param ["left", "center", "right", ""] align
+        # @return [:left, :center, :right]
+        def text_align(align)
+          case align
+          when 'left' then :left
+          when 'center' then :center
+          when 'right' then :right
+          when '' then :left
+          else :left
+          end
         end
-      end
 
-      # @param ["top", "middle", "bottom", "", nil] valign
-      # @return [:top, :center, :bottom]
-      def text_valign(valign)
-        case valign
-        when 'top' then :top
-        when 'middle' then :center
-        when 'bottom' then :bottom
-        when '' then :top
-        else :top
+        # @param ["top", "middle", "bottom", "", nil] valign
+        # @return [:top, :center, :bottom]
+        def text_valign(valign)
+          case valign
+          when 'top' then :top
+          when 'middle' then :center
+          when 'bottom' then :bottom
+          when '' then :top
+          else :top
+          end
         end
-      end
 
-      # @param ["truncate", "fit", "expand", "", nil] overflow
-      # @return [:truncate, :shrink_to_fit, :expand]
-      def text_overflow(overflow)
-        case overflow
-        when 'truncate' then :truncate
-        when 'fit' then :shrink_to_fit
-        when 'expand' then :expand
-        when '' then :truncate
-        else :truncate
+        # @param ["truncate", "fit", "expand", "", nil] overflow
+        # @return [:truncate, :shrink_to_fit, :expand]
+        def text_overflow(overflow)
+          case overflow
+          when 'truncate' then :truncate
+          when 'fit' then :shrink_to_fit
+          when 'expand' then :expand
+          when '' then :truncate
+          else :truncate
+          end
         end
-      end
 
-      # @param ["break-word", "none", "", nil] word_wrap
-      # @return [:break_word, :none]
-      def word_wrap(word_wrap)
-        case word_wrap
-        when 'break-word' then :break_word
-        when 'none' then :none
-        else :none
+        # @param ["break-word", "none", "", nil] word_wrap
+        # @return [:break_word, :none]
+        def word_wrap(word_wrap)
+          case word_wrap
+          when 'break-word' then :break_word
+          when 'none' then :none
+          else :none
+          end
         end
-      end
 
-      # @param [Float, "", nil] height
-      # @return [Float, nil]
-      def line_height(height)
-        blank_value?(height) ? nil : height
-      end
+        # @param [Float, "", nil] height
+        # @return [Float, nil]
+        def line_height(height)
+          blank_value?(height) ? nil : height
+        end
 
-      # @param ["left", "center", "right", ""] position
-      # @return [:left, :center, :right]
-      def image_position_x(position)
-        case position
-        when 'left' then :left
-        when 'center' then :center
-        when 'right' then :right
-        when '' then :left
-        else :left
+        # @param ["left", "center", "right", ""] position
+        # @return [:left, :center, :right]
+        def image_position_x(position)
+          case position
+          when 'left' then :left
+          when 'center' then :center
+          when 'right' then :right
+          when '' then :left
+          else :left
+          end
         end
-      end
 
-      # @param ["top", "middle", "bottom", ""] position
-      # @return [:left, :center, :right]
-      def image_position_y(position)
-        case position
-        when 'top' then :top
-        when 'middle' then :center
-        when 'bottom' then :bottom
-        when '' then :top
-        else :top
+        # @param ["top", "middle", "bottom", ""] position
+        # @return [:left, :center, :right]
+        def image_position_y(position)
+          case position
+          when 'top' then :top
+          when 'middle' then :center
+          when 'bottom' then :bottom
+          when '' then :top
+          else :top
+          end
         end
       end
     end
-
   end
 end

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

@@ -1,137 +1,135 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
   module Generator
-
-    module PDF::Graphics
-      STROKE_DASH = {
-        dashed: [2, 2],
-        dotted: [1, 2]
-      }
-
-      # @param [Numeric, String] x1
-      # @param [Numeric, String] y1
-      # @param [Numeric, String] x2
-      # @param [Numeric, String] y2
-      # @param [Hash] attrs ({})
-      # @option attrs [String] :stroke
-      # @option attrs [Numeric, String] :stroke_width
-      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
-      def line(x1, y1, x2, y2, attrs = {})
-        with_graphic_styles(attrs) do
-          pdf.line(pos(x1, y1), pos(x2, y2))
+    class PDF
+      module Graphics
+        STROKE_DASH = {
+          dashed: [2, 2],
+          dotted: [1, 2]
+        }.freeze
+
+        # @param [Numeric, String] x1
+        # @param [Numeric, String] y1
+        # @param [Numeric, String] x2
+        # @param [Numeric, String] y2
+        # @param [Hash] attrs ({})
+        # @option attrs [String] :stroke
+        # @option attrs [Numeric, String] :stroke_width
+        # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+        def line(x1, y1, x2, y2, attrs = {})
+          with_graphic_styles(attrs) do
+            pdf.line(pos(x1, y1), pos(x2, y2))
+          end
         end
-      end
 
-      # @param [Numeric, String] x
-      # @param [Numeric, String] y
-      # @param [Numeric, String] w width
-      # @param [Numeric, String] h height
-      # @param [Hash] attrs ({})
-      # @option attrs [Integer, String] :radius
-      # @option attrs [String] :stroke
-      # @option attrs [Numeric, String] :stroke_width
-      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
-      # @option attrs [String] :fill
-      def rect(x, y, w, h, attrs = {})
-        w, h   = s2f(w, h)
-        radius = s2f(attrs[:radius])
-
-        with_graphic_styles(attrs) do
-          if radius && !radius.zero?
-            pdf.rounded_rectangle(pos(x, y), w, h, radius)
-          else
-            pdf.rectangle(pos(x, y), w, h)
+        # @param [Numeric, String] x
+        # @param [Numeric, String] y
+        # @param [Numeric, String] w width
+        # @param [Numeric, String] h height
+        # @param [Hash] attrs ({})
+        # @option attrs [Integer, String] :radius
+        # @option attrs [String] :stroke
+        # @option attrs [Numeric, String] :stroke_width
+        # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+        # @option attrs [String] :fill
+        def rect(x, y, w, h, attrs = {})
+          w, h = s2f(w, h)
+          radius = s2f(attrs[:radius])
+
+          with_graphic_styles(attrs) do
+            if radius && !radius.zero?
+              pdf.rounded_rectangle(pos(x, y), w, h, radius)
+            else
+              pdf.rectangle(pos(x, y), w, h)
+            end
           end
         end
-      end
 
-      # @param [Numeric, String] x center-x
-      # @param [Numeric, String] y center-y
-      # @param [Numeric, String] rx
-      # @param [Numeric, String] ry
-      # @param [Hash] attrs ({})
-      # @option attrs [String] :stroke
-      # @option attrs [Numeric, String] :stroke_width
-      # @option attrs [Array<Integer, String>] :stroke_dash
-      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
-      # @option attrs [String] :fill
-      def ellipse(x, y, rx, ry, attrs = {})
-        rx, ry = s2f(rx, ry)
-
-        with_graphic_styles(attrs) do
-          pdf.ellipse(pos(x, y), rx, ry)
+        # @param [Numeric, String] x center-x
+        # @param [Numeric, String] y center-y
+        # @param [Numeric, String] rx
+        # @param [Numeric, String] ry
+        # @param [Hash] attrs ({})
+        # @option attrs [String] :stroke
+        # @option attrs [Numeric, String] :stroke_width
+        # @option attrs [Array<Integer, String>] :stroke_dash
+        # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+        # @option attrs [String] :fill
+        def ellipse(x, y, rx, ry, attrs = {})
+          rx, ry = s2f(rx, ry)
+
+          with_graphic_styles(attrs) do
+            pdf.ellipse(pos(x, y), rx, ry)
+          end
         end
-      end
 
-      # @param [Hash] attrs
-      def with_graphic_styles(attrs, &block)
-        stroke = build_stroke_styles(attrs)
-        fill   = build_fill_styles(attrs)
+        # @param [Hash] attrs
+        def with_graphic_styles(attrs, &block)
+          stroke = build_stroke_styles(attrs)
+          fill = build_fill_styles(attrs)
+
+          # Do not draw if no colors given.
+          return unless fill || stroke
 
-        # Do not draw if no colors given.
-        return unless fill || stroke
+          save_graphics_state
 
-        save_graphics_state
+          # Apply stroke-dashed.
+          if stroke && stroke[:dash]
+            length, space = stroke[:dash]
+            pdf.dash(length, space: space)
+          end
+
+          # Draw with fill and stroke.
+          if fill && stroke
+            pdf.fill_and_stroke do
+              line_width(stroke[:width])
+              pdf.fill_color(fill[:color])
+              pdf.stroke_color(stroke[:color])
+              block.call
+            end
+          # Draw only with fill.
+          elsif fill
+            pdf.fill do
+              pdf.fill_color(fill[:color])
+              block.call
+            end
+          # Draw only with stroke.
+          elsif stroke
+            pdf.stroke do
+              line_width(stroke[:width])
+              pdf.stroke_color(stroke[:color])
+              block.call
+            end
+          end
 
-        # Apply stroke-dashed.
-        if stroke && stroke[:dash]
-          length, space = stroke[:dash]
-          pdf.dash(length, space: space)
+          restore_graphics_state
         end
 
-        case
-        # Draw with fill and stroke.
-        when fill && stroke
-          pdf.fill_and_stroke {
-            line_width(stroke[:width])
-            pdf.fill_color(fill[:color])
-            pdf.stroke_color(stroke[:color])
-            block.call
-          }
-        # Draw only with fill.
-        when fill
-          pdf.fill {
-            pdf.fill_color(fill[:color])
-            block.call
-          }
-        # Draw only with stroke.
-        when stroke
-          pdf.stroke {
-            line_width(stroke[:width])
-            pdf.stroke_color(stroke[:color])
-            block.call
+        # @param [Hash] styles
+        # @return [Hash, nil]
+        def build_stroke_styles(styles)
+          color = styles[:stroke]
+          width = styles[:stroke_width]
+          return nil unless color && color != 'none'
+          return nil unless width && width != 0
+
+          {
+            color: parse_color(color),
+            width: s2f(width),
+            dash: STROKE_DASH[styles[:stroke_type].to_sym]
           }
         end
 
-        restore_graphics_state
-      end
-
-      # @param [Hash] styles
-      # @return [Hash, nil]
-      def build_stroke_styles(styles)
-        color = styles[:stroke]
-        width = styles[:stroke_width]
-        return nil unless color && color != 'none'
-        return nil unless width && width != 0
-
-        {
-          color: parse_color(color),
-          width: s2f(width),
-          dash: STROKE_DASH[styles[:stroke_type].to_sym]
-        }
-      end
+        # @param [Hash] styles
+        # @return [Hash, nil]
+        def build_fill_styles(styles)
+          color = styles[:fill]
+          return nil unless color && color != 'none'
 
-      # @param [Hash] styles
-      # @return [Hash, nil]
-      def build_fill_styles(styles)
-        color = styles[:fill]
-        return nil unless color && color != 'none'
-
-        { color: parse_color(color) }
+          { color: parse_color(color) }
+        end
       end
-
     end
-
   end
 end