Shopify/active_merchant

View on GitHub

Showing 984 of 1,463 total issues

Class IpgGateway has 42 methods (exceeds 20 allowed). Consider refactoring.
Open

    class IpgGateway < Gateway
      self.test_url = 'https://test.ipg-online.com/ipgapi/services'
      self.live_url = 'https://www5.ipg-online.com/ipgapi/services'

      self.supported_countries = %w(AR)
Severity: Minor
Found in lib/active_merchant/billing/gateways/ipg.rb - About 5 hrs to fix

    File cyber_source_rest.rb has 400 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    require 'active_merchant/billing/gateways/cyber_source/cyber_source_common'
    
    module ActiveMerchant #:nodoc:
      module Billing #:nodoc:
        class CyberSourceRestGateway < Gateway
    Severity: Minor
    Found in lib/active_merchant/billing/gateways/cyber_source_rest.rb - About 5 hrs to fix

      Method add_address has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
      Open

            def add_address(xml, payment_method, address, options, shipTo = false)
              first_name, last_name = address_names(address[:name], payment_method)
              bill_to_merchant_tax_id = options[:merchant_tax_id] unless shipTo
      
              xml.tag! shipTo ? 'shipTo' : 'billTo' do
      Severity: Minor
      Found in lib/active_merchant/billing/gateways/cyber_source.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

      Class AirwallexGateway has 41 methods (exceeds 20 allowed). Consider refactoring.
      Open

          class AirwallexGateway < Gateway
            self.test_url = 'https://api-demo.airwallex.com/api/v1'
            self.live_url = 'https://pci-api.airwallex.com/api/v1'
      
            # per https://www.airwallex.com/docs/online-payments__overview, cards are accepted in all EU countries
      Severity: Minor
      Found in lib/active_merchant/billing/gateways/airwallex.rb - About 5 hrs to fix

        File beanstream_core.rb has 393 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        module ActiveMerchant #:nodoc:
          module Billing #:nodoc:
            module BeanstreamCore
              include Empty
        
        
        Severity: Minor
        Found in lib/active_merchant/billing/gateways/beanstream/beanstream_core.rb - About 5 hrs to fix

          File pay_trace.rb has 393 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          module ActiveMerchant #:nodoc:
            module Billing #:nodoc:
              class PayTraceGateway < Gateway
                self.test_url = 'https://api.sandbox.paytrace.com'
                self.live_url = 'https://api.paytrace.com'
          Severity: Minor
          Found in lib/active_merchant/billing/gateways/pay_trace.rb - About 5 hrs to fix

            Method add_line_items has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
            Open

                  def add_line_items(post, options)
                    return unless options[:line_items]
            
                    line_items = []
                    options[:line_items].each do |li|
            Severity: Minor
            Found in lib/active_merchant/billing/gateways/pay_trace.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 add_transaction has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
            Open

                  def add_transaction(xml, money, options = {})
                    xml.transaction do
                      xml.ReversalType options[:reversal_type] if options[:reversal_type]
                      xml.TransactionID options[:trans_id] if options[:trans_id]
                      xml.TransactionAmount amount(money.to_i) if money
            Severity: Minor
            Found in lib/active_merchant/billing/gateways/element.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

            Class MercadoPagoGateway has 40 methods (exceeds 20 allowed). Consider refactoring.
            Open

                class MercadoPagoGateway < Gateway
                  self.live_url = self.test_url = 'https://api.mercadopago.com/v1'
            
                  self.supported_countries = %w[AR BR CL CO MX PE UY]
                  self.supported_cardtypes = %i[visa master american_express elo cabal naranja creditel]
            Severity: Minor
            Found in lib/active_merchant/billing/gateways/mercado_pago.rb - About 5 hrs to fix

              Method build_check_request has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
              Open

                    def build_check_request(action, money, check, options)
                      xml = Builder::XmlMarkup.new
                      xml.tag! TRANSACTIONS[action] do
                        xml.tag! 'PayData' do
                          xml.tag! 'Invoice' do
              Severity: Minor
              Found in lib/active_merchant/billing/gateways/payflow.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 add_submerchant has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
              Open

                    def add_submerchant(post, options)
                      if submerchant = options[:submerchant]
                        post[:SubMerchant] = {}
                        post[:SubMerchant][:Merchant_Category_Code] = submerchant[:merchant_category_code] if submerchant[:merchant_category_code]
                        post[:SubMerchant][:Payment_Facilitator_Code] = submerchant[:payment_facilitator_code] if submerchant[:payment_facilitator_code]
              Severity: Minor
              Found in lib/active_merchant/billing/gateways/mundipagg.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

              File payflow.rb has 384 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              require 'nokogiri'
              require 'active_merchant/billing/gateways/payflow/payflow_common_api'
              require 'active_merchant/billing/gateways/payflow/payflow_response'
              require 'active_merchant/billing/gateways/payflow_express'
              
              
              Severity: Minor
              Found in lib/active_merchant/billing/gateways/payflow.rb - About 5 hrs to fix

                Class MonerisGateway has 39 methods (exceeds 20 allowed). Consider refactoring.
                Open

                    class MonerisGateway < Gateway
                      WALLETS = %w(APP GPP)
                
                      self.test_url = 'https://esqa.moneris.com/gateway2/servlet/MpgRequest'
                      self.live_url = 'https://www3.moneris.com/gateway2/servlet/MpgRequest'
                Severity: Minor
                Found in lib/active_merchant/billing/gateways/moneris.rb - About 5 hrs to fix

                  File jetpay_v2.rb has 380 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  module ActiveMerchant #:nodoc:
                    module Billing #:nodoc:
                      class JetpayV2Gateway < Gateway
                        self.test_url = 'https://test1.jetpay.com/jetpay'
                        self.live_url = 'https://gateway20.jetpay.com/jetpay'
                  Severity: Minor
                  Found in lib/active_merchant/billing/gateways/jetpay_v2.rb - About 5 hrs to fix

                    File blue_pay.rb has 379 lines of code (exceeds 250 allowed). Consider refactoring.
                    Open

                    require 'digest/md5'
                    
                    module ActiveMerchant #:nodoc:
                      module Billing #:nodoc:
                        class BluePayGateway < Gateway
                    Severity: Minor
                    Found in lib/active_merchant/billing/gateways/blue_pay.rb - About 5 hrs to fix

                      Method add_pay_data has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
                      Open

                            def add_pay_data(xml, money, options)
                              xml.tag! 'PayData' do
                                xml.tag! 'Invoice' do
                                  xml.tag! 'CustIP', options[:ip] unless options[:ip].blank?
                                  xml.tag! 'InvNum', options[:order_id] unless options[:order_id].blank?
                      Severity: Minor
                      Found in lib/active_merchant/billing/gateways/payflow_express.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 add_payment_details has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
                      Open

                            def add_payment_details(xml, money, currency_code, options = {})
                              xml.tag! 'n2:PaymentDetails' do
                                xml.tag! 'n2:OrderTotal', localized_amount(money, currency_code), 'currencyID' => currency_code
                      
                                # All of the values must be included together and add up to the order total
                      Severity: Minor
                      Found in lib/active_merchant/billing/gateways/paypal/paypal_common_api.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

                      Class OgoneGateway has 38 methods (exceeds 20 allowed). Consider refactoring.
                      Open

                          class OgoneGateway < Gateway
                            CVV_MAPPING = { 'OK' => 'M',
                                            'KO' => 'N',
                                            'NO' => 'P' }
                      
                      
                      Severity: Minor
                      Found in lib/active_merchant/billing/gateways/ogone.rb - About 5 hrs to fix

                        Class PayTraceGateway has 38 methods (exceeds 20 allowed). Consider refactoring.
                        Open

                            class PayTraceGateway < Gateway
                              self.test_url = 'https://api.sandbox.paytrace.com'
                              self.live_url = 'https://api.paytrace.com'
                        
                              self.supported_countries = ['US']
                        Severity: Minor
                        Found in lib/active_merchant/billing/gateways/pay_trace.rb - About 5 hrs to fix

                          Class QuickpayV10Gateway has 38 methods (exceeds 20 allowed). Consider refactoring.
                          Open

                              class QuickpayV10Gateway < Gateway
                                include QuickpayCommon
                                API_VERSION = 10
                          
                                self.live_url = self.test_url = 'https://api.quickpay.net'
                          Severity: Minor
                          Found in lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb - About 5 hrs to fix
                            Severity
                            Category
                            Status
                            Source
                            Language