thinreports 0.12.1 → 0.13.0

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Style
+          class Base
+            include Utils
+
+            class << self
+              # @param [Symbol] style_method
+              # @param [String] style
+              # @return [void]
+              def style_accessor(style_method, style)
+                style_reader(style_method, style)
+                style_writer(style_method, style)
+              end
+
+              # @see .style_accessor
+              def style_reader(style_method, style)
+                define_method(style_method) do
+                  read_internal_style(style)
+                end
+              end
+
+              # @see .style_accessor
+              def style_writer(style_method, style)
+                define_method(:"#{style_method}=") do |value|
+                  write_internal_style(style, value)
+                end
+              end
+
+              # @param [Array<Symbol>] style_methods
+              def style_accessible(*style_methods)
+                accessible_styles.concat(style_methods)
+              end
+
+              # @return [Array<Symbol>]
+              def accessible_styles
+                @accessible_styles ||= []
+              end
+
+              def inherited(s)
+                s.accessible_styles.concat(accessible_styles.dup)
+              end
+            end
+
+            # @return [Hash]
+            attr_accessor :styles
+            # @see .accessible_styles
+            attr_reader :accessible_styles
+
+            # @param [Thinreports::BasicReport::Core::Format::Base] format
+            # @param [Hash] default_styles ({})
+            def initialize(format, default_styles = {})
+              @format = format
+              @styles = default_styles
+              @base_styles = format.style || {}
+
+              @accessible_styles = self.class.accessible_styles.dup
+            end
+
+            # @param [Symbol] style_method
+            # @return [Object]
+            def [](style_method)
+              verify_style_method(style_method)
+              send(style_method.to_sym)
+            end
+
+            # @param [Symbol] style_method
+            # @param [String, Number, Array<String, Number>] value
+            def []=(style_method, value)
+              verify_style_method(style_method)
+              send(:"#{style_method}=", value)
+            end
+
+            # @return [String]
+            def identifier
+              create_identifier(@styles)
+            end
+
+            # @return [self]
+            def copy
+              self.class.new(@format, @styles.empty? ? {} : deep_copy(@styles))
+            end
+
+            # @param [String, Symbol] style
+            # @return [Object]
+            def read_internal_style(style)
+              style = style.to_s
+              @styles.key?(style) ? @styles[style] : @base_styles[style]
+            end
+
+            # @param [String, Symbol] style
+            # @param [Object] value
+            def write_internal_style(style, value)
+              @styles[style.to_s] = value
+            end
+
+            # @param [Symbol] style_method
+            # @return [Boolean]
+            def has_style?(style_method)
+              accessible_styles.include?(style_method)
+            end
+
+            # @return [Hash]
+            def finalized_styles
+              @finalized_styles ||=
+                if @styles.empty?
+                  @base_styles.dup
+                else
+                  @base_styles.merge(@styles)
+                end
+            end
+
+            private
+
+            # @param [Hash] s
+            # @return [String]
+            def create_identifier(s)
+              s.empty? ? '' : s.hash.to_s
+            end
+
+            # @param [Symbol] style_method
+            # @raise Thinreports::BasicReport::Errors::UnknownShapeStyleName
+            def verify_style_method(style_method)
+              return if has_style?(style_method)
+
+              raise Thinreports::BasicReport::Errors::UnknownShapeStyleName.new(
+                style_method,
+                accessible_styles
+              )
+            end
+
+            # @param [Object] value
+            # @param [Array<Object>] allows
+            # @param [String] msg (nil)
+            # @raise ArgumentError
+            def verify_style_value(value, allows, msg = nil)
+              raise ArgumentError, msg unless allows.include?(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Style
+          class Basic < Style::Base
+            style_accessible :visible, :offset_x, :offset_y
+            attr_accessor :visible
+
+            style_accessor :offset_x, 'offset-x'
+            style_accessor :offset_y, 'offset-y'
+
+            def initialize(*args)
+              super
+              @visible = @format.display?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Style
+          class Graphic < Style::Basic
+            style_accessible :border_color, :border_width, :fill_color, :border
+
+            # @method border_color
+            #   @return [String]
+            # @method border_color=(color)
+            #   @param [String] color
+            style_accessor :border_color, 'border-color'
+
+            # @method border_width
+            #   @return [Number]
+            style_accessor :border_width, 'border-width'
+
+            # @method fill_color
+            #   @return [String]
+            # @method fill_color=(color)
+            #   @param [String] color
+            style_accessor :fill_color, 'fill-color'
+
+            # @return [Array<String, Number>]
+            def border
+              [border_width, border_color]
+            end
+
+            # @param [Array<String, Number>] width_and_color
+            def border=(width_and_color)
+              w, c = width_and_color
+              self.border_width = w
+              self.border_color = c
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Style
+          class Text < Style::Basic
+            style_accessible :bold, :italic, :underline, :linethrough,
+                             :align, :valign, :color, :font_size
+
+            # @method color
+            #   @return [String]
+            # @method color=(v)
+            #   @param [String] v
+            style_accessor :color, 'color'
+
+            # @method font_size
+            #   @return [Numeric, String]
+            # @method font_size=(v)
+            #   @param [Numeric, String] v
+            style_accessor :font_size, 'font-size'
+
+            def initialize(*)
+              super
+              initialize_font_style
+            end
+
+            # @return [Boolean]
+            def bold
+              read_internal_style('font-style').include?('bold')
+            end
+
+            # @param [Boolean] enable
+            def bold=(enable)
+              write_font_style('bold', enable)
+            end
+
+            # @return [Boolean]
+            def italic
+              read_internal_style('font-style').include?('italic')
+            end
+
+            # @param [Boolean] enable
+            def italic=(enable)
+              write_font_style('italic', enable)
+            end
+
+            # @return [Boolean]
+            def underline
+              read_internal_style('font-style').include?('underline')
+            end
+
+            # @param [Boolean] enable
+            def underline=(enable)
+              write_font_style('underline', enable)
+            end
+
+            # @return [Boolean]
+            def linethrough
+              read_internal_style('font-style').include?('linethrough')
+            end
+
+            # @param [Boolean] enable
+            def linethrough=(enable)
+              write_font_style('linethrough', enable)
+            end
+
+            # @return [:left, :center, :right]
+            def align
+              read_internal_style('text-align').to_sym
+            end
+
+            # @param [:left, :center, :right] align_name
+            def align=(align_name)
+              verify_style_value(align_name, %i[left center right],
+                                 'Only :left or :center, :right can be specified as align.')
+              write_internal_style('text-align', align_name.to_s)
+            end
+
+            # @return [:top, :middle, :bottom]
+            def valign
+              vertical_align = read_internal_style('vertical-align')
+              blank_value?(vertical_align) ? :top : vertical_align.to_sym
+            end
+
+            # @param [:top, :center, :middle, :bottom] valign_name
+            def valign=(valign_name)
+              if valign_name == :center
+                warn '[DEPRECATION] :center value for valign style is deprecated' \
+                     ' and will be removed in thinreports-generator 1.0.' \
+                     ' Please use :middle instead of :center.'
+                valign_name = :middle
+              end
+
+              verify_style_value(
+                valign_name,
+                %i[top middle bottom],
+                'Only :top or :middle (:center), :bottom can be specified as valign.'
+              )
+              write_internal_style('vertical-align', valign_name.to_s)
+            end
+
+            private
+
+            def initialize_font_style
+              styles['font-style'] ||= (@base_styles['font-style'] || []).dup
+            end
+
+            def write_font_style(style_name, enable)
+              if enable
+                styles['font-style'].push(style_name).uniq!
+              else
+                styles['font-style'].delete(style_name)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Text
+          class Format < Basic::Format
+            config_reader :texts
+            config_reader valign: %w[style vertical-align]
+            config_reader line_height: %w[style line-height]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Text
+          class Interface < Basic::Interface
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              Text::Internal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

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

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'