thinreports 0.6.0.pre3

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

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    class Basic::Internal < Base::Internal
+      # Delegate to Format's methods
+      format_delegators :id, :svg_tag, :svg_attrs, :type
+      
+      def visible(visibility)
+        states[:display] = visibility
+      end
+      
+      def visible?
+        states.key?(:display) ? states[:display] : format.display?
+      end
+      
+      def svg_attr(attr_name, value)
+        attrs[attr_name.to_s] = value
+      end
+      
+      def type_of?(type_name)
+        ['s-basic', self.type].include?("s-#{type_name}")
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    module List
+      TYPE_NAME = 's-list'
+    end
+    
+  end
+end
+
+require 'thinreports/core/shape/list/format'
+require 'thinreports/core/shape/list/manager'
+
+require 'thinreports/core/shape/list/page'
+require 'thinreports/core/shape/list/page_state'
+
+require 'thinreports/core/shape/list/section_format'
+require 'thinreports/core/shape/list/section_interface'
+require 'thinreports/core/shape/list/section_internal'
+
+require 'thinreports/core/shape/list/store'
+require 'thinreports/core/shape/list/events'
+require 'thinreports/core/shape/list/configuration'

data/lib/thinreports/core/shape/list/configuration.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    class List::Configuration
+      # @return [ThinReports::Core::Shape::List::Events]
+      attr_reader :events
+      
+      # @return [ThinReports::Core::Shape::List::Store]
+      attr_reader :store
+            
+      # @param [ThinReports::Core::Shape::List::Events, nil] events (nil)
+      # @param [ThinReports::Core::Shape::List::Store, nil] store (nil)
+      def initialize(events = nil, store = nil)
+        @events = events || List::Events.new
+        @store  = store
+      end
+      
+      # @param [Hash] stores :name => default value
+      def use_stores(stores)
+        @store = List::Store.init(stores)
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Configuration]
+      # @private
+      def copy
+        self.class.new(@events.copy, @store && @store.copy)
+      end
+    end
+    
+  end
+end

data/lib/thinreports/core/shape/list/events.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    class List::Events < Core::Events
+      def initialize
+        super(:page_footer_insert,
+              :footer_insert)
+      end
+      
+      class SectionEvent < Event
+        # @return [ThinReports::Core::Shape::List::Store]
+        attr_reader :store
+        
+        # @param type (see ThinReports::Core::Events::Event#initialize)
+        # @param target (see ThinReports::Core::Events::Event#initialize)
+        # @param [ThinReports::Core::Shape::List::Store] store
+        def initialize(type, target, store)
+          super(type, target)
+          @store = store
+        end
+        
+        # @return [ThinReports::Core::Shape::List::SectionInterface]
+        alias_method :section, :target
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    class List::Format < Basic::Format
+      config_reader :height => %w( content-height )
+      config_checker 'true', :auto_page_break => %w( page-break )
+      
+      config_reader :header,
+                    :detail,
+                    :footer
+      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 )
+      
+      config_accessor :sections
+      
+      # @param [Symbol] section_name
+      # @return [Hash]
+      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
+      
+      class << self
+        
+      private
+        
+        # @param [Hash] raw_format
+        # @return [ThinReports::Core::Shape::List::Format]
+        def build_internal(raw_format)
+          new(raw_format) do |f|
+            f.sections = {}
+            build_section(:detail, f)
+            build_section(:header, f) if f.has_header?
+            build_section(:footer, f) if f.has_footer?
+            build_section(:page_footer, f) if f.has_page_footer?
+          end
+        end
+        
+        # @param [Symbol] section_name
+        # @param [ThinReports::Core::Shape::List::Format] list
+        # @return [ThinReports::Core::Shape::List::SectionFormat]
+        def build_section(section_name, list)
+          list.sections[section_name] =
+            List::SectionFormat.build(list.section(section_name))
+        end
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,209 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    class List::Manager
+      attr_reader :config
+      
+      # @return [ThinReports::Core::Shape:::List::Page]
+      attr_reader :current_page
+      
+      # @return [ThinReports::Core::Shape::List::PageState]
+      attr_reader :current_page_state
+      
+      # @param [ThinReports::Core::Shape::List::Page] page
+      def initialize(page)
+        switch_current!(page)
+
+        @config    = init_config
+        @finalized = false
+      end
+      
+      # @param [ThinReports::Core::Shape::List::Page] page
+      # @return [ThinReports::Core::Shape::List::Manager]
+      def switch_current!(page)
+        @current_page       = page
+        @current_page_state = page.internal
+        self
+      end
+      
+      # @yield [new_list]
+      # @yieldparam [ThinReports::Core::Shape::List::Page] new_list
+      def change_new_page(&block)
+        finalize_page
+        new_page = report.internal.copy_page
+        
+        if block_given?
+          block.call(new_page.list(current_page.id))
+        end
+      end
+      
+      # @see List::Page#header
+      def header(values = {}, &block)
+        unless format.has_header?
+          raise ThinReports::Errors::DisabledListSection, 'header'
+        end        
+        current_page_state.header ||= init_section(:header)
+        build_section(current_page_state.header, values, &block)
+      end
+      
+      # @param (see #build_section)
+      # @return [Boolean]
+      def insert_new_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_new_row(:detail, values, &block)
+            end
+          else
+            finalize
+            successful = false
+          end
+        else
+          insert_new_row(:detail, values, &block)
+        end
+        successful
+      end
+      
+      # @see #build_section
+      def insert_new_row(section_name, values = {}, &block)
+        row = build_section(init_section(section_name), values, &block)
+        row.internal.move_top_to(current_page_state.height)
+        
+        current_page_state.rows << row
+        current_page_state.height += row.height
+        row
+      end
+      
+      # @param [ThinReports::Core::Shape::List::SectionInterface] section
+      # @param values (see ThinReports::Core::Shape::Manager::Target#values)
+      # @yield [section,]
+      # @yieldparam [ThinReports::Core::Shape::List::SectionInterface] section
+      # @return [ThinReports::Core::Shape::List::SectionInterface]
+      def build_section(section, values = {}, &block)
+        section.values(values)
+        block_exec_on(section, &block)
+      end
+      
+      # @param [Symbol] section_name
+      # @return [ThinReports::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)
+        height = format.section_height(section_name)
+        current_page_state.height + height > page_max_height
+      end
+      
+      # @return [Numeric]
+      def page_max_height
+        unless @page_max_height
+          h  = format.height
+          h -= format.section_height(:page_footer)
+          h -= format.section_height(:footer) unless auto_page_break?
+          @page_max_height = h
+        end
+        @page_max_height
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Store]
+      def store
+        config.store
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Events]
+      def events
+        config.events
+      end
+      
+      # @return [Boolean]
+      def auto_page_break?
+        format.auto_page_break?
+      end
+      
+      # @param [Hash] options
+      # @option [Boolean] :ignore_page_footer (false)
+      # @private
+      def finalize_page(options = {})
+        return if current_page_state.finalized?
+        
+        if format.has_header?
+          current_page_state.header ||= init_section(:header)
+        end
+        
+        if !options[:ignore_page_footer] && format.has_page_footer?
+          footer = insert_new_row(:page_footer)
+          # Dispatch event on footer insert.
+          events.
+            dispatch(List::Events::SectionEvent.new(:page_footer_insert,
+                                                    footer, store))
+        end
+        current_page_state.finalized!
+      end      
+      
+      # @private
+      def finalize
+        return if finalized?
+        
+        finalize_page
+        
+        if format.has_footer?
+          footer = nil
+          
+          if auto_page_break? && overflow_with?(:footer)
+            change_new_page do |new_list|
+              footer = new_list.manager.insert_new_row(:footer)
+              new_list.manager.finalize_page(:ignore_page_footer => true)
+            end
+          else
+            footer = insert_new_row(:footer)
+          end
+          # Dispatch event on footer insert.
+          events.dispatch(List::Events::SectionEvent.new(:footer_insert,
+                                                         footer, store))
+        end
+        @finalized = true
+      end
+      
+      # @return [Boolean]
+      # @private
+      def finalized?
+        @finalized
+      end      
+      
+    private
+      
+      # @return [ThinReports::Report::Base]
+      def report
+        current_page_state.parent.report
+      end
+      
+      # @return [ThinReports::Layout::Base]
+      def layout
+        current_page_state.parent.layout
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Format]
+      def format
+        current_page_state.format
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Configuration]
+      def init_config
+        layout.config.activate(current_page.id) || List::Configuration.new
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    class List::Page < Basic::Interface
+      
+      # @param [ThinReports::Core::Page] parent
+      # @param [ThinReports::Core::Shape::Basic::Format] format
+      # @param [ThinReports::Core::Shape::List::PageState] internal (nil)
+      # @param [ThinReports::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
+      end
+      
+      # @param [Hash] values ({})
+      # @yield [header,]
+      # @yieldparam [ThinReports::Core::Shape::List::SectionInterface] header
+      # @return [ThinReports::Core::Shape::List::SectionInterface]
+      # @raise [ThinReports::Errors::DisabledListSection]
+      def header(values = {}, &block)
+        manager.header(values, &block)
+      end
+      
+      # @param [Hash] values ({})
+      # @yield [row,]
+      # @yieldparam [ThinReports::Core::Shape::List::SectionInterface] row
+      # @return [Boolean]
+      def add_row(values = {}, &block)
+        manager.insert_new_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_method :finalize, :page_break
+      
+      # @return [Boolean] If overfilling the list to insert a detail row
+      #   or already finalized, return the true. Otherwise false.
+      def overflow?
+        finalized? || manager.overflow_with?(:detail)
+      end
+      
+      # @return [Boolean] Return the true,
+      #   if the current page of list is already finalized.
+      def finalized?
+        internal.finalized?
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Configuration]
+      def config
+        manager.config
+      end
+            
+      # @return [ThinReports::Core::Shape::List::Store]
+      def store
+        config.store
+      end
+      
+      # @return [ThinReports::Core::Shape::List::Events]
+      def events
+        config.events
+      end
+      
+      # @param [ThinReports::Core::Page] new_parent
+      # @return [ThinReports::Core::Shape::List::Page]
+      # @private
+      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)
+          
+          new_list.internal.header = internal.header.copy(new_list)
+          internal.rows.each do |row|
+            new_list.internal.rows << row.copy(new_list)
+          end
+          new_list.finalized!
+        end
+        new_list
+      end
+      
+      # @private
+      def manager
+        @manager
+      end
+      
+    private
+      
+      # @see ThinReports::Core::Shape::Base::Interface#init_internal
+      def init_internal(parent, format)
+        List::PageState.new(parent, format)
+      end
+    end
+    
+    # Alias to List::Page.
+    # @see ThinReports::Core::Shape::List::Page
+    # @private
+    List::Interface = List::Page
+    
+  end
+end