callsite.py

Go to the documentation of this file.

 
 
import hashlib
import json
import os
import re
from dataclasses import dataclass
from typing import Optional
 
 
 
@dataclass(frozen=True)
class CallsiteIdentity:
    
    rel_path: str
 
    
    lineno: int
 
    
    col_offset: int
 
    
    end_lineno: Optional[int]
 
    
    end_col_offset: Optional[int]
 
    
    call_text: str
 
    
    normalized_call: str
 
    
    def artifactPayload(self):
        return {
            'rel_path': self.rel_path,
            'lineno': self.lineno,
            'col_offset': self.col_offset,
            'end_lineno': self.end_lineno,
            'end_col_offset': self.end_col_offset,
            'normalized_call': self.normalized_call,
        }
 
    
    def artifactHash(self):
        payload = json.dumps(
            self.artifactPayloadartifactPayload(),
            sort_keys=True,
            separators=(',', ':'),
        ).encode('utf-8')
        return hashlib.sha256(payload).hexdigest()
 
    
    def artifactId(self):
        MAX_REL = 64   # max slug length for relative path
        MAX_CALL = 48  # max slug length for call name
        # slugify relative path
        rel_slug = re.sub(r'[^0-9A-Za-z]+', '_', str(self.rel_path)).strip('_').lower()
        rel_slug = re.sub(r'_+', '_', rel_slug)[:MAX_REL].strip('_') or 'source'
        # slugify call name (everything before the first '(')
        call_name = str(self.normalized_call).split('(', 1)[0]
        call_slug = re.sub(r'[^0-9A-Za-z]+', '_', call_name).strip('_').lower()
        call_slug = re.sub(r'_+', '_', call_slug)[:MAX_CALL].strip('_') or 'call'
        return f'{rel_slug}__L{self.lineno}C{self.col_offset}__{call_slug}__{self.artifactHash()}'
 
 
 
@dataclass(frozen=True)
class CallsiteRecord:
    
    identity: CallsiteIdentity
 
    
    artifact_id: str
 
    
    format_api: str
 
    
    parameters: str
 
    
    def toDict(self):
        return {
            'id': self.artifact_id,
            'artifact_hash': self.identity.artifactHash(),
            'rel_path': self.identity.rel_path,
            'lineno': self.identity.lineno,
            'col_offset': self.identity.col_offset,
            'end_lineno': self.identity.end_lineno,
            'end_col_offset': self.identity.end_col_offset,
            'call_text': self.identity.call_text,
            'normalized_call': self.identity.normalized_call,
            'format_api': self.format_api,
            'parameters': self.parameters,
        }
 
 
 
def normalizeCallText(call_text):
    return call_text.replace(' ', '').replace('"', '').replace("'", '')
 
 
 
def normalizeRelPath(file_path, proj_path=None):
    normalized_file = os.path.abspath(file_path).replace('\\', '/')
    if proj_path:
        normalized_root = os.path.abspath(proj_path).replace('\\', '/').rstrip('/')
        try:
            rel_path = os.path.relpath(normalized_file, normalized_root).replace('\\', '/')
            if not rel_path.startswith('..'):
                return rel_path
        except ValueError:
            pass
    return normalized_file
 
 
 
def makeCallsiteRecord(
    file_path,
    call_text,
    format_api,
    parameters,
    lineno,
    col_offset,
    end_lineno=None,
    end_col_offset=None,
    proj_path=None,
):
    identity = CallsiteIdentity(
        rel_path=normalizeRelPath(file_path, proj_path),
        lineno=int(lineno),
        col_offset=int(col_offset),
        end_lineno=end_lineno,
        end_col_offset=end_col_offset,
        call_text=call_text,
        normalized_call=normalizeCallText(call_text),
    )
    record = CallsiteRecord(
        identity=identity,
        artifact_id=identity.artifactId(),
        format_api=format_api,
        parameters=parameters,
    )
    return record.toDict()