Sid Gifari File Manager Pro v10.0.3

✏️ Editing: parser.rb Read Only

# frozen_string_literal: true

class Gem::RequestSet::Lockfile::Parser
  ###
  # Parses lockfiles

def initialize(tokenizer, set, platforms, filename = nil)
    @tokens    = tokenizer
    @filename  = filename
    @set       = set
    @platforms = platforms
  end

def parse
    until @tokens.empty? do
      token = get

case token.type
      when :section then
        @tokens.skip :newline

case token.value
        when "DEPENDENCIES" then
          parse_DEPENDENCIES
        when "GIT" then
          parse_GIT
        when "GEM" then
          parse_GEM
        when "PATH" then
          parse_PATH
        when "PLATFORMS" then
          parse_PLATFORMS
        else
          token = get until @tokens.empty? || peek.first == :section
        end
      else
        raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"
      end
    end
  end

##
  # Gets the next token for a Lockfile

def get(expected_types = nil, expected_value = nil) # :nodoc:
    token = @tokens.shift

if expected_types && !Array(expected_types).include?(token.type)
      unget token

message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
                "expected #{expected_types.inspect}"

raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
    end

if expected_value && expected_value != token.value
      unget token

message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
                "expected [#{expected_types.inspect}, " \
                "#{expected_value.inspect}]"

raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
    end

token
  end

def parse_DEPENDENCIES # :nodoc:
    while !@tokens.empty? && peek.type == :text do
      token = get :text

requirements = []

case peek[0]
      when :bang then
        get :bang

requirements << pinned_requirement(token.value)
      when :l_paren then
        get :l_paren

loop do
          op      = get(:requirement).value
          version = get(:text).value

requirements << "#{op} #{version}"

break unless peek.type == :comma

get :comma
        end

get :r_paren

if peek[0] == :bang
          requirements.clear
          requirements << pinned_requirement(token.value)

get :bang
        end
      end

@set.gem token.value, *requirements

skip :newline
    end
  end

def parse_GEM # :nodoc:
    sources = []

while peek.first(2) == [:entry, "remote"] do
      get :entry, "remote"
      data = get(:text).value
      skip :newline

sources << Gem::Source.new(data)
    end

sources << Gem::Source.new(Gem::DEFAULT_HOST) if sources.empty?

get :entry, "specs"

skip :newline

set = Gem::Resolver::LockSet.new sources
    last_specs = nil

while !@tokens.empty? && peek.type == :text do
      token = get :text
      name = token.value
      column = token.column

case peek[0]
      when :newline then
        last_specs.each do |spec|
          spec.add_dependency Gem::Dependency.new name if column == 6
        end
      when :l_paren then
        get :l_paren

token = get [:text, :requirement]
        type = token.type
        data = token.value

if type == :text && column == 4
          version, platform = data.split "-", 2

platform =
            platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY

last_specs = set.add name, version, platform
        else
          dependency = parse_dependency name, data

last_specs.each do |spec|
            spec.add_dependency dependency
          end
        end

get :r_paren
      else
        raise "BUG: unknown token #{peek}"
      end

skip :newline
    end

@set.sets << set
  end

def parse_GIT # :nodoc:
    get :entry, "remote"
    repository = get(:text).value

skip :newline

get :entry, "revision"
    revision = get(:text).value

skip :newline

type = peek.type
    value = peek.value
    if type == :entry && %w[branch ref tag].include?(value)
      get
      get :text

skip :newline
    end

get :entry, "specs"

skip :newline

set = Gem::Resolver::GitSet.new
    set.root_dir = @set.install_dir

last_spec = nil

while !@tokens.empty? && peek.type == :text do
      token = get :text
      name = token.value
      column = token.column

case peek[0]
      when :newline then
        last_spec.add_dependency Gem::Dependency.new name if column == 6
      when :l_paren then
        get :l_paren

token = get [:text, :requirement]
        type = token.type
        data = token.value

if type == :text && column == 4
          last_spec = set.add_git_spec name, data, repository, revision, true
        else
          dependency = parse_dependency name, data

last_spec.add_dependency dependency
        end

get :r_paren
      else
        raise "BUG: unknown token #{peek}"
      end

skip :newline
    end

@set.sets << set
  end

def parse_PATH # :nodoc:
    get :entry, "remote"
    directory = get(:text).value

skip :newline

get :entry, "specs"

skip :newline

set = Gem::Resolver::VendorSet.new
    last_spec = nil

while !@tokens.empty? && peek.first == :text do
      token = get :text
      name = token.value
      column = token.column

case peek[0]
      when :newline then
        last_spec.add_dependency Gem::Dependency.new name if column == 6
      when :l_paren then
        get :l_paren

token = get [:text, :requirement]
        type = token.type
        data = token.value

if type == :text && column == 4
          last_spec = set.add_vendor_gem name, directory
        else
          dependency = parse_dependency name, data

last_spec.dependencies << dependency
        end

get :r_paren
      else
        raise "BUG: unknown token #{peek}"
      end

skip :newline
    end

@set.sets << set
  end

def parse_PLATFORMS # :nodoc:
    while !@tokens.empty? && peek.first == :text do
      name = get(:text).value

@platforms << name

skip :newline
    end
  end

##
  # Parses the requirements following the dependency +name+ and the +op+ for
  # the first token of the requirements and returns a Gem::Dependency object.

def parse_dependency(name, op) # :nodoc:
    return Gem::Dependency.new name, op unless peek[0] == :text

version = get(:text).value

requirements = ["#{op} #{version}"]

while peek.type == :comma do
      get :comma
      op      = get(:requirement).value
      version = get(:text).value

requirements << "#{op} #{version}"
    end

Gem::Dependency.new name, requirements
  end

private

def skip(type) # :nodoc:
    @tokens.skip type
  end

##
  # Peeks at the next token for Lockfile

def peek # :nodoc:
    @tokens.peek
  end

def pinned_requirement(name) # :nodoc:
    requirement = Gem::Dependency.new name
    specification = @set.sets.flat_map do |set|
      set.find_all(requirement)
    end.compact.first

specification&.version
  end

##
  # Ungets the last token retrieved by #get

def unget(token) # :nodoc:
    @tokens.unshift token
  end
end

📁 File Manager Pro

📁 File Manager Pro