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

Open

      def insert_to(data, statement)
        raise ArgumentError, "Statement #{statement.inspect} is incomplete" if statement.incomplete?

        unless statement_in?(data, statement)
          s, p, o, c = statement.to_quad

• Read up
  Read up

Method query_values= has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def query_values=(value)
      if value.nil?
        self.query = nil
        return
      end

• Read up
  Read up

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

Open

    def normalized_path
      if normalized_scheme == "urn"
        # Special-case URI. Normalize the NID component only
        nid, p = path.to_s.split(':', 2)
        return "#{nid.downcase}:#{p}"

• Read up
  Read up

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

Open

    def format_uri(uri, **options)
      string = uri.to_s
      iriref = case
        when string.match?(ESCAPE_PLAIN_U) # a shortcut for the simple case
          string

• Read up
  Read up

Method open_file has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def self.open_file(filename_or_url, proxy: nil, headers: {}, verify_none: false, **options, &block)
      filename_or_url = $1 if filename_or_url.to_s.match(/^file:(.*)$/)
      remote_document = nil

      if filename_or_url.to_s.match?(/^https?/)

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

Open

    def initialize(subject: nil, graph: nil, values: nil, wrap_transaction: false, &block)
      @subject = subject || RDF.nil
      @graph   = graph   || RDF::Graph.new
      is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?

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

Open

      def attribute_value(prop)
        values = attributes[prop]
        return nil if values.nil?
        values = [values].compact unless values.is_a?(Array)
        prop_values = values.map do |value|

Method commands has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def self.commands(format: nil, **options)
      # First, load commands from other formats
      load_commands

      case format

• Read up
  Read up

Method solution has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def solution(statement)
      RDF::Query::Solution.new do |solution|
        solution[subject.to_sym]    = statement.subject    if subject.is_a?(Variable)
        solution[predicate.to_sym]  = statement.predicate  if predicate.is_a?(Variable)
        solution[object.to_sym]     = statement.object     if object.is_a?(Variable)

• Read up
  Read up

Method variable_terms has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def variable_terms(name = nil)
      warn "[DEPRECATION] RDF::Query::Pattern#variable_terms is deprecated and will be removed in a future version.\n" +
           "Called from #{Gem.location_of_caller.join(':')}"
      terms = []
      terms << :subject    if subject.is_a?(Variable)    && (!name || name.eql?(subject.name))

• Read up
  Read up

Method expand_pname has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

      def expand_pname(pname)
        return pname unless pname.is_a?(String) || pname.is_a?(Symbol)
        prefix, suffix = pname.to_s.split(":", 2)
        # Unescape escaped PN_ESCAPE_CHARS
        if suffix.match?(RDF::URI::PN_ESCAPES)

• Read up
  Read up

Method format_uri has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def format_uri(uri, **options)
      string = uri.to_s
      iriref = case
        when string.match?(ESCAPE_PLAIN_U) # a shortcut for the simple case
          string

Method query has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def query(pattern, **options, &block)
      raise TypeError, "#{self} is not readable" if respond_to?(:readable?) && !readable?

      case pattern
        # A basic graph pattern (BGP) query:

Method new has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def self.new(*args, vocab: nil, attributes: {}, **options)
        klass = if args.first.nil?
          RDF::Node
        elsif args.first.is_a?(Hash)
          args.unshift(nil)

Method options has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def self.options
      [
        RDF::CLI::Option.new(
          symbol: :canonicalize,
          datatype: TrueClass,

Method each has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def self.each(file_name: nil,
                  file_extension: nil,
                  content_type: nil,
                  has_reader: false,
                  has_writer: false,

Method valid? has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def valid?
      li = subject
      list_nodes = []
      while li != RDF.nil do
        return false if list_nodes.include?(li)

Method valid? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def valid?
      BCP47.parse(language.to_s) if language?
      return false if direction? && !%i{ltr rtl}.include?(direction)
      return false if datatype? && datatype.invalid?
      grammar = self.class.const_get(:GRAMMAR) rescue nil

• Read up
  Read up

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

Open

    def self.open_file(filename_or_url, proxy: nil, headers: {}, verify_none: false, **options, &block)
      filename_or_url = $1 if filename_or_url.to_s.match(/^file:(.*)$/)
      remote_document = nil

      if filename_or_url.to_s.match?(/^https?/)

• Read up
  Read up

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

Open

      def read_triple
        loop do
          readline.strip! # EOFError thrown on end of input
          line = @line    # for backtracking input in case of parse error

• Read up
  Read up