CSS cleaner: ottimizzazione automatica dei file CSS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

PROBLEMI COMUNI:
├── File CSS gonfiati (fino a 80% di codice inutile)
├── Tempi di caricamento lenti
├── Bandwidth sprecato
├── Core Web Vitals peggiori
└── SEO ranking inferiore

BENEFICI CSS CLEANING:
├── Riduzione dimensione file (30-80%)
├── First Contentful Paint piu rapido
├── Largest Contentful Paint migliorato
├── Time to Interactive ridotto
└── Migliori performance SEO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Crea virtual environment
python -m venv css_cleaner_env
source css_cleaner_env/bin/activate  # Linux/Mac
# css_cleaner_env\Scripts\activate  # Windows

# Installa dipendenze base
pip install beautifulsoup4 lxml cssutils tinycss2

# Dipendenze avanzate
pip install click rich colorama watchdog
pip install selenium webdriver-manager  # Per JS-generated content
pip install flask flask-cors  # Per web interface
pip install tkinter-modern  # Per GUI moderna

# Development tools
pip install black pytest coverage mypy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

css-cleaner/
├── src/
│   ├── __init__.py
│   ├── core/
│   │   ├── __init__.py
│   │   ├── html_parser.py
│   │   ├── css_parser.py
│   │   └── optimizer.py
│   ├── interfaces/
│   │   ├── cli.py
│   │   ├── gui.py
│   │   └── web_app.py
│   └── utils/
│       ├── __init__.py
│       ├── logger.py
│       └── performance.py
├── tests/
├── examples/
├── docs/
└── requirements.txt

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

#!/usr/bin/env python3
"""
CSS Cleaner - Advanced Version
Rimuove automaticamente regole CSS non utilizzate
"""

import os
import re
import logging
from typing import Set, List, Dict, Tuple
from pathlib import Path
from dataclasses import dataclass
from bs4 import BeautifulSoup, Comment
import cssutils
from urllib.parse import urljoin, urlparse

@dataclass
class CleaningStats:
    """Statistiche del processo di pulizia"""
    original_size: int
    cleaned_size: int
    rules_removed: int
    rules_kept: int
    selectors_found: int
    files_processed: int

class CSSCleaner:
    """CSS Cleaner con funzionalità avanzate"""

    def __init__(self, html_dir: str, css_dir: str, output_dir: str = None):
        self.html_dir = Path(html_dir)
        self.css_dir = Path(css_dir)
        self.output_dir = Path(output_dir) if output_dir else self.css_dir
        self.used_selectors: Set[str] = set()
        self.stats = CleaningStats(0, 0, 0, 0, 0, 0)

        # Imposta logging
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)

        # Configurazione CSS parser
        cssutils.log.setLevel(logging.CRITICAL)  # Silenzia warning CSS

    def extract_selectors_from_html(self) -> Set[str]:
        """Estrae tutti i selettori utilizzati dai file HTML"""
        selectors = set()

        # Pattern per attributi class e id
        class_pattern = re.compile(r'class\s*=\s*["\']([^"\']+)["\']', re.IGNORECASE)
        id_pattern = re.compile(r'id\s*=\s*["\']([^"\']+)["\']', re.IGNORECASE)

        # Pattern per selettori in JavaScript
        js_selector_patterns = [
            re.compile(r'document\.querySelector\(["\']([^"\']+)["\']\)'),
            re.compile(r'document\.querySelectorAll\(["\']([^"\']+)["\']\)'),
            re.compile(r'jQuery\(["\']([^"\']+)["\']\)'),
            re.compile(r'\$\(["\']([^"\']+)["\']\)'),
            re.compile(r'getElementsByClassName\(["\']([^"\']+)["\']\)'),
            re.compile(r'getElementById\(["\']([^"\']+)["\']\)'),
        ]

        for html_file in self.html_dir.rglob("*.html"):
            try:
                with open(html_file, 'r', encoding='utf-8') as f:
                    content = f.read()

                # Parse HTML con BeautifulSoup
                soup = BeautifulSoup(content, 'html.parser')

                # Rimuovi commenti HTML
                for comment in soup.find_all(string=lambda text: isinstance(text, Comment)):
                    comment.extract()

                # Estrai classi e ID da attributi HTML
                for element in soup.find_all():
                    # Classi CSS
                    if element.get('class'):
                        classes = element.get('class')
                        if isinstance(classes, list):
                            classes = ' '.join(classes)
                        for css_class in classes.split():
                            selectors.add(f".{css_class}")

                    # ID CSS
                    if element.get('id'):
                        selectors.add(f"#{element.get('id')}")

                    # Data attributes che potrebbero essere usati come selettori
                    for attr in element.attrs:
                        if attr.startswith('data-'):
                            selectors.add(f"[{attr}]")

                # Cerca selettori in JavaScript inline
                script_tags = soup.find_all('script')
                for script in script_tags:
                    if script.string:
                        for pattern in js_selector_patterns:
                            matches = pattern.findall(script.string)
                            for match in matches:
                                selectors.add(match)

                # Cerca selettori nel contenuto raw (per pattern complessi)
                class_matches = class_pattern.findall(content)
                for match in class_matches:
                    for css_class in match.split():
                        selectors.add(f".{css_class}")

                id_matches = id_pattern.findall(content)
                for match in id_matches:
                    selectors.add(f"#{match}")

                self.stats.files_processed += 1
                self.logger.info(f"Processed HTML: {html_file}")

            except Exception as e:
                self.logger.error(f"Errore durante l'elaborazione di {html_file}: {e}")

        self.stats.selectors_found = len(selectors)
        self.logger.info(f"Trovati {len(selectors)} selettori unici")
        return selectors

    def is_selector_used(self, selector: str) -> bool:
        """Verifica se un selettore CSS è utilizzato"""
        selector = selector.strip()

        # Selettori universali sempre mantenuti
        universal_selectors = ['*', 'html', 'body', ':root']
        if selector in universal_selectors:
            return True

        # Pseudo-elementi e pseudo-classi comuni
        if any(pseudo in selector for pseudo in [':hover', ':focus', ':active', ':visited',
                                                ':before', ':after', ':first-child', ':last-child']):
            base_selector = re.sub(r':[a-zA-Z-]+(\([^)]*\))?', '', selector)
            return base_selector in self.used_selectors or selector in self.used_selectors

        # Media query prefixes
        if selector.startswith('@'):
            return True

        # Verifica diretta
        if selector in self.used_selectors:
            return True

        # Verifica selettori composti (es: .class1.class2)
        if '.' in selector and selector.count('.') > 1:
            classes = [f".{cls}" for cls in selector.replace('.', ' ').split() if cls]
            return any(cls in self.used_selectors for cls in classes)

        # Verifica selettori discendenti (es: .parent .child)
        if ' ' in selector:
            parts = [part.strip() for part in selector.split()]
            return any(part in self.used_selectors for part in parts)

        return False

    def clean_css_file(self, css_file: Path) -> Tuple[str, int, int]:
        """Pulisce un singolo file CSS"""
        try:
            with open(css_file, 'r', encoding='utf-8') as f:
                css_content = f.read()

            original_size = len(css_content)
            self.stats.original_size += original_size

            # Parse CSS con cssutils per handling più robusto
            sheet = cssutils.parseString(css_content)
            cleaned_rules = []
            rules_kept = 0
            rules_removed = 0

            for rule in sheet:
                if rule.type == rule.STYLE_RULE:
                    # Analizza ogni selettore nella regola
                    selectors = [s.selectorText.strip() for s in rule.selectorList]
                    used_selectors = [s for s in selectors if self.is_selector_used(s)]

                    if used_selectors:
                        # Ricostruisci la regola solo con selettori utilizzati
                        rule.selectorText = ', '.join(used_selectors)
                        cleaned_rules.append(rule.cssText)
                        rules_kept += 1
                    else:
                        rules_removed += 1

                elif rule.type in [rule.MEDIA_RULE, rule.KEYFRAMES_RULE, rule.FONT_FACE_RULE]:
                    # Mantieni media queries, keyframes e font-face
                    cleaned_rules.append(rule.cssText)
                    rules_kept += 1

                elif rule.type == rule.IMPORT_RULE:
                    # Mantieni import rules
                    cleaned_rules.append(rule.cssText)
                    rules_kept += 1

            cleaned_css = '\n'.join(cleaned_rules)
            cleaned_size = len(cleaned_css)

            self.stats.cleaned_size += cleaned_size
            self.stats.rules_kept += rules_kept
            self.stats.rules_removed += rules_removed

            return cleaned_css, rules_kept, rules_removed

        except Exception as e:
            self.logger.error(f"Errore durante la pulizia del file CSS {css_file}: {e}")
            return "", 0, 0

    def process_all_css(self, backup: bool = True) -> CleaningStats:
        """Processa tutti i file CSS"""
        self.used_selectors = self.extract_selectors_from_html()

        if backup:
            self.create_backup()

        css_files = list(self.css_dir.rglob("*.css"))
        self.logger.info(f"Elaborazione di {len(css_files)} file CSS")

        for css_file in css_files:
            cleaned_css, kept, removed = self.clean_css_file(css_file)

            if cleaned_css:
                output_file = self.output_dir / css_file.relative_to(self.css_dir)
                output_file.parent.mkdir(parents=True, exist_ok=True)

                with open(output_file, 'w', encoding='utf-8') as f:
                    f.write(cleaned_css)

                self.logger.info(f"Cleaned {css_file}: {kept} kept, {removed} removed")

        return self.stats

    def create_backup(self):
        """Crea backup dei file CSS originali"""
        import shutil
        from datetime import datetime

        backup_dir = self.css_dir.parent / f"css_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        backup_dir.mkdir(exist_ok=True)

        for css_file in self.css_dir.rglob("*.css"):
            relative_path = css_file.relative_to(self.css_dir)
            backup_file = backup_dir / relative_path
            backup_file.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(css_file, backup_file)

        self.logger.info(f"Backup created: {backup_dir}")

    def generate_report(self) -> str:
        """Genera report dettagliato della pulizia"""
        if self.stats.original_size == 0:
            return "Nessun file elaborato"

        reduction_percent = ((self.stats.original_size - self.stats.cleaned_size) /
                           self.stats.original_size) * 100

        report = f"""
Report pulizia CSS
==================
Files processed: {self.stats.files_processed} HTML, {len(list(self.css_dir.rglob('*.css')))} CSS
Selectors found: {self.stats.selectors_found}
Original size: {self.stats.original_size:,} bytes ({self.stats.original_size/1024:.1f} KB)
Cleaned size: {self.stats.cleaned_size:,} bytes ({self.stats.cleaned_size/1024:.1f} KB)
Size reduction: {self.stats.original_size - self.stats.cleaned_size:,} bytes ({reduction_percent:.1f}%)
Rules kept: {self.stats.rules_kept}
Rules removed: {self.stats.rules_removed}
Removal rate: {(self.stats.rules_removed/(self.stats.rules_kept + self.stats.rules_removed)*100):.1f}%
"""
        return report

# Esempio di utilizzo
if __name__ == "__main__":
    import sys

    if len(sys.argv) < 3:
        print("Uso: python css_cleaner.py <html_dir> <css_dir> [output_dir]")
        sys.exit(1)

    html_dir = sys.argv[1]
    css_dir = sys.argv[2]
    output_dir = sys.argv[3] if len(sys.argv) > 3 else None

    cleaner = CSSCleaner(html_dir, css_dir, output_dir)
    stats = cleaner.process_all_css()

    print(cleaner.generate_report())

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#!/usr/bin/env python3
"""
Test suite per CSS Cleaner
"""

import pytest
import tempfile
import shutil
from pathlib import Path
from css_cleaner import CSSCleaner

class TestCSSCleaner:

    @pytest.fixture
    def temp_dirs(self):
        """Crea directory temporanee per i test"""
        temp_dir = Path(tempfile.mkdtemp())
        html_dir = temp_dir / "html"
        css_dir = temp_dir / "css"
        html_dir.mkdir()
        css_dir.mkdir()

        yield html_dir, css_dir

        shutil.rmtree(temp_dir)

    def test_basic_cleaning(self, temp_dirs):
        """Test pulizia base CSS"""
        html_dir, css_dir = temp_dirs

        # Crea file HTML di test
        html_content = '''
        <html>
        <body>
            <div class="used-class">Content</div>
            <p id="used-id">Paragraph</p>
        </body>
        </html>
        '''

        # Crea file CSS di test
        css_content = '''
        .used-class { color: red; }
        .unused-class { color: blue; }
        #used-id { font-size: 16px; }
        #unused-id { font-size: 14px; }
        '''

        (html_dir / "test.html").write_text(html_content)
        (css_dir / "test.css").write_text(css_content)

        # Esegui pulizia
        cleaner = CSSCleaner(str(html_dir), str(css_dir))
        stats = cleaner.process_all_css(backup=False)

        # Verifica risultati
        cleaned_css = (css_dir / "test.css").read_text()

        assert ".used-class" in cleaned_css
        assert "#used-id" in cleaned_css
        assert ".unused-class" not in cleaned_css
        assert "#unused-id" not in cleaned_css
        assert stats.rules_removed == 2
        assert stats.rules_kept == 2

    def test_javascript_selectors(self, temp_dirs):
        """Test riconoscimento selettori in JavaScript"""
        html_dir, css_dir = temp_dirs

        html_content = '''
        <html>
        <head>
            <script>
                document.querySelector('.js-class');
                $('#jquery-id').hide();
            </script>
        </head>
        <body></body>
        </html>
        '''

        css_content = '''
        .js-class { color: red; }
        #jquery-id { display: block; }
        .unused { color: blue; }
        '''

        (html_dir / "test.html").write_text(html_content)
        (css_dir / "test.css").write_text(css_content)

        cleaner = CSSCleaner(str(html_dir), str(css_dir))
        stats = cleaner.process_all_css(backup=False)

        cleaned_css = (css_dir / "test.css").read_text()

        assert ".js-class" in cleaned_css
        assert "#jquery-id" in cleaned_css
        assert ".unused" not in cleaned_css

    def test_pseudo_classes(self, temp_dirs):
        """Test gestione pseudo-classes"""
        html_dir, css_dir = temp_dirs

        html_content = '''
        <html>
        <body>
            <a class="link">Link</a>
        </body>
        </html>
        '''

        css_content = '''
        .link { color: blue; }
        .link:hover { color: red; }
        .unused:hover { color: green; }
        '''

        (html_dir / "test.html").write_text(html_content)
        (css_dir / "test.css").write_text(css_content)

        cleaner = CSSCleaner(str(html_dir), str(css_dir))
        stats = cleaner.process_all_css(backup=False)

        cleaned_css = (css_dir / "test.css").read_text()

        assert ".link" in cleaned_css
        assert ".link:hover" in cleaned_css
        assert ".unused:hover" not in cleaned_css

# Esegui test
if __name__ == "__main__":
    pytest.main([__file__])

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239

#!/usr/bin/env python3
"""
Advanced CSS Parser - Gestione completa di tutte le regole CSS
"""

import re
import cssutils
from tinycss2 import parse_stylesheet, parse_declaration_list
from tinycss2.ast import QualifiedRule, AtRule, Declaration
from typing import Dict, List, Set, Tuple, Optional
import logging

class AdvancedCSSParser:
    """Parser CSS avanzato per analisi completa delle regole"""

    def __init__(self):
        self.media_queries: Dict[str, List] = {}
        self.keyframes: Dict[str, Dict] = {}
        self.font_faces: List[Dict] = []
        self.imports: List[str] = []
        self.variables: Dict[str, str] = {}
        self.supports_rules: Dict[str, List] = {}

        # Configurazione logging
        cssutils.log.setLevel(logging.CRITICAL)

    def parse_css_file(self, css_file_path: str) -> Dict:
        """Parsing completo di un file CSS"""

        try:
            with open(css_file_path, 'r', encoding='utf-8') as f:
                css_content = f.read()

            # Parse con tinycss2 per parsing moderno
            stylesheet = parse_stylesheet(css_content)

            # Parse con cssutils per compatibilità
            css_sheet = cssutils.parseString(css_content)

            result = {
                'selectors': self._extract_selectors(stylesheet),
                'media_queries': self._extract_media_queries(css_sheet),
                'keyframes': self._extract_keyframes(css_sheet),
                'font_faces': self._extract_font_faces(css_sheet),
                'imports': self._extract_imports(css_sheet),
                'variables': self._extract_css_variables(css_content),
                'supports': self._extract_supports_rules(css_sheet),
                'performance_metrics': self._calculate_performance_metrics(stylesheet),
                'file_stats': self._calculate_file_stats(css_content)
            }

            return result

        except Exception as e:
            logging.error(f"Errore durante il parsing del file CSS {css_file_path}: {e}")
            return {}

    def _extract_selectors(self, stylesheet) -> List[Dict]:
        """Estrae tutti i selettori con dettagli"""
        selectors = []

        for rule in stylesheet:
            if hasattr(rule, 'prelude') and hasattr(rule, 'content'):
                # Regola normale con selettore
                selector_text = ''.join([token.serialize() for token in rule.prelude])
                declarations = self._parse_declarations(rule.content)

                selectors.append({
                    'selector': selector_text.strip(),
                    'specificity': self._calculate_specificity(selector_text),
                    'declarations': declarations,
                    'complexity_score': self._calculate_complexity(selector_text),
                    'performance_impact': self._assess_performance_impact(selector_text)
                })

        return selectors

    def _calculate_specificity(self, selector: str) -> Tuple[int, int, int, int]:
        """Calcola specificità CSS (inline, ids, classes, elements)"""

        # Rimuovi pseudo-elements e pseudo-classes per il calcolo
        clean_selector = re.sub(r':+[\w-]+(\([^)]*\))?', '', selector)

        # Conta IDs
        ids = len(re.findall(r'#[\w-]+', clean_selector))

        # Conta classi, attributi, pseudo-classi
        classes = len(re.findall(r'\.[\w-]+', clean_selector))
        attributes = len(re.findall(r'\[[^\]]*\]', clean_selector))
        pseudo_classes = len(re.findall(r':[\w-]+(?!\()', selector))

        # Conta elementi e pseudo-elementi
        elements = len(re.findall(r'(?:^|[\s>+~])(?![.#:])[a-zA-Z][\w-]*', clean_selector))
        pseudo_elements = len(re.findall(r'::[\w-]+', selector))

        return (0, ids, classes + attributes + pseudo_classes, elements + pseudo_elements)

    def _calculate_complexity(self, selector: str) -> int:
        """Calcola score di complessità del selettore"""
        complexity = 0

        # Punti per lunghezza
        complexity += len(selector.split()) * 2

        # Punti per combinatori
        complexity += selector.count('>') * 3
        complexity += selector.count('+') * 3
        complexity += selector.count('~') * 3

        # Punti per pseudo-selettori complessi
        complexity += selector.count(':nth-child') * 5
        complexity += selector.count(':nth-of-type') * 5
        complexity += selector.count(':not(') * 4

        # Punti per attributi complessi
        complexity += len(re.findall(r'\[[^\]]*[*^$|~][^]]*\]', selector)) * 4

        return complexity

    def _assess_performance_impact(self, selector: str) -> str:
        """Valuta l'impatto performance del selettore"""

        # Selettori ad alto impatto
        if selector.startswith('*') or '*' in selector:
            return 'HIGH'

        if re.search(r'[^>+~\s][>+~]\s*\*', selector):
            return 'HIGH'

        # Selettori che finiscono con tag
        if re.search(r'\s+[a-zA-Z]+$', selector):
            return 'MEDIUM'

        # Selettori molto specifici
        specificity = self._calculate_specificity(selector)
        total_spec = sum(specificity)
        if total_spec > 100:
            return 'MEDIUM'

        return 'LOW'

    def _extract_media_queries(self, css_sheet) -> Dict:
        """Estrae e organizza media queries"""
        media_queries = {}

        for rule in css_sheet:
            if rule.type == rule.MEDIA_RULE:
                media_text = rule.media.mediaText
                rules_in_media = []

                for nested_rule in rule:
                    if hasattr(nested_rule, 'selectorText'):
                        rules_in_media.append({
                            'selector': nested_rule.selectorText,
                            'declarations': nested_rule.style.cssText
                        })

                media_queries[media_text] = rules_in_media

        return media_queries

    def _extract_keyframes(self, css_sheet) -> Dict:
        """Estrae definizioni keyframes"""
        keyframes = {}

        for rule in css_sheet:
            if rule.type == rule.KEYFRAMES_RULE:
                animation_name = rule.name
                keyframe_rules = {}

                for keyframe in rule:
                    keyframe_rules[keyframe.keyText] = keyframe.style.cssText

                keyframes[animation_name] = keyframe_rules

        return keyframes

    def _extract_css_variables(self, css_content: str) -> Dict:
        """Estrae variabili CSS custom properties"""
        variables = {}

        # Pattern per custom properties
        var_pattern = r'--([^:]+):\s*([^;]+);'
        matches = re.findall(var_pattern, css_content)

        for var_name, var_value in matches:
            variables[f"--{var_name.strip()}"] = var_value.strip()

        return variables

    def _calculate_performance_metrics(self, stylesheet) -> Dict:
        """Calcola metriche di performance"""

        total_rules = 0
        complex_selectors = 0
        universal_selectors = 0
        id_selectors = 0
        class_selectors = 0

        for rule in stylesheet:
            if hasattr(rule, 'prelude'):
                total_rules += 1
                selector_text = ''.join([token.serialize() for token in rule.prelude])

                complexity = self._calculate_complexity(selector_text)
                if complexity > 20:
                    complex_selectors += 1

                if '*' in selector_text:
                    universal_selectors += 1

                if '#' in selector_text:
                    id_selectors += 1

                if '.' in selector_text:
                    class_selectors += 1

        return {
            'total_rules': total_rules,
            'complex_selectors': complex_selectors,
            'universal_selectors': universal_selectors,
            'id_selectors': id_selectors,
            'class_selectors': class_selectors,
            'complexity_ratio': (complex_selectors / total_rules * 100) if total_rules > 0 else 0
        }

# Esempio di utilizzo avanzato
if __name__ == "__main__":
    parser = AdvancedCSSParser()

    # Analizza file CSS complesso
    css_analysis = parser.parse_css_file("complex_stylesheet.css")

    print("=== CSS ANALYSIS REPORT ===")
    print(f"Total rules: {css_analysis['performance_metrics']['total_rules']}")
    print(f"Complex selectors: {css_analysis['performance_metrics']['complex_selectors']}")
    print(f"Media queries: {len(css_analysis['media_queries'])}")
    print(f"CSS Variables: {len(css_analysis['variables'])}")
    print(f"Keyframes: {len(css_analysis['keyframes'])}")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

#!/usr/bin/env python3
"""
Dynamic HTML Analyzer - Analisi avanzata per contenuto dinamico
"""

import re
import json
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from pathlib import Path
from typing import Set, List, Dict, Optional
import time

class DynamicHTMLAnalyzer:
    """Analizzatore HTML per contenuto generato dinamicamente"""

    def __init__(self, use_selenium: bool = False, headless: bool = True):
        self.use_selenium = use_selenium
        self.headless = headless
        self.driver = None
        self.dynamic_selectors: Set[str] = set()
        self.js_selectors: Set[str] = set()
        self.framework_selectors: Set[str] = set()

    def setup_selenium(self):
        """Configura Selenium WebDriver"""
        if not self.use_selenium:
            return

        chrome_options = Options()
        if self.headless:
            chrome_options.add_argument('--headless')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--disable-gpu')

        try:
            self.driver = webdriver.Chrome(options=chrome_options)
            self.driver.set_page_load_timeout(30)
        except Exception as e:
            print(f"Avviso: impossibile inizializzare Selenium WebDriver: {e}")
            self.use_selenium = False

    def analyze_static_html(self, html_content: str) -> Set[str]:
        """Analizza HTML statico con BeautifulSoup"""
        selectors = set()

        soup = BeautifulSoup(html_content, 'html.parser')

        # Selettori da attributi HTML standard
        for element in soup.find_all():
            # Classi CSS
            if element.get('class'):
                classes = element.get('class')
                if isinstance(classes, list):
                    classes = ' '.join(classes)
                for css_class in classes.split():
                    selectors.add(f".{css_class}")

            # IDs
            if element.get('id'):
                selectors.add(f"#{element.get('id')}")

            # Data attributes (spesso usati da framework)
            for attr in element.attrs:
                if attr.startswith('data-'):
                    selectors.add(f"[{attr}]")
                    # Valore specifico per data attributes importanti
                    if attr in ['data-component', 'data-widget', 'data-module']:
                        selectors.add(f"[{attr}='{element.get(attr)}']")

            # Attributi framework-specific
            framework_attrs = ['ng-class', 'v-bind:class', ':class', 'class-name', 'className']
            for attr in framework_attrs:
                if element.get(attr):
                    # Parsing per framework attributes
                    self._parse_framework_classes(element.get(attr), selectors)

        return selectors

    def analyze_javascript_selectors(self, html_content: str) -> Set[str]:
        """Estrae selettori da codice JavaScript"""
        selectors = set()

        # Pattern per selettori in JavaScript
        js_patterns = [
            r'document\.querySelector\(["\']([^"\']+)["\']\)',
            r'document\.querySelectorAll\(["\']([^"\']+)["\']\)',
            r'document\.getElementById\(["\']([^"\']+)["\']\)',
            r'document\.getElementsByClassName\(["\']([^"\']+)["\']\)',
            r'jQuery\(["\']([^"\']+)["\']\)',
            r'\$\(["\']([^"\']+)["\']\)',
            r'\.addClass\(["\']([^"\']+)["\']\)',
            r'\.removeClass\(["\']([^"\']+)["\']\)',
            r'\.toggleClass\(["\']([^"\']+)["\']\)',
            r'\.hasClass\(["\']([^"\']+)["\']\)',
        ]

        for pattern in js_patterns:
            matches = re.findall(pattern, html_content, re.IGNORECASE)
            for match in matches:
                # Pulisci e standardizza il selettore
                cleaned_selector = self._clean_selector(match)
                if cleaned_selector:
                    selectors.add(cleaned_selector)

        # Pattern per classi in stringhe JavaScript
        class_patterns = [
            r'["\']([a-zA-Z][\w-]*(?:\s+[a-zA-Z][\w-]*)*)["\']',
        ]

        # Cerca in tag script
        soup = BeautifulSoup(html_content, 'html.parser')
        scripts = soup.find_all('script')

        for script in scripts:
            if script.string:
                # Analizza contenuto script per possibili classi CSS
                potential_classes = re.findall(r'["\']([a-z][\w-]+(?:-[a-z][\w-]*)*)["\']', script.string)
                for class_name in potential_classes:
                    # Filtro per classi che sembrano CSS (pattern comuni)
                    if self._looks_like_css_class(class_name):
                        selectors.add(f".{class_name}")

        return selectors

    def analyze_dynamic_content(self, url: str, wait_time: int = 5) -> Set[str]:
        """Analizza contenuto generato dinamicamente con Selenium"""
        if not self.use_selenium or not self.driver:
            return set()

        selectors = set()

        try:
            # Carica la pagina
            self.driver.get(url)

            # Attendi caricamento iniziale
            time.sleep(wait_time)

            # Attendi elementi dinamici comuni
            common_dynamic_selectors = [
                '[data-loaded="true"]',
                '.loaded',
                '.ready',
                '[aria-hidden="false"]'
            ]

            for selector in common_dynamic_selectors:
                try:
                    WebDriverWait(self.driver, 10).until(
                        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
                    )
                except:
                    pass

            # Simula interazioni per trigger contenuto dinamico
            self._simulate_interactions()

            # Estrai selettori dal DOM finale
            final_html = self.driver.page_source
            selectors.update(self.analyze_static_html(final_html))
            selectors.update(self.analyze_javascript_selectors(final_html))

            # Analizza stili inline aggiunti dinamicamente
            elements_with_style = self.driver.find_elements(By.XPATH, "//*[@style]")
            for element in elements_with_style:
                class_names = element.get_attribute('class')
                if class_names:
                    for class_name in class_names.split():
                        selectors.add(f".{class_name}")

        except Exception as e:
            print(f"Errore durante l'analisi del contenuto dinamico: {e}")

        return selectors

    def _simulate_interactions(self):
        """Simula interazioni utente per trigger contenuto dinamico"""
        try:
            # Click su elementi interattivi comuni
            interactive_selectors = [
                'button', '[role="button"]', '.btn', '.button',
                '.menu-toggle', '.dropdown-toggle', '.tab',
                '[data-toggle]', '[data-trigger]'
            ]

            for selector in interactive_selectors:
                try:
                    elements = self.driver.find_elements(By.CSS_SELECTOR, selector)
                    for element in elements[:3]:  # Limita a primi 3 elementi
                        if element.is_displayed() and element.is_enabled():
                            self.driver.execute_script("arguments[0].click();", element)
                            time.sleep(1)  # Attendi animazioni
                except:
                    continue

            # Scroll per trigger lazy loading
            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
            time.sleep(2)
            self.driver.execute_script("window.scrollTo(0, 0);")

        except Exception as e:
            print(f"Errore durante la simulazione delle interazioni: {e}")

    def _parse_framework_classes(self, attr_value: str, selectors: Set[str]):
        """Parsing per attributi classe di framework JavaScript"""

        # Vue.js :class binding
        if attr_value.startswith('{') or attr_value.startswith('['):
            try:
                # Estrai nomi di classi da oggetti/array JavaScript
                class_names = re.findall(r'["\']([a-zA-Z][\w-]+)["\']', attr_value)
                for class_name in class_names:
                    selectors.add(f".{class_name}")
            except:
                pass

        # Angular [ngClass]
        elif 'ngClass' in attr_value or any(op in attr_value for op in ['?', ':']):
            class_names = re.findall(r'["\']([a-zA-Z][\w-]+)["\']', attr_value)
            for class_name in class_names:
                selectors.add(f".{class_name}")

        # React className con espressioni
        else:
            # Estrai classi da stringhe template o concatenazioni
            class_names = re.findall(r'["\']([a-zA-Z][\w-]+(?:\s+[a-zA-Z][\w-]+)*)["\']', attr_value)
            for class_string in class_names:
                for class_name in class_string.split():
                    selectors.add(f".{class_name}")

    def _clean_selector(self, selector: str) -> Optional[str]:
        """Pulisce e valida selettori estratti da JavaScript"""
        selector = selector.strip()

        # Rimuovi spazi extra e caratteri non validi
        selector = re.sub(r'\s+', ' ', selector)

        # Valida che sia un selettore CSS valido
        if not selector:
            return None

        # Se è solo una classe, aggiungi il punto
        if re.match(r'^[a-zA-Z][\w-]*$', selector):
            return f".{selector}"

        # Se è solo un ID, aggiungi il cancelletto
        if re.match(r'^[a-zA-Z][\w-]*$', selector) and selector not in ['body', 'html', 'div', 'span']:
            return f"#{selector}"

        return selector

    def _looks_like_css_class(self, class_name: str) -> bool:
        """Determina se una stringa sembra essere una classe CSS"""

        # Pattern comuni per classi CSS
        css_patterns = [
            r'^[a-z]+(-[a-z]+)*$',  # kebab-case
            r'^[a-zA-Z]+[A-Z][a-zA-Z]*$',  # camelCase
            r'^[a-z]+(_[a-z]+)*$',  # snake_case
            r'^(btn|nav|menu|header|footer|sidebar|content|main|wrapper|container)',  # Prefissi comuni
            r'(active|disabled|hidden|visible|primary|secondary|success|danger|warning|info)$'  # Stati comuni
        ]

        return any(re.match(pattern, class_name) for pattern in css_patterns)

    def close(self):
        """Chiude il WebDriver"""
        if self.driver:
            self.driver.quit()

# Esempio di utilizzo completo
if __name__ == "__main__":
    # Analisi statica
    static_analyzer = DynamicHTMLAnalyzer(use_selenium=False)

    html_files = Path("./html").glob("*.html")
    all_selectors = set()

    for html_file in html_files:
        with open(html_file, 'r', encoding='utf-8') as f:
            content = f.read()

        static_selectors = static_analyzer.analyze_static_html(content)
        js_selectors = static_analyzer.analyze_javascript_selectors(content)

        all_selectors.update(static_selectors)
        all_selectors.update(js_selectors)

        print(f"File: {html_file}")
        print(f"  Static selectors: {len(static_selectors)}")
        print(f"  JS selectors: {len(js_selectors)}")

    # Analisi dinamica (opzionale)
    dynamic_analyzer = DynamicHTMLAnalyzer(use_selenium=True)
    dynamic_analyzer.setup_selenium()

    if dynamic_analyzer.use_selenium:
        dynamic_selectors = dynamic_analyzer.analyze_dynamic_content("http://localhost:3000")
        all_selectors.update(dynamic_selectors)
        print(f"Dynamic selectors: {len(dynamic_selectors)}")

    dynamic_analyzer.close()

    print(f"\nTotal unique selectors found: {len(all_selectors)}")
    print("Selectors:", sorted(all_selectors))

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273

#!/usr/bin/env python3
"""
Media Query Processor - Gestione intelligente delle media queries
"""

import re
from typing import Dict, List, Set, Tuple
from dataclasses import dataclass

@dataclass
class MediaQueryRule:
    """Rappresenta una regola dentro una media query"""
    selector: str
    declarations: str
    usage_context: str = ""

@dataclass
class MediaQuery:
    """Rappresenta una media query completa"""
    query_text: str
    rules: List[MediaQueryRule]
    breakpoint: int = 0
    device_type: str = ""
    is_responsive: bool = True

class MediaQueryProcessor:
    """Processore avanzato per media queries"""

    def __init__(self):
        self.common_breakpoints = {
            320: "mobile-small",
            375: "mobile",
            768: "tablet",
            1024: "desktop",
            1200: "desktop-large",
            1440: "desktop-xl"
        }

        self.processed_queries: Dict[str, MediaQuery] = {}

    def process_media_queries(self, css_content: str, used_selectors: Set[str]) -> Dict[str, MediaQuery]:
        """Processa tutte le media queries nel CSS"""

        # Pattern per estrarre media queries
        media_pattern = r'@media\s+([^{]+)\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}'

        matches = re.finditer(media_pattern, css_content, re.DOTALL | re.IGNORECASE)

        for match in matches:
            query_text = match.group(1).strip()
            query_content = match.group(2).strip()

            # Analizza la query
            media_query = self._parse_media_query(query_text, query_content)

            # Filtra regole basate sui selettori utilizzati
            filtered_rules = self._filter_media_rules(media_query.rules, used_selectors)
            media_query.rules = filtered_rules

            # Salva solo se ha regole utilizzate
            if filtered_rules:
                self.processed_queries[query_text] = media_query

        return self.processed_queries

    def _parse_media_query(self, query_text: str, content: str) -> MediaQuery:
        """Parsing di una singola media query"""

        # Determina breakpoint e tipo device
        breakpoint = self._extract_breakpoint(query_text)
        device_type = self._determine_device_type(query_text)
        is_responsive = self._is_responsive_query(query_text)

        # Estrai regole CSS dentro la media query
        rules = self._extract_rules_from_content(content)

        return MediaQuery(
            query_text=query_text,
            rules=rules,
            breakpoint=breakpoint,
            device_type=device_type,
            is_responsive=is_responsive
        )

    def _extract_breakpoint(self, query_text: str) -> int:
        """Estrae il breakpoint principale dalla media query"""

        # Pattern per width/height values
        width_pattern = r'(?:max-width|min-width):\s*(\d+)px'
        matches = re.findall(width_pattern, query_text)

        if matches:
            return int(matches[0])

        # Pattern per em/rem values
        em_pattern = r'(?:max-width|min-width):\s*(\d+(?:\.\d+)?)em'
        em_matches = re.findall(em_pattern, query_text)

        if em_matches:
            # Convert em to px (assuming 16px = 1em)
            return int(float(em_matches[0]) * 16)

        return 0

    def _determine_device_type(self, query_text: str) -> str:
        """Determina il tipo di device dalla media query"""

        query_lower = query_text.lower()

        if 'print' in query_lower:
            return 'print'
        elif 'screen' in query_lower:
            if 'max-width' in query_lower:
                breakpoint = self._extract_breakpoint(query_text)
                if breakpoint <= 767:
                    return 'mobile'
                elif breakpoint <= 1023:
                    return 'tablet'
                else:
                    return 'desktop'
            return 'screen'
        elif 'handheld' in query_lower:
            return 'mobile'
        else:
            return 'all'

    def _is_responsive_query(self, query_text: str) -> bool:
        """Determina se è una media query responsive"""

        responsive_keywords = ['width', 'height', 'orientation', 'resolution', 'aspect-ratio']
        return any(keyword in query_text.lower() for keyword in responsive_keywords)

    def _extract_rules_from_content(self, content: str) -> List[MediaQueryRule]:
        """Estrae regole CSS dal contenuto della media query"""

        rules = []

        # Pattern per regole CSS
        rule_pattern = r'([^{}]+)\s*\{([^{}]+)\}'
        matches = re.finditer(rule_pattern, content)

        for match in matches:
            selector = match.group(1).strip()
            declarations = match.group(2).strip()

            # Pulisci il selettore
            selector = re.sub(r'\s+', ' ', selector)

            rules.append(MediaQueryRule(
                selector=selector,
                declarations=declarations,
                usage_context=self._determine_usage_context(declarations)
            ))

        return rules

    def _determine_usage_context(self, declarations: str) -> str:
        """Determina il contesto d'uso delle dichiarazioni CSS"""

        declarations_lower = declarations.lower()

        if any(prop in declarations_lower for prop in ['display: none', 'visibility: hidden']):
            return 'hiding'
        elif any(prop in declarations_lower for prop in ['display: block', 'display: flex', 'display: grid']):
            return 'showing'
        elif any(prop in declarations_lower for prop in ['font-size', 'line-height', 'letter-spacing']):
            return 'typography'
        elif any(prop in declarations_lower for prop in ['width', 'height', 'padding', 'margin']):
            return 'layout'
        elif any(prop in declarations_lower for prop in ['background', 'color', 'border']):
            return 'styling'
        else:
            return 'general'

    def _filter_media_rules(self, rules: List[MediaQueryRule], used_selectors: Set[str]) -> List[MediaQueryRule]:
        """Filtra regole basate sui selettori utilizzati"""

        filtered_rules = []

        for rule in rules:
            # Check se almeno uno dei selettori nella regola è utilizzato
            rule_selectors = [s.strip() for s in rule.selector.split(',')]

            used_rule_selectors = []
            for selector in rule_selectors:
                if self._is_selector_used(selector, used_selectors):
                    used_rule_selectors.append(selector)

            # Se almeno un selettore è utilizzato, mantieni la regola
            if used_rule_selectors:
                # Aggiorna la regola con solo i selettori utilizzati
                rule.selector = ', '.join(used_rule_selectors)
                filtered_rules.append(rule)

        return filtered_rules

    def _is_selector_used(self, selector: str, used_selectors: Set[str]) -> bool:
        """Verifica se un selettore è utilizzato"""

        # Check diretto
        if selector in used_selectors:
            return True

        # Check per selettori composti
        if ' ' in selector:
            parts = selector.split()
            return any(part in used_selectors for part in parts)

        # Check per pseudo-selettori
        if ':' in selector:
            base_selector = selector.split(':')[0]
            return base_selector in used_selectors

        return False

    def generate_optimized_media_queries(self) -> str:
        """Genera CSS ottimizzato per le media queries"""

        if not self.processed_queries:
            return ""

        css_output = []

        # Ordina media queries per breakpoint
        sorted_queries = sorted(
            self.processed_queries.items(),
            key=lambda x: x[1].breakpoint
        )

        for query_text, media_query in sorted_queries:
            css_output.append(f"@media {query_text} {{")

            for rule in media_query.rules:
                css_output.append(f"  {rule.selector} {{")
                css_output.append(f"    {rule.declarations}")
                css_output.append(f"  }}")

            css_output.append("}")
            css_output.append("")  # Riga vuota tra media queries

        return '\n'.join(css_output)

    def get_media_query_report(self) -> Dict:
        """Genera report dettagliato delle media queries"""

        total_queries = len(self.processed_queries)
        responsive_queries = sum(1 for mq in self.processed_queries.values() if mq.is_responsive)

        device_breakdown = {}
        for mq in self.processed_queries.values():
            device_type = mq.device_type
            if device_type not in device_breakdown:
                device_breakdown[device_type] = 0
            device_breakdown[device_type] += 1

        breakpoint_usage = {}
        for mq in self.processed_queries.values():
            if mq.breakpoint > 0:
                # Trova il breakpoint più vicino
                closest_bp = min(self.common_breakpoints.keys(),
                               key=lambda x: abs(x - mq.breakpoint))
                bp_name = self.common_breakpoints[closest_bp]
                if bp_name not in breakpoint_usage:
                    breakpoint_usage[bp_name] = 0
                breakpoint_usage[bp_name] += 1

        return {
            'total_media_queries': total_queries,
            'responsive_queries': responsive_queries,
            'device_breakdown': device_breakdown,
            'breakpoint_usage': breakpoint_usage,
            'coverage_percentage': (responsive_queries / total_queries * 100) if total_queries > 0 else 0
        }

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

#!/usr/bin/env python3
"""
Sistema di backup e ripristino CSS - gestione completa
"""

import os
import shutil
import json
import hashlib
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
import zipfile
import tempfile

class CSSBackupManager:
    """Gestione completa backup e recovery per file CSS"""

    def __init__(self, backup_dir: str = "./css_backups"):
        self.backup_dir = Path(backup_dir)
        self.backup_dir.mkdir(exist_ok=True)
        self.metadata_file = self.backup_dir / "backup_metadata.json"
        self.metadata = self._load_metadata()

    def create_backup(self, css_files: List[str], backup_name: Optional[str] = None) -> str:
        """Crea backup completo dei file CSS"""

        if not backup_name:
            backup_name = f"css_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"

        backup_path = self.backup_dir / backup_name
        backup_path.mkdir(exist_ok=True)

        backup_info = {
            'name': backup_name,
            'created_at': datetime.now().isoformat(),
            'files': {},
            'total_size': 0,
            'file_count': 0
        }

        for css_file in css_files:
            css_path = Path(css_file)
            if not css_path.exists():
                continue

            # Calcola hash per verifica integrità
            file_hash = self._calculate_file_hash(css_path)
            file_size = css_path.stat().st_size

            # Copia file nel backup
            backup_file_path = backup_path / css_path.name
            shutil.copy2(css_path, backup_file_path)

            # Salva metadati file
            backup_info['files'][str(css_path)] = {
                'original_path': str(css_path),
                'backup_path': str(backup_file_path),
                'size': file_size,
                'hash': file_hash,
                'modified_at': datetime.fromtimestamp(css_path.stat().st_mtime).isoformat()
            }

            backup_info['total_size'] += file_size
            backup_info['file_count'] += 1

        # Salva metadati backup
        metadata_file = backup_path / "backup_info.json"
        with open(metadata_file, 'w', encoding='utf-8') as f:
            json.dump(backup_info, f, indent=2, ensure_ascii=False)

        # Aggiorna metadata globali
        self.metadata[backup_name] = backup_info
        self._save_metadata()

        # Crea archivio ZIP
        zip_path = self.backup_dir / f"{backup_name}.zip"
        self._create_zip_archive(backup_path, zip_path)

        print(f"Backup creato: {backup_name}")
        print(f"File processati: {backup_info['file_count']}")
        print(f"Dimensione totale: {self._format_size(backup_info['total_size'])}")
        print(f"Archivio: {zip_path}")

        return backup_name

    def restore_backup(self, backup_name: str, restore_path: Optional[str] = None, verify_integrity: bool = True) -> bool:
        """Ripristina backup in una directory specifica"""

        if backup_name not in self.metadata:
            print(f"Backup non trovato: {backup_name}")
            return False

        backup_info = self.metadata[backup_name]

        # Determina path di ripristino
        if restore_path:
            restore_dir = Path(restore_path)
        else:
            restore_dir = Path(f"./restored_{backup_name}")

        restore_dir.mkdir(exist_ok=True)

        print(f"Ripristino backup: {backup_name}")
        print(f"Destinazione: {restore_dir}")

        # Estrai da archivio se necessario
        zip_path = self.backup_dir / f"{backup_name}.zip"
        backup_dir = self.backup_dir / backup_name

        if zip_path.exists() and not backup_dir.exists():
            self._extract_zip_archive(zip_path, backup_dir.parent)

        # Verifica esistenza backup
        if not backup_dir.exists():
            print(f"Directory backup non trovata: {backup_dir}")
            return False

        restored_files = 0
        failed_files = []

        for original_path, file_info in backup_info['files'].items():
            backup_file_path = Path(file_info['backup_path'])

            if not backup_file_path.exists():
                failed_files.append(f"File backup non trovato: {backup_file_path}")
                continue

            # Verifica integrità se richiesta
            if verify_integrity:
                current_hash = self._calculate_file_hash(backup_file_path)
                if current_hash != file_info['hash']:
                    failed_files.append(f"Hash mismatch per: {backup_file_path}")
                    continue

            # Ripristina file
            try:
                restore_file_path = restore_dir / backup_file_path.name
                shutil.copy2(backup_file_path, restore_file_path)
                restored_files += 1
                print(f"Ripristinato: {restore_file_path}")
            except Exception as e:
                failed_files.append(f"Errore ripristino {backup_file_path}: {e}")

        # Report risultati
        print(f"\\nRipristino completato:")
        print(f"File ripristinati: {restored_files}")
        print(f"Errori: {len(failed_files)}")

        if failed_files:
            print("\\nErrori riscontrati:")
            for error in failed_files:
                print(f"  - {error}")

        return len(failed_files) == 0

    def list_backups(self) -> None:
        """Elenca tutti i backup disponibili"""

        if not self.metadata:
            print("Nessun backup trovato")
            return

        print("Backup disponibili:")
        print("-" * 80)

        for backup_name, backup_info in self.metadata.items():
            created_at = datetime.fromisoformat(backup_info['created_at'])

            print(f"Nome: {backup_name}")
            print(f"Creato: {created_at.strftime('%Y-%m-%d %H:%M:%S')}")
            print(f"File: {backup_info['file_count']}")
            print(f"Dimensione: {self._format_size(backup_info['total_size'])}")
            print("-" * 40)

    def delete_backup(self, backup_name: str) -> bool:
        """Elimina un backup specifico"""

        if backup_name not in self.metadata:
            print(f"Backup non trovato: {backup_name}")
            return False

        # Rimuovi directory backup
        backup_dir = self.backup_dir / backup_name
        if backup_dir.exists():
            shutil.rmtree(backup_dir)

        # Rimuovi archivio ZIP
        zip_path = self.backup_dir / f"{backup_name}.zip"
        if zip_path.exists():
            zip_path.unlink()

        # Rimuovi da metadata
        del self.metadata[backup_name]
        self._save_metadata()

        print(f"Backup eliminato: {backup_name}")
        return True

    def cleanup_old_backups(self, keep_days: int = 30, keep_count: int = 10) -> None:
        """Pulizia automatica backup vecchi"""

        cutoff_date = datetime.now().timestamp() - (keep_days * 24 * 60 * 60)

        # Ordina backup per data di creazione
        backup_list = []
        for name, info in self.metadata.items():
            created_at = datetime.fromisoformat(info['created_at'])
            backup_list.append((name, created_at.timestamp()))

        backup_list.sort(key=lambda x: x[1], reverse=True)  # Più recenti primi

        deleted_count = 0

        # Mantieni almeno keep_count backup più recenti
        backups_to_check = backup_list[keep_count:]

        for backup_name, timestamp in backups_to_check:
            if timestamp < cutoff_date:
                self.delete_backup(backup_name)
                deleted_count += 1

        print(f"Pulizia completata: {deleted_count} backup eliminati")

    def _calculate_file_hash(self, file_path: Path) -> str:
        """Calcola hash SHA256 di un file"""

        hash_sha256 = hashlib.sha256()
        with open(file_path, "rb") as f:
            for chunk in iter(lambda: f.read(4096), b""):
                hash_sha256.update(chunk)
        return hash_sha256.hexdigest()

    def _create_zip_archive(self, source_dir: Path, zip_path: Path) -> None:
        """Crea archivio ZIP del backup"""

        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
            for file_path in source_dir.rglob('*'):
                if file_path.is_file():
                    arcname = file_path.relative_to(source_dir)
                    zipf.write(file_path, arcname)

    def _extract_zip_archive(self, zip_path: Path, extract_dir: Path) -> None:
        """Estrae archivio ZIP"""

        with zipfile.ZipFile(zip_path, 'r') as zipf:
            zipf.extractall(extract_dir)

    def _load_metadata(self) -> Dict:
        """Carica metadata backup"""

        if self.metadata_file.exists():
            try:
                with open(self.metadata_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except Exception as e:
                print(f"Errore caricamento metadata: {e}")

        return {}

    def _save_metadata(self) -> None:
        """Salva metadata backup"""

        try:
            with open(self.metadata_file, 'w', encoding='utf-8') as f:
                json.dump(self.metadata, f, indent=2, ensure_ascii=False)
        except Exception as e:
            print(f"Errore salvataggio metadata: {e}")

    def _format_size(self, size_bytes: int) -> str:
        """Formatta dimensione file in formato leggibile"""

        for unit in ['B', 'KB', 'MB', 'GB']:
            if size_bytes < 1024.0:
                return f"{size_bytes:.1f} {unit}"
            size_bytes /= 1024.0
        return f"{size_bytes:.1f} TB"