File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby19/lib64/ruby/1.9.1

opt / alt / ruby19 / lib64 / ruby / 1.9.1 /

ðŸ“ ..
ðŸ“„ English.rb(5.59 KB)
ðŸ“„ abbrev.rb(2.57 KB)
ðŸ“„ base64.rb(2.63 KB)
ðŸ“„ benchmark.rb(18 KB)
ðŸ“ cgi
ðŸ“„ cgi.rb(9.3 KB)
ðŸ“„ cmath.rb(7.22 KB)
ðŸ“„ complex.rb(380 B)
ðŸ“„ csv.rb(82.66 KB)
ðŸ“ date
ðŸ“„ date.rb(946 B)
ðŸ“„ debug.rb(23.23 KB)
ðŸ“„ delegate.rb(9.74 KB)
ðŸ“ digest
ðŸ“„ digest.rb(2.24 KB)
ðŸ“ dl
ðŸ“„ dl.rb(176 B)
ðŸ“ drb
ðŸ“„ drb.rb(19 B)
ðŸ“„ e2mmap.rb(3.8 KB)
ðŸ“„ erb.rb(25.72 KB)
ðŸ“„ expect.rb(1.33 KB)
ðŸ“ fiddle
ðŸ“„ fiddle.rb(928 B)
ðŸ“„ fileutils.rb(45.32 KB)
ðŸ“„ find.rb(2.03 KB)
ðŸ“„ forwardable.rb(7.64 KB)
ðŸ“„ getoptlong.rb(15.38 KB)
ðŸ“„ gserver.rb(8.83 KB)
ðŸ“„ ipaddr.rb(24.92 KB)
ðŸ“ irb
ðŸ“„ irb.rb(8.34 KB)
ðŸ“ json
ðŸ“„ json.rb(1.74 KB)
ðŸ“„ kconv.rb(5.74 KB)
ðŸ“„ logger.rb(20.85 KB)
ðŸ“„ mathn.rb(6.52 KB)
ðŸ“ matrix
ðŸ“„ matrix.rb(47.65 KB)
ðŸ“„ mkmf.rb(68.9 KB)
ðŸ“„ monitor.rb(6.94 KB)
ðŸ“„ mutex_m.rb(1.61 KB)
ðŸ“ net
ðŸ“„ observer.rb(5.69 KB)
ðŸ“„ open-uri.rb(25.84 KB)
ðŸ“„ open3.rb(20.64 KB)
ðŸ“ openssl
ðŸ“„ openssl.rb(547 B)
ðŸ“ optparse
ðŸ“„ optparse.rb(51.13 KB)
ðŸ“„ ostruct.rb(6.49 KB)
ðŸ“„ pathname.rb(14.21 KB)
ðŸ“„ pp.rb(13.31 KB)
ðŸ“„ prettyprint.rb(9.63 KB)
ðŸ“„ prime.rb(13.98 KB)
ðŸ“„ profile.rb(205 B)
ðŸ“„ profiler.rb(1.59 KB)
ðŸ“„ pstore.rb(15.81 KB)
ðŸ“ psych
ðŸ“„ psych.rb(9.82 KB)
ðŸ“ racc
ðŸ“ rake
ðŸ“„ rake.rb(2.02 KB)
ðŸ“„ rational.rb(308 B)
ðŸ“ rbconfig
ðŸ“ rdoc
ðŸ“„ rdoc.rb(4.29 KB)
ðŸ“„ resolv-replace.rb(1.74 KB)
ðŸ“„ resolv.rb(59.91 KB)
ðŸ“ rexml
ðŸ“ rinda
ðŸ“ ripper
ðŸ“„ ripper.rb(91 B)
ðŸ“ rss
ðŸ“„ rss.rb(2.84 KB)
ðŸ“ rubygems
ðŸ“„ rubygems.rb(34.13 KB)
ðŸ“„ scanf.rb(23.53 KB)
ðŸ“„ securerandom.rb(8.46 KB)
ðŸ“„ set.rb(29.91 KB)
ðŸ“ shell
ðŸ“„ shell.rb(5.9 KB)
ðŸ“„ shellwords.rb(3.88 KB)
ðŸ“„ singleton.rb(4.02 KB)
ðŸ“„ socket.rb(23.22 KB)
ðŸ“ syck
ðŸ“„ syck.rb(13.91 KB)
ðŸ“„ sync.rb(6.87 KB)
ðŸ“„ tempfile.rb(10.42 KB)
ðŸ“ test
ðŸ“„ thread.rb(6.59 KB)
ðŸ“„ thwait.rb(3.38 KB)
ðŸ“„ time.rb(17.03 KB)
ðŸ“„ timeout.rb(3.26 KB)
ðŸ“„ tmpdir.rb(3.72 KB)
ðŸ“„ tracer.rb(6.63 KB)
ðŸ“„ tsort.rb(6.79 KB)
ðŸ“„ ubygems.rb(268 B)
ðŸ“„ un.rb(8.32 KB)
ðŸ“ uri
ðŸ“„ uri.rb(3.07 KB)
ðŸ“„ weakref.rb(2.29 KB)
ðŸ“ webrick
ðŸ“„ webrick.rb(6.8 KB)
ðŸ“ x86_64-linux
ðŸ“ xmlrpc
ðŸ“ yaml
ðŸ“„ yaml.rb(2.58 KB)

Editing: pp.rb

# == Pretty-printer for Ruby objects.
#
# = Which seems better?
#
# non-pretty-printed output by #p is:
#   #<PP:0x81fedf0 @genspace=#<Proc:0x81feda0>, @group_queue=#<PrettyPrint::GroupQueue:0x81fed3c @queue=[[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], []]>, @buffer=[], @newline="\n", @group_stack=[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], @buffer_width=0, @indent=0, @maxwidth=79, @output_width=2, @output=#<IO:0x8114ee4>>
#
# pretty-printed output by #pp is:
#   #<PP:0x81fedf0
#    @buffer=[],
#    @buffer_width=0,
#    @genspace=#<Proc:0x81feda0>,
#    @group_queue=
#     #<PrettyPrint::GroupQueue:0x81fed3c
#      @queue=
#       [[#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
#        []]>,
#    @group_stack=
#     [#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
#    @indent=0,
#    @maxwidth=79,
#    @newline="\n",
#    @output=#<IO:0x8114ee4>,
#    @output_width=2>
#
# I like the latter.  If you do too, this library is for you.
#
# = Usage
#
#   pp(obj)
#
# output +obj+ to +$>+ in pretty printed format.
#
# It returns +nil+.
#
# = Output Customization
# To define your customized pretty printing function for your classes,
# redefine a method #pretty_print(+pp+) in the class.
# It takes an argument +pp+ which is an instance of the class PP.
# The method should use PP#text, PP#breakable, PP#nest, PP#group and
# PP#pp to print the object.
#
# = Author
# Tanaka Akira <akr@m17n.org>

require 'prettyprint'

module Kernel
  # returns a pretty printed object as a string.
  def pretty_inspect
    PP.pp(self, '')
  end

private
  # prints arguments in pretty form.
  #
  # pp returns argument(s).
  def pp(*objs) # :doc:
    objs.each {|obj|
      PP.pp(obj)
    }
    objs.size <= 1 ? objs.first : objs
  end
  module_function :pp
end

class PP < PrettyPrint
  # Outputs +obj+ to +out+ in pretty printed format of
  # +width+ columns in width.
  #
  # If +out+ is omitted, +$>+ is assumed.
  # If +width+ is omitted, 79 is assumed.
  #
  # PP.pp returns +out+.
  def PP.pp(obj, out=$>, width=79)
    q = PP.new(out, width)
    q.guard_inspect_key {q.pp obj}
    q.flush
    #$pp = q
    out << "\n"
  end

# Outputs +obj+ to +out+ like PP.pp but with no indent and
  # newline.
  #
  # PP.singleline_pp returns +out+.
  def PP.singleline_pp(obj, out=$>)
    q = SingleLine.new(out)
    q.guard_inspect_key {q.pp obj}
    q.flush
    out
  end

# :stopdoc:
  def PP.mcall(obj, mod, meth, *args, &block)
    mod.instance_method(meth).bind(obj).call(*args, &block)
  end
  # :startdoc:

@sharing_detection = false
  class << self
    # Returns the sharing detection flag as a boolean value.
    # It is false by default.
    attr_accessor :sharing_detection
  end

module PPMethods
    def guard_inspect_key
      if Thread.current[:__recursive_key__] == nil
        Thread.current[:__recursive_key__] = {}.untrust
      end

if Thread.current[:__recursive_key__][:inspect] == nil
        Thread.current[:__recursive_key__][:inspect] = {}.untrust
      end

save = Thread.current[:__recursive_key__][:inspect]

begin
        Thread.current[:__recursive_key__][:inspect] = {}.untrust
        yield
      ensure
        Thread.current[:__recursive_key__][:inspect] = save
      end
    end

def check_inspect_key(id)
      Thread.current[:__recursive_key__] &&
      Thread.current[:__recursive_key__][:inspect] &&
      Thread.current[:__recursive_key__][:inspect].include?(id)
    end
    def push_inspect_key(id)
      Thread.current[:__recursive_key__][:inspect][id] = true
    end
    def pop_inspect_key(id)
      Thread.current[:__recursive_key__][:inspect].delete id
    end

# Adds +obj+ to the pretty printing buffer
    # using Object#pretty_print or Object#pretty_print_cycle.
    #
    # Object#pretty_print_cycle is used when +obj+ is already
    # printed, a.k.a the object reference chain has a cycle.
    def pp(obj)
      id = obj.object_id

if check_inspect_key(id)
        group {obj.pretty_print_cycle self}
        return
      end

begin
        push_inspect_key(id)
        group {obj.pretty_print self}
      ensure
        pop_inspect_key(id) unless PP.sharing_detection
      end
    end

# A convenience method which is same as follows:
    #
    #   group(1, '#<' + obj.class.name, '>') { ... }
    def object_group(obj, &block) # :yield:
      group(1, '#<' + obj.class.name, '>', &block)
    end

PointerMask = (1 << ([""].pack("p").size * 8)) - 1

case Object.new.inspect
    when /\A\#<Object:0x([0-9a-f]+)>\z/
      PointerFormat = "%0#{$1.length}x"
    else
      PointerFormat = "%x"
    end

def object_address_group(obj, &block)
      id = PointerFormat % (obj.object_id * 2 & PointerMask)
      group(1, "\#<#{obj.class}:0x#{id}", '>', &block)
    end

# A convenience method which is same as follows:
    #
    #   text ','
    #   breakable
    def comma_breakable
      text ','
      breakable
    end

# Adds a separated list.
    # The list is separated by comma with breakable space, by default.
    #
    # #seplist iterates the +list+ using +iter_method+.
    # It yields each object to the block given for #seplist.
    # The procedure +separator_proc+ is called between each yields.
    #
    # If the iteration is zero times, +separator_proc+ is not called at all.
    #
    # If +separator_proc+ is nil or not given,
    # +lambda { comma_breakable }+ is used.
    # If +iter_method+ is not given, :each is used.
    #
    # For example, following 3 code fragments has similar effect.
    #
    #   q.seplist([1,2,3]) {|v| xxx v }
    #
    #   q.seplist([1,2,3], lambda { q.comma_breakable }, :each) {|v| xxx v }
    #
    #   xxx 1
    #   q.comma_breakable
    #   xxx 2
    #   q.comma_breakable
    #   xxx 3
    def seplist(list, sep=nil, iter_method=:each) # :yield: element
      sep ||= lambda { comma_breakable }
      first = true
      list.__send__(iter_method) {|*v|
        if first
          first = false
        else
          sep.call
        end
        yield(*v)
      }
    end

def pp_object(obj)
      object_address_group(obj) {
        seplist(obj.pretty_print_instance_variables, lambda { text ',' }) {|v|
          breakable
          v = v.to_s if Symbol === v
          text v
          text '='
          group(1) {
            breakable ''
            pp(obj.instance_eval(v))
          }
        }
      }
    end

def pp_hash(obj)
      group(1, '{', '}') {
        seplist(obj, nil, :each_pair) {|k, v|
          group {
            pp k
            text '=>'
            group(1) {
              breakable ''
              pp v
            }
          }
        }
      }
    end
  end

include PPMethods

class SingleLine < PrettyPrint::SingleLine
    include PPMethods
  end

module ObjectMixin
    # 1. specific pretty_print
    # 2. specific inspect
    # 3. specific to_s
    # 4. generic pretty_print

# A default pretty printing method for general objects.
    # It calls #pretty_print_instance_variables to list instance variables.
    #
    # If +self+ has a customized (redefined) #inspect method,
    # the result of self.inspect is used but it obviously has no
    # line break hints.
    #
    # This module provides predefined #pretty_print methods for some of
    # the most commonly used built-in classes for convenience.
    def pretty_print(q)
      method_method = Object.instance_method(:method).bind(self)
      begin
        inspect_method = method_method.call(:inspect)
      rescue NameError
      end
      begin
        to_s_method = method_method.call(:to_s)
      rescue NameError
      end
      if inspect_method && /$Kernel$#/ !~ inspect_method.inspect
        q.text self.inspect
      elsif !inspect_method && self.respond_to?(:inspect)
        q.text self.inspect
      elsif to_s_method && /$Kernel$#/ !~ to_s_method.inspect
        q.text self.to_s
      elsif !to_s_method && self.respond_to?(:to_s)
        q.text self.to_s
      else
        q.pp_object(self)
      end
    end

# A default pretty printing method for general objects that are
    # detected as part of a cycle.
    def pretty_print_cycle(q)
      q.object_address_group(self) {
        q.breakable
        q.text '...'
      }
    end

# Returns a sorted array of instance variable names.
    #
    # This method should return an array of names of instance variables as symbols or strings as:
    # +[:@a, :@b]+.
    def pretty_print_instance_variables
      instance_variables.sort
    end

# Is #inspect implementation using #pretty_print.
    # If you implement #pretty_print, it can be used as follows.
    #
    #   alias inspect pretty_print_inspect
    #
    # However, doing this requires that every class that #inspect is called on
    # implement #pretty_print, or a RuntimeError will be raised.
    def pretty_print_inspect
      if /$PP::ObjectMixin$#/ =~ Object.instance_method(:method).bind(self).call(:pretty_print).inspect
        raise "pretty_print is not overridden for #{self.class}"
      end
      PP.singleline_pp(self, '')
    end
  end
end

class Array
  def pretty_print(q)
    q.group(1, '[', ']') {
      q.seplist(self) {|v|
        q.pp v
      }
    }
  end

def pretty_print_cycle(q)
    q.text(empty? ? '[]' : '[...]')
  end
end

class Hash
  def pretty_print(q)
    q.pp_hash self
  end

def pretty_print_cycle(q)
    q.text(empty? ? '{}' : '{...}')
  end
end

class << ENV
  def pretty_print(q)
    h = {}
    ENV.keys.sort.each {|k|
      h[k] = ENV[k]
    }
    q.pp_hash h
  end
end

class Struct
  def pretty_print(q)
    q.group(1, sprintf("#<struct %s", PP.mcall(self, Kernel, :class).name), '>') {
      q.seplist(PP.mcall(self, Struct, :members), lambda { q.text "," }) {|member|
        q.breakable
        q.text member.to_s
        q.text '='
        q.group(1) {
          q.breakable ''
          q.pp self[member]
        }
      }
    }
  end

def pretty_print_cycle(q)
    q.text sprintf("#<struct %s:...>", PP.mcall(self, Kernel, :class).name)
  end
end

class Range
  def pretty_print(q)
    q.pp self.begin
    q.breakable ''
    q.text(self.exclude_end? ? '...' : '..')
    q.breakable ''
    q.pp self.end
  end
end

class File < IO
  class Stat
    def pretty_print(q)
      require 'etc.so'
      q.object_group(self) {
        q.breakable
        q.text sprintf("dev=0x%x", self.dev); q.comma_breakable
        q.text "ino="; q.pp self.ino; q.comma_breakable
        q.group {
          m = self.mode
          q.text sprintf("mode=0%o", m)
          q.breakable
          q.text sprintf("(%s %c%c%c%c%c%c%c%c%c)",
            self.ftype,
            (m & 0400 == 0 ? ?- : ?r),
            (m & 0200 == 0 ? ?- : ?w),
            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
                             (m & 04000 == 0 ? ?x : ?s)),
            (m & 0040 == 0 ? ?- : ?r),
            (m & 0020 == 0 ? ?- : ?w),
            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
                             (m & 02000 == 0 ? ?x : ?s)),
            (m & 0004 == 0 ? ?- : ?r),
            (m & 0002 == 0 ? ?- : ?w),
            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
                             (m & 01000 == 0 ? ?x : ?t)))
        }
        q.comma_breakable
        q.text "nlink="; q.pp self.nlink; q.comma_breakable
        q.group {
          q.text "uid="; q.pp self.uid
          begin
            pw = Etc.getpwuid(self.uid)
          rescue ArgumentError
          end
          if pw
            q.breakable; q.text "(#{pw.name})"
          end
        }
        q.comma_breakable
        q.group {
          q.text "gid="; q.pp self.gid
          begin
            gr = Etc.getgrgid(self.gid)
          rescue ArgumentError
          end
          if gr
            q.breakable; q.text "(#{gr.name})"
          end
        }
        q.comma_breakable
        q.group {
          q.text sprintf("rdev=0x%x", self.rdev)
          q.breakable
          q.text sprintf('(%d, %d)', self.rdev_major, self.rdev_minor)
        }
        q.comma_breakable
        q.text "size="; q.pp self.size; q.comma_breakable
        q.text "blksize="; q.pp self.blksize; q.comma_breakable
        q.text "blocks="; q.pp self.blocks; q.comma_breakable
        q.group {
          t = self.atime
          q.text "atime="; q.pp t
          q.breakable; q.text "(#{t.tv_sec})"
        }
        q.comma_breakable
        q.group {
          t = self.mtime
          q.text "mtime="; q.pp t
          q.breakable; q.text "(#{t.tv_sec})"
        }
        q.comma_breakable
        q.group {
          t = self.ctime
          q.text "ctime="; q.pp t
          q.breakable; q.text "(#{t.tv_sec})"
        }
      }
    end
  end
end

class MatchData
  def pretty_print(q)
    nc = []
    self.regexp.named_captures.each {|name, indexes|
      indexes.each {|i| nc[i] = name }
    }
    q.object_group(self) {
      q.breakable
      q.seplist(0...self.size, lambda { q.breakable }) {|i|
        if i == 0
          q.pp self[i]
        else
          if nc[i]
            q.text nc[i]
          else
            q.pp i
          end
          q.text ':'
          q.pp self[i]
        end
      }
    }
  end
end

class Object < BasicObject
  include PP::ObjectMixin
end

[Numeric, Symbol, FalseClass, TrueClass, NilClass, Module].each {|c|
  c.class_eval {
    def pretty_print_cycle(q)
      q.text inspect
    end
  }
}

[Numeric, FalseClass, TrueClass, Module].each {|c|
  c.class_eval {
    def pretty_print(q)
      q.text inspect
    end
  }
}

X7ROOT File Manager

Editing: pp.rb

Upload File

Create Folder