thinreports 0.12.1 → 0.13.0

data/lib/thinreports/core/shape/text/internal.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Core
-    module Shape
-      module Text
-        class Internal < Basic::Internal
-          # Delegate to Format's methods
-          format_delegators :texts, :box
-
-          def style
-            @style ||= Style::Text.new(format)
-          end
-
-          def type_of?(type_name)
-            type_name == Text::TYPE_NAME
-          end
-        end
-      end
-    end
-  end
-end

data/lib/thinreports/core/shape/text_block/format.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Core
-    module Shape
-      module TextBlock
-        class Format < Basic::BlockFormat
-          # For saving compatible 0.8.x format API
-          config_reader ref_id: %w[reference-id]
-          config_reader valign: %w[style vertical-align]
-          config_reader overflow: %w[style overflow]
-          config_reader line_height: %w[style line-height]
-
-          config_reader format_base: %w[format base],
-                        format_type: %w[format type],
-                        format_datetime_format: %w[format datetime format],
-                        format_number_delimiter: %w[format number delimiter],
-                        format_number_precision: %w[format number precision],
-                        format_padding_char: %w[format padding char],
-                        format_padding_dir: %w[format padding direction]
-
-          config_checker true, multiple: %w[multiple-line]
-          config_checker 'R', format_padding_rdir: %w[format padding direction]
-
-          config_reader format_padding_length: %w[format padding length] do |len|
-            blank_value?(len) ? 0 : len.to_i
-          end
-
-          config_reader has_format?: %w[format type] do |type|
-            %w[datetime number padding].include?(type)
-          end
-
-          # For saving compatible 0.8.x format API
-          def has_reference?
-            !blank_value?(ref_id)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Core
-    module Shape
-      module TextBlock
-        module Formatter
-          class Basic
-            include Utils
-
-            attr_reader :format
-
-            def initialize(format)
-              @format = format
-            end
-
-            def apply(value)
-              value = apply_format_to(value) if applicable?(value)
-
-              return value if blank_value?(format.format_base)
-
-              format.format_base.gsub(/\{value\}/, value.to_s)
-            end
-
-            private
-
-            def apply_format_to(value)
-              value
-            end
-
-            def applicable?(_value)
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Core
-    module Shape
-      module TextBlock
-        module Formatter
-          class Datetime < Formatter::Basic
-            private
-
-            def apply_format_to(value)
-              value.strftime(format.format_datetime_format)
-            end
-
-            def applicable?(value)
-              !blank_value?(format.format_datetime_format) && value.respond_to?(:strftime)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'bigdecimal'
-
-module Thinreports
-  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

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Core
-    module Shape
-      module TextBlock
-        module Formatter
-          # @param [Thinreports::Core::Shape::TextBlock::Format] format
-          # @return [Thinreports::Core::Shape::TextBlock::Formatter::Base]
-          def self.setup(format)
-            klass =
-              if Thinreports.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::Errors::UnknownFormatterType
-                end
-              end
-            klass.new(format)
-          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/core/shape/text_block/interface.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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::Core::Shape::Base::Interface#init_internal
-          def init_internal(parent, format)
-            TextBlock::Internal.new(parent, format)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

data/lib/thinreports/core/shape.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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::Errors::UnknownShapeType
-        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/core/utils.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

data/lib/thinreports/generate.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'section_report/generate'
-
-module Thinreports
-  class Generate
-    def call(report_params, filename: nil)
-      SectionReport::Generate.new.call(report_params, filename: filename)
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Generator
-    class PDF
-      module DrawShape
-        # @param [Thinreports::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::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::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::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::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::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::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

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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