thinreports 0.12.1 → 0.13.0

data/lib/thinreports/basic_report/core/shape/text_block/interface.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          class Interface < Basic::BlockInterface
+            internal_delegators :format_enabled?
+
+            # @param [Boolean] enabled
+            # @return [self]
+            def format_enabled(enabled)
+              internal.format_enabled(enabled)
+              self
+            end
+
+            # @param [Object] val
+            # @param [Hash<Symbol, Object>] style_settings
+            # @return [self]
+            def set(val, style_settings = {})
+              value(val)
+              styles(style_settings) #=> self
+            end
+
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              TextBlock::Internal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/core/shape/text_block/internal.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          class Internal < Basic::BlockInternal
+            format_delegators :multiple?
+
+            attr_reader :style
+
+            def initialize(*args)
+              super(*args)
+
+              @reference = nil
+              @formatter = nil
+
+              @style = Style::Text.new(format)
+              @style.accessible_styles.delete(:valign) unless multiple?
+            end
+
+            def read_value
+              if format.has_reference?
+                @reference ||= parent.item(format.ref_id)
+                @reference.value
+              else
+                super
+              end
+            end
+
+            def write_value(val)
+              if format.has_reference?
+                warn 'The set value was not saved, ' \
+                     "Because '#{format.id}' has reference to '#{format.ref_id}'."
+              else
+                super
+              end
+            end
+
+            def real_value
+              if format_enabled?
+                formatter.apply(read_value)
+              else
+                super
+              end
+            end
+
+            def format_enabled(enabled)
+              states[:format_enabled] = enabled
+            end
+
+            def format_enabled?
+              if states.key?(:format_enabled)
+                states[:format_enabled]
+              else
+                !blank_value?(format.format_base) || format.has_format?
+              end
+            end
+
+            def type_of?(type_name)
+              type_name == TextBlock::TYPE_NAME || super
+            end
+
+            private
+
+            def formatter
+              @formatter ||= TextBlock::Formatter.setup(format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/{core → basic_report/core}/shape/text_block.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Thinreports
-  module Core
-    module Shape
-      module TextBlock
-        TYPE_NAME = 'text-block'
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          TYPE_NAME = 'text-block'
+        end
       end
     end
   end

data/lib/thinreports/basic_report/core/shape.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        def Interface(parent, format)
+          find_by_type(format.type)::Interface.new(parent, format)
+        end
+
+        def Format(type)
+          find_by_type(type)::Format
+        end
+
+        module_function :Interface, :Format
+
+        def self.find_by_type(type)
+          case type
+          when TextBlock::TYPE_NAME  then TextBlock
+          when ImageBlock::TYPE_NAME then ImageBlock
+          when List::TYPE_NAME       then List
+          when StackView::TYPE_NAME  then StackView
+          when Text::TYPE_NAME       then Text
+          when PageNumber::TYPE_NAME then PageNumber
+          when *Basic::TYPE_NAMES    then Basic
+          else
+            raise Thinreports::BasicReport::Errors::UnknownShapeType
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'shape/style'
+require_relative 'shape/manager'
+require_relative 'shape/base'
+require_relative 'shape/basic'
+require_relative 'shape/text'
+require_relative 'shape/text_block'
+require_relative 'shape/image_block'
+require_relative 'shape/list'
+require_relative 'shape/stack_view'
+require_relative 'shape/page_number'

data/lib/thinreports/basic_report/core/utils.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Utils
+      def self.included(klass)
+        klass.extend self
+      end
+
+      def deep_copy(src)
+        case src
+        when Hash
+          src.each_with_object({}) do |(k, v), h|
+            h[k] = v.dup rescue v
+          end
+        when Array
+          src.map do |a|
+            a.dup rescue a
+          end
+        else
+          raise ArgumentError
+        end
+      end
+
+      def blank_value?(value)
+        case value
+        when String   then value.empty?
+        when NilClass then true
+        else false
+        end
+      end
+
+      def call_block_in(scope, &block)
+        return scope unless block_given?
+
+        if block.arity == 1
+          block.call(scope)
+        else
+          scope.instance_eval(&block)
+        end
+        scope
+      end
+    end
+
+    extend Utils
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module DrawShape
+          # @param [Thinreports::BasicReport::Core::Shape::TextBlock::Internal] shape
+          # @param [Numeric] height (nil) It will be used as rendering height if present.
+          #   Otherwise, the rendering height is the height of schema.
+          # @param [:truncate, :shrink_to_fit, :expand] overflow (nil) It will be set the overflow attribute if present.
+          def draw_shape_tblock(shape, height: nil, overflow: nil, &block)
+            x, y, w = shape.format.attributes.values_at('x', 'y', 'width')
+
+            h = height || shape.format.attributes['height']
+
+            content = shape.real_value.to_s
+            return if content.empty?
+
+            attrs = build_text_attributes(shape.style.finalized_styles)
+            attrs[:overflow] = overflow if overflow
+
+            unless shape.multiple?
+              content = content.tr("\n", ' ')
+              attrs[:single] = true
+            end
+
+            text_box(content, x, y, w, h, attrs, &block)
+          end
+
+          def draw_shape_pageno(shape, page_no, page_count)
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+
+            attrs = build_text_attributes(shape.style.finalized_styles)
+            text_box(shape.build_format(page_no, page_count), x, y, w, h, attrs)
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::Basic::Internal] shape
+          def draw_shape_image(shape)
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+
+            image_data = shape.format.attributes['data']
+            base64image(image_data['base64'], x, y, w, h)
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::ImageBlock::Internal] shape
+          def draw_shape_iblock(shape)
+            return if blank_value?(shape.src)
+
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+            style = shape.style.finalized_styles
+
+            image_box(
+              shape.src, x, y, w, h,
+              position_x: image_position_x(style['position-x']),
+              position_y: image_position_y(style['position-y']),
+              offset_x: style['offset-x'],
+              offset_y: style['offset-y']
+            )
+          end
+
+          def shape_iblock_dimenions(shape)
+            return nil if blank_value?(shape.src)
+
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+            style = shape.style.finalized_styles
+
+            image_dimensions(
+              shape.src, x, y, w, h,
+              position_x: image_position_x(style['position-x']),
+              position_y: image_position_y(style['position-y'])
+            )
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::Text::Internal] shape
+          def draw_shape_text(shape, dheight = 0)
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+            text(
+              shape.texts.join("\n"), x, y, w, h + dheight,
+              build_text_attributes(shape.style.finalized_styles)
+            )
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::Basic::Internal] shape
+          def draw_shape_ellipse(shape)
+            cx, cy, rx, ry = shape.format.attributes.values_at('cx', 'cy', 'rx', 'ry')
+            ellipse(cx, cy, rx, ry, build_graphic_attributes(shape.style.finalized_styles))
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::Basic::Internal] shape
+          def draw_shape_line(shape, dy1 = 0, dy2 = 0)
+            x1, y1, x2, y2 = shape.format.attributes.values_at('x1', 'y1', 'x2', 'y2')
+            line(x1, y1 + dy1, x2, y2 + dy2, build_graphic_attributes(shape.style.finalized_styles))
+          end
+
+          # @param [Thinreports::BasicReport::Core::Shape::Basic::Internal] shape
+          def draw_shape_rect(shape, dheight = 0)
+            x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+            rect_attributes = build_graphic_attributes(shape.style.finalized_styles) do |attrs|
+              attrs[:radius] = shape.format.attributes['border-radius']
+            end
+            rect(x, y, w, h + dheight, rect_attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module DrawTemplateItems
+          # @param [Array<Hash>] items
+          def draw_template_items(items)
+            items.each do |item_attributes|
+              next unless drawable?(item_attributes)
+
+              case item_attributes['type']
+              when 'text' then draw_text(item_attributes)
+              when 'image' then draw_image(item_attributes)
+              when 'rect' then draw_rect(item_attributes)
+              when 'ellipse' then draw_ellipse(item_attributes)
+              when 'line' then draw_line(item_attributes)
+              end
+            end
+          end
+
+          private
+
+          # @param [Hash] item_attributes
+          def draw_rect(item_attributes)
+            x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+            graphic_attributes = build_graphic_attributes(item_attributes['style']) do |attrs|
+              attrs[:radius] = item_attributes['border-radius']
+            end
+
+            rect(x, y, w, h, graphic_attributes)
+          end
+
+          # @see #draw_rect
+          def draw_ellipse(item_attributes)
+            x, y, rx, ry = item_attributes.values_at('cx', 'cy', 'rx', 'ry')
+            ellipse(x, y, rx, ry, build_graphic_attributes(item_attributes['style']))
+          end
+
+          # @see #draw_rect
+          def draw_line(item_attributes)
+            x1, y1, x2, y2 = item_attributes.values_at('x1', 'y1', 'x2', 'y2')
+            line(x1, y1, x2, y2, build_graphic_attributes(item_attributes['style']))
+          end
+
+          # @see #draw_rect
+          def draw_text(item_attributes)
+            x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+            text(
+              item_attributes['texts'].join("\n"), x, y, w, h,
+              build_text_attributes(item_attributes['style'])
+            )
+          end
+
+          # @see #draw_rect
+          def draw_image(item_attributes)
+            x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+            image_data = item_attributes['data']
+
+            base64image(image_data['base64'], x, y, w, h)
+          end
+
+          def drawable?(item_attributes)
+            item_attributes['id'].empty? && item_attributes['display']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Font
+          FONT_STORE = Thinreports.root.join('fonts')
+
+          BUILTIN_FONTS = {
+            'IPAMincho'  => FONT_STORE.join('ipam.ttf').to_s,
+            'IPAPMincho' => FONT_STORE.join('ipamp.ttf').to_s,
+            'IPAGothic'  => FONT_STORE.join('ipag.ttf').to_s,
+            'IPAPGothic' => FONT_STORE.join('ipagp.ttf').to_s
+          }.freeze
+
+          DEFAULT_FALLBACK_FONTS = %w[IPAMincho].freeze
+
+          PRAWN_BUINTIN_FONT_ALIASES = {
+            'Courier New' => 'Courier',
+            'Times New Roman' => 'Times-Roman'
+          }.freeze
+
+          def setup_fonts
+            # Install built-in fonts.
+            BUILTIN_FONTS.each do |font_name, font_path|
+              install_font(font_name, font_path)
+            end
+
+            # Create aliases from the font list provided by Prawn.
+            PRAWN_BUINTIN_FONT_ALIASES.each do |alias_name, name|
+              pdf.font_families[alias_name] = pdf.font_families[name]
+            end
+
+            # Setup custom fallback fonts
+            fallback_fonts = Thinreports.config.fallback_fonts.uniq
+            fallback_fonts.map!.with_index do |font, i|
+              if pdf.font_families.key?(font)
+                font
+              else
+                install_font "Custom-fallback-font#{i}", font
+              end
+            end
+
+            # Set fallback fonts
+            pdf.fallback_fonts(fallback_fonts + DEFAULT_FALLBACK_FONTS)
+          end
+
+          # @param [String] name
+          # @param [String] file
+          # @return [String] installed font name
+          def install_font(name, file)
+            raise Errors::FontFileNotFound unless File.exist?(file)
+
+            pdf.font_families[name] = {
+              normal: file,
+              bold: file,
+              italic: file,
+              bold_italic: file
+            }
+            name
+          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_name
+          # @param [:bold, :italic] font_style
+          # @return [Boolean]
+          def font_has_style?(font_name, font_style)
+            font = pdf.font_families[font_name]
+
+            return false unless font
+            return false unless font.key?(font_style)
+
+            font[font_style] != font[:normal]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    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
+
+          # @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>] 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
+
+          # @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
+            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
+            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
+            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
+            end
+          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
+            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
+            end
+          end
+        end
+      end
+    end
+  end
+end