AndyObtiva/glimmer-dsl-swt

View on GitHub
lib/glimmer/swt/custom/shape.rb

Summary

Maintainability
F
2 wks
Test Coverage

File shape.rb has 1245 lines of code (exceeds 250 allowed). Consider refactoring.
Open

require 'glimmer/swt/properties'
require 'glimmer/swt/swt_proxy'
require 'glimmer/swt/display_proxy'
require 'glimmer/swt/color_proxy'
require 'glimmer/swt/font_proxy'
Severity: Major
Found in lib/glimmer/swt/custom/shape.rb - About 3 days to fix

    Class Shape has 121 methods (exceeds 20 allowed). Consider refactoring.
    Open

          class Shape
            include Properties
            
            DropEvent = Struct.new(:doit, :x, :y, :dragged_shape, :dragged_shape_original_x, :dragged_shape_original_y, :dragging_x, :dragging_y, :drop_shapes, keyword_init: true)
            
    Severity: Major
    Found in lib/glimmer/swt/custom/shape.rb - About 2 days to fix

      Method apply_property_arg_conversions has a Cognitive Complexity of 60 (exceeds 5 allowed). Consider refactoring.
      Open

              def apply_property_arg_conversions(property, args)
                method_name = attribute_setter(property)
                args = args.dup
                the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
                return args if the_java_method.nil?
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method set_attribute has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.
      Open

              def set_attribute(attribute_name, *args)
                options = args.last if args.last.is_a?(Hash)
                args.pop if !options.nil? && !options[:redraw].nil?
                options ||= {}
                perform_redraw = @perform_redraw
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 7 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method handle_observation_request has a Cognitive Complexity of 39 (exceeds 5 allowed). Consider refactoring.
      Open

              def handle_observation_request(observation_request, source_observation_request: nil, &block)
                if observation_request.to_s == 'on_shape_disposed'
                  @on_shape_disposed_handlers ||= []
                  @on_shape_disposed_handlers << block
                  return ShapeListenerProxy.new(shape: self, drawable: drawable, shape_listener_block: block, observation_request: 'on_shape_disposed')
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 5 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method calculate_args! has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
      Open

              def calculate_args!
                return @args if parent.is_a?(Drawable) && !default_x? && !default_y? && !default_width? && !default_height? && !max_width? && !max_height?
                calculated_args_dependencies = [
                  x,
                  y,
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 4 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method paint_self has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
      Open

              def paint_self(paint_event)
                @painting = true
                unless container?
                  calculate_paint_args!
                  @original_gc_properties = {} # this stores GC properties before making calls to updates TODO avoid using in pixel graphics
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method calculate_paint_args! has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
      Open

              def calculate_paint_args!
                unless @calculated_paint_args
                  if @name == 'pixel'
                    @name = 'point'
                    # optimized performance calculation for pixel points
      Severity: Minor
      Found in lib/glimmer/swt/custom/shape.rb - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method calculate_args! has 77 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              def calculate_args!
                return @args if parent.is_a?(Drawable) && !default_x? && !default_y? && !default_width? && !default_height? && !max_width? && !max_height?
                calculated_args_dependencies = [
                  x,
                  y,
      Severity: Major
      Found in lib/glimmer/swt/custom/shape.rb - About 3 hrs to fix

        Method apply_property_arg_conversions has 77 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                def apply_property_arg_conversions(property, args)
                  method_name = attribute_setter(property)
                  args = args.dup
                  the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
                  return args if the_java_method.nil?
        Severity: Major
        Found in lib/glimmer/swt/custom/shape.rb - About 3 hrs to fix

          Method apply_shape_arg_conversions! has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
          Open

                  def apply_shape_arg_conversions!
                    if @args.size > 1 && (['polygon', 'polyline'].include?(@name))
                      @args[0] = @args.dup
                      @args[1..-1] = []
                    end
          Severity: Minor
          Found in lib/glimmer/swt/custom/shape.rb - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method handle_observation_request has 60 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  def handle_observation_request(observation_request, source_observation_request: nil, &block)
                    if observation_request.to_s == 'on_shape_disposed'
                      @on_shape_disposed_handlers ||= []
                      @on_shape_disposed_handlers << block
                      return ShapeListenerProxy.new(shape: self, drawable: drawable, shape_listener_block: block, observation_request: 'on_shape_disposed')
          Severity: Major
          Found in lib/glimmer/swt/custom/shape.rb - About 2 hrs to fix

            Method inspect has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
            Open

                    def inspect(recursive: 1, calculated: false, args: true, properties: true, calculated_args: false)
                      recurse = recursive == true || recursive.is_a?(Integer) && recursive.to_i > 0
                      recursive = [recursive -= 1, 0].max if recursive.is_a?(Integer)
                      args_string = " args=#{@args.inspect}" if args
                      properties_string = " properties=#{@properties.inspect}}" if properties
            Severity: Minor
            Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method set_attribute has 45 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    def set_attribute(attribute_name, *args)
                      options = args.last if args.last.is_a?(Hash)
                      args.pop if !options.nil? && !options[:redraw].nil?
                      options ||= {}
                      perform_redraw = @perform_redraw
            Severity: Minor
            Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

              Method ensure_extent has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

                      def ensure_extent(paint_event)
                        old_extent = @extent
                        old_extent_args = @extent_args
                        if ['text', 'string'].include?(@name)
                          extent_args = [string]
              Severity: Minor
              Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Method apply_shape_arg_defaults! has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

                      def apply_shape_arg_defaults!
                        if current_parameter_name?(:dest_x) && dest_x.nil?
                          self.dest_x = :default
                        elsif parameter_name?(:x) && x.nil?
                          self.x = :default
              Severity: Minor
              Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Method method_name has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
              Open

                        def method_name(keyword, method_arg_options)
                          keyword = keyword.to_s
                          method_arg_options = method_arg_options.select {|key, value| %w[fill gradient round].include?(key.to_s)}
                          unless flyweight_method_names.keys.include?([keyword, method_arg_options])
                            gradient = 'Gradient' if method_arg_options[:gradient]
              Severity: Minor
              Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Method paint_self has 29 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                      def paint_self(paint_event)
                        @painting = true
                        unless container?
                          calculate_paint_args!
                          @original_gc_properties = {} # this stores GC properties before making calls to updates TODO avoid using in pixel graphics
              Severity: Minor
              Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                Method drag_and_move= has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        def drag_and_move=(drag_and_move_value)
                          deregister_drag_listeners if @drag_source
                          drag_and_move_old_value = @drag_and_move
                          @drag_and_move = drag_and_move_value
                          if @drag_and_move && !drag_and_move_old_value
                Severity: Minor
                Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                  Method calculate_paint_args! has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                          def calculate_paint_args!
                            unless @calculated_paint_args
                              if @name == 'pixel'
                                @name = 'point'
                                # optimized performance calculation for pixel points
                  Severity: Minor
                  Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                    Method apply_shape_arg_conversions! has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            def apply_shape_arg_conversions!
                              if @args.size > 1 && (['polygon', 'polyline'].include?(@name))
                                @args[0] = @args.dup
                                @args[1..-1] = []
                              end
                    Severity: Minor
                    Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                      Method drag_source= has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                              def drag_source=(drag_source_value)
                                deregister_drag_listeners if @drag_and_move
                                drag_source_old_value = @drag_source
                                @drag_source = drag_source_value
                                if @drag_source && !drag_source_old_value
                      Severity: Minor
                      Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                        Consider simplifying this complex logical expression.
                        Open

                                  return @args if parent.is_a?(Drawable) && !default_x? && !default_y? && !default_width? && !default_height? && !max_width? && !max_height?
                        Severity: Major
                        Found in lib/glimmer/swt/custom/shape.rb - About 1 hr to fix

                          Method default_height has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                                  def default_height
                                    default_height_dependencies = [shapes.empty? && max_height, shapes.size == 1 && shapes.first.max_height? && parent.size.y, shapes.size >= 1 && !shapes.first.max_height? && shapes.map {|s| s.max_height? ? 0 : s.y_end}]
                                    if default_height_dependencies != @default_height_dependencies
                                      # Do not repeat calculations
                                      max_height, parent_size_y, y_ends = @default_height_dependencies = default_height_dependencies
                          Severity: Minor
                          Found in lib/glimmer/swt/custom/shape.rb - About 55 mins to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Method default_width has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                                  def default_width
                                    default_width_dependencies = [shapes.empty? && max_width, shapes.size == 1 && shapes.first.max_width? && parent.size.x, shapes.size >= 1 && !shapes.first.max_width? && shapes.map {|s| s.max_width? ? 0 : s.x_end}]
                                    if default_width_dependencies != @default_width_dependencies
                                      # Do not repeat calculations
                                      max_width, parent_size_x, x_ends = @default_width_dependencies = default_width_dependencies
                          Severity: Minor
                          Found in lib/glimmer/swt/custom/shape.rb - About 55 mins to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Method move_by has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                                  def move_by(x_delta, y_delta)
                                    if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
                                      if default_x?
                                        self.x_delta += x_delta
                                      else
                          Severity: Minor
                          Found in lib/glimmer/swt/custom/shape.rb - About 45 mins to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Method amend_method_name_options_based_on_properties! has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                                  def amend_method_name_options_based_on_properties!
                                    @original_method_name = @method_name
                                    return if @name == 'point'
                                    if (@name != 'text' && @name != 'string' && has_some_background? && !has_some_foreground?) || (@name == 'path' && has_some_background?)
                                      @options[:fill] = true
                          Severity: Minor
                          Found in lib/glimmer/swt/custom/shape.rb - About 45 mins to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Consider simplifying this complex logical expression.
                          Open

                                    if (@name != 'text' && @name != 'string' && has_some_background? && !has_some_foreground?) || (@name == 'path' && has_some_background?)
                                      @options[:fill] = true
                                    elsif !has_some_background? && has_some_foreground?
                                      @options[:fill] = false
                                    elsif @name == 'rectangle' && has_some_background? && has_some_foreground?
                          Severity: Major
                          Found in lib/glimmer/swt/custom/shape.rb - About 40 mins to fix

                            Method drag_and_move= has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def drag_and_move=(drag_and_move_value)
                                      deregister_drag_listeners if @drag_source
                                      drag_and_move_old_value = @drag_and_move
                                      @drag_and_move = drag_and_move_value
                                      if @drag_and_move && !drag_and_move_old_value
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 35 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method calculated_args_changed_for_defaults! has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def calculated_args_changed_for_defaults!
                                      has_default_dimensions = default_width? || default_height?
                                      parent_calculated_args_changed_for_defaults = has_default_dimensions
                                      calculated_args_changed!(children: false) if default_x? || default_y? || has_default_dimensions
                                      if has_default_dimensions && parent.is_a?(Shape)
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 35 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method clear_shapes has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def clear_shapes(dispose_images: true, dispose_patterns: true, redraw: :all)
                                      if redraw == true || redraw == :all
                                        shapes.dup.each {|shape| shape.dispose(dispose_images: dispose_images, dispose_patterns: dispose_patterns, redraw: false) }
                                        drawable.redraw if redraw && !drawable.is_a?(ImageProxy)
                                      elsif redraw == :each
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 35 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method drag_source= has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def drag_source=(drag_source_value)
                                      deregister_drag_listeners if @drag_and_move
                                      drag_source_old_value = @drag_source
                                      @drag_source = drag_source_value
                                      if @drag_source && !drag_source_old_value
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 35 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method expanded_shapes has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def expanded_shapes(except_shape: nil)
                                      if shapes.to_a.any?
                                        shapes.map do |shape|
                                          shape.equal?(except_shape) ? [] : ([shape] + shape.expanded_shapes(except_shape: except_shape))
                                        end.flatten
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method dispose has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def dispose(dispose_images: true, dispose_patterns: true, redraw: true)
                                      return if drawable.respond_to?(:shell_proxy) && drawable&.shell_proxy&.last_shell_closing?
                                      return if @disposed
                                      @disposed = true
                                      deregister_drag_listeners
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method calculated_height has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def calculated_height
                                      calculated_height_dependencies = [height, default_height? && (default_height + height_delta), max_height? && (max_height + height_delta)]
                                      if calculated_height_dependencies != @calculated_height_dependencies
                                        @calculated_height_dependencies = calculated_height_dependencies
                                        result_height = height
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method get_attribute has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def get_attribute(attribute_name)
                                      if parameter_name?(attribute_name)
                                        arg_index = parameter_index(attribute_name)
                                        @args[arg_index] if arg_index
                                      elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method paint has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def paint(paint_event)
                                      paint_children(paint_event) if default_width? || default_height?
                                      paint_self(paint_event)
                                      # re-paint children from scratch in the special case of pre-calculating parent width/height to re-center within new parent dimensions
                                      shapes.each(&:calculated_args_changed!) if default_width? || default_height?
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method respond_to? has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def respond_to?(method_name, *args, &block)
                                      options = args.last if args.last.is_a?(Hash)
                                      super_invocation = options && options[:super]
                                      if !super_invocation && has_attribute?(method_name)
                                        true
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method calculated_width has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def calculated_width
                                      calculated_width_dependencies = [width, default_width? && (default_width + width_delta), max_width? && (max_width + width_delta)]
                                      if calculated_width_dependencies != @calculated_width_dependencies
                                        @calculated_width_dependencies = calculated_width_dependencies
                                        result_width = width
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb - About 25 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def default_height
                                      default_height_dependencies = [shapes.empty? && max_height, shapes.size == 1 && shapes.first.max_height? && parent.size.y, shapes.size >= 1 && !shapes.first.max_height? && shapes.map {|s| s.max_height? ? 0 : s.y_end}]
                                      if default_height_dependencies != @default_height_dependencies
                                        # Do not repeat calculations
                                        max_height, parent_size_y, y_ends = @default_height_dependencies = default_height_dependencies
                            Severity: Major
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 1 hr to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1259..1272

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 72.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def default_width
                                      default_width_dependencies = [shapes.empty? && max_width, shapes.size == 1 && shapes.first.max_width? && parent.size.x, shapes.size >= 1 && !shapes.first.max_width? && shapes.map {|s| s.max_width? ? 0 : s.x_end}]
                                      if default_width_dependencies != @default_width_dependencies
                                        # Do not repeat calculations
                                        max_width, parent_size_x, x_ends = @default_width_dependencies = default_width_dependencies
                            Severity: Major
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 1 hr to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1275..1288

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 72.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def calculated_x
                                      calculated_x_dependencies = [default_x? && default_x, !default_x? && self.x, self.x_delta]
                                      if calculated_x_dependencies != @calculated_x_dependencies
                                        default_x, x, x_delta = @calculated_x_dependencies = calculated_x_dependencies
                                        result = default_x? ? default_x : x
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 45 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1390..1398

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 39.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def calculated_height
                                      calculated_height_dependencies = [height, default_height? && (default_height + height_delta), max_height? && (max_height + height_delta)]
                                      if calculated_height_dependencies != @calculated_height_dependencies
                                        @calculated_height_dependencies = calculated_height_dependencies
                                        result_height = height
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 45 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1311..1320

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 39.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def calculated_y
                                      calculated_y_dependencies = [default_y? && default_y, !default_y? && self.y, self.y_delta]
                                      if calculated_y_dependencies != @calculated_y_dependencies
                                        default_y, y, y_delta = @calculated_y_dependencies = calculated_y_dependencies
                                        result = default_y? ? default_y : y
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 45 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1379..1387

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 39.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def calculated_width
                                      calculated_width_dependencies = [width, default_width? && (default_width + width_delta), max_width? && (max_width + width_delta)]
                                      if calculated_width_dependencies != @calculated_width_dependencies
                                        @calculated_width_dependencies = calculated_width_dependencies
                                        result_width = width
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 45 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1323..1332

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 39.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def max_height
                                      max_height_dependencies = [parent.is_a?(Drawable) && parent.size.y, !parent.is_a?(Drawable) && parent.calculated_height]
                                      if max_height_dependencies != @max_height_dependencies
                                        # do not repeat calculations
                                        parent_size_y, parent_calculated_height = @max_height_dependencies = max_height_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1291..1298

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 38.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Identical blocks of code found in 2 locations. Consider refactoring.
                            Open

                                        @drawable_on_mouse_move ||= drawable.handle_observation_request('on_mouse_move') do |event|
                                          if Shape.dragging && Shape.dragged_shape.equal?(self)
                                            Shape.dragged_shape.move_by((event.x - Shape.dragging_x), (event.y - Shape.dragging_y))
                                            Shape.dragging_x = event.x
                                            Shape.dragging_y = event.y
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 781..788

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 38.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def max_width
                                      max_width_dependencies = [parent.is_a?(Drawable) && parent.size.x, !parent.is_a?(Drawable) && parent.calculated_width]
                                      if max_width_dependencies != @max_width_dependencies
                                        # do not repeat calculations
                                        parent_size_x, parent_calculated_width = @max_width_dependencies = max_width_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1301..1308

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 38.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Identical blocks of code found in 2 locations. Consider refactoring.
                            Open

                                        @drawable_on_mouse_move ||= drawable.handle_observation_request('on_mouse_move') do |event|
                                          if Shape.dragging && Shape.dragged_shape.equal?(self)
                                            Shape.dragged_shape.move_by((event.x - Shape.dragging_x), (event.y - Shape.dragging_y))
                                            Shape.dragging_x = event.x
                                            Shape.dragging_y = event.y
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 819..826

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 38.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def x_end
                                      x_end_dependencies = [calculated_width, default_x?, !default_x? && x]
                                      if x_end_dependencies != @x_end_dependencies
                                        # avoid recalculation of dependencies
                                        calculated_width, is_default_x, x = @x_end_dependencies = x_end_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1247..1256

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 37.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def y_end
                                      y_end_dependencies = [calculated_height, default_y?, !default_y? && y]
                                      if y_end_dependencies != @y_end_dependencies
                                        # avoid recalculation of dependencies
                                        calculated_height, is_default_y, y = @y_end_dependencies = y_end_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 40 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1234..1243

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 37.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def default_width?
                                      return false unless current_parameter_name?(:width)
                                      width = self.width
                                      (width.nil? || width == :default || width == 'default' || (width.is_a?(Array) && (width.first.to_s == :default || width.first.to_s == 'default')))
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 35 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1194..1197

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 36.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def default_height?
                                      return false unless current_parameter_name?(:height)
                                      height = self.height
                                      (height.nil? || height == :default || height == 'default' || (height.is_a?(Array) && (height.first.to_s == :default || height.first.to_s == 'default')))
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 35 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1188..1191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 36.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def absolute_y
                                      absolute_y_dependencies = [calculated_y, parent.is_a?(Shape) && parent.absolute_y]
                                      if absolute_y_dependencies != @absolute_y_dependencies
                                        calculated_y, parent_absolute_y = @absolute_y_dependencies = absolute_y_dependencies
                                        y = calculated_y
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 35 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1401..1413

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 35.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def absolute_x
                                      absolute_x_dependencies = [calculated_x, parent.is_a?(Shape) && parent.absolute_x]
                                      if absolute_x_dependencies != @absolute_x_dependencies
                                        # do not repeat calculations
                                        calculated_x, parent_absolute_x = @absolute_x_dependencies = absolute_x_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 35 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1416..1427

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 35.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Identical blocks of code found in 2 locations. Consider refactoring.
                            Open

                                        @on_drag_detected ||= handle_observation_request('on_drag_detected') do |event|
                                          Shape.dragging = true
                                          Shape.dragging_x = event.x
                                          Shape.dragging_y = event.y
                                          Shape.drop_shape_handling_count = 0
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 25 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 810..819

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 31.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Identical blocks of code found in 2 locations. Consider refactoring.
                            Open

                                        @on_drag_detected ||= handle_observation_request('on_drag_detected') do |event|
                                          Shape.dragging = true
                                          Shape.dragging_x = event.x
                                          Shape.dragging_y = event.y
                                          Shape.drop_shape_handling_count = 0
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 25 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 772..781

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 31.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 4 locations. Consider refactoring.
                            Open

                                    def max_width?
                                      return false unless current_parameter_name?(:width)
                                      width = self.width
                                      (width.nil? || width.to_s == 'max' || (width.is_a?(Array) && width.first.to_s == 'max'))
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 3 other locations - About 20 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1176..1180
                            lib/glimmer/swt/custom/shape.rb on lines 1182..1186
                            lib/glimmer/swt/custom/shape.rb on lines 1206..1209

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 27.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 4 locations. Consider refactoring.
                            Open

                                    def max_height?
                                      return false unless current_parameter_name?(:height)
                                      height = self.height
                                      (height.nil? || height.to_s == 'max' || (height.is_a?(Array) && height.first.to_s == 'max'))
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 3 other locations - About 20 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1176..1180
                            lib/glimmer/swt/custom/shape.rb on lines 1182..1186
                            lib/glimmer/swt/custom/shape.rb on lines 1200..1203

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 27.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 4 locations. Consider refactoring.
                            Open

                                    def default_y?
                                      return false unless current_parameter_name?(:y)
                                      y = self.y
                                      y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default')
                                    end
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 3 other locations - About 20 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1176..1180
                            lib/glimmer/swt/custom/shape.rb on lines 1200..1203
                            lib/glimmer/swt/custom/shape.rb on lines 1206..1209

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 27.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 4 locations. Consider refactoring.
                            Open

                                    def default_x?
                                      return false unless current_parameter_name?(:x)
                                      x = self.x
                                      x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default')
                                    end
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 3 other locations - About 20 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1182..1186
                            lib/glimmer/swt/custom/shape.rb on lines 1200..1203
                            lib/glimmer/swt/custom/shape.rb on lines 1206..1209

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 27.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def center_x
                                      center_x_dependencies = [x_end, calculated_width]
                                      if center_x_dependencies != @center_x_dependencies
                                        @center_x_dependencies = center_x_dependencies
                                        the_x_end, the_calculated_width = center_x_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 333..340

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 26.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                      default_x_dependencies = [parent.size.x, size.x, parent.is_a?(Shape) && parent.irregular? && parent.bounds.x, parent.is_a?(Shape) && parent.irregular? && parent.absolute_x]
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1224..1224

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 26.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def center_y
                                      center_y_dependencies = [y_end, calculated_height]
                                      if center_y_dependencies != @center_y_dependencies
                                        @center_y_dependencies = center_y_dependencies
                                        the_y_end, the_calculated_height = center_y_dependencies
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 323..330

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 26.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                      default_y_dependencies = [parent.size.y, size.y, parent.is_a?(Shape) && parent.irregular? && parent.bounds.y, parent.is_a?(Shape) && parent.irregular? && parent.absolute_y]
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 1213..1213

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 26.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def parent_shape_composites
                                      if @parent_shape_composites.nil?
                                        if parent.is_a?(Drawable)
                                          @parent_shape_composites = []
                                        elsif !parent.container?
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 933..943

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 25.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            Similar blocks of code found in 2 locations. Consider refactoring.
                            Open

                                    def parent_shape_containers
                                      if @parent_shape_containers.nil?
                                        if parent.is_a?(Drawable)
                                          @parent_shape_containers = []
                                        elsif !parent.container?
                            Severity: Minor
                            Found in lib/glimmer/swt/custom/shape.rb and 1 other location - About 15 mins to fix
                            lib/glimmer/swt/custom/shape.rb on lines 947..957

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 25.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            There are no issues that match your filters.

                            Category
                            Status