thinreports 0.12.1 → 0.13.0

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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module StackView
+          class Format < Basic::Format
+            attr_reader :rows
+
+            def initialize(*)
+              super
+              initialize_rows
+            end
+
+            private
+
+            def initialize_rows
+              @rows = []
+              attributes['rows'].each do |row|
+                @rows << StackView::RowFormat.new(row)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module StackView
+          class Internal < Basic::Internal
+            def initialize(parent, format)
+              super
+              @rows = []
+            end
+
+            attr_accessor :rows
+
+            def type_of?(type_name)
+              type_name == StackView::TYPE_NAME
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/core/shape/stack_view/row_format.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Core
+      module Shape
+        module StackView
+          class RowFormat < Core::Format::Base
+            config_reader :id
+            config_reader :height
+            config_checker true, :display
+            config_checker true, auto_stretch: 'auto-stretch'
+
+            attr_reader :items
+
+            def initialize(*)
+              super
+              @items = []
+              @item_with_ids = {}
+              initialize_items(attributes['items'])
+            end
+
+            def find_item(id)
+              @item_with_ids[id.to_sym]
+            end
+
+            private
+
+            def initialize_items(item_schemas)
+              item_schemas.each do |item_schema|
+                item = Core::Shape::Format(item_schema['type']).new(item_schema)
+                @items << item
+                @item_with_ids[item.id.to_sym] = item unless item.id.empty?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Thinreports
-  module Core
-    module Shape
-      module StackView
-        TYPE_NAME = 'stack-view'.freeze
+  module BasicReport
+    module Core
+      module Shape
+        module StackView
+          TYPE_NAME = 'stack-view'.freeze
+        end
       end
     end
   end