thinreports 0.12.0 → 0.13.0

data/lib/thinreports/basic_report/core/shape/text_block/formatter/number.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          module Formatter
+            class Number < Formatter::Basic
+              private
+
+              def apply_format_to(value)
+                precision = format.format_number_precision
+                delimiter = format.format_number_delimiter
+
+                if_applicable value do |val|
+                  val = number_with_precision(val, precision) unless blank_value?(precision)
+                  val = number_with_delimiter(val, delimiter) unless blank_value?(delimiter)
+                  val
+                end
+              end
+
+              def if_applicable(value, &block)
+                normalized_value = normalize(value)
+                normalized_value.nil? ? value : block.call(normalized_value)
+              end
+
+              def normalize(value)
+                if value.is_a?(String)
+                  convert_to_integer(value) || convert_to_float(value)
+                else
+                  value
+                end
+              end
+
+              def number_with_delimiter(value, delimiter = ',')
+                value_int, value_float = value.to_s.split('.')
+
+                [
+                  value_int.gsub(/(\d)(?=(\d{3})+(?!\d))/) { "#{$1}#{delimiter}" },
+                  value_float
+                ].compact.join('.')
+              end
+
+              def number_with_precision(value, precision = 3)
+                value = BigDecimal(value.to_s).round(precision)
+                sprintf("%.#{precision}f", value)
+              end
+
+              def convert_to_integer(value)
+                Integer(value)
+              rescue ArgumentError
+                nil
+              end
+
+              def convert_to_float(value)
+                Float(value)
+              rescue ArgumentError
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/core/shape/text_block/formatter/padding.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          module Formatter
+            class Padding < Formatter::Basic
+              private
+
+              def apply_format_to(value)
+                value.to_s.send(format.format_padding_rdir? ? :ljust : :rjust,
+                                format.format_padding_length,
+                                format.format_padding_char)
+              end
+
+              def applicable?(_value)
+                !blank_value?(format.format_padding_char) && format.format_padding_length > 0
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module TextBlock
+          module Formatter
+            include Utils
+
+            # @param [Thinreports::BasicReport::Core::Shape::TextBlock::Format] format
+            # @return [Thinreports::BasicReport::Core::Shape::TextBlock::Formatter::Base]
+            def self.setup(format)
+              klass =
+                if blank_value?(format.format_type)
+                  Basic
+                else
+                  case format.format_type
+                  when 'number'   then Number
+                  when 'datetime' then Datetime
+                  when 'padding'  then Padding
+                  else
+                    raise Thinreports::BasicReport::Errors::UnknownFormatterType
+                  end
+                end
+              klass.new(format)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'formatter/basic'
+require_relative 'formatter/datetime'
+require_relative 'formatter/padding'
+require_relative 'formatter/number'

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