Graybyt3 Was Here

Linux host74.registrar-servers.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64
Apache
162.213.253.119

File Name : store.rb

require 'rdoc/code_objects'
require 'fileutils'

##
# A set of ri data.
#
# The store manages reading and writing ri data for a project (gem, path,
# etc.) and maintains a cache of methods, classes and ancestors in the
# store.
#
# The store maintains a #cache of its contents for faster lookup.  After
# adding items to the store it must be flushed using #save_cache.  The cache
# contains the following structures:
#
#    @cache = {
#      :class_methods    => {}, # class name => class methods
#      :instance_methods => {}, # class name => instance methods
#      :attributes       => {}, # class name => attributes
#      :modules          => [], # classes and modules in this store
#      :ancestors        => {}, # class name => ancestor names
#    }
#--
# TODO need to store the list of files and prune classes

class RDoc::RI::Store

##
  # If true this Store will not write any files

attr_accessor :dry_run

##
  # Path this store reads or writes

attr_accessor :path

##
  # Type of ri datastore this was loaded from.  See RDoc::RI::Driver,
  # RDoc::RI::Paths.

attr_accessor :type

##
  # The contents of the Store

attr_reader :cache

##
  # The encoding of the contents in the Store

attr_accessor :encoding

##
  # Creates a new Store of +type+ that will load or save to +path+

def initialize path, type = nil
    @dry_run  = false
    @type     = type
    @path     = path
    @encoding = nil

@cache = {
      :ancestors        => {},
      :attributes       => {},
      :class_methods    => {},
      :encoding         => @encoding,
      :instance_methods => {},
      :modules          => [],
    }
  end

##
  # Ancestors cache accessor.  Maps a klass name to an Array of its ancestors
  # in this store.  If Foo in this store inherits from Object, Kernel won't be
  # listed (it will be included from ruby's ri store).

def ancestors
    @cache[:ancestors]
  end

##
  # Attributes cache accessor.  Maps a class to an Array of its attributes.

def attributes
    @cache[:attributes]
  end

##
  # Path to the cache file

def cache_path
    File.join @path, 'cache.ri'
  end

##
  # Path to the ri data for +klass_name+

def class_file klass_name
    name = klass_name.split('::').last
    File.join class_path(klass_name), "cdesc-#{name}.ri"
  end

##
  # Class methods cache accessor.  Maps a class to an Array of its class
  # methods (not full name).

def class_methods
    @cache[:class_methods]
  end

##
  # Path where data for +klass_name+ will be stored (methods or class data)

def class_path klass_name
    File.join @path, *klass_name.split('::')
  end

##
  # Removes empty items and ensures item in each collection are unique and
  # sorted

def clean_cache_collection collection # :nodoc:
    collection.each do |name, item|
      if item.empty? then
        collection.delete name
      else
        # HACK mongrel-1.1.5 documents its files twice
        item.uniq!
        item.sort!
      end
    end
  end

##
  # Friendly rendition of #path

def friendly_path
    case type
    when :gem    then
      sep = Regexp.union(*['/', File::ALT_SEPARATOR].compact)
      @path =~ /#{sep}doc#{sep}(.*?)#{sep}ri$/
      "gem #{$1}"
    when :home   then '~/.ri'
    when :site   then 'ruby site'
    when :system then 'ruby core'
    else @path
    end
  end

def inspect # :nodoc:
    "#<%s:0x%x %s %p>" % [self.class, object_id, @path, modules.sort]
  end

##
  # Instance methods cache accessor.  Maps a class to an Array of its
  # instance methods (not full name).

def instance_methods
    @cache[:instance_methods]
  end

##
  # Loads cache file for this store

def load_cache
    #orig_enc = @encoding

open cache_path, 'rb' do |io|
      @cache = Marshal.load io.read
    end

load_enc = @cache[:encoding]

# TODO this feature will be time-consuming to add:
    # a) Encodings may be incompatible but transcodeable
    # b) Need to warn in the appropriate spots, wherever they may be
    # c) Need to handle cross-cache differences in encodings
    # d) Need to warn when generating into a cache with diffent encodings
    #
    #if orig_enc and load_enc != orig_enc then
    #  warn "Cached encoding #{load_enc} is incompatible with #{orig_enc}\n" \
    #       "from #{path}/cache.ri" unless
    #    Encoding.compatible? orig_enc, load_enc
    #end

@encoding = load_enc unless @encoding

@cache
  rescue Errno::ENOENT
  end

##
  # Loads ri data for +klass_name+

def load_class klass_name
    open class_file(klass_name), 'rb' do |io|
      Marshal.load io.read
    end
  end

##
  # Loads ri data for +method_name+ in +klass_name+

def load_method klass_name, method_name
    open method_file(klass_name, method_name), 'rb' do |io|
      Marshal.load io.read
    end
  end

##
  # Path to the ri data for +method_name+ in +klass_name+

def method_file klass_name, method_name
    method_name = method_name.split('::').last
    method_name =~ /#(.*)/
    method_type = $1 ? 'i' : 'c'
    method_name = $1 if $1

method_name = if ''.respond_to? :ord then
                    method_name.gsub(/\W/) { "%%%02x" % $&[0].ord }
                  else
                    method_name.gsub(/\W/) { "%%%02x" % $&[0] }
                  end

File.join class_path(klass_name), "#{method_name}-#{method_type}.ri"
  end

##
  # Modules cache accessor.  An Array of all the modules (and classes) in the
  # store.

def modules
    @cache[:modules]
  end

##
  # Writes the cache file for this store

def save_cache
    clean_cache_collection @cache[:ancestors]
    clean_cache_collection @cache[:attributes]
    clean_cache_collection @cache[:class_methods]
    clean_cache_collection @cache[:instance_methods]

@cache[:modules].uniq!
    @cache[:modules].sort!
    @cache[:encoding] = @encoding # this gets set twice due to assert_cache

return if @dry_run

marshal = Marshal.dump @cache

open cache_path, 'wb' do |io|
      io.write marshal
    end
  end

##
  # Writes the ri data for +klass+

def save_class klass
    full_name = klass.full_name

FileUtils.mkdir_p class_path(full_name) unless @dry_run

@cache[:modules] << full_name

path = class_file full_name

begin
      disk_klass = load_class full_name

klass = disk_klass.merge klass
    rescue Errno::ENOENT
    end

# BasicObject has no ancestors
    ancestors = klass.ancestors.compact.map do |ancestor|
      # HACK for classes we don't know about (class X < RuntimeError)
      String === ancestor ? ancestor : ancestor.full_name
    end

@cache[:ancestors][full_name] ||= []
    @cache[:ancestors][full_name].push(*ancestors)

attributes = klass.attributes.map do |attribute|
      "#{attribute.definition} #{attribute.name}"
    end

unless attributes.empty? then
      @cache[:attributes][full_name] ||= []
      @cache[:attributes][full_name].push(*attributes)
    end

to_delete = []

unless klass.method_list.empty? then
      @cache[:class_methods][full_name]    ||= []
      @cache[:instance_methods][full_name] ||= []

class_methods, instance_methods =
        klass.method_list.partition { |meth| meth.singleton }

class_methods    = class_methods.   map { |method| method.name }
      instance_methods = instance_methods.map { |method| method.name }

old = @cache[:class_methods][full_name] - class_methods
      to_delete.concat old.map { |method|
        method_file full_name, "#{full_name}::#{method}"
      }

old = @cache[:instance_methods][full_name] - instance_methods
      to_delete.concat old.map { |method|
        method_file full_name, "#{full_name}##{method}"
      }

@cache[:class_methods][full_name]    = class_methods
      @cache[:instance_methods][full_name] = instance_methods
    end

return if @dry_run

FileUtils.rm_f to_delete

marshal = Marshal.dump klass

open path, 'wb' do |io|
      io.write marshal
    end
  end

##
  # Writes the ri data for +method+ on +klass+

def save_method klass, method
    full_name = klass.full_name

FileUtils.mkdir_p class_path(full_name) unless @dry_run

cache = if method.singleton then
              @cache[:class_methods]
            else
              @cache[:instance_methods]
            end
    cache[full_name] ||= []
    cache[full_name] << method.name

return if @dry_run

marshal = Marshal.dump method

open method_file(full_name, method.full_name), 'wb' do |io|
      io.write marshal
    end
  end

end

System Information
*ReClick For Close
File : BlackDragon /wp-content/uploads/2019/09/hq95bs/index.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	0755	2024-03-29 09:05:54
..	dir	-	root/linksafe	0755	2024-03-29 09:05:54
driver.rb	text/x-ruby	26.66 KB	root/linksafe	0644	2011-08-05 09:21:55
formatter.rb	text/x-ruby	84 B	root/linksafe	0644	2010-04-01 07:45:16
paths.rb	text/x-ruby	2.97 KB	root/linksafe	0644	2010-12-28 10:08:56
store.rb	text/x-ruby	8.35 KB	root/linksafe	0644	2011-06-29 09:17:31