k_fileset 0.0.3

data/lib/k_fileset/glob_entry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module KFileset
+  # Glob entry can be used to find <PathEntries> that match a Glob
+  # with optional exclusion patterns and flags
+  class GlobEntry
+    include GlobProps
+
+    def initialize(working_directory, glob, flags, exclusions)
+      @working_directory = working_directory
+      @glob = glob
+      @flags = flags
+      @exclusions = exclusions
+    end
+
+    # Dealing with edge cases:
+    # https://bugs.ruby-lang.org/issues/17280
+
+    def path_entries
+      Dir.chdir(working_directory) do
+        Dir.glob(glob, flags)
+           .reject { |file| exclusions.any? { |pattern| pattern_match?(pattern, file) } }
+           .map do |file|
+          # pathname = Pathname.new(file)
+          # key = pathname.realpath.to_s
+          # key = File.join(key, '.') if file.ends_with?('.')
+          # PathEntry.new(key, pathname, Dir.pwd, file)
+          PathEntry.new(file)
+        end
+      end
+    end
+
+    def match?(absolute_file)
+      # match the inclusion Glob first
+
+      # Using absolute files because two sibling Globs may have different exclusion rules
+      # and the incoming file needs to be tested against the correct Glob and it's exclusions
+      absolute_glob = File.expand_path(glob, path)
+
+      return false unless File.fnmatch?(absolute_glob, absolute_file)
+
+      true
+    end
+
+    private
+
+    def pattern_match?(pattern, file)
+      return pattern.match?(file) if pattern.is_a?(Regexp)
+      return pattern.call(file) if pattern.respond_to?(:call)
+
+      File.fnmatch?(pattern, file) # As String
+    end
+  end
+end
+# File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false : wildcard doesn't match '/' on FNM_PATHNAME
+# File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false : ditto
+# File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false : ditto

data/lib/k_fileset/glob_info.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module KFileset
+  # GlobConfig, GlobBuilder
+  class GlobInfo
+    include GlobProps
+
+    def initialize(glob, exclude = nil, flags = File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      @working_directory = Dir.pwd
+      @glob = Pathname.new(glob).cleanpath.to_s
+      @glob += File::SEPARATOR if glob.end_with?(File::SEPARATOR)
+      @flags = flags
+
+      # absolute_path_glob
+      @exclusions = build_exclusions(exclude)
+    end
+
+    def entry
+      GlobEntry.new(working_directory, glob, flags, exclusions)
+    end
+
+    class << self
+      # rubocop:disable Metrics/AbcSize:
+      def build_glob_entries(glob_infos)
+        glob_entries = []
+
+        glob_infos.each do |glob_info|
+          found = glob_entries.find_index { |entry| entry.working_directory == glob_info.working_directory && entry.glob == glob_info.glob }
+
+          if found
+            glob_entries[found].exclusions = (glob_entries[found].exclusions + glob_info.exclusions).uniq
+          else
+            glob_entries << GlobEntry.new(glob_info.working_directory, glob_info.glob, glob_info.flags, glob_info.exclusions)
+          end
+        end
+        glob_entries
+      end
+      # rubocop:enable Metrics/AbcSize:
+    end
+
+    private
+
+    # Handles String based Glob, Regexp pattern or lambda expression
+    def build_exclusions(exclude)
+      return [] if exclude.nil?
+      return [exclude] if valid_exclusion?(exclude)
+
+      exclude.select { |ex| valid_exclusion?(ex) }
+    end
+
+    def valid_exclusion?(exclusion)
+      exclusion.is_a?(String) || exclusion.is_a?(Regexp) || exclusion.respond_to?(:call)
+    end
+  end
+end

data/lib/k_fileset/glob_props.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KFileset
+  module GlobProps
+    attr_accessor :working_directory
+    attr_accessor :glob
+    attr_accessor :exclusions
+    attr_accessor :flags
+  end
+end

data/lib/k_fileset/path_entry.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module KFileset
+  # PathEntry is a (RUBY) Pathname object with some extra properties
+  class PathEntry < Pathname
+    include KLog::Logging
+    # unique absolute path name e.g.(/abc, /abc/.)
+    # attr_reader :key
+    # attr_reader :path_name # Pathname
+    attr_reader :working_directory
+
+    # attr_reader :relative_path
+
+    # _path_name,
+    def initialize(path)
+      super(path)
+      # @key = realpath.to_s
+      # @key = File.join(@key, '.') if pathname.ends_with?('.')
+      # puts @key
+      # @path_name = path_name
+      @working_directory = Dir.getwd
+      # @pathname = pathname
+      # debug
+    end
+
+    def key
+      return @key if defined? @key
+
+      @key = begin
+        key = realpath.to_s
+        key = File.join(key, '.') if basename.to_s == '.' # if pathname.ends_with?('.')
+        key
+      end
+    end
+
+    # Realpath (is the absolute path of the entry)
+    #
+    # The Realpath is based on the current directory at the time this entry was created
+    # def realpath
+    #   path_name.realpath(working_directory).to_s
+    # end
+
+    def path
+      realpath.to_s
+    end
+
+    def debug
+      # puts "expand_path   : #{self.expand_path.to_s}"
+      # puts "realdirpath   : #{self.realdirpath.to_s}"
+      # puts "realpath      : #{self.realpath.to_s}"
+      # puts "extname       : #{self.extname.to_s}"
+      # puts "basename      : #{self.basename.to_s}"
+      # puts "dirname       : #{self.dirname.to_s}"
+      # puts "to_path       : #{self.to_path.to_s}"
+      # puts "parent        : #{self.parent.to_s}"
+      # log.line
+      log.kv 'key', key
+      log.kv 'working_directory', working_directory
+      log.kv 'pathname', path
+
+      log.kv 'to_path', to_path
+      log.kv 'cleanpath', cleanpath
+
+      # log.kv 'directory?', directory?
+      # log.kv 'root?', root?
+      # log.kv 'absolute?', absolute?
+      # log.kv 'relative?', relative?
+      # log.kv 'exist?', exist?
+      # log.kv 'file?', file?
+      # log.kv 'size?', size?
+      # log.kv 'ftype', ftype
+      # log.kv 'empty?', empty?
+      # log.kv 'readable?', readable?
+      # log.kv 'birthtime', birthtime
+      # log.kv 'expand_path', expand_path
+      # log.kv 'realdirpath', realdirpath
+      # log.kv 'realpath', realpath
+      # log.kv 'extname', extname
+      # log.kv 'basename', basename
+      # log.kv 'dirname', dirname
+      # log.kv 'to_path', to_path
+      # log.kv 'size', size
+
+      log.line
+    end
+  end
+end
+
+# relative_path() if its in two places
+
+# Useful Pathname methods
+#
+# p.directory?
+# p.root?
+# p.absolute?
+# p.relative?
+# p.exist?
+# p.file?
+# p.size?
+# p.zero?
+# p.ftype
+# p.empty?
+# p.each_line
+# p.read
+# p.readlines
+
+# p.readable?
+# p.birthtime
+
+# p.join
+# p.mkpath
+# p.find
+# p.entries
+# p.stat
+# p.each_entry
+# p.relative_path_from
+
+# p.expand_path
+# p.realdirpath
+# p.realpath
+# p.extname
+# p.basename
+# p.dirname
+# p.relative_path_from
+# p.to_path
+# p.parent
+# p.split
+# p.size
+# p.cleanpath
+# p.children
+# p.mkdir
+# p.rmdir
+# p.glob
+# p.fnmatch
+# p.fnmatch?
+# p.delete
+# p.each_filename
+# p.each_line
+
+# p.read
+# p.readlines

data/lib/k_fileset/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module KFileset
+  VERSION = '0.0.3'
+end

data/lib/k_fileset/whitelist.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module KFileset
+  # Whitelist rules around including of files with optional exclusion rules
+  class Whitelist
+    def initialize
+      @glob_entries = nil     # glob_entries
+      @globs = []             # glob_infos /
+    end
+
+    def path_entries
+      glob_entries.flat_map(&:path_entries)
+    end
+
+    def add(glob, exclude = nil, flags = nil)
+      flags ||= FileSet::DEF_FLAGS
+      @glob_entries = nil
+      @globs << KFileset::GlobInfo.new(glob, exclude, flags)
+
+      self
+    end
+
+    def clear
+      @glob_entries = nil
+      @globs = []
+
+      self
+    end
+
+    # Return true if file is matched against an entry in the whitelist
+    def match?(file)
+      glob_entries.any? { |entry| entry.match?(file) }
+    end
+
+    # Return GlobInfo entries with the directory, glob and exclusions
+    #
+    # Will denormalize the entries where matching (path and glob), whilst expanding with any new exclusions.
+    def glob_entries
+      @glob_entries ||= KFileset::GlobInfo.build_glob_entries(@globs)
+    end
+
+    # def glob_entries
+    #   @glob_entries ||= begin
+    #     glob_entries = []
+
+    #     @globs.each do |glob|
+    #       # found = glob_entries.find_index { |entry| entry.path == glob.absolute_path && entry.glob == glob.absolute_glob }
+    #       found = glob_entries.find_index { |entry| entry.path == glob.path && entry.glob == glob.glob }
+
+    #       if found
+    #         glob_entries[found].exclusions = (glob_entries[found].exclusions + glob.exclusions).uniq
+    #       else
+    #         glob_entries << glob.entry
+    #       end
+    #     end
+    #     glob_entries
+    #   end
+
+    #   @glob_entries
+    # end
+  end
+end

data/lib/k_fileset.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'k_log'
+require 'k_fileset/version'
+require 'k_fileset/whitelist'
+require 'k_fileset/path_entry'
+require 'k_fileset/glob_props'
+require 'k_fileset/glob_entry'
+require 'k_fileset/glob_info'
+require 'k_fileset/file_set'
+
+module KFileset
+  # raise KFileset::Error, 'Sample message'
+  class Error < StandardError; end
+
+  # Your code goes here...
+end
+
+if ENV['KLUE_DEBUG']&.to_s&.downcase == 'true'
+  namespace = 'KFileset::Version'
+  file_path = $LOADED_FEATURES.find { |f| f.include?('k_fileset/version') }
+  version = KFileset::VERSION.ljust(9)
+  puts "#{namespace.ljust(35)} : #{version.ljust(9)} : #{file_path}"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: k_fileset
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- David Cruwys
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: k_log
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+description: "    K-Fileset provides file system snapshot using GLOB inclusions and
+  exclusions\n"
+email:
+- david@ideasmen.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- STORIES.md
+- USAGE.md
+- bin/console
+- bin/k
+- bin/kgitsync
+- bin/khotfix
+- bin/setup
+- hooks/pre-commit
+- hooks/update-version
+- k_fileset.gemspec
+- lib/k_fileset.rb
+- lib/k_fileset/file_set.rb
+- lib/k_fileset/file_set_examples.rb
+- lib/k_fileset/glob_entry.rb
+- lib/k_fileset/glob_info.rb
+- lib/k_fileset/glob_props.rb
+- lib/k_fileset/path_entry.rb
+- lib/k_fileset/version.rb
+- lib/k_fileset/whitelist.rb
+homepage: http://appydave.com/gems/k-fileset
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://appydave.com/gems/k-fileset
+  source_code_uri: https://github.com/klueless-io/k_fileset
+  changelog_uri: https://github.com/klueless-io/k_fileset/commits/master
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.7
+signing_key:
+specification_version: 4
+summary: K-Fileset provides file system snapshot using GLOB inclusions and exclusions
+test_files: []