thinreports 0.12.0 → 0.13.0

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class SectionFormat < Shape::Manager::Format
+            config_reader :height
+            config_reader relative_left: %w[translate x],
+                          relative_top: %w[translate y]
+            config_reader :style
+
+            # For compatible 0.8.x format API
+            config_checker true, display: %w[enabled]
+
+            def initialize(*)
+              super
+              initialize_items(attributes['items'])
+            end
+
+            private
+
+            def initialize_items(item_schemas)
+              item_schemas.each do |item_schema|
+                id, type = item_schema.values_at 'id', 'type'
+                next if id.empty?
+
+                shapes[id.to_sym] = Core::Shape::Format(type).new(item_schema)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class SectionInterface < Base::Interface
+            include Core::Shape::Manager::Target
+
+            undef_method :list
+            internal_delegators :height
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::Page] parent
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionFormat] format
+            # @param [Symbol] section_name
+            def initialize(parent, format, section_name)
+              super(parent, format)
+              internal.section_name = section_name
+
+              initialize_manager(format) do |f|
+                Core::Shape::Interface(self, f)
+              end
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::Page] parent
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInterface]
+            def copy(parent)
+              new_sec = super
+              new_sec.internal.section_name = internal.section_name
+
+              manager.shapes.each do |id, shape|
+                new_sec.manager.shapes[id] = shape.copy(new_sec)
+              end
+              new_sec
+            end
+
+            private
+
+            # @param parent (see #initialize)
+            # @param format (see #initialize)
+            # @return [Thinreports::BasicReport::Core::Shape::List::SectionInternal]
+            def init_internal(parent, format)
+              List::SectionInternal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module List
+          class SectionInternal < Base::Internal
+            format_delegators :height,
+                              :relative_left
+
+            # @return [Symbol]
+            attr_accessor :section_name
+
+            def style
+              @style ||= Style::Base.new(format)
+            end
+
+            # @param [Numeric] ry
+            def move_top_to(ry)
+              states[:relative_top] = ry
+            end
+
+            # @return [Float]
+            def relative_top
+              states[:relative_top] || 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Manager
+          class Format < Core::Format::Base
+            # @return [Symbol, Integer]
+            attr_reader :identifier
+
+            def initialize(config, id = nil, &block)
+              super(config, &block)
+              @identifier = id || object_id
+            end
+
+            def find_shape(id)
+              shapes[id]
+            end
+
+            def has_shape?(id)
+              shapes.key?(id)
+            end
+
+            def shapes
+              @shapes ||= {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Manager
+          class Internal
+            include Utils
+
+            attr_reader :format
+            attr_reader :shapes
+            attr_reader :lists
+
+            # @param [Thinreports::BasicReport::Core::Manager::Format] format
+            # @param [Proc] init_item_handler
+            def initialize(format, init_item_handler)
+              @format = format
+              @shapes = {}
+              @lists = {}
+              @init_item_handler = init_item_handler
+            end
+
+            # @param [String, Symbol] id
+            # @return [Thinreports::BasicReport::Core::Shape::Basic::Format]
+            def find_format(id)
+              format.find_shape(id.to_sym)
+            end
+
+            # @param [String, Symbol] id
+            # @param limit (see #valid_type?)
+            def find_item(id, limit = {})
+              id = id.to_sym
+
+              if shapes.key?(id)
+                shape = shapes[id]
+                valid_type?(shape.type, limit) ? shape : nil
+              elsif find_format(id)
+                shape_format = find_format(id)
+                return nil unless valid_type?(shape_format.type, limit)
+
+                shape = init_item(shape_format)
+                shapes[id] = shape
+
+                shape
+              end
+            end
+
+            # @param [String, Symbol] id
+            # @return [Thinreports::BasicReport::Core::Shape::Base::Interface, nil]
+            def final_shape(id)
+              shape = shapes[id]
+
+              # When shape was found in registry.
+              if shape
+                return nil unless shape.visible?
+
+                # In the case of TextBlock or ImageBlock.
+                if shape.internal.type_of?(:block)
+                  blank_value?(shape.internal.real_value) ? nil : shape
+                else
+                  shape
+                end
+              # When shape was not found in registry.
+              elsif format.has_shape?(id)
+                shape_format = find_format(id)
+                return nil unless shape_format.display?
+
+                case shape_format.type
+                # In the case of TextBlock.
+                when TextBlock::TYPE_NAME
+                  return nil if !shape_format.has_reference? && blank_value?(shape_format.value)
+                  init_item(shape_format)
+                # In the case of ImageBlock, Return the nil constantly.
+                when ImageBlock::TYPE_NAME
+                  nil
+                else
+                  init_item(shape_format)
+                end
+              end
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::Basic::Format] format
+            def init_item(format)
+              @init_item_handler.call(format)
+            end
+
+            # @param [String] type
+            # @param [Hash] limit
+            # @option limit [String] :only
+            # @option limit [String] :except
+            # @return [Booldan]
+            def valid_type?(type, limit = {})
+              return true if limit.empty?
+
+              if limit[:only]
+                type == limit[:only]
+              elsif limit[:except]
+                type != limit[:except]
+              else
+                raise ArgumentError
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module Manager
+          module Target
+            include Utils
+
+            attr_reader :manager
+
+            # @example
+            #   item(:title).value('Title').style(:fill, 'red')
+            #
+            #   item(:title) do
+            #     value('Title')
+            #     style(:fill, 'red')
+            #   end
+            #
+            #   item(:title) do |t|
+            #     t.value('Title')
+            #     t.style(:fill, 'red')
+            #   end
+            #   item(:list)       # => Error: UnknownItemId
+            #   item(:unknown_id) # => Error: UnknownItemId
+            # @param [String, Symbol] id
+            # @yield [item,]
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::Base::Interface] item
+            # @raise [Thinreports::BasicReport::Errors::UnknownItemId]
+            # @return [Thinreports::BasicReport::Core::Shape::Base::Interface]
+            def item(id, &block)
+              shape = find_item(id, except: Core::Shape::List::TYPE_NAME)
+
+              raise Thinreports::BasicReport::Errors::UnknownItemId, id unless shape
+
+              call_block_in(shape, &block)
+            end
+
+            # @example
+            #   page[:text_block].style(:bold, true)
+            #   page[:rect].style(:border_color, 'red')
+            #
+            #   page[:list]       # => Error: UnknownItemId
+            #   page[:unknown_id] # => Error: UnknownItemId
+            # @param [String, Symbol] id
+            # @return [Thinreports::BasicReport::Core::Shape::Base::Interface]
+            def [](id)
+              item(id)
+            end
+
+            # @example
+            #   page[:text_block]  = 'Title'
+            #   page[:image_block] = '/path/to/image.png'
+            #   page[:list]        = 'value' # => Error: UnknownItemId
+            #   page[:ellipse]     = 'value' # => Error: NoMethodError #value
+            #   page[:unknown_id]  = 'value' # => Error: UnknownItemId
+            # @param [String, Symbol] id
+            # @param [Object] value
+            def []=(id, value)
+              item(id).value = value
+            end
+
+            # @example
+            #   page.values text_block: 'value',
+            #               image_block: '/path/to/image.png'
+            # @param [Hash] item_values
+            def values(item_values)
+              item_values.each { |id, val| item(id).value(val) }
+            end
+
+            # @param [Symbol, String] id
+            # @return [Boolean]
+            def item_exists?(id)
+              !manager.find_format(id).nil?
+            end
+            alias exists? item_exists?
+
+            # @example
+            #   report.list.add_row do |row|
+            #     row.item(:price).value(1000)
+            #   end
+            #
+            #   report.list(:list_id) # => List
+            #   report.list(:text_block_id) # => raises UnknownItemId
+            # @see #item
+            def list(id = nil, &block)
+              shape = find_item(id ||= :default, only: Core::Shape::List::TYPE_NAME)
+
+              raise Thinreports::BasicReport::Errors::UnknownItemId.new(id, 'List') unless shape
+
+              manager.lists[id.to_sym] ||= shape
+              call_block_in(shape, &block)
+            end
+
+            private
+
+            # @param format (see Thinreports::BasicReport::Core::Shape::Manager::Internal#initialize)
+            # @yield [format] Handler for initialize item.
+            # @yieldparam [Thinreports::BasicReport::Core::Shape::Basic::Format] format
+            def initialize_manager(format, &block)
+              @manager = Manager::Internal.new(format, block)
+            end
+
+            # @see Thinreports::BasicReport::Core::Shape::Manager::Internal#find_item
+            def find_item(id, limit = {})
+              manager.find_item(id, limit)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module PageNumber
+          class Format < Basic::Format
+            config_reader :target
+            config_reader default_format: %w[format]
+
+            # For saving compatible 0.8.x format API
+            config_reader overflow: %w[style overflow]
+
+            def id
+              @id ||= blank_value?(read('id')) ? self.class.next_default_id : read('id')
+            end
+
+            def for_report?
+              blank_value?(target)
+            end
+
+            def self.next_default_id
+              @id_counter ||= 0
+              "__pageno#{@id_counter += 1}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module PageNumber
+          class Interface < Basic::Interface
+            internal_delegators :reset_format
+
+            def format(*args)
+              if args.empty?
+                internal.read_format
+              else
+                internal.write_format(args.first)
+                self
+              end
+            end
+
+            private
+
+            # @see Thinreports::BasicReport::Core::Shape::Base::Interface#init_internal
+            def init_internal(parent, format)
+              PageNumber::Internal.new(parent, format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module PageNumber
+          class Internal < Basic::Internal
+            format_delegators :box, :for_report?
+
+            def read_format
+              states.key?(:format) ? states[:format] : format.default_format.dup
+            end
+
+            def reset_format
+              states.delete(:format)
+            end
+
+            def write_format(format)
+              states[:format] = format.to_s
+            end
+
+            def build_format(page_no, page_count)
+              return '' if blank_value?(read_format)
+
+              if start_page_number > 1
+                page_no += start_page_number - 1
+                page_count += start_page_number - 1
+              end
+
+              read_format.dup.tap do |f|
+                f.gsub! '{page}', page_no.to_s
+                f.gsub! '{total}', page_count.to_s
+              end
+            end
+
+            def style
+              @style ||= PageNumber::Style.new(format)
+            end
+
+            def type_of?(type_name)
+              type_name == PageNumber::TYPE_NAME
+            end
+
+            def start_page_number
+              for_report? ? parent.report.start_page_number : 1
+            end
+          end
+
+          class Style < Style::Text
+            accessible_styles.delete :valign
+          end
+        end
+      end
+    end
+  end
+end

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

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