class Asciidoctor::AbstractNode

def add_role(name)
  unless (roles = (@attributes['role'] || '').split(' ')).include? name
    @attributes['role'] = roles.push(name) * ' '
  end
end

def attr(name, default_value = nil, inherit = true)
  name = name.to_s if ::Symbol === name
  inherit = false if self == @document
  if inherit
    @attributes[name] || @document.attributes[name] || default_value
  else
    @attributes[name] || default_value
  end
end

def attr?(name, expect = nil, inherit = true)
  name = name.to_s if ::Symbol === name
  inherit = false if self == @document
  if expect.nil?
    @attributes.has_key?(name) || (inherit && @document.attributes.has_key?(name))
  elsif inherit
    expect == (@attributes[name] || @document.attributes[name])
  else
    expect == @attributes[name]
  end
end

def block?
  # :nocov:
  raise ::NotImplementedError
  # :nocov:
end

def converter
  @document.converter
end

def generate_data_uri(target_image, asset_dir_key = nil)
  ext = ::File.extname target_image
  # QUESTION what if ext is empty?
  mimetype = (ext == '.svg' ? 'image/svg+xml' : %(image/#{ext[1..-1]}))
  if asset_dir_key
    image_path = normalize_system_path(target_image, @document.attr(asset_dir_key), nil, :target_name => 'image')
  else
    image_path = normalize_system_path(target_image)
  end
  unless ::File.readable? image_path
    warn %(asciidoctor: WARNING: image to embed not found or not readable: #{image_path})
    # must enclose string following return in " for Opal
    return "data:#{mimetype}:base64,"
    # uncomment to return 1 pixel white dot instead
    #return 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
  end
  bindata = nil
  if ::IO.respond_to? :binread
    bindata = ::IO.binread(image_path)
  else
    bindata = ::File.open(image_path, 'rb') {|file| file.read }
  end
  # NOTE base64 is autoloaded by reference to ::Base64
  %(data:#{mimetype};base64,#{::Base64.encode64(bindata).delete EOL})
end

def generate_data_uri_from_uri image_uri, cache_uri = false
  if cache_uri
    # caching requires the open-uri-cached gem to be installed
    # processing will be automatically aborted if these libraries can't be opened
    Helpers.require_library 'open-uri/cached', 'open-uri-cached'
  elsif !::RUBY_ENGINE_OPAL
    # autoload open-uri
    ::OpenURI
  end
  begin
    mimetype = nil
    bindata = open(image_uri, 'rb') {|file|
      mimetype = file.content_type 
      file.read
    }
    # NOTE base64 is autoloaded by reference to ::Base64
    %(data:#{mimetype};base64,#{::Base64.encode64(bindata).delete EOL})
  rescue
    warn %(asciidoctor: WARNING: could not retrieve image data from URI: #{image_uri})
    image_uri
    # uncomment to return empty data (however, mimetype needs to be resolved)
    #%(data:#{mimetype}:base64,)
    # uncomment to return 1 pixel white dot instead
    #'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
  end
end

def has_role?(name)
  if (val = (@attributes['role'] || @document.attributes['role']))
    val.split(' ').include?(name)
  else
    false
  end
end

def icon_uri(name)
  if attr? 'icon'
    image_uri(attr('icon'), nil)
  else
    image_uri(%(#{name}.#{@document.attr('icontype', 'png')}), 'iconsdir')
  end
end

def image_uri(target_image, asset_dir_key = 'imagesdir')
  if (doc = @document).safe < SafeMode::SECURE && doc.attr?('data-uri')
    if (Helpers.uriish? target_image) ||
        (asset_dir_key && (images_base = doc.attr(asset_dir_key)) && (Helpers.uriish? images_base) &&
        (target_image = normalize_web_path(target_image, images_base, false)))
      if doc.attr?('allow-uri-read')
        generate_data_uri_from_uri target_image, doc.attr?('cache-uri')
      else
        target_image
      end
    else
      generate_data_uri target_image, asset_dir_key
    end
  else
    normalize_web_path target_image, (asset_dir_key ? doc.attr(asset_dir_key) : nil)
  end
end

def initialize parent, context, opts = {}
  # document is a special case, should refer to itself
  if context == :document
    @document = parent
  else
    if parent
      @parent = parent
      @document = parent.document
    else
      @parent = nil
      @document = nil
    end
  end
  @context = context
  @node_name = context.to_s
  # QUESTION are we correct in duplicating the attributes (seems to be just as fast)
  @attributes = (opts.key? :attributes) ? opts[:attributes].dup : {}
  @passthroughs = {}
end

def inline?
  # :nocov:
  raise ::NotImplementedError
  # :nocov:
end

def is_uri? str
  Helpers.uriish? str
end

def list_marker_keyword(list_type = nil)
  ORDERED_LIST_KEYWORDS[list_type || @style]
end

def media_uri(target, asset_dir_key = 'imagesdir')
  normalize_web_path target, (asset_dir_key ? @document.attr(asset_dir_key) : nil)
end

def normalize_asset_path(asset_ref, asset_name = 'path', autocorrect = true)
  normalize_system_path(asset_ref, @document.base_dir, nil,
      :target_name => asset_name, :recover => autocorrect)
end

def normalize_system_path target, start = nil, jail = nil, opts = {}
  path_resolver = (@path_resolver ||= PathResolver.new)
  if (doc = @document).safe < SafeMode::SAFE
    if start
      start = ::File.join doc.base_dir, start unless path_resolver.is_root? start
    else
      start = doc.base_dir
    end
  else
    start = doc.base_dir unless start
    jail = doc.base_dir unless jail
  end
  path_resolver.system_path target, start, jail, opts
end

def normalize_web_path(target, start = nil, preserve_uri_target = true)
  if preserve_uri_target && (Helpers.uriish? target)
    target
  else
    (@path_resolver ||= PathResolver.new).web_path target, start
  end
end

def option?(name)
  @attributes.has_key? %(#{name}-option)
end

def parent=(parent)
  @parent = parent
  @document = parent.document
  nil
end

def read_asset(path, opts = {})
  # remap opts for backwards compatibility
  opts = { :warn_on_failure => (opts != false) } unless ::Hash === opts
  if ::File.readable? path
    if opts[:normalize]
      Helpers.normalize_lines_from_string(::IO.read(path)) * EOL
    else
      # QUESTION should we chomp or rstrip content?
      ::IO.read(path)
    end
  else
    warn %(asciidoctor: WARNING: file does not exist or cannot be read: #{path}) if opts[:warn_on_failure]
    nil
  end
end

def read_contents target, opts = {}
  doc = @document
  if (Helpers.uriish? target) || ((start = opts[:start]) && (Helpers.uriish? start) &&
      (target = (@path_resolver ||= PathResolver.new).web_path target, start))
    if doc.attr? 'allow-uri-read'
      Helpers.require_library 'open-uri/cached', 'open-uri-cached' if doc.attr? 'cache-uri'
      begin
        data = ::OpenURI.open_uri(target) {|fd| fd.read }
        data = (Helpers.normalize_lines_from_string data) * EOL if opts[:normalize]
      rescue
        warn %(asciidoctor: WARNING: could not retrieve contents of #{opts[:label] || 'asset'} at URI: #{target}) if opts.fetch :warn_on_failure, true
        data = nil
      end
    else
      warn %(asciidoctor: WARNING: cannot retrieve contents of #{opts[:label] || 'asset'} at URI: #{target} (allow-uri-read attribute not enabled)) if opts.fetch :warn_on_failure, true
      data = nil
    end
  else
    target = normalize_system_path target, opts[:start], nil, :target_name => (opts[:label] || 'asset')
    data = read_asset target, :normalize => opts[:normalize], :warn_on_failure => (opts.fetch :warn_on_failure, true)
  end
  data
end

def reftext
  @attributes['reftext'] || @document.attributes['reftext']
end

def reftext?
  @attributes.has_key?('reftext') || @document.attributes.has_key?('reftext')
end

def relative_path(filename)
  (@path_resolver ||= PathResolver.new).relative_path filename, @document.base_dir
end

def remove_role(name)
  if (roles = (@attributes['role'] || '').split(' ')).include? name
    roles.delete name
    @attributes['role'] = roles * ' '
  end
end

def role
  @attributes['role'] || @document.attributes['role']
end

def role?(expect = nil)
  if expect
    expect == (@attributes['role'] || @document.attributes['role'])
  else
    @attributes.has_key?('role') || @document.attributes.has_key?('role')
  end
end

def roles
  if (val = (@attributes['role'] || @document.attributes['role']))
    val.split(' ')
  else
    []
  end
end

def set_attr name, value, overwrite = true
  if overwrite == false && (@attributes.key? name)
    false
  else
    @attributes[name] = value
    true
  end
end

def set_option(name)
  if @attributes.has_key? 'options'
    @attributes['options'] = "#{@attributes['options']},#{name}"
  else
    @attributes['options'] = name
  end
  @attributes["#{name}-option"] = ''
end

def update_attributes(attributes)
  @attributes.update(attributes)
  nil
end