trop 0.0.16 → 0.4.27

data/lib/trop/filefind.rb

@@ -0,0 +1,501 @@
+# frozen_string_literal: false
+
+require 'date'
+
+begin
+  require_relative 'find'
+  require 'sys/admin'
+  require 'win32/file'
+rescue LoadError
+  # Do nothing, not required, just nicer.
+end
+module Trop
+
+  class FileFind
+
+    # The version of the file-find library
+    VERSION = '0.4.1'.freeze
+
+
+    # :stopdoc:
+    VALID_OPTIONS = %w[
+    atime
+    ctime
+    follow
+    ftype
+    inum
+    group
+    links
+    maxdepth
+    mindepth
+    mount
+    mtime
+    name
+    pattern
+    path
+    perm
+    prune
+    size
+    user
+  ]
+    # :startdoc:
+
+    # The starting path(s) for the search. The default is the current directory.
+    # This can be a single path or an array of paths.
+    #
+    attr_accessor :path
+
+    # The list of options passed to the constructor and/or used by the
+    # Trop::Find#find method.
+    #
+    attr_accessor :options
+
+    # Limits searches by file access time, where the value you supply is the
+    # number of days back from the time that the File::Find#find method was
+    # called.
+    #
+    attr_accessor :atime
+
+    # Limits searches by file change time, where the value you supply is the
+    # number of days back from the time that the File::Find#find method was
+    # called.
+    #
+    attr_accessor :ctime
+
+    # Limits searches to files that belong to a specific group, where the
+    # group can be either a group name or ID.
+    #
+    attr_accessor :group
+
+    # An array of two element arrays for storing FileTest methods and their
+    # boolean value.
+    #
+    attr_accessor :filetest
+
+    # Controls the behavior of how symlinks are followed. If set to true (the
+    # default), then follows the file pointed to. If false, it considers the
+    # symlink itself.
+    #
+    attr_accessor :follow
+
+    # Limits searches to specific types of files. The possible values here are
+    # those returned by the File.ftype method.
+    #
+    attr_accessor :ftype
+
+    # Limits search to a file with a specific inode number.
+    #
+    attr_accessor :inum
+
+    # Limits search to files with the specified number of links.
+    #
+    attr_accessor :links
+
+    # Limits search to a maximum depth into the tree relative to the starting
+    # search directory.
+    #
+    attr_accessor :maxdepth
+
+    # Limits searches to a minimum depth into the tree relative to the starting
+    # search directory.
+    #
+    attr_accessor :mindepth
+
+    # Limits searches to the same filesystem as the specified directory. For
+    # Windows users, this refers to the volume.
+    #
+    attr_reader :mount
+
+    # Limits searches by file modification time, where the value you supply is
+    # the number of days back from the time that the File::Find#find method was
+    # called.
+    #
+    attr_accessor :mtime
+
+    # The name pattern used to limit file searches. The patterns that are legal
+    # for Dir.glob are legal here. The default is '*', i.e. everything.
+    #
+    attr_accessor :name
+
+    # Limits searches to files which have permissions that match the octal
+    # value that you provide. For purposes of this comparison, only the user,
+    # group, and world settings are used.
+    #
+    # You may optionally use symbolic permissions, e.g. "g+rw", "u=rwx", etc.
+    #
+    # MS Windows only recognizes two modes, 0644 and 0444.
+    #
+    attr_accessor :perm
+
+    # Skips files or directories that match the string provided as an argument.
+    #
+    attr_accessor :prune
+
+    # If the value passed is an integer, this option limits searches to files
+    # that match the size, in bytes, exactly. If a string is passed, you can
+    # use the standard comparable operators to match files, e.g. ">= 200" would
+    # limit searches to files greater than or equal to 200 bytes.
+    #
+    attr_accessor :size
+
+    # Limits searches to files that belong to a specific user, where the user
+    # can be either a user name or an ID.
+    #
+    attr_accessor :user
+
+    # The file that matched previously in the current search.
+    #
+    attr_reader :previous
+
+    alias pattern name
+    alias pattern= name=
+
+    # Creates and returns a new File::Find object. The options set for this
+    # object serve as the rules for determining what files the File::Find#find
+    # method will search for.
+    #
+    # In addition to the standard list of valid options, you may also use
+    # FileTest methods as options, setting their value to true or false.
+    #
+    # Example:
+    #
+    #    rule = File::Find.new(
+    #       :name      => "*.rb",
+    #       :follow    => false,
+    #       :path      => ['/usr/local/lib', '/opt/local/lib'],
+    #       :readable? => true
+    #    )
+    #
+    def initialize(options = {})
+      @options = options
+
+      @atime = nil
+      @ctime = nil
+      @ftype = nil
+      @group = nil
+      @follow = true
+      @inum = nil
+      @links = nil
+      @mount = nil
+      @mtime = nil
+      @perm = nil
+      @prune = nil
+      @size = nil
+      @user = nil
+
+      @previous = nil
+      @maxdepth = nil
+      @mindepth = nil
+      @filetest = []
+
+      validate_and_set_options(options) unless options.empty?
+
+      @filesystem = File.stat(@mount).dev if @mount
+
+      @path ||= Dir.pwd
+      @name ||= '*'
+    end
+
+    # Executes the find based on the rules you set for the File::Find object.
+    # In block form, yields each file in turn that matches the specified rules.
+    # In non-block form it will return an array of matches instead.
+    #
+    # Example:
+    #
+    #   rule = Trop::Find.new(
+    #      :name    => "*.rb",
+    #      :follow  => false,
+    #      :path    => ['/usr/local/lib', '/opt/local/lib']
+    #   )
+    #
+    #   rule.find{ |f|
+    #      puts f
+    #   }
+    #
+    def find
+      results = [] unless block_given?
+      paths = @path.is_a?(String) ? [@path] : @path # Ruby 1.9.x compatibility
+
+      if @prune
+        prune_regex = Regexp.new(@prune)
+      else
+        prune_regex = nil
+      end
+
+      paths.each {|path|
+        begin
+          Dir.foreach(path) {|file|
+            next if file == '.'
+            next if file == '..'
+
+            if prune_regex
+              next if prune_regex.match(file)
+            end
+
+            file = File.join(path, file)
+
+            stat_method = @follow ? :stat : :lstat
+            # Skip files we cannot access, stale links, etc.
+            begin
+              stat_info = File.send(stat_method, file)
+            rescue Errno::ENOENT, Errno::EACCES
+              next
+            rescue Errno::ELOOP
+              stat_method = :lstat # Handle recursive symlinks
+              retry if stat_method.to_s != 'lstat'
+            end
+
+            # We need to escape any brackets in the directory name.
+            glob = File.join(File.dirname(file).gsub(/([\[\]])/, '\\\\\1'), @name)
+
+            # Dir[] doesn't like backslashes
+            if File::ALT_SEPARATOR
+              file.tr!(File::ALT_SEPARATOR, File::SEPARATOR)
+              glob.tr!(File::ALT_SEPARATOR, File::SEPARATOR)
+            end
+
+            if @mount
+              next unless stat_info.dev == @filesystem
+            end
+
+            if @links
+              next unless stat_info.nlink == @links
+            end
+
+            if @maxdepth || @mindepth
+              file_depth = file.split(File::SEPARATOR).length
+              current_base_path = [@path].flatten.find {|tpath| file.include?(tpath)}
+              path_depth = current_base_path.split(File::SEPARATOR).length
+
+              depth = file_depth - path_depth
+
+              if @maxdepth && (depth > @maxdepth)
+                if File.directory?(file)
+                  unless paths.include?(file) && depth > @maxdepth
+                    paths << file
+                  end
+                end
+
+                next
+              end
+
+              if @mindepth && (depth < @mindepth)
+                if File.directory?(file)
+                  unless paths.include?(file) && depth < @mindepth
+                    paths << file
+                  end
+                end
+
+                next
+              end
+            end
+
+            # Add directories back onto the list of paths to search unless
+            # they've already been added
+            #
+            if stat_info.directory?
+              paths << file unless paths.include?(file)
+            end
+
+            next unless Dir[glob].include?(file)
+
+            unless @filetest.empty?
+              file_test = true
+
+              @filetest.each {|array|
+                meth = array[0]
+                bool = array[1]
+
+                unless File.send(meth, file) == bool
+                  file_test = false
+                  break
+                end
+              }
+
+              next unless file_test
+            end
+
+            if @atime || @ctime || @mtime
+              date1 = Date.parse(Time.now.to_s)
+
+              if @atime
+                date2 = Date.parse(stat_info.atime.to_s)
+                next unless (date1 - date2).numerator == @atime
+              end
+
+              if @ctime
+                date2 = Date.parse(stat_info.ctime.to_s)
+                next unless (date1 - date2).numerator == @ctime
+              end
+
+              if @mtime
+                date2 = Date.parse(stat_info.mtime.to_s)
+                next unless (date1 - date2).numerator == @mtime
+              end
+            end
+
+            if @ftype
+              next unless File.ftype(file) == @ftype
+            end
+
+            if @group
+              if @group.is_a?(String)
+                if File::ALT_SEPARATOR
+                  begin
+                    next unless Sys::Admin.get_group(stat_info.gid, :LocalAccount => true).name == @group
+                  rescue Sys::Admin::Error
+                    next
+                  end
+                else
+                  begin
+                    next unless Sys::Admin.get_group(stat_info.gid).name == @group
+                  rescue Sys::Admin::Error
+                    next
+                  end
+                end
+              else
+                next unless stat_info.gid == @group
+              end
+            end
+
+            if @inum
+              next unless stat_info.ino == @inum
+            end
+
+            # Note that only 0644 and 0444 are supported on MS Windows.
+            if @perm
+              if @perm.is_a?(String)
+                octal_perm = sym2oct(@perm)
+                next unless stat_info.mode & octal_perm == octal_perm
+              else
+                next unless sprintf("%o", stat_info.mode & 07777) == sprintf("%o", @perm)
+              end
+            end
+
+            # Allow plain numbers, or strings for comparison operators.
+            if @size
+              if @size.is_a?(String)
+                regex = /^([><=]+)\s*?(\d+)$/
+                match = regex.match(@size)
+
+                if match.nil? || match.captures.include?(nil)
+                  raise ArgumentError, "invalid size string: '#{@size}'"
+                end
+
+                operator = match.captures.first.strip
+                number = match.captures.last.strip.to_i
+
+                next unless stat_info.size.send(operator, number)
+              else
+                next unless stat_info.size == @size
+              end
+            end
+
+            if @user
+              if @user.is_a?(String)
+                if File::ALT_SEPARATOR
+                  begin
+                    next unless Sys::Admin.get_user(stat_info.uid, :LocalAccount => true).name == @user
+                  rescue Sys::Admin::Error
+                    next
+                  end
+                else
+                  begin
+                    next unless Sys::Admin.get_user(stat_info.uid).name == @user
+                  rescue Sys::Admin::Error
+                    next
+                  end
+                end
+              else
+                next unless stat_info.uid == @user
+              end
+            end
+
+            if block_given?
+              yield file
+            else
+              results << file
+            end
+
+            @previous = file unless @previous == file
+          }
+        rescue Errno::EACCES
+          next # Skip inaccessible directories
+        end
+      }
+
+      block_given? ? nil : results
+    end
+
+    # Limits searches to the same file system as the specified +mount_point+.
+    #
+    def mount=(mount_point)
+      @mount = mount_point
+      @filesystem = File.stat(mount_point).dev
+    end
+
+    private
+
+    # This validates that the keys are valid. If they are, it sets the value
+    # of that key's corresponding method to the given value. If a key ends
+    # with a '?', it's validated as a File method.
+    #
+    def validate_and_set_options(options)
+      options.each do |key, value|
+        key = key.to_s.downcase
+
+        if key[-1].chr == '?'
+          sym = key.to_sym
+
+          unless File.respond_to?(sym)
+            raise ArgumentError, "invalid option '#{key}'"
+          end
+
+          @filetest << [sym, value]
+        else
+          unless VALID_OPTIONS.include?(key)
+            raise ArgumentError, "invalid option '#{key}'"
+          end
+
+          send("#{key}=", value)
+        end
+      end
+    end
+
+    # Converts a symoblic permissions mode into its octal equivalent.
+    #--
+    # Taken almost entirely from ruby-talk: 96956 (Hal Fulton).
+    #
+    def sym2oct(str)
+      left = {'u' => 0700, 'g' => 0070, 'o' => 0007, 'a' => 0777}
+      right = {'r' => 0444, 'w' => 0222, 'x' => 0111}
+      regex = /([ugoa]+)([+-=])([rwx]+)/
+
+      cmds = str.split(',')
+
+      perm = 0
+
+      cmds.each do |cmd|
+        match = cmd.match(regex)
+        raise "Invalid symbolic permissions: '#{str}'" if match.nil?
+
+        who, what, how = match.to_a[1..-1]
+
+        who = who.split(//).inject(0) {|num, b| num |= left[b]; num}
+        how = how.split(//).inject(0) {|num, b| num |= right[b]; num}
+        mask = who & how
+
+        case what
+        when '+'
+          perm = perm | mask
+        when '-'
+          perm = perm & ~mask
+        when '='
+          perm = mask
+        end
+      end
+
+      perm
+    end
+  end
+end

data/lib/trop/infogit.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: false
+
+require_relative 'shell_deb_verb'
+
+module Trop
+  module InfoGit
+    class User
+      attr_accessor :user_name, :user_email
+
+      def initialize
+        @user_name ||= `git config --get --global user.name`
+        @user_mail ||= `git config --get --global user.email`
+      end
+
+      def self.user_name
+        initialize
+        @user_name.chomp!
+      end
+
+      def self.user_mail
+        initialize
+        @user_mail.chomp!
+      end
+
+    end
+
+    class GitProject
+
+      def self.project_git_info(projectdir = '.')
+        Dir.chdir(File.absolute_path(projectdir)) do
+          @project_git_repo = `git config --get remote.origin.url`.chomp
+          @project_git_name = @project_git_repo.to_s.split('/').last.gsub(/.git$/, '') unless @project_git_repo.empty?
+
+          @project_username = `git config --get user.name`.chomp
+          @project_useremail = `git config --get user.email`.chomp
+          puts 'Project repo: #{@project_git_repo}'.blue if Sh.verbose?
+
+          return @project_git_name, @project_git_repo, @project_username, @project_useremail
+        end
+      end
+
+      def self.commit_id
+        commit_id = `git show --format='%H' -q`
+        return commit_id
+      end
+    end
+  end
+end

data/lib/trop/os.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: false
+
+module Trop
+  # OS detection lib
+  class OS
+    # @return  true/false if 'on windows ?'
+    def self.win?
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # @return  true/false if 'on mac?'
+    def self.mac?
+      (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    # @return  true/false if 'on unix?'
+    def self.unix?
+      !::Trop::OS.win?
+    end
+
+    # @return  true/false if 'on tux?'
+    def self.linux?
+      ::Trop::OS.unix? and not ::Trop::OS.mac?
+    end
+
+    # @return  true/false if 'on jruby?'
+    def self.jruby?
+      (RUBY_ENGINE == 'jruby')
+    end
+  end
+end

data/lib/trop/shell_deb_verb.rb

@@ -0,0 +1,61 @@
+
+require 'rake/file_utils_ext'
+require_relative 'core-ext'
+
+#def bash_cmd(cmd)
+#  # sh <<-EOS.strip_heredoc, {verbose: false}
+#  sh <<-EOS << cmd
+#/bin/bash -xeuo pipefail
+#EOS
+#end
+
+# noinspection ALL
+module Trop
+  class Sh
+
+    DEFAULT = false
+    @@verbose = false
+    @@debug = false
+
+    def self.verbose?
+      if Rake::FileUtilsExt.verbose_flag == true || (!ENV['VERBOSE'].nil? && ENV['VERBOSE'] == 'true') || !(ENV['DEBUG'].nil?)
+        @@verbose = true
+      end
+      return !!@@verbose
+    end
+
+    def self.verbose!(mode = true)
+      if mode.false?
+        @@verbose = false
+        ENV['VERBOSE'] = nil
+      else
+        @@verbose = true
+      end
+      return !!@@verbose
+    end
+
+    def self.silent!(mode = true)
+      return !::Trop::Sh.verbose!(!mode)
+    end
+
+    def self.silent?
+      return !(::Trop::Sh.verbose? || ::Trop::Sh.debug?)
+    end
+
+    def self.debug?
+      @@debug = true unless ENV['DEBUG'].nil?
+      @@debug = true if $DEBUG
+      return @@debug
+    end
+
+    def self.debug!(mode = true)
+      if mode.false?
+        @@debug = false
+        ENV['DEBUG'] = nil
+      else
+        @@debug = true
+      end
+      return @@debug
+    end
+  end
+end

data/lib/trop/version.rb

@@ -1,7 +1,3 @@
 module Trop
-  VERSION = '0.1.0'.freeze
-end
-
-module Support
-  VERSION = ::Trop::VERSION
+  VERSION = '0.4.29'
 end