\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5�\D6?\BD�\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2� \00$\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4�\E9\F2�\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// File Manager

File Manager

Path: /opt/chef/embedded/lib/ruby/gems/2.7.0/gems/tins-1.25.0/lib/tins/

Viewing File: find.rb

require 'enumerator'
require 'pathname'
require 'tins/module_group'

module Tins
  module Find
    EXPECTED_STANDARD_ERRORS = ModuleGroup[
      Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP,
      Errno::ENAMETOOLONG
    ]

    class Finder
      module PathExtension
        attr_accessor :finder

        def finder_stat
          finder.protect_from_errors do
            finder.follow_symlinks ? File.stat(self) : File.lstat(self)
          end
        end

        def file
          finder.protect_from_errors do
            File.new(self) if file?
          end
        end

        def file?
          finder.protect_from_errors { s = finder_stat and s.file? }
        end

        def directory?
          finder.protect_from_errors { s = finder_stat and s.directory? }
        end

        def exist?
          finder.protect_from_errors { File.exist?(self) }
        end

        def stat
          finder.protect_from_errors { File.stat(self) }
        end

        def lstat
          finder.protect_from_errors { File.lstat(self) }
        end

        def pathname
          Pathname.new(self)
        end

        def suffix
          pathname.extname[1..-1] || ''
        end
      end

      def initialize(opts = {})
        @show_hidden     = opts.fetch(:show_hidden)     { true }
        @raise_errors    = opts.fetch(:raise_errors)    { false }
        @follow_symlinks = opts.fetch(:follow_symlinks) { true }
        if opts.key?(:visit) && opts.key?(:suffix)
          raise ArgumentError, 'either use visit or suffix argument'
        elsif opts.key?(:visit)
          @visit = opts.fetch(:visit) { -> path { true } }
        elsif opts.key?(:suffix)
          @suffix = Array(opts[:suffix])
          @visit = -> path { @suffix.nil? || @suffix.empty? || @suffix.include?(path.suffix) }
        end
      end

      attr_accessor :show_hidden

      attr_accessor :raise_errors

      attr_accessor :follow_symlinks

      attr_accessor :suffix

      def visit_path?(path)
        if !defined?(@visit) || @visit.nil?
          true
        else
          @visit.(path)
        end
      end

      def find(*paths)
        block_given? or return enum_for(__method__, *paths)
        paths.collect! { |d| d.dup }
        while path = paths.shift
          path = prepare_path(path)
          catch(:prune) do
            stat = path.finder_stat or next
            visit_path?(path) and yield path
            if stat.directory?
              ps = protect_from_errors { Dir.entries(path) } or next
              ps.sort!
              ps.reverse_each do |p|
                next if p == "." or p == ".."
                next if !@show_hidden && p.start_with?('.')
                p = File.join(path, p)
                paths.unshift p
              end
            end
          end
        end
      end

      def prepare_path(path)
        path = path.dup
        path.extend PathExtension
        path.finder = self
        path
      end

      def protect_from_errors(errors = Find::EXPECTED_STANDARD_ERRORS)
        yield
      rescue errors
        raise_errors and raise
        return
      end
    end

    #
    # Calls the associated block with the name of every path and directory
    # listed as arguments, then recursively on their subdirectories, and so on.
    #
    # See the +Find+ module documentation for an example.
    #
    def find(*paths, &block) # :yield: path
      opts = Hash === paths.last ? paths.pop : {}
      Finder.new(opts).find(*paths, &block)
    end

    #
    # Skips the current path or directory, restarting the loop with the next
    # entry. If the current path is a directory, that directory will not be
    # recursively entered. Meaningful only within the block associated with
    # Find::find.
    #
    # See the +Find+ module documentation for an example.
    #
    def prune
      throw :prune
    end

    module_function :find, :prune
  end
end