revolter/fastlane-plugin-icon_versioning

View on GitHub

Showing 42 of 44 total issues

Complex method Fastlane::Helper::VersionIconHelper#version_icon (97.2)
Open

      def version_icon(original_icon_path, versioned_icon_path)
        image = MiniMagick::Image.open(original_icon_path)

        image_width = image[:width]
        image_height = image[:height]

Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

You can read more about ABC metrics or the flog tool

Complex method Fastlane::Actions::VersionIconAction::available_options (74.4)
Open

Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

You can read more about ABC metrics or the flog tool

Method available_options has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
Open

Severity: Minor
Found in lib/fastlane/plugin/icon_versioning/actions/version_icon_action.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 available_options has 91 lines of code (exceeds 25 allowed). Consider refactoring.
Open

Severity: Major
Found in lib/fastlane/plugin/icon_versioning/actions/version_icon_action.rb - About 3 hrs to fix

    Complex method Fastlane::Helper::VersionIconHelper#run (54.2)
    Open

          def run()
            versioned_appiconset_path = self.class.get_versioned_path(@appiconset_path, @versioned_appiconset_suffix)
    
            Dir.mkdir(versioned_appiconset_path) unless Dir.exist?(versioned_appiconset_path)
    
    

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    Method version_icon has 62 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

          def version_icon(original_icon_path, versioned_icon_path)
            image = MiniMagick::Image.open(original_icon_path)
    
            image_width = image[:width]
            image_height = image[:height]
    Severity: Major
    Found in lib/fastlane/plugin/icon_versioning/helper/version_icon_helper.rb - About 2 hrs to fix

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

            def run()
              versioned_appiconset_path = self.class.get_versioned_path(@appiconset_path, @versioned_appiconset_suffix)
      
              Dir.mkdir(versioned_appiconset_path) unless Dir.exist?(versioned_appiconset_path)
      
      
      Severity: Minor
      Found in lib/fastlane/plugin/icon_versioning/helper/version_icon_helper.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 run has 30 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

            def run()
              versioned_appiconset_path = self.class.get_versioned_path(@appiconset_path, @versioned_appiconset_suffix)
      
              Dir.mkdir(versioned_appiconset_path) unless Dir.exist?(versioned_appiconset_path)
      
      
      Severity: Minor
      Found in lib/fastlane/plugin/icon_versioning/helper/version_icon_helper.rb - About 1 hr to fix

        Complex method Fastlane::Helper::VersionIconHelper#initialize (30.2)
        Open

              def initialize(params)
                @appiconset_path = File.expand_path(params[:appiconset_path])
                @versioned_appiconset_suffix = params[:versioned_appiconset_suffix]
                @text = params[:text]
                @text_color = params[:text_color]

        Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

        You can read more about ABC metrics or the flog tool

        Fastlane::Helper::VersionIconHelper#version_icon has approx 56 statements
        Open

              def version_icon(original_icon_path, versioned_icon_path)

        A method with Too Many Statements is any method that has a large number of lines.

        Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

        So the following method would score +6 in Reek's statement-counting algorithm:

        def parse(arg, argv, &error)
          if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
            return nil, block, nil                                         # +1
          end
          opt = (val = parse_arg(val, &error))[1]                          # +2
          val = conv_arg(*val)                                             # +3
          if opt and !arg
            argv.shift                                                     # +4
          else
            val[0] = nil                                                   # +5
          end
          val                                                              # +6
        end

        (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

        Fastlane::Helper::VersionIconHelper has at least 12 instance variables
        Open

            class VersionIconHelper

        Too Many Instance Variables is a special case of LargeClass.

        Example

        Given this configuration

        TooManyInstanceVariables:
          max_instance_variables: 3

        and this code:

        class TooManyInstanceVariables
          def initialize
            @arg_1 = :dummy
            @arg_2 = :dummy
            @arg_3 = :dummy
            @arg_4 = :dummy
          end
        end

        Reek would emit the following warning:

        test.rb -- 5 warnings:
          [1]:TooManyInstanceVariables has at least 4 instance variables (TooManyInstanceVariables)

        Fastlane::Helper::VersionIconHelper#run has approx 20 statements
        Open

              def run()

        A method with Too Many Statements is any method that has a large number of lines.

        Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

        So the following method would score +6 in Reek's statement-counting algorithm:

        def parse(arg, argv, &error)
          if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
            return nil, block, nil                                         # +1
          end
          opt = (val = parse_arg(val, &error))[1]                          # +2
          val = conv_arg(*val)                                             # +3
          if opt and !arg
            argv.shift                                                     # +4
          else
            val[0] = nil                                                   # +5
          end
          val                                                              # +6
        end

        (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

        Fastlane::Actions::VersionIconAction#self.available_options contains iterators nested 2 deep
        Open

        A Nested Iterator occurs when a block contains another block.

        Example

        Given

        class Duck
          class << self
            def duck_names
              %i!tick trick track!.each do |surname|
                %i!duck!.each do |last_name|
                  puts "full name is #{surname} #{last_name}"
                end
              end
            end
          end
        end

        Reek would report the following warning:

        test.rb -- 1 warning:
          [5]:Duck#duck_names contains iterators nested 2 deep (NestedIterators)

        Fastlane::Helper::VersionIconHelper#version_icon refers to 'convert' more than self (maybe move it to another class?)
        Open

                  convert << original_icon_path
                  convert << '-blur' << "#{band_blur_radius}x#{band_blur_sigma}"
                  convert << blurred_icon_path
                end
        
        

        Feature Envy occurs when a code fragment references another object more often than it references itself, or when several clients do the same series of manipulations on a particular type of object.

        Feature Envy reduces the code's ability to communicate intent: code that "belongs" on one class but which is located in another can be hard to find, and may upset the "System of Names" in the host class.

        Feature Envy also affects the design's flexibility: A code fragment that is in the wrong class creates couplings that may not be natural within the application's domain, and creates a loss of cohesion in the unwilling host class.

        Feature Envy often arises because it must manipulate other objects (usually its arguments) to get them into a useful form, and one force preventing them (the arguments) doing this themselves is that the common knowledge lives outside the arguments, or the arguments are of too basic a type to justify extending that type. Therefore there must be something which 'knows' about the contents or purposes of the arguments. That thing would have to be more than just a basic type, because the basic types are either containers which don't know about their contents, or they are single objects which can't capture their relationship with their fellows of the same type. So, this thing with the extra knowledge should be reified into a class, and the utility method will most likely belong there.

        Example

        Running Reek on:

        class Warehouse
          def sale_price(item)
            (item.price - item.rebate) * @vat
          end
        end

        would report:

        Warehouse#total_price refers to item more than self (FeatureEnvy)

        since this:

        (item.price - item.rebate)

        belongs to the Item class, not the Warehouse.

        Fastlane::Actions::VersionIconAction#self.available_options has approx 15 statements
        Open

        A method with Too Many Statements is any method that has a large number of lines.

        Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

        So the following method would score +6 in Reek's statement-counting algorithm:

        def parse(arg, argv, &error)
          if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
            return nil, block, nil                                         # +1
          end
          opt = (val = parse_arg(val, &error))[1]                          # +2
          val = conv_arg(*val)                                             # +3
          if opt and !arg
            argv.shift                                                     # +4
          else
            val[0] = nil                                                   # +5
          end
          val                                                              # +6
        end

        (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

        Fastlane::Actions::VersionIconAction tests 'value < 0' at least 3 times
        Open

        Repeated Conditional is a special case of Simulated Polymorphism. Basically it means you are checking the same value throughout a single class and take decisions based on this.

        Example

        Given

        class RepeatedConditionals
          attr_accessor :switch
        
          def repeat_1
            puts "Repeat 1!" if switch
          end
        
          def repeat_2
            puts "Repeat 2!" if switch
          end
        
          def repeat_3
            puts "Repeat 3!" if switch
          end
        end

        Reek would emit the following warning:

        test.rb -- 4 warnings:
          [5, 9, 13]:RepeatedConditionals tests switch at least 3 times (RepeatedConditional)

        If you get this warning then you are probably not using the right abstraction or even more probable, missing an additional abstraction.

        Fastlane::Actions::IconVersioningAction has no descriptive comment
        Open

            class IconVersioningAction < VersionIconAction

        Classes and modules are the units of reuse and release. It is therefore considered good practice to annotate every class and module with a brief comment outlining its responsibilities.

        Example

        Given

        class Dummy
          # Do things...
        end

        Reek would emit the following warning:

        test.rb -- 1 warning:
          [1]:Dummy has no descriptive comment (IrresponsibleModule)

        Fixing this is simple - just an explaining comment:

        # The Dummy class is responsible for ...
        class Dummy
          # Do things...
        end

        Fastlane::Actions::VersionIconAction#self.available_options calls 'value < 0' 3 times
        Open

        Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

        Reek implements a check for Duplicate Method Call.

        Example

        Here's a very much simplified and contrived example. The following method will report a warning:

        def double_thing()
          @other.thing + @other.thing
        end

        One quick approach to silence Reek would be to refactor the code thus:

        def double_thing()
          thing = @other.thing
          thing + thing
        end

        A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

        class Other
          def double_thing()
            thing + thing
          end
        end

        The approach you take will depend on balancing other factors in your code.

        Fastlane::Helper::VersionIconHelper#run calls 'Digest::SHA2.file(versioned_icon_path)' 2 times
        Open

                      versioned_icon_sha = Digest::SHA2.file(versioned_icon_path).hexdigest
        
                      cached_text_sha = cache[original_icon_path][:text]
                      cached_icon_sha = cache[original_icon_path][:icon]
        
        

        Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

        Reek implements a check for Duplicate Method Call.

        Example

        Here's a very much simplified and contrived example. The following method will report a warning:

        def double_thing()
          @other.thing + @other.thing
        end

        One quick approach to silence Reek would be to refactor the code thus:

        def double_thing()
          thing = @other.thing
          thing + thing
        end

        A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

        class Other
          def double_thing()
            thing + thing
          end
        end

        The approach you take will depend on balancing other factors in your code.

        Fastlane::Helper::VersionIconHelper#version_icon calls 'convert << '-composite'' 3 times
        Open

                  convert << '-composite'
                  convert << temp_icon_path
                end
        
                File.delete(blurred_icon_path, mask_icon_path)

        Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

        Reek implements a check for Duplicate Method Call.

        Example

        Here's a very much simplified and contrived example. The following method will report a warning:

        def double_thing()
          @other.thing + @other.thing
        end

        One quick approach to silence Reek would be to refactor the code thus:

        def double_thing()
          thing = @other.thing
          thing + thing
        end

        A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

        class Other
          def double_thing()
            thing + thing
          end
        end

        The approach you take will depend on balancing other factors in your code.

        Severity
        Category
        Status
        Source
        Language