thinreports 0.9.1 → 0.10.0

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

@@ -1,88 +1,89 @@
-# coding: utf-8
-module Thinreports::Core
-  module Format
+# frozen_string_literal: true
 
-    # @abstract
-    class Base
-      class << self
-        def config_reader(*configs, &block)
-          each_configs(*configs) do |m, location|
-            define_read_method(m, location, &block)
+module Thinreports
+  module Core
+    module Format
+      # @abstract
+      class Base
+        class << self
+          def config_reader(*configs, &block)
+            each_configs(*configs) do |m, location|
+              define_read_method(m, location, &block)
+            end
           end
-        end
 
-        def config_checker(check, *configs)
-          checker = lambda {|val| val == check}
-          each_configs(*configs) do |m, location|
-            define_read_method(:"#{m}?", location, &checker)
+          def config_checker(check, *configs)
+            checker = ->(val) { val == check }
+            each_configs(*configs) do |m, location|
+              define_read_method(:"#{m}?", location, &checker)
+            end
           end
-        end
 
-        def config_writer(*configs)
-          each_configs(*configs) do |m, location|
-            define_write_method(m, location)
+          def config_writer(*configs)
+            each_configs(*configs) do |m, location|
+              define_write_method(m, location)
+            end
           end
-        end
 
-        def config_accessor(*configs, &block)
-          config_reader(*configs, &block)
-          config_writer(*configs)
-        end
+          def config_accessor(*configs, &block)
+            config_reader(*configs, &block)
+            config_writer(*configs)
+          end
 
-        private
+          private
 
-        def define_read_method(m, location = nil, &block)
-          define_method(m) do
-            read(*location, &block)
+          def define_read_method(m, location = nil, &block)
+            define_method(m) do
+              read(*location, &block)
+            end
           end
-        end
 
-        def define_write_method(m, location = nil)
-          define_method(:"#{m}=") do |value|
-            write(value, *location)
+          def define_write_method(m, location = nil)
+            define_method(:"#{m}=") do |value|
+              write(value, *location)
+            end
           end
-        end
 
-        def each_configs(*configs, &block)
-          c = configs.first.is_a?(::Hash) ? configs.first : (configs || [])
-          c.each do |m, location|
-            block.call(m, location || [m.to_s])
+          def each_configs(*configs, &block)
+            c = configs.first.is_a?(::Hash) ? configs.first : (configs || [])
+            c.each do |m, location|
+              block.call(m, location || [m.to_s])
+            end
           end
         end
-      end
 
-      def initialize(config, &block)
-        @config = config
-        block.call(self) if ::Kernel.block_given?
-      end
+        def initialize(config, &block)
+          @config = config
+          block.call(self) if ::Kernel.block_given?
+        end
 
-      def attributes
-        @config
-      end
+        def attributes
+          @config
+        end
 
-      private
+        private
 
-      def find(*keys)
-        if keys.empty?
-          @config
-        else
-          keys.inject(@config) do |c, k|
-            c.is_a?(::Hash) ? c[k] : (break c)
+        def find(*keys)
+          if keys.empty?
+            @config
+          else
+            keys.inject(@config) do |c, k|
+              c.is_a?(::Hash) ? c[k] : (break c)
+            end
           end
         end
-      end
 
-      def write(value, *keys)
-        key = keys.pop
-        owner = find(*keys)
-        owner[key] = value
-      end
+        def write(value, *keys)
+          key = keys.pop
+          owner = find(*keys)
+          owner[key] = value
+        end
 
-      def read(*keys, &block)
-        value = find(*keys)
-        ::Kernel.block_given? ? block.call(value) : value
+        def read(*keys, &block)
+          value = find(*keys)
+          ::Kernel.block_given? ? block.call(value) : value
+        end
       end
     end
-
   end
 end

data/lib/thinreports/core/shape.rb

@@ -1,19 +1,19 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
   module Core
-
     module Shape
-      def Interface(parent, format)
+      def Interface(parent, format) # rubocop:disable Style/MethodName
         find_by_type(format.type)::Interface.new(parent, format)
       end
 
-      def Format(type)
+      def Format(type) # rubocop:disable Style/MethodName
         find_by_type(type)::Format
       end
 
       module_function :Interface, :Format
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def self.find_by_type(type)
         case type
         when TextBlock::TYPE_NAME  then TextBlock
@@ -27,16 +27,15 @@ module Thinreports
         end
       end
     end
-
   end
 end
 
-require 'thinreports/core/shape/style'
-require 'thinreports/core/shape/manager'
-require 'thinreports/core/shape/base'
-require 'thinreports/core/shape/basic'
-require 'thinreports/core/shape/text'
-require 'thinreports/core/shape/text_block'
-require 'thinreports/core/shape/image_block'
-require 'thinreports/core/shape/list'
-require 'thinreports/core/shape/page_number'
+require_relative 'shape/style'
+require_relative 'shape/manager'
+require_relative 'shape/base'
+require_relative 'shape/basic'
+require_relative 'shape/text'
+require_relative 'shape/text_block'
+require_relative 'shape/image_block'
+require_relative 'shape/list'
+require_relative 'shape/page_number'

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

@@ -1,15 +1,6 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 require 'forwardable'
 
-module Thinreports
-  module Core::Shape
-
-    module Base
-    end
-
-  end
-end
-
-require 'thinreports/core/shape/base/internal'
-require 'thinreports/core/shape/base/interface'
+require_relative 'base/internal'
+require_relative 'base/interface'

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

@@ -1,38 +1,41 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
-  module Core::Shape
-
-    # @abstract
-    class Base::Interface
-      include Utils
-      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::Report::Page, Thinreports::Core::Shape::List::SectionInterface] parent
-      # @param [Thinreports::Core::Shape::Basic::Format] format
-      # @return [Thinreports::Core::Shape::Basic::Internal]
-      # @abstract
-      def init_internal
-        raise NotImplementedError
+  module Core
+    module Shape
+      module Base
+        # @abstract
+        class Interface
+          include Utils
+          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::Report::Page, Thinreports::Core::Shape::List::SectionInterface] parent
+          # @param [Thinreports::Core::Shape::Basic::Format] format
+          # @return [Thinreports::Core::Shape::Basic::Internal]
+          # @abstract
+          # rubocop:disable Lint/UnusedMethodArgument
+          def init_internal(parent, format)
+            raise NotImplementedError
+          end
+        end
       end
     end
-
   end
 end

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

@@ -1,49 +1,51 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
-  module Core::Shape
-
-    # @abstract
-    class Base::Internal
-      include Utils
-      extend  Forwardable
-
-      def self.format_delegators(*args)
-        def_delegators :format, *args
-      end
-      private_class_method :format_delegators
-
-      attr_reader :parent
-      attr_reader :format
-      attr_writer :style
-      attr_accessor :states
-
-      def initialize(parent, format)
-        @parent = parent
-        @format = format
-        @states = {}
-        @style  = nil
-
-        @finalized_attributes = nil
-      end
-
-      def style
-        raise NotImplementedError
-      end
-
-      def copy(new_parent, &block)
-        new_internal = self.class.new(new_parent, format)
-        new_internal.style  = style.copy
-        new_internal.states = deep_copy(states)
-
-        block.call(new_internal) if block_given?
-        new_internal
-      end
-
-      def type_of?
-        raise NotImplementedError
+  module Core
+    module Shape
+      module Base
+        # @abstract
+        class Internal
+          include Utils
+          extend  Forwardable
+
+          def self.format_delegators(*args)
+            def_delegators :format, *args
+          end
+          private_class_method :format_delegators
+
+          attr_reader :parent
+          attr_reader :format
+          attr_writer :style
+          attr_accessor :states
+
+          def initialize(parent, format)
+            @parent = parent
+            @format = format
+            @states = {}
+            @style = nil
+
+            @finalized_attributes = nil
+          end
+
+          def style
+            raise NotImplementedError
+          end
+
+          def copy(new_parent, &block)
+            new_internal = self.class.new(new_parent, format)
+            new_internal.style = style.copy
+            new_internal.states = deep_copy(states)
+
+            block.call(new_internal) if block_given?
+            new_internal
+          end
+
+          def type_of?
+            raise NotImplementedError
+          end
+        end
       end
     end
-
   end
 end

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

@@ -1,18 +1,18 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
-  module Core::Shape
-
-    module Basic
-      TYPE_NAMES = %w( line rect ellipse image )
+  module Core
+    module Shape
+      module Basic
+        TYPE_NAMES = %w[line rect ellipse image].freeze
+      end
     end
-
   end
 end
 
-require 'thinreports/core/shape/basic/format'
-require 'thinreports/core/shape/basic/internal'
-require 'thinreports/core/shape/basic/interface'
-require 'thinreports/core/shape/basic/block_format'
-require 'thinreports/core/shape/basic/block_internal'
-require 'thinreports/core/shape/basic/block_interface'
+require_relative 'basic/format'
+require_relative 'basic/internal'
+require_relative 'basic/interface'
+require_relative 'basic/block_format'
+require_relative 'basic/block_internal'
+require_relative 'basic/block_interface'

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

@@ -1,11 +1,13 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
-  module Core::Shape
-
-    class Basic::BlockFormat < Basic::Format
-      config_reader :value
+  module Core
+    module Shape
+      module Basic
+        class BlockFormat < Basic::Format
+          config_reader :value
+        end
+      end
     end
-
   end
 end

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

@@ -1,30 +1,32 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
-  module Core::Shape
+  module Core
+    module Shape
+      module Basic
+        class BlockInterface < Basic::Interface
+          # @overload value(val)
+          #   Set a val
+          #   @param [Object] val
+          #   @return [self]
+          # @overload value
+          #   Return the value
+          #   @return [Object]
+          def value(*args)
+            if args.empty?
+              internal.read_value
+            else
+              internal.write_value(args.first)
+              self
+            end
+          end
 
-    class Basic::BlockInterface < Basic::Interface
-      # @overload value(val)
-      #   Set a val
-      #   @param [Object] val
-      #   @return [self]
-      # @overload value
-      #   Return the value
-      #   @return [Object]
-      def value(*args)
-        if args.empty?
-          internal.read_value
-        else
-          internal.write_value(args.first)
-          self
+          # @param [Object] val
+          def value=(val)
+            value(val)
+          end
         end
       end
-
-      # @param [Object] val
-      def value=(val)
-        value(val)
-      end
     end
-
   end
 end