thinreports 0.12.0 → 0.13.0

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class BlockFormat < Basic::Format
+            config_reader :value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class BlockInterface < Basic::Interface
+            # @overload value(val)
+            #   Set a val
+            #   @param [Object] val
+            #   @return [self]
+            # @overload value
+            #   Return the value
+            #   @return [Object]
+            def value(*args)
+              if args.empty?
+                internal.read_value
+              else
+                internal.write_value(args.first)
+                self
+              end
+            end
+
+            # @param [Object] val
+            def value=(val)
+              value(val)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class BlockInternal < Basic::Internal
+            format_delegators :box
+
+            def style
+              @style ||= Style::Basic.new(format)
+            end
+
+            def read_value
+              states.key?(:value) ? states[:value] : format.value.dup
+            end
+            alias value read_value
+
+            def write_value(val)
+              states[:value] = val
+            end
+
+            def real_value
+              read_value
+            end
+
+            def type_of?(type_name)
+              type_name == :block
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class Format < Core::Format::Base
+            include Utils
+
+            config_reader :type, :id
+            config_reader :style
+            config_checker true, :display
+            config_reader follow_stretch: %w[follow-stretch]
+
+            def affect_bottom_margin?
+              attributes.fetch('affect-bottom-margin', true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class Interface < Base::Interface
+            internal_delegators :type
+
+            # @return [String]
+            def id
+              internal.id.dup
+            end
+
+            # @param [Boolean] visibility
+            # @return [self]
+            def visible(visibility)
+              internal.style.visible = visibility
+              self
+            end
+
+            # @return [Boolean]
+            def visible?
+              internal.style.visible
+            end
+
+            # @overload style(style_name)
+            #   @param [Symbol] style_name
+            #   @return [Object]
+            # @overload style(style_name, value)
+            #   @param [Symbol] style_name
+            #   @param [String, Symbol, Number, Array] value
+            #   @return [self]
+            # @overload style(style_name, value1, value2)
+            #   @param [Symbol] style_name
+            #   @param [String, Number] value1
+            #   @param [String, Number] value2
+            #   @return [self]
+            def style(*args)
+              case args.length
+              when 1
+                internal.style[args.first]
+              when 2
+                internal.style[args.first] = args.last
+                self
+              when 3
+                internal.style[args.shift] = args
+                self
+              else
+                raise ArgumentError, '#style requires 1 or 2, 3 arguments'
+              end
+            end
+
+            # @param [Hash] settings style_name: value
+            # @return [self]
+            def styles(settings)
+              settings.each { |args| style(*args) }
+              self
+            end
+
+            # @see #visible
+            # @return [self]
+            def hide
+              visible(false)
+              self
+            end
+
+            # @see #visible
+            # @return [self]
+            def show
+              visible(true)
+              self
+            end
+
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              Basic::Internal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          class Internal < Base::Internal
+            # Delegate to Format's methods
+            format_delegators :id, :type
+
+            def style
+              @style ||= Style::Graphic.new(format)
+            end
+
+            def type_of?(type_name)
+              [:basic, type].include?(type_name)
+            end
+
+            def identifier
+              "#{id}#{style.identifier}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Thinreports
-  module Core
-    module Shape
-      module Basic
-        TYPE_NAMES = %w[line rect ellipse image].freeze
+  module BasicReport
+    module Core
+      module Shape
+        module Basic
+          TYPE_NAMES = %w[line rect ellipse image].freeze
+        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module ImageBlock
+          class Format < Basic::BlockFormat
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module ImageBlock
+          class Interface < Basic::BlockInterface
+            # @see #value
+            alias src value
+            # @see #value=
+            alias src= value=
+
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              ImageBlock::Internal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module ImageBlock
+          class Internal < Basic::BlockInternal
+            alias src read_value
+
+            def type_of?(type_name)
+              type_name == ImageBlock::TYPE_NAME || super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class Format < Basic::Format
+            config_reader height: %w[content-height]
+            config_checker true, auto_page_break: %w[auto-page-break]
+
+            # @deprecated
+            config_reader :header,
+                          :detail,
+                          :footer
+            # @deprecated
+            config_reader page_footer: %w[page-footer]
+
+            config_checker true, has_header: %w[header enabled]
+            config_checker true, has_footer: %w[footer enabled]
+            config_checker true, has_page_footer: %w[page-footer enabled]
+
+            config_reader page_footer_height: %w[page-footer height]
+            config_reader footer_height: %w[footer height]
+            config_reader header_height: %w[header height]
+            config_reader detail_height: %w[detail height]
+
+            attr_reader :sections
+
+            def initialize(*)
+              super
+              initialize_sections
+            end
+
+            # @param [Symbol] section_name
+            # @return [Hash]
+            # @deprecated
+            def section(section_name)
+              __send__(section_name)
+            end
+
+            # @param [Symbol] section_name
+            # @return [Boolean]
+            def has_section?(section_name)
+              section_name == :detail ? true : __send__(:"has_#{section_name}?")
+            end
+
+            # @param [Symbol] section_name
+            # @return [Numeric]
+            def section_height(section_name)
+              has_section?(section_name) ? __send__(:"#{section_name}_height") : 0
+            end
+
+            # @param [:detai, :header, :page_footer, :footer] section_name
+            # @return [Numeric]
+            def section_base_position_top(section_name)
+              section = @sections[section_name]
+              return 0 unless has_section?(section_name)
+
+              top = section.relative_top
+
+              case section_name
+              when :page_footer
+                top - section_height(:detail)
+              when :footer
+                top - section_height(:detail) - section_height(:page_footer)
+              else
+                top
+              end
+            end
+
+            private
+
+            def initialize_sections
+              @sections = {
+                detail: List::SectionFormat.new(attributes['detail'])
+              }
+
+              @sections[:header] = section_format('header') if has_section?(:header)
+              @sections[:page_footer] = section_format('page-footer') if has_section?(:page_footer)
+              @sections[:footer] = section_format('footer') if has_section?(:footer)
+            end
+
+            def section_format(section_name)
+              List::SectionFormat.new(attributes[section_name])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class Manager
+            include Utils
+
+            # @return [Thinreports::BasicReport::Core::Shape:::List::Page]
+            attr_reader :current_page
+
+            # @return [Thinreports::BasicReport::Core::Shape::List::PageState]
+            attr_reader :current_page_state
+
+            # @return [Integer]
+            attr_accessor :page_count
+
+            # @return [Proc]
+            attr_accessor :page_finalize_handler
+
+            # @return [Proc]
+            attr_accessor :page_footer_handler
+
+            # @return [Proc]
+            attr_accessor :footer_handler
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::Page] page
+            def initialize(page)
+              switch_current!(page)
+
+              @finalized = false
+              @page_count = 0
+
+              @page_finalize_handler = nil
+              @page_footer_handler = nil
+              @footer_handler = nil
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::Page] page
+            # @return [Thinreports::BasicReport::Core::Shape::List::Manager]
+            def switch_current!(page)
+              @current_page = page
+              @current_page_state = page.internal
+              self
+            end
+
+            # @yield [new_list]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::Page] new_list
+            def change_new_page(&block)
+              finalize_page
+              new_page = report.internal.copy_page
+
+              block.call(new_page.list(current_page.id)) if block_given?
+            end
+
+            # @param [Hash] values ({})
+            # @yield [header]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] header
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            # @raise [Thinreports::BasicReport::Errors::DisabledListSection]
+            def build_header(values = {}, &block)
+              raise Thinreports::BasicReport::Errors::DisabledListSection, 'header' unless format.has_header?
+
+              current_page_state.header ||= init_section(:header)
+              build_section(header_section, values, &block)
+            end
+
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def header_section
+              current_page_state.header
+            end
+
+            # @param (see #build_section)
+            # @return [Boolean]
+            def add_detail(values = {}, &block)
+              return false if current_page_state.finalized?
+
+              successful = true
+
+              if overflow_with?(:detail)
+                if auto_page_break?
+                  change_new_page do |new_list|
+                    new_list.manager.insert_detail(values, &block)
+                  end
+                else
+                  finalize
+                  successful = false
+                end
+              else
+                insert_detail(values, &block)
+              end
+              successful
+            end
+
+            # @param values (see Thinreports::BasicReport::Core::Shape::Manager::Target#values)
+            # @yield [section,]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] section
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def insert_detail(values = {}, &block)
+              detail = build_section(init_section(:detail), values, &block)
+              insert_row(detail)
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionInterface] row
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def insert_row(row)
+              row.internal.move_top_to(current_page_state.height)
+
+              current_page_state.rows << row
+              current_page_state.height += row.height
+              row
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionInterface] section
+            # @param values (see Thinreports::BasicReport::Core::Shape::Manager::Target#values)
+            # @yield [section,]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] section
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def build_section(section, values = {}, &block)
+              section.values(values)
+              call_block_in(section, &block)
+            end
+
+            # @param [Symbol] section_name
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def init_section(section_name)
+              List::SectionInterface.new(current_page,
+                                         format.sections[section_name],
+                                         section_name)
+            end
+
+            # @param [Symbol] section_name
+            # @return [Boolean]
+            def overflow_with?(section_name = :detail)
+              max_height = page_max_height
+
+              max_height += format.section_height(:page_footer) if section_name == :footer && format.has_page_footer?
+
+              height = format.section_height(section_name)
+              (current_page_state.height + height) > max_height
+            end
+
+            # @return [Numeric]
+            def page_max_height
+              @page_max_height ||= begin
+                h = format.height
+                h -= format.section_height(:page_footer)
+                h -= format.section_height(:footer) unless auto_page_break?
+                h
+              end
+            end
+
+            # @return [Boolean]
+            def auto_page_break?
+              format.auto_page_break?
+            end
+
+            # @param [Hash] options
+            # @option options [Boolean] :ignore_page_footer (false)
+            #   When the switch of the page is generated by #finalize, it is used.
+            def finalize_page(options = {})
+              return if current_page_state.finalized?
+
+              build_header if format.has_header?
+
+              finalize_page_footer unless options[:ignore_page_footer]
+
+              current_page_state.finalized!
+              @page_finalize_handler.call if @page_finalize_handler
+
+              @page_count += 1
+              current_page_state.no = @page_count
+            end
+
+            def finalize_page_footer
+              return unless format.has_page_footer?
+
+              page_footer = init_section(:page_footer)
+              insert_row(page_footer)
+
+              @page_footer_handler.call(page_footer) if @page_footer_handler
+            end
+
+            def finalize
+              return if finalized?
+              finalize_page
+
+              if format.has_footer?
+                footer = init_section(:footer)
+
+                @footer_handler.call(footer) if @footer_handler
+
+                if auto_page_break? && overflow_with?(:footer)
+                  change_new_page do |new_list|
+                    new_list.manager.insert_row(footer)
+                    new_list.manager.finalize_page(ignore_page_footer: true)
+                  end
+                else
+                  insert_row(footer)
+                end
+              end
+              @finalized = true
+            end
+
+            # @return [Boolean]
+            def finalized?
+              @finalized
+            end
+
+            # @return [Thinreports::BasicReport::Report::Base]
+            def report
+              current_page_state.parent.report
+            end
+
+            # @return [Thinreports::BasicReport::Layout::Base]
+            def layout
+              current_page_state.parent.layout
+            end
+
+            # @return [Thinreports::BasicReport::Core::Shape::List::Format]
+            def format
+              current_page_state.format
+            end
+          end
+        end
+      end
+    end
+  end
+end