file_query_text 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

file_query_text/__init__.py

@@ -2,4 +2,4 @@
 SQL-like interface for querying files in your filesystem.
 """
 
-__version__ = "0.1.5"
+__version__ = "0.1.7"

file_query_text/cli.py

@@ -5,6 +5,7 @@ import argparse
 from pathlib import Path
 # Fix imports to work when installed as a package
 from file_query_text.main import parse_query, QueryVisitor, execute_query, get_file_attributes
+from file_query_text import __version__
 
 def main():
     parser = argparse.ArgumentParser(description="SQL-like queries for your filesystem")
@@ -30,6 +31,12 @@ def main():
         action="store_true",
         help="Show hidden files (starting with a dot)"
     )
+    parser.add_argument(
+        "--version", "-v",
+        action="version",
+        version=f"file_query_text {__version__}",
+        help="Show the version and exit"
+    )
     args = parser.parse_args()
 
     # Get current working directory for the query

file_query_text/gitignore_parser.py

@@ -0,0 +1,224 @@
+import collections
+import os
+import re
+
+from os.path import abspath, dirname, join
+from pathlib import Path
+from typing import Reversible, Union
+
+def handle_negation(file_path, rules: Reversible["IgnoreRule"]):
+    for rule in reversed(rules):
+        if rule.match(file_path):
+            return not rule.negation
+    return False
+
+def parse_gitignore(full_path, base_dir=None):
+    if base_dir is None:
+        base_dir = dirname(full_path)
+    with open(full_path) as ignore_file:
+        return _parse_gitignore_lines(ignore_file, full_path, base_dir)
+
+def parse_gitignore_str(gitignore_str, base_dir):
+    full_path = join(base_dir, '.gitignore')
+    lines = gitignore_str.splitlines()
+    return _parse_gitignore_lines(lines, full_path, base_dir)
+
+def _parse_gitignore_lines(lines, full_path, base_dir):
+    base_dir = _normalize_path(base_dir)
+    rules = []
+    for line_no, line in enumerate(lines, start=1):
+        rule = rule_from_pattern(
+            line.rstrip('\n'), base_path=base_dir, source=(full_path, line_no))
+        if rule:
+            rules.append(rule)
+    if not any(r.negation for r in rules):
+        return lambda file_path: any(r.match(file_path) for r in rules)
+    else:
+        # We have negation rules. We can't use a simple "any" to evaluate them.
+        # Later rules override earlier rules.
+        return lambda file_path: handle_negation(file_path, rules)
+
+def rule_from_pattern(pattern, base_path=None, source=None):
+    """
+    Take a .gitignore match pattern, such as "*.py[cod]" or "**/*.bak",
+    and return an IgnoreRule suitable for matching against files and
+    directories. Patterns which do not match files, such as comments
+    and blank lines, will return None.
+    Because git allows for nested .gitignore files, a base_path value
+    is required for correct behavior. The base path should be absolute.
+    """
+    # Store the exact pattern for our repr and string functions
+    orig_pattern = pattern
+    # Early returns follow
+    # Discard comments and separators
+    if pattern.strip() == '' or pattern[0] == '#':
+        return
+    # Strip leading bang before examining double asterisks
+    if pattern[0] == '!':
+        negation = True
+        pattern = pattern[1:]
+    else:
+        negation = False
+    # Multi-asterisks not surrounded by slashes (or at the start/end) should
+    # be treated like single-asterisks.
+    pattern = re.sub(r'([^/])\*{2,}', r'\1*', pattern)
+    pattern = re.sub(r'\*{2,}([^/])', r'*\1', pattern)
+
+    # Special-casing '/', which doesn't match any files or directories
+    if pattern.rstrip() == '/':
+        return
+
+    directory_only = pattern[-1] == '/'
+    # A slash is a sign that we're tied to the base_path of our rule
+    # set.
+    anchored = '/' in pattern[:-1]
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[0] == '*' and len(pattern) >= 2 and pattern[1] == '*':
+        pattern = pattern[2:]
+        anchored = False
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[-1] == '/':
+        pattern = pattern[:-1]
+    # patterns with leading hashes or exclamation marks are escaped with a
+    # backslash in front, unescape it
+    if pattern[0] == '\\' and pattern[1] in ('#', '!'):
+        pattern = pattern[1:]
+    # trailing spaces are ignored unless they are escaped with a backslash
+    i = len(pattern)-1
+    striptrailingspaces = True
+    while i > 1 and pattern[i] == ' ':
+        if pattern[i-1] == '\\':
+            pattern = pattern[:i-1] + pattern[i:]
+            i = i - 1
+            striptrailingspaces = False
+        else:
+            if striptrailingspaces:
+                pattern = pattern[:i]
+        i = i - 1
+    regex = fnmatch_pathname_to_regex(
+        pattern, directory_only, negation, anchored=bool(anchored)
+    )
+    return IgnoreRule(
+        pattern=orig_pattern,
+        regex=regex,
+        negation=negation,
+        directory_only=directory_only,
+        anchored=anchored,
+        base_path=base_path if base_path else None,
+        source=source
+    )
+
+
+IGNORE_RULE_FIELDS = [
+    'pattern', 'regex',  # Basic values
+    'negation', 'directory_only', 'anchored',  # Behavior flags
+    'base_path',  # Meaningful for gitignore-style behavior
+    'source'  # (file, line) tuple for reporting
+]
+
+
+class IgnoreRule(collections.namedtuple('IgnoreRule_', IGNORE_RULE_FIELDS)):
+    def __str__(self):
+        return self.pattern
+
+    def __repr__(self):
+        return ''.join(['IgnoreRule(\'', self.pattern, '\')'])
+
+    def match(self, abs_path: Union[str, Path]):
+        matched = False
+        if self.base_path:
+            rel_path = str(_normalize_path(abs_path).relative_to(self.base_path))
+        else:
+            rel_path = str(_normalize_path(abs_path))
+        # Path() strips the trailing slash, so we need to preserve it
+        # in case of directory-only negation
+        if self.negation and type(abs_path) == str and abs_path[-1] == '/':
+            rel_path += '/'
+        if rel_path.startswith('./'):
+            rel_path = rel_path[2:]
+        if re.search(self.regex, rel_path):
+            matched = True
+        return matched
+
+
+# Frustratingly, python's fnmatch doesn't provide the FNM_PATHNAME
+# option that .gitignore's behavior depends on.
+def fnmatch_pathname_to_regex(
+    pattern, directory_only: bool, negation: bool, anchored: bool = False
+):
+    """
+    Implements fnmatch style-behavior, as though with FNM_PATHNAME flagged;
+    the path separator will not match shell-style '*' and '.' wildcards.
+    """
+    i, n = 0, len(pattern)
+
+    seps = [re.escape(os.sep)]
+    if os.altsep is not None:
+        seps.append(re.escape(os.altsep))
+    seps_group = '[' + '|'.join(seps) + ']'
+    nonsep = r'[^{}]'.format('|'.join(seps))
+
+    res = []
+    while i < n:
+        c = pattern[i]
+        i += 1
+        if c == '*':
+            try:
+                if pattern[i] == '*':
+                    i += 1
+                    if i < n and pattern[i] == '/':
+                        i += 1
+                        res.append(''.join(['(.*', seps_group, ')?']))
+                    else:
+                        res.append('.*')
+                else:
+                    res.append(''.join([nonsep, '*']))
+            except IndexError:
+                res.append(''.join([nonsep, '*']))
+        elif c == '?':
+            res.append(nonsep)
+        elif c == '/':
+            res.append(seps_group)
+        elif c == '[':
+            j = i
+            if j < n and pattern[j] == '!':
+                j += 1
+            if j < n and pattern[j] == ']':
+                j += 1
+            while j < n and pattern[j] != ']':
+                j += 1
+            if j >= n:
+                res.append('\\[')
+            else:
+                stuff = pattern[i:j].replace('\\', '\\\\').replace('/', '')
+                i = j + 1
+                if stuff[0] == '!':
+                    stuff = ''.join(['^', stuff[1:]])
+                elif stuff[0] == '^':
+                    stuff = ''.join('\\' + stuff)
+                res.append('[{}]'.format(stuff))
+        else:
+            res.append(re.escape(c))
+    if anchored:
+        res.insert(0, '^')
+    else:
+        res.insert(0, f"(^|{seps_group})")
+    if not directory_only:
+        res.append('($|\\/.*$)')
+    elif directory_only and negation:
+        res.append('/$')
+    else:
+        res.append('($|\\/)')
+    return ''.join(res)
+
+
+def _normalize_path(path: Union[str, Path]) -> Path:
+    """Normalize a path without resolving symlinks.
+
+    This is equivalent to `Path.resolve()` except that it does not resolve symlinks.
+    Note that this simplifies paths by removing double slashes, `..`, `.` etc. like
+    `Path.resolve()` does.
+    """
+    return Path(abspath(path))

file_query_text/main.py

@@ -1,7 +1,7 @@
 import os
 import sys
 from file_query_text.grammar import query  # Import the fixed grammar
-import gitignore_parser
+import file_query_text.gitignore_parser as gitignore_parser
 import os.path
 
 

{file_query_text-0.1.5.dist-info → file_query_text-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: file_query_text
-Version: 0.1.5
+Version: 0.1.7
 Summary: SQL-like interface for querying files in your filesystem
 Author-email: nik <42a11b@nikdav.is>
 License-Expression: MIT
@@ -11,7 +11,6 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: pyparsing>=3.2.3
-Requires-Dist: gitignore-parser>=0.1.12
 Provides-Extra: dev
 Requires-Dist: pytest>=8.3.5; extra == "dev"
 

file_query_text-0.1.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+file_query_text/__init__.py,sha256=0koRSyAOr7mcK_M2meJyNhIJ9Bu-dOUa-wR1SJdXvw4,89
+file_query_text/cli.py,sha256=eijCT1pHk4wtBhhmFHyeTOoLNz0zwk7Bm4izRLrjZb4,3709
+file_query_text/gitignore_parser.py,sha256=PZk5MKyW5e8NXCyfC8w3r2JIp1HeF5CpZ5MdXOWlPNM,7734
+file_query_text/grammar.py,sha256=XanSi9VCKuIQNlOMXRBZbeWxaJj2UhMJPDIYKgw4lEQ,1655
+file_query_text/main.py,sha256=PQGwULcO0R8MxMcWcyjcXbH6UyZZAgNOML2zACVVZu4,7060
+file_query_text-0.1.7.dist-info/METADATA,sha256=gx0dg_yfDf1x94hDMIDB4qwLb3Gsi03c_KslaM1GS_A,2440
+file_query_text-0.1.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+file_query_text-0.1.7.dist-info/entry_points.txt,sha256=rNFYWzvcIsUZkGNsc_E_B5HyYRnqqdj_u8_IeQpw1wo,48
+file_query_text-0.1.7.dist-info/top_level.txt,sha256=o1FzSvLa6kSV61b7RLHWRhEezc96m05YwIKqjuWUSxU,16
+file_query_text-0.1.7.dist-info/RECORD,,

file_query_text-0.1.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-file_query_text/__init__.py,sha256=TR6o-sOsqfd8VfdEVBpdzVzQbFEzBzcOJR8IC3YuYVw,89
-file_query_text/cli.py,sha256=EEhvQXPOd9j_SixosrNbf1ZWnmno6ywkcEaVoCVv79U,3494
-file_query_text/grammar.py,sha256=XanSi9VCKuIQNlOMXRBZbeWxaJj2UhMJPDIYKgw4lEQ,1655
-file_query_text/main.py,sha256=YUdNijSm_iIcb2rkdKtDsE0Jl2tVbGi0J3G-bSO5_J0,7024
-file_query_text-0.1.5.dist-info/METADATA,sha256=IaXuonSrI6hdAY-WMJLuPH17Co0v8G9H9JsH7Gbf5jo,2480
-file_query_text-0.1.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-file_query_text-0.1.5.dist-info/entry_points.txt,sha256=rNFYWzvcIsUZkGNsc_E_B5HyYRnqqdj_u8_IeQpw1wo,48
-file_query_text-0.1.5.dist-info/top_level.txt,sha256=o1FzSvLa6kSV61b7RLHWRhEezc96m05YwIKqjuWUSxU,16
-file_query_text-0.1.5.dist-info/RECORD,,