thinreports 0.6.0.pre3

data/lib/thinreports/core/format/builder.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+require 'json'
+
+module ThinReports
+  module Core::Format
+    
+    # @private
+    module Builder
+      def build(*args)
+        build_internal(*args)
+      rescue ThinReports::Errors::Basic => e
+        raise e
+      rescue => e
+        raise ThinReports::Errors::InvalidLayoutFormat
+      end
+      
+    private
+      
+      # @abstract
+      def build_internal(*args)
+        raise NotImplementedError
+      end
+
+      # @param [ThinReports::Core::Format::Base] format
+      # @param [Hash] options
+      def build_layout(format, options = {}, &block)
+        level = '-' * ((options[:level] || 1 ) - 1)
+
+        format.layout.gsub!(/<!--#{level}SHAPE(.*?)SHAPE#{level}-->/) do
+          shape_format = block.call(*parsed_format_and_shape_type($1))
+          
+          format.shapes[shape_format.id.to_sym] = shape_format
+          shape_tag(shape_format)
+        end
+      end
+      
+      # @param [String] svg
+      def clean(svg)
+        svg.gsub!(/<!--.*?-->/, '')
+      end
+      
+      # @param [String] svg
+      def clean_with_attributes(svg)
+        clean(svg)
+        svg.gsub!(/ x\-[a-z\d\-]+?=".*?"/, '')
+        svg.gsub!(/ class=".*?"/, '')        
+      end
+      
+      def shape_tag(format)
+        %{<%= r(:"#{format.id}")%>}
+      end
+      
+      def parsed_format_and_shape_type(json_string)
+        f = parse_json(json_string)
+        [ f['type'], f ]
+      end
+
+      def parse_json(json_string)
+        JSON.parse(json_string)
+      end
+    end
+    
+  end
+end

data/lib/thinreports/core/ordered_hash.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+module ThinReports
+  module Core
+    
+    ruby_18 do
+      # @private
+      class OrderedHash < ::Hash
+        def initialize
+          @keys = []
+          super
+        end
+        
+        def []=(key, value)
+          @keys << key unless member?(key)
+          super
+        end
+        
+        def each
+          @keys.each {|key| yield(key, self[key])}
+        end
+        
+        def each_key
+          @keys.each {|key| yield(key)}
+        end
+        
+        def keys
+          @keys
+        end
+      end
+    end
+    
+    ruby_19 do
+      # @private
+      OrderedHash = ::Hash
+    end
+    
+  end
+end

data/lib/thinreports/core/page.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+module ThinReports
+  module Core
+    
+    class BlankPage
+      # @return [Integer]
+			attr_accessor :no
+			
+      # @param [Boolean] count (nil)
+      def initialize(count = nil)
+        @count = count.nil? ? true : count
+      end
+      
+      # @return [Boolean]
+      def count?
+        @count
+      end
+      
+      # @return [Boolean] (true)
+      def blank?
+        true
+      end
+    end
+    
+    class Page < BlankPage
+      include Core::Shape::Manager::Target
+      
+      # @return [ThinReports::Report::Base]
+      # @private
+      attr_reader :report
+      
+      # @return [ThinReports::Layout::Base]
+      attr_reader :layout
+      
+      # @param [ThinReports::Report::Base] report
+      # @param [ThinReports::Layout::Base] layout
+      def initialize(report, layout)
+        super(true)
+        
+        @report    = report
+        @layout    = layout
+        @finalized = false
+        
+        initialize_manager(layout.format) do |f|
+          Core::Shape::Interface(self, f)
+        end
+      end
+      
+      # @return [Boolean] (false)
+      def blank?
+        false
+      end
+      
+      # @private
+      def copy
+        new_page = self.class.new(report, layout)
+        
+        manager.shapes.each do |id, shape|
+          new_shape = shape.copy(new_page)
+          new_page.manager.shapes[id] = new_shape
+          
+          if new_shape.internal.type_of?(:list)
+						new_page.manager.lists[id] = new_shape
+          end
+        end
+        new_page
+      end
+      
+      # @param [Hash] options
+      # @option options [:create, :copy] :at (:create)
+      # @private
+      def finalize(options = {})
+				at = options[:at] || :create
+				
+        # For list shapes.
+        if at == :create
+					manager.lists.values.each {|list| list.manager.finalize }
+        end
+        
+        @finalized = true
+      end
+      
+      # @private
+      def finalized?
+        @finalized
+      end
+    end
+    
+  end
+end

data/lib/thinreports/core/shape.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+module ThinReports
+  module Core
+    
+    module Shape
+      # @private
+      def Interface(parent, format)
+        find_by_type(format.type)::Interface.new(parent, format)
+      end
+      
+      # @private
+      def Format(type)
+        find_by_type(type)::Format
+      end
+      
+      # @private
+      def Configuration(type)
+        klass = find_by_type(type)
+        unless klass.const_defined?(:Configuration)
+          raise ThinReports::Errors::NoConfigurationFound, type
+        end
+        klass.const_get(:Configuration)
+      end
+      
+      module_function :Interface, :Format, :Configuration
+      
+      # @private
+      def self.find_by_type(type)
+        case type
+        when Tblock::TYPE_NAME
+          Tblock
+        when List::TYPE_NAME
+          List
+        when Text::TYPE_NAME
+          Text
+        when *Basic::TYPE_NAMES
+          Basic
+        else
+          raise ThinReports::Errors::UnknownShapeType
+        end
+      end
+    end
+  
+  end
+end
+
+require 'thinreports/core/shape/manager'
+require 'thinreports/core/shape/base'
+require 'thinreports/core/shape/basic'
+require 'thinreports/core/shape/text'
+require 'thinreports/core/shape/tblock'
+require 'thinreports/core/shape/list'

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

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    module Base
+    end
+    
+  end
+end
+
+require 'thinreports/core/shape/base/internal'
+require 'thinreports/core/shape/base/interface'

data/lib/thinreports/core/shape/base/interface.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    # @abstract
+    class Base::Interface
+      extend ::Forwardable
+      
+      def self.internal_delegators(*args)
+        def_delegators :internal, *args
+      end
+      private_class_method :internal_delegators
+      
+      attr_reader :internal
+      
+      def initialize(parent, format, internal = nil)
+        @internal = internal || init_internal(parent, format)
+      end
+      
+      def copy(parent)
+        self.class.new(parent, internal.format, internal.copy(parent))
+      end
+      
+    private
+    
+      # @param [ThinReports::Core::Page, ThinReports::Core::Shape::List::SectionInterface] parent
+      # @param [ThinReports::Core::Shape::Basic::Format] format
+      # @return [ThinReports::Core::Shape::Basic::Internal]
+      # @abstract
+      def init_internal(parent, format)
+        raise NotImplementedError
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    # @abstract
+    class Base::Internal
+      extend ::Forwardable
+      
+      def self.format_delegators(*args)
+        def_delegators :format, *args
+      end
+      private_class_method :format_delegators
+      
+      AVAILABLE_STYLES = [:fill, :stroke]
+      
+      attr_reader :parent
+      attr_reader :format
+      attr_accessor :attrs, :states
+      
+      def initialize(parent, format)
+        @parent = parent
+        @format = format
+        
+        @states = {}
+        @attrs  = {}
+        
+        @finalized_attributes = nil
+      end
+      
+      def attributes
+        @finalized_attributes ||= (format.svg_attrs || {}).merge(attrs)
+      end
+      
+      def copy(new_parent, &block)
+        new_internal = self.class.new(new_parent, format)
+        new_internal.attrs  = attrs.simple_deep_copy
+        new_internal.states = states.simple_deep_copy
+        
+        block.call(new_internal) if block_given?
+        new_internal
+      end
+      
+      def switch_parent!(new_parent)
+        @parent = new_parent
+        self
+      end
+      
+      def available_style?(style_name)
+        AVAILABLE_STYLES.include?(style_name)
+      end
+      
+      def type_of?(type_name)
+        raise NotImplementedError
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    module Basic
+      TYPE_NAMES = %w( s-line s-rect s-ellipse s-image )
+    end
+    
+  end
+end
+
+require 'thinreports/core/shape/basic/format'
+require 'thinreports/core/shape/basic/internal'
+require 'thinreports/core/shape/basic/interface'

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

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    # @private
+    class Basic::Format < Core::Format::Base
+      config_reader :type, :id
+      config_reader :svg_tag     => %w( svg tag ),
+                    :svg_attrs   => %w( svg attrs )
+                    
+      config_checker 'true', :display
+      
+      class << self
+      private
+        
+        # @param [Hash] raw_format
+        # @return [ThinReports::Core::Shape::Basic::Format]
+        def build_internal(raw_format)
+          new(raw_format)
+        end
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+module ThinReports
+  module Core::Shape
+    
+    class Basic::Interface < Base::Interface
+      internal_delegators :visible?, :id, :type
+      
+      # @param [Boolean] visibility
+      # @return [self]
+      def visible(visibility)
+        internal.visible(visibility)
+        self
+      end
+      
+      # @param [Symbol] style_name
+      # @param [String] value
+      # @return [self]
+      def style(style_name, value)
+        unless internal.available_style?(style_name)
+          raise ThinReports::Errors::UnknownShapeStyleName
+        end
+        internal.svg_attr(style_name, value)
+        self
+      end
+      
+      # @param [Hash] settings
+      # @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::Core::Shape::Base::Interface#init_internal
+      def init_internal(parent, format)
+        Basic::Internal.new(parent, format)
+      end
+    end
+    
+  end
+end