thinreports 0.12.1 → 0.13.0

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

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class Page < Basic::Interface
+            extend Forwardable
+
+            attr_reader :manager
+
+            # @param [Thinreports::BasicReport::Report::Page] parent
+            # @param [Thinreports::BasicReport::Core::Shape::Basic::Format] format
+            # @param [Thinreports::BasicReport::Core::Shape::List::PageState] internal (nil)
+            # @param [Thinreports::BasicReport::Core::Shape::List::Manager] manager (nil)
+            def initialize(parent, format, internal = nil, manager = nil)
+              super(parent, format, internal)
+
+              @manager =
+                if manager
+                  manager.switch_current!(self)
+                else
+                  List::Manager.new(self)
+                end
+
+              # Set a reference to List::PageState List::Manager
+              self.internal.manager = self.manager
+            end
+
+            # @see Thinreports::BasicReport::Core::Shape::List::Manager#build_header
+            def_delegator :manager, :build_header, :header
+
+            def on_page_finalize(&block)
+              manager.page_finalize_handler = block
+            end
+
+            # @yield [page_footer]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] page_footer
+            def on_page_footer_insert(&block)
+              manager.page_footer_handler = block
+            end
+
+            # @yield [footer]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] footer
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def on_footer_insert(&block)
+              manager.footer_handler = block
+            end
+
+            # @param [Hash] values ({})
+            # @yield [row,]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::List::SectionInterface] row
+            # @return [Boolean]
+            def add_row(values = {}, &block)
+              manager.add_detail(values, &block)
+            end
+
+            # If enabled, the auto-page-break of the list will force a page break
+            # at the time this method is called. Otherwise, this list will be finalized.
+            def page_break
+              if manager.auto_page_break?
+                manager.change_new_page
+              else
+                manager.finalize_page
+              end
+            end
+            alias finalize page_break
+
+            # @return [Boolean] Returns true if list has overflowed
+            #   when `list#add_row` is called at the next time.
+            def overflow?
+              manager.overflow_with?(:detail)
+            end
+
+            # @param [Thinreports::BasicReport::Report::Page] new_parent
+            # @return [Thinreports::BasicReport::Core::Shape::List::Page]
+            def copy(new_parent)
+              if manager.auto_page_break?
+                new_list = self.class.new(new_parent, internal.format,
+                                          nil, manager)
+              else
+                manager.finalize
+
+                new_list = self.class.new(new_parent, internal.format,
+                                          internal.copy(new_parent), manager)
+                internal.rows.each do |row|
+                  new_list.internal.rows << row.copy(new_list)
+                end
+                new_list.internal.finalized!
+              end
+
+              new_list.internal.header = internal.header.copy(new_list) if internal.format.has_header?
+              new_list
+            end
+
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              List::PageState.new(parent, format)
+            end
+          end
+
+          # Alias to List::Page.
+          # @see Thinreports::BasicReport::Core::Shape::List::Page
+          List::Interface = List::Page
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class PageState < Basic::Internal
+            attr_reader :rows
+
+            attr_accessor :height
+            attr_accessor :header
+            attr_accessor :no
+            attr_accessor :manager
+
+            def initialize(*args)
+              super(*args)
+
+              @rows = []
+              @height = 0
+              @finalized = false
+
+              @header = nil
+            end
+
+            def style
+              @style ||= Style::Basic.new(format)
+            end
+
+            def finalized?
+              @finalized
+            end
+
+            def finalized!
+              @finalized = true
+            end
+
+            def type_of?(type_name)
+              type_name == List::TYPE_NAME
+            end
+          end
+
+          # Alias to List::PageState.
+          # @see Thinreports::BasicReport::Core::Shape::List::PageState
+          List::Internal = List::PageState
+        end
+      end
+    end
+  end
+end