reveal-cli 0.8.0__py3-none-any.whl

reveal/tests/test_json_yaml_line_numbers.py

@@ -0,0 +1,238 @@
+"""
+Tests for JSON/YAML line number support.
+
+Ensures that JSON and YAML analyzers return real line numbers
+from the source file, not fake enumerated positions.
+"""
+
+import unittest
+from reveal.analyzers.json_analyzer import JSONAnalyzer
+from reveal.analyzers.yaml_analyzer import YAMLAnalyzer
+
+
+class TestJSONLineNumbers(unittest.TestCase):
+    """Test JSON analyzer line number extraction."""
+
+    def test_json_returns_line_numbers(self):
+        """JSON analyzer should return line numbers for top-level keys."""
+        json_lines = [
+            '{',
+            '  "name": "test",',
+            '  "version": "1.0.0",',
+            '  "dependencies": {',
+            '    "foo": "1.0"',
+            '  }',
+            '}'
+        ]
+
+        analyzer = JSONAnalyzer(json_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should have top-level keys
+        self.assertIn('top_level_keys', structure)
+        keys = structure['top_level_keys']
+
+        # Should have 3 keys
+        self.assertEqual(len(keys), 3)
+
+        # Each key should be a dict with 'name' and 'line'
+        for key in keys:
+            self.assertIsInstance(key, dict)
+            self.assertIn('name', key)
+            self.assertIn('line', key)
+
+        # Check specific line numbers
+        key_dict = {k['name']: k['line'] for k in keys}
+
+        self.assertEqual(key_dict['name'], 2)
+        self.assertEqual(key_dict['version'], 3)
+        self.assertEqual(key_dict['dependencies'], 4)
+
+    def test_json_with_file_path(self):
+        """JSON analyzer should use file_path when provided."""
+        json_lines = [
+            '{',
+            '  "key1": "value1",',
+            '  "key2": "value2"',
+            '}'
+        ]
+
+        analyzer = JSONAnalyzer(json_lines, file_path='/tmp/test.json')
+        structure = analyzer.analyze_structure()
+
+        # Verify file_path is stored
+        self.assertEqual(analyzer.file_path, '/tmp/test.json')
+
+        # Line numbers should still be found
+        keys = structure['top_level_keys']
+        self.assertEqual(len(keys), 2)
+        self.assertEqual(keys[0]['line'], 2)
+        self.assertEqual(keys[1]['line'], 3)
+
+    def test_json_empty_object(self):
+        """JSON analyzer should handle empty objects."""
+        json_lines = ['{}']
+
+        analyzer = JSONAnalyzer(json_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should return empty list, not crash
+        self.assertEqual(structure['top_level_keys'], [])
+
+    def test_json_array_top_level(self):
+        """JSON analyzer should handle arrays at top level."""
+        json_lines = ['[1, 2, 3]']
+
+        analyzer = JSONAnalyzer(json_lines)
+        structure = analyzer.analyze_structure()
+
+        # Arrays have no keys
+        self.assertEqual(structure['top_level_keys'], [])
+
+    def test_json_parse_error(self):
+        """JSON analyzer should handle parse errors gracefully."""
+        json_lines = ['{invalid json}']
+
+        analyzer = JSONAnalyzer(json_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should have error key
+        self.assertIn('error', structure)
+        self.assertEqual(structure['top_level_keys'], [])
+
+
+class TestYAMLLineNumbers(unittest.TestCase):
+    """Test YAML analyzer line number extraction."""
+
+    def test_yaml_returns_line_numbers(self):
+        """YAML analyzer should return line numbers for top-level keys."""
+        yaml_lines = [
+            'name: test-project',
+            'version: 1.0.0',
+            'dependencies:',
+            '  foo: 1.0',
+            '  bar: 2.0',
+            'scripts:',
+            '  test: pytest'
+        ]
+
+        analyzer = YAMLAnalyzer(yaml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should have top-level keys
+        self.assertIn('top_level_keys', structure)
+        keys = structure['top_level_keys']
+
+        # Should have 4 keys
+        self.assertEqual(len(keys), 4)
+
+        # Each key should be a dict with 'name' and 'line'
+        for key in keys:
+            self.assertIsInstance(key, dict)
+            self.assertIn('name', key)
+            self.assertIn('line', key)
+
+        # Check specific line numbers
+        key_dict = {k['name']: k['line'] for k in keys}
+
+        self.assertEqual(key_dict['name'], 1)
+        self.assertEqual(key_dict['version'], 2)
+        self.assertEqual(key_dict['dependencies'], 3)
+        self.assertEqual(key_dict['scripts'], 6)
+
+    def test_yaml_with_file_path(self):
+        """YAML analyzer should use file_path when provided."""
+        yaml_lines = [
+            'key1: value1',
+            'key2: value2'
+        ]
+
+        analyzer = YAMLAnalyzer(yaml_lines, file_path='/tmp/test.yaml')
+        structure = analyzer.analyze_structure()
+
+        # Verify file_path is stored
+        self.assertEqual(analyzer.file_path, '/tmp/test.yaml')
+
+        # Line numbers should still be found
+        keys = structure['top_level_keys']
+        self.assertEqual(len(keys), 2)
+        self.assertEqual(keys[0]['line'], 1)
+        self.assertEqual(keys[1]['line'], 2)
+
+    def test_yaml_with_comments(self):
+        """YAML analyzer should find keys despite comments."""
+        yaml_lines = [
+            '# Configuration file',
+            'name: test',
+            '# Database settings',
+            'database:',
+            '  host: localhost'
+        ]
+
+        analyzer = YAMLAnalyzer(yaml_lines)
+        structure = analyzer.analyze_structure()
+
+        keys = structure['top_level_keys']
+        key_dict = {k['name']: k['line'] for k in keys}
+
+        # Should find correct lines despite comments
+        self.assertEqual(key_dict['name'], 2)
+        self.assertEqual(key_dict['database'], 4)
+
+    def test_yaml_empty_document(self):
+        """YAML analyzer should handle empty documents."""
+        yaml_lines = ['']
+
+        analyzer = YAMLAnalyzer(yaml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should return empty list, not crash
+        self.assertEqual(structure['top_level_keys'], [])
+
+    def test_yaml_list_top_level(self):
+        """YAML analyzer should handle lists at top level."""
+        yaml_lines = ['- item1', '- item2', '- item3']
+
+        analyzer = YAMLAnalyzer(yaml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Lists have no keys
+        self.assertEqual(structure['top_level_keys'], [])
+
+
+class TestLineNumberComposability(unittest.TestCase):
+    """Test that line numbers make output composable with other tools."""
+
+    def test_json_format_location_helper(self):
+        """JSON analyzer should use format_location helper."""
+        json_lines = ['{', '  "test": "value"', '}']
+
+        analyzer = JSONAnalyzer(json_lines, file_path='config.json')
+
+        # Test format_location helper
+        loc = analyzer.format_location(2)
+        self.assertEqual(loc, 'config.json:2')
+
+        # Without file_path, should use L0000 format
+        analyzer_no_path = JSONAnalyzer(json_lines)
+        loc = analyzer_no_path.format_location(2)
+        self.assertEqual(loc, 'L0002')
+
+    def test_yaml_format_location_helper(self):
+        """YAML analyzer should use format_location helper."""
+        yaml_lines = ['test: value']
+
+        analyzer = YAMLAnalyzer(yaml_lines, file_path='config.yaml')
+
+        # Test format_location helper
+        loc = analyzer.format_location(1)
+        self.assertEqual(loc, 'config.yaml:1')
+
+        # Without file_path, should use L0000 format
+        analyzer_no_path = YAMLAnalyzer(yaml_lines)
+        loc = analyzer_no_path.format_location(1)
+        self.assertEqual(loc, 'L0001')
+
+
+if __name__ == '__main__':
+    unittest.main()

reveal/tests/test_line_numbers.py

@@ -0,0 +1,151 @@
+"""Tests for line number functionality."""
+
+import unittest
+from pathlib import Path
+from reveal.cli import parse_file_location
+from reveal.analyzers import SQLAnalyzer, PythonAnalyzer, JSONAnalyzer, YAMLAnalyzer
+
+
+class TestFileLocationParsing(unittest.TestCase):
+    """Test file:line parsing."""
+
+    def test_plain_file(self):
+        """Test plain filename without line number."""
+        path, start, end = parse_file_location("test.sql")
+        self.assertEqual(path, "test.sql")
+        self.assertIsNone(start)
+        self.assertIsNone(end)
+
+    def test_file_with_single_line(self):
+        """Test file:32 syntax."""
+        path, start, end = parse_file_location("test.sql:32")
+        self.assertEqual(path, "test.sql")
+        self.assertEqual(start, 32)
+        self.assertEqual(end, 32)
+
+    def test_file_with_range(self):
+        """Test file:10-50 syntax."""
+        path, start, end = parse_file_location("test.sql:10-50")
+        self.assertEqual(path, "test.sql")
+        self.assertEqual(start, 10)
+        self.assertEqual(end, 50)
+
+    def test_file_with_open_range(self):
+        """Test file:10- syntax (from line 10 to end)."""
+        path, start, end = parse_file_location("test.sql:10-")
+        self.assertEqual(path, "test.sql")
+        self.assertEqual(start, 10)
+        self.assertIsNone(end)
+
+
+class TestAnalyzerParameters(unittest.TestCase):
+    """Test that all analyzers accept the new parameters."""
+
+    def test_sql_analyzer_accepts_kwargs(self):
+        """SQL analyzer should accept file_path and focus parameters."""
+        lines = ["CREATE TABLE test (id INT);"]
+        analyzer = SQLAnalyzer(
+            lines,
+            file_path="test.sql",
+            focus_start=1,
+            focus_end=10
+        )
+        self.assertEqual(analyzer.file_path, "test.sql")
+        self.assertEqual(analyzer.focus_start, 1)
+        self.assertEqual(analyzer.focus_end, 10)
+
+    def test_python_analyzer_accepts_kwargs(self):
+        """Python analyzer should accept file_path and focus parameters."""
+        lines = ["def test(): pass"]
+        analyzer = PythonAnalyzer(
+            lines,
+            file_path="test.py",
+            focus_start=1,
+            focus_end=10
+        )
+        self.assertEqual(analyzer.file_path, "test.py")
+
+    def test_json_analyzer_accepts_kwargs(self):
+        """JSON analyzer should accept file_path and focus parameters."""
+        lines = ['{"key": "value"}']
+        analyzer = JSONAnalyzer(
+            lines,
+            file_path="test.json",
+            focus_start=1
+        )
+        self.assertEqual(analyzer.file_path, "test.json")
+
+    def test_yaml_analyzer_accepts_kwargs(self):
+        """YAML analyzer should accept file_path and focus parameters."""
+        lines = ["key: value"]
+        analyzer = YAMLAnalyzer(
+            lines,
+            file_path="test.yaml"
+        )
+        self.assertEqual(analyzer.file_path, "test.yaml")
+
+
+class TestPythonAnalyzerLineNumbers(unittest.TestCase):
+    """Test Python analyzer returns line numbers."""
+
+    def test_function_has_line_number(self):
+        """Functions should include line numbers."""
+        lines = [
+            "# comment",
+            "def test_func():",
+            "    pass",
+        ]
+        analyzer = PythonAnalyzer(lines)
+        structure = analyzer.analyze_structure()
+
+        self.assertEqual(len(structure['functions']), 1)
+        func = structure['functions'][0]
+        self.assertIsInstance(func, dict)
+        self.assertEqual(func['name'], 'test_func')
+        self.assertEqual(func['line'], 2)
+
+    def test_class_has_line_number(self):
+        """Classes should include line numbers."""
+        lines = [
+            "# comment",
+            "",
+            "class TestClass:",
+            "    pass",
+        ]
+        analyzer = PythonAnalyzer(lines)
+        structure = analyzer.analyze_structure()
+
+        self.assertEqual(len(structure['classes']), 1)
+        cls = structure['classes'][0]
+        self.assertIsInstance(cls, dict)
+        self.assertEqual(cls['name'], 'TestClass')
+        self.assertEqual(cls['line'], 3)
+
+
+class TestFormatLocation(unittest.TestCase):
+    """Test BaseAnalyzer format_location helper."""
+
+    def test_format_location_with_file_path(self):
+        """Should return filename:line when file_path is set."""
+        lines = ["CREATE TABLE test (id INT);"]
+        analyzer = SQLAnalyzer(lines, file_path="/path/to/test.sql")
+        loc = analyzer.format_location(32)
+        self.assertEqual(loc, "/path/to/test.sql:32")
+
+    def test_format_location_without_file_path(self):
+        """Should return L0000 format when no file_path."""
+        lines = ["CREATE TABLE test (id INT);"]
+        analyzer = SQLAnalyzer(lines)
+        loc = analyzer.format_location(32)
+        self.assertEqual(loc, "L0032")
+
+    def test_format_location_none(self):
+        """Should return empty string for None."""
+        lines = ["CREATE TABLE test (id INT);"]
+        analyzer = SQLAnalyzer(lines)
+        loc = analyzer.format_location(None)
+        self.assertEqual(loc, "")
+
+
+if __name__ == '__main__':
+    unittest.main()

reveal/tests/test_toml_analyzer.py

@@ -0,0 +1,220 @@
+"""
+Tests for TOML analyzer line number support.
+
+Ensures that TOML analyzer returns real line numbers
+from the source file using the find_definition() helper.
+"""
+
+import unittest
+from reveal.analyzers.toml_analyzer import TOMLAnalyzer
+
+
+class TestTOMLLineNumbers(unittest.TestCase):
+    """Test TOML analyzer line number extraction."""
+
+    def test_toml_returns_line_numbers_for_keys(self):
+        """TOML analyzer should return line numbers for top-level keys."""
+        toml_lines = [
+            '# Configuration file',
+            'name = "test-project"',
+            'version = "1.0.0"',
+            'debug = true',
+            '',
+            '[server]',
+            'host = "localhost"',
+            'port = 8080',
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should have top-level keys
+        self.assertIn('top_level_keys', structure)
+        keys = structure['top_level_keys']
+
+        # Should have 3 top-level keys (name, version, debug)
+        self.assertEqual(len(keys), 3)
+
+        # Each key should be a dict with 'name' and 'line'
+        for key in keys:
+            self.assertIsInstance(key, dict)
+            self.assertIn('name', key)
+            self.assertIn('line', key)
+
+        # Check specific line numbers
+        key_dict = {k['name']: k['line'] for k in keys}
+        self.assertEqual(key_dict['name'], 2)
+        self.assertEqual(key_dict['version'], 3)
+        self.assertEqual(key_dict['debug'], 4)
+
+    def test_toml_returns_line_numbers_for_sections(self):
+        """TOML analyzer should return line numbers for sections."""
+        toml_lines = [
+            'name = "test"',
+            '',
+            '[server]',
+            'host = "localhost"',
+            '',
+            '[database]',
+            'driver = "postgresql"',
+            '',
+            '[logging]',
+            'level = "info"',
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should have sections
+        self.assertIn('sections', structure)
+        sections = structure['sections']
+
+        # Should have 3 sections
+        self.assertEqual(len(sections), 3)
+
+        # Each section should be a dict with 'name' and 'line'
+        for section in sections:
+            self.assertIsInstance(section, dict)
+            self.assertIn('name', section)
+            self.assertIn('line', section)
+
+        # Check specific line numbers
+        section_dict = {s['name']: s['line'] for s in sections}
+        self.assertEqual(section_dict['server'], 3)
+        self.assertEqual(section_dict['database'], 6)
+        self.assertEqual(section_dict['logging'], 9)
+
+    def test_toml_with_file_path(self):
+        """TOML analyzer should use file_path when provided."""
+        toml_lines = [
+            'key1 = "value1"',
+            'key2 = "value2"'
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines, file_path='/tmp/test.toml')
+        structure = analyzer.analyze_structure()
+
+        # Verify file_path is stored
+        self.assertEqual(analyzer.file_path, '/tmp/test.toml')
+
+        # Line numbers should still be found
+        keys = structure['top_level_keys']
+        self.assertEqual(len(keys), 2)
+        self.assertEqual(keys[0]['line'], 1)
+        self.assertEqual(keys[1]['line'], 2)
+
+    def test_toml_pyproject_example(self):
+        """TOML analyzer should handle real pyproject.toml structure."""
+        toml_lines = [
+            '[build-system]',
+            'requires = ["setuptools>=61.0"]',
+            '',
+            '[project]',
+            'name = "reveal"',
+            'version = "0.1.0"',
+            'description = "Progressive file revelation tool"',
+            '',
+            '[project.scripts]',
+            'reveal = "reveal.cli:main"',
+            '',
+            '[tool.pytest]',
+            'testpaths = ["tests"]',
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        sections = structure['sections']
+        section_dict = {s['name']: s['line'] for s in sections}
+
+        # Check section line numbers
+        self.assertEqual(section_dict['build-system'], 1)
+        self.assertEqual(section_dict['project'], 4)
+        self.assertEqual(section_dict['tool'], 12)
+
+    def test_toml_nested_sections(self):
+        """TOML analyzer should count subsections."""
+        toml_lines = [
+            '[project]',
+            'name = "test"',
+            '',
+            '[project.dependencies]',
+            'pytest = "^7.0"',
+            '',
+            '[project.scripts]',
+            'test = "pytest"',
+            '',
+            '[tool]',
+            'version = "1.0"',
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        sections = structure['sections']
+
+        # Find project section
+        project_section = next(s for s in sections if s['name'] == 'project')
+
+        # Should have subsections count
+        self.assertIn('subsections', project_section)
+        # project.dependencies and project.scripts are subsections
+        self.assertGreater(project_section['subsections'], 0)
+
+    def test_toml_empty_file(self):
+        """TOML analyzer should handle empty files."""
+        toml_lines = ['']
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        # Should return empty lists, not crash
+        self.assertEqual(structure['top_level_keys'], [])
+        self.assertEqual(structure['sections'], [])
+
+    def test_toml_with_comments(self):
+        """TOML analyzer should find keys despite comments."""
+        toml_lines = [
+            '# Application settings',
+            'name = "myapp"',
+            '',
+            '# Server configuration',
+            '[server]',
+            'port = 8080',
+        ]
+
+        analyzer = TOMLAnalyzer(toml_lines)
+        structure = analyzer.analyze_structure()
+
+        keys = structure['top_level_keys']
+        sections = structure['sections']
+
+        # Should find keys on correct lines (not comment lines)
+        key_dict = {k['name']: k['line'] for k in keys}
+        self.assertEqual(key_dict['name'], 2)
+
+        section_dict = {s['name']: s['line'] for s in sections}
+        self.assertEqual(section_dict['server'], 5)
+
+
+class TestTOMLComposability(unittest.TestCase):
+    """Test that TOML line numbers make output composable."""
+
+    def test_toml_format_location_helper(self):
+        """TOML analyzer should use format_location helper."""
+        toml_lines = ['name = "test"']
+
+        analyzer = TOMLAnalyzer(toml_lines, file_path='config.toml')
+
+        # Test format_location helper
+        loc = analyzer.format_location(1)
+        self.assertEqual(loc, 'config.toml:1')
+
+        # Without file_path, should use L0000 format
+        analyzer_no_path = TOMLAnalyzer(toml_lines)
+        loc = analyzer_no_path.format_location(1)
+        self.assertEqual(loc, 'L0001')
+
+
+if __name__ == '__main__':
+    unittest.main()