Sign upLogin

AndyObtiva/glimmer-dsl-tk

View on GitHub
Star

Showing 65 of 117 total issues

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

      def set_attribute(attribute, *args)
        begin
          args = normalize_attribute_arguments(attribute, args)
          widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
          if respond_to?(attribute_setter(attribute), super_only: true)
Severity: Minor
Found in lib/glimmer/tk/widget_proxy.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 set_attribute has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
Open

      def set_attribute(attribute, *args)
        case attribute.to_s
        when 'yscrollbar'
          @yscrollbar = args.first
          if @yscrollbar == true
Severity: Minor
Found in lib/glimmer/tk/scrollbar_frame_proxy.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 make_draggable has 55 lines of code (exceeds 25 allowed). Consider refactoring.
Open

      def make_draggable
        drag_event = nil
        bind("<DropAcceptedEvent>", proc { |event| drag_event.drop_accepted = true })
        bind("B1-Motion", proc { |tk_event|
          if drag_event.nil?
Severity: Major
Found in lib/glimmer/tk/draggable_and_droppable.rb - About 2 hrs to fix

    Method launch has 53 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      def launch
    root {
      title 'Hello, Entry!'
      minsize 230, 0
    Severity: Major
    Found in samples/hello/hello_entry.rb - About 2 hrs to fix

      Method build_widget has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
      Open

            def build_widget
        @args.prepend(:command) if @args.first.is_a?(Hash)
        @args.append({}) if !@args.last.is_a?(Hash)
        @args.last.merge!(variable: variable, value: label) if radiobutton? || checkbutton?
        case @parent_proxy
      Severity: Minor
      Found in lib/glimmer/tk/menu_item_proxy.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 remove_font_format has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
      Open

            def remove_font_format(region_start, region_end, font_option, value)
        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
          if tag
            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
      Severity: Minor
      Found in lib/glimmer/tk/text_proxy.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 add_font_format has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
      Open

            def add_font_format(region_start, region_end, font_option, value)
        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
          if tag
            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
      Severity: Minor
      Found in lib/glimmer/tk/text_proxy.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 launch has 49 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        def launch
    root {
      title 'Hello, Computed!'
      
      frame {
      Severity: Minor
      Found in samples/hello/hello_computed.rb - About 1 hr to fix

        Method launch has 48 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def launch
    root {
      title 'Hello, Button!'
      
      frame {
        Severity: Minor
        Found in samples/hello/hello_button.rb - About 1 hr to fix

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

            def launch
    root {
      title 'Hello, Radio!'
      
      label {
          Severity: Minor
          Found in samples/hello/hello_radiobutton.rb - About 1 hr to fix

            Method configure_menu_item_attribute has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
            Open

                  def configure_menu_item_attribute(attribute_value_hash)
        if preferences? && attribute_value_hash[:command]
          ::Tk.ip_eval("proc ::tk::mac::ShowPreferences {} {#{::Tk.install_cmd(attribute_value_hash[:command])}}") if OS.mac?
        elsif help? && attribute_value_hash[:command]
          ::Tk.ip_eval("proc ::tk::mac::ShowHelp {} {#{::Tk.install_cmd(attribute_value_hash[:command])}}") if OS.mac?
            Severity: Minor
            Found in lib/glimmer/tk/menu_item_proxy.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 handle_listener has 40 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                  def handle_listener(listener_name, &listener)
        case listener_name.to_s.downcase
        when '<<modified>>', '<modified>', 'modified'
          modified_listener = Proc.new do |*args|
            @modified_count ||= 0
            Severity: Minor
            Found in lib/glimmer/tk/text_proxy.rb - About 1 hr to fix

              Method add_font_format has 40 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                    def add_font_format(region_start, region_end, font_option, value)
        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
          if tag
            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
              Severity: Minor
              Found in lib/glimmer/tk/text_proxy.rb - About 1 hr to fix

                Method remove_font_format has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                      def remove_font_format(region_start, region_end, font_option, value)
        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
          if tag
            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
                Severity: Minor
                Found in lib/glimmer/tk/text_proxy.rb - About 1 hr to fix

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

                      def initialize
      reset_activities!
      individual_observer = Glimmer::DataBinding::Observer.proc do
        unless @updating_group
          @updating_individual = true
                  Severity: Minor
                  Found in samples/hello/hello_checkbutton.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 build_widget has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                        def build_widget
        if application?
          if OS.mac?
            @tk = ::TkSysMenu_Apple.new(@parent_proxy.tk).tap {|tk| tk.singleton_class.include(Glimmer::Tk::Widget); tk.proxy = self}
            @parent_proxy.tk.add :cascade, :menu => @tk
                  Severity: Minor
                  Found in lib/glimmer/tk/menu_proxy.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 interpret has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def interpret(parent, keyword, *args, &block)
          if args.first.is_a?(Hash)
            options = args.first.symbolize_keys
            options[:initialcolor] = options.delete(:initial_color) if options.keys.include?(:initial_color)
            options[:filetypes] = options.delete(:file_types) if options.keys.include?(:file_types)
                  Severity: Minor
                  Found in lib/glimmer/dsl/tk/built_in_dialog_expression.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 launch has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    def launch
    root {
      title 'Hello, Checkbutton!'
      
      label {
                  Severity: Minor
                  Found in samples/hello/hello_checkbutton.rb - About 1 hr to fix

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

                          def set_attribute(attribute, *args)
        begin
          args = normalize_attribute_arguments(attribute, args)
          widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
          if respond_to?(attribute_setter(attribute), super_only: true)
                    Severity: Minor
                    Found in lib/glimmer/tk/widget_proxy.rb - About 1 hr to fix

                      Method show_find_dialog has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        def show_find_dialog
    toplevel(@root) { |tl|
      title 'Find'
      
      label {
                      Severity: Minor
                      Found in samples/hello/hello_text.rb - About 1 hr to fix
                        Severity
                        Category
                        Status
                        Source
                        Language