├── .checkignore
├── .checkmate.yml
├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── checkmate
    ├── .checkmate
    │   └── db.sqlite
    ├── __init__.py
    ├── __main__.py
    ├── contrib
    │   ├── __init__.py
    │   └── plugins
    │   │   ├── __init__.py
    │   │   ├── git
    │   │       ├── __init__.py
    │   │       ├── commands
    │   │       │   ├── __init__.py
    │   │       │   ├── analyze.py
    │   │       │   ├── base.py
    │   │       │   ├── diff.py
    │   │       │   ├── init.py
    │   │       │   └── update_stats.py
    │   │       ├── hooks
    │   │       │   ├── __init__.py
    │   │       │   └── project.py
    │   │       ├── lib
    │   │       │   ├── __init__.py
    │   │       │   ├── repository.py
    │   │       │   ├── repository_pygit2.py
    │   │       │   └── ssh
    │   │       ├── models.py
    │   │       ├── setup.py
    │   │       └── test
    │   │       │   ├── __init__.py
    │   │       │   ├── analysis
    │   │       │       ├── __init__.py
    │   │       │       ├── test_analysis.py
    │   │       │       └── test_diffing.py
    │   │       │   ├── data
    │   │       │       ├── diff_project.tar.gz
    │   │       │       ├── project.tar.gz
    │   │       │       ├── simple_project.tar.gz
    │   │       │       └── test_repository
    │   │       │       │   └── d3py.tar.gz
    │   │       │   ├── git
    │   │       │       ├── __init__.py
    │   │       │       └── test_git.py
    │   │       │   ├── helpers.py
    │   │       │   └── lib
    │   │       │       ├── __init__.py
    │   │       │       └── test_repository.py
    │   │   ├── github
    │   │       ├── __init__.py
    │   │       ├── commands
    │   │       │   ├── __init__.py
    │   │       │   └── analyze_pull_requests.py
    │   │       ├── models.py
    │   │       └── setup.py
    │   │   ├── javascript
    │   │       ├── __init__.py
    │   │       └── jshint
    │   │       │   ├── __init__.py
    │   │       │   ├── analyzer.py
    │   │       │   ├── issues_data.py
    │   │       │   ├── js
    │   │       │       └── json_reporter.js
    │   │       │   └── setup.py
    │   │   └── python
    │   │       ├── __init__.py
    │   │       ├── metrics
    │   │           ├── __init__.py
    │   │           ├── analyzer.py
    │   │           ├── issues_data.py
    │   │           └── setup.py
    │   │       ├── pep8
    │   │           ├── __init__.py
    │   │           ├── analyzer.py
    │   │           ├── issues_data.py
    │   │           └── setup.py
    │   │       ├── pyflakes
    │   │           ├── __init__.py
    │   │           ├── analyzer.py
    │   │           ├── issues_data.py
    │   │           └── setup.py
    │   │       └── pylint
    │   │           ├── __init__.py
    │   │           ├── analyzer.py
    │   │           ├── issues_data.py
    │   │           └── setup.py
    ├── helpers
    │   ├── __init__.py
    │   ├── facts.py
    │   ├── hashing.py
    │   ├── issue.py
    │   └── settings.py
    ├── lib
    │   ├── __init__.py
    │   ├── analysis
    │   │   ├── __init__.py
    │   │   └── base.py
    │   ├── code
    │   │   ├── __init__.py
    │   │   └── environment.py
    │   ├── models.py
    │   └── stats
    │   │   ├── __init__.py
    │   │   ├── helpers.py
    │   │   └── mapreduce.py
    ├── management
    │   ├── __init__.py
    │   ├── commands
    │   │   ├── __init__.py
    │   │   ├── alembic.py
    │   │   ├── analyze.py
    │   │   ├── analyzers.py
    │   │   ├── base.py
    │   │   ├── compare.py
    │   │   ├── export.py
    │   │   ├── info.py
    │   │   ├── init.py
    │   │   ├── issues.py
    │   │   ├── props
    │   │   │   ├── __init__.py
    │   │   │   ├── delete.py
    │   │   │   ├── get.py
    │   │   │   └── set.py
    │   │   ├── reset.py
    │   │   ├── shell.py
    │   │   ├── snapshots.py
    │   │   ├── stats.py
    │   │   ├── summary.py
    │   │   ├── sync.py
    │   │   ├── trend.py
    │   │   └── watch.py
    │   ├── decorators.py
    │   └── helpers.py
    ├── migrations
    │   ├── README
    │   ├── alembic.ini
    │   ├── env.py
    │   ├── script.py.mako
    │   └── versions
    │   │   └── 14361ae029cf_initial_db_layout.py
    ├── scripts
    │   ├── __init__.py
    │   └── manage.py
    ├── settings
    │   ├── __init__.py
    │   ├── base.py
    │   └── defaults.py
    └── test
    │   ├── __init__.py
    │   ├── data
    │       ├── project.tar.gz
    │       └── simple_project.tar.gz
    │   ├── diff
    │       ├── __init__.py
    │       ├── test_basic_diff.py
    │       └── test_object_diffing.py
    │   ├── helpers.py
    │   └── settings
    │       ├── __init__.py
    │       ├── test_analyzers.py
    │       └── test_checkignore.py
├── contributing
    ├── README.md
    ├── ecla.pdf
    └── icla.pdf
├── docs
    ├── LICENCE.md
    ├── Makefile
    ├── README.md
    ├── _themes
    │   ├── .gitignore
    │   ├── LICENSE
    │   ├── README
    │   ├── flask
    │   │   ├── layout.html
    │   │   ├── relations.html
    │   │   ├── static
    │   │   │   └── flasky.css_t
    │   │   └── theme.conf
    │   ├── flask_small
    │   │   ├── layout.html
    │   │   ├── static
    │   │   │   └── flasky.css_t
    │   │   └── theme.conf
    │   ├── flask_theme_support.py
    │   └── sphinx_rtd_theme
    │   │   ├── __init__.py
    │   │   ├── breadcrumbs.html
    │   │   ├── footer.html
    │   │   ├── layout.html
    │   │   ├── layout_old.html
    │   │   ├── search.html
    │   │   ├── searchbox.html
    │   │   ├── static
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   ├── ribbon.css
    │   │       │   └── theme.css
    │   │       ├── fonts
    │   │       │   ├── FontAwesome.otf
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.svg
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   └── fontawesome-webfont.woff
    │   │       └── js
    │   │       │   └── theme.js
    │   │   ├── theme.conf
    │   │   └── versions.html
    ├── license.txt
    ├── make.bat
    └── source
    │   ├── _static
    │       └── img
    │       │   └── logo.png
    │   ├── api
    │       ├── commands.rst
    │       ├── concepts.rst
    │       ├── dependencies.rst
    │       ├── index.rst
    │       └── plugins.rst
    │   ├── conf.py
    │   ├── contents.rst.inc
    │   ├── index.rst
    │   ├── integrations
    │       ├── git.rst
    │       └── index.rst
    │   └── tutorials
    │       ├── basic.rst
    │       └── index.rst
├── requirements-docs.txt
├── requirements-test.txt
├── requirements.txt
└── setup.py


/.checkignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/.checkignore


--------------------------------------------------------------------------------
/.checkmate.yml:
--------------------------------------------------------------------------------
1 | disable: [pylint]
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.pyc
 2 | *~
 3 | *.json
 4 | *REMOTE*
 5 | *BASE*
 6 | *LOCAL*
 7 | *BACKUP*
 8 | *.orig
 9 | **/.cache/*
10 | *.remote
11 | **venv*/
12 | *.local
13 | foo.py
14 | checkmate/plugins/*
15 | .zedstate
16 | .checkmate/*
17 | build/*
18 | docs/build/*
19 | dist/*
20 | *egg-info
21 | settings/github.py
22 | *#
23 | tmp/*
24 | *.ipynb
25 | *ipynb*


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: python
 2 | sudo: false
 3 | dist: trusty
 4 | before_script:
 5 |   - sleep 10
 6 | python:
 7 |   - "2.7"
 8 | #  - "3.3"
 9 |   # does not have headers provided, please ask https://launchpad.net/~pypy/+archive/ppa
10 |   # maintainers to fix their pypy-dev package.
11 | #  - "pypy"
12 | # command to install dependencies
13 | install:
14 |   - pip install .
15 |   - pip install -r requirements.txt
16 |   - pip install -r requirements-test.txt
17 | # command to run tests
18 | script: py.test
19 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) <year> <copyright holders>
3 | 
4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Welcome to Checkmate!
 2 | 
 3 | [![Build Status](https://travis-ci.org/quantifiedcode/checkmate.svg?branch=master)](https://travis-ci.org/quantifiedcode/checkmate)
 4 | [![PyPI](https://img.shields.io/pypi/v/checkmate.svg?maxAge=10000)](https://pypi.python.org/pypi/checkmate)
 5 | [![Code Issues](https://www.quantifiedcode.com/api/v1/project/gh:quantifiedcode:checkmate/badge.svg)](https://www.quantifiedcode.com/app/project/gh:quantifiedcode:checkmate)
 6 | 
 7 | ## About
 8 | Checkmate is a cross-language (meta-)tool for static code analysis, written in Python. Unlike other tools, it provides a global overview of the code quality in a project and aims to provide clear, actionable insights to the user.
 9 | 
10 | ### Keypoints
11 | 
12 | * Provides a global overview of code quality in a project
13 | * Plays nicely with 3rd party libraries and checkers (e.g. pylint, pep8, jslint, etc.)
14 | * Keeps analysis results in a document-oriented database and allows for fast querying
15 | * Can be easily extended to new code checkers or version control systems by creating plugins
16 | 
17 | ### Current Status
18 | 
19 | The first working version of the tool nears completion, please be patient :)
20 | 
21 | ## Licences
22 | 
23 | * Checkmate is licensed under the MIT license. To view a copy of this license, visit [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT).
24 | 
25 | * [![Creative Commons License](https://i.creativecommons.org/l/by-nc/4.0/80x15.png)](http://creativecommons.org/licenses/by-nc/4.0/)
26 | Checkmate's documentation by [QuantifiedCode UG (haftungsbeschränkt)](https://github.com/quantifiedcode/checkmate) is licensed under a [Creative Commons Attribution-NonCommercial 4.0 International License](http://creativecommons.org/licenses/by-nc/4.0/).
27 | 
28 | ## Questions?
29 | 
30 | If you have any questions, please get in touch with us:
31 | 
32 | * [E-Mail](andreas@quantifiedcode.com)
33 | * [@quantifiedcode](https://twitter.com/quantifiedcode)
34 | 


--------------------------------------------------------------------------------
/checkmate/.checkmate/db.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/.checkmate/db.sqlite


--------------------------------------------------------------------------------
/checkmate/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/__init__.py


--------------------------------------------------------------------------------
/checkmate/__main__.py:
--------------------------------------------------------------------------------
1 | import sys
2 | 
3 | if __name__ == '__main__':
4 |     print("test")
5 |     print(sys.argv)
6 | 


--------------------------------------------------------------------------------
/checkmate/contrib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/commands/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 
3 | from .init import Command as InitCommand
4 | from .analyze import Command as AnalyzeCommand
5 | from .diff import Command as DiffCommand
6 | from .update_stats import Command as UpdateStatsCommand
7 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/commands/base.py:
--------------------------------------------------------------------------------
 1 | from checkmate.management.commands.base import BaseCommand
 2 | from sqlalchemy.orm.exc import NoResultFound
 3 | 
 4 | class Command(BaseCommand):
 5 | 
 6 |     def __init__(self,*args,**kwargs):
 7 |         super(Command,self).__init__(*args,**kwargs)
 8 |         if not hasattr(self,'project'):
 9 |             raise AttributeError("No project defined!")
10 |         if not hasattr(self.project,'git'):
11 |             raise AttributeError("Not a git project!")
12 |         try:
13 |             self.project.git.eager
14 |         except self.project.git.DoesNotExist:
15 |             raise AttributeError("Repository not found!")


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/commands/init.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from checkmate.management.commands.init import Command as BaseCommand
 5 | from checkmate.management.helpers import (get_project_config,
 6 |                                           get_project,
 7 |                                           get_backend)
 8 | import sys
 9 | import os
10 | import os.path
11 | import json
12 | import time
13 | import uuid
14 | import logging
15 | 
16 | from ..models import GitRepository
17 | 
18 | logger = logging.getLogger(__name__)
19 | 
20 | class Command(BaseCommand):
21 | 
22 |     description = """
23 |     Initializes a new git checkmate project. Requires an initialized checkmate project.
24 |     """
25 | 
26 |     def find_git_repository(self, path):
27 |         """
28 |         Tries to find a directory with a .git repository
29 |         """
30 |         while path is not None:
31 |             git_path = os.path.join(path,'.git')
32 |             if os.path.exists(git_path) and os.path.isdir(git_path):
33 |                 return path
34 |             path = os.path.dirname(path)
35 |         return None
36 | 
37 |     def run(self):
38 | 
39 |         project_path = self.opts['path'] or os.getcwd()
40 | 
41 |         if self.opts.get('git_path'):
42 |             git_path = self.opts['git_path']
43 |         else:
44 |             git_path = self.find_git_repository(project_path)
45 | 
46 |         if git_path is None:
47 |             logger.error("No git project found!")
48 |             return -1
49 | 
50 |         try:
51 |             repo = self.backend.get(GitRepository,{'project' : self.project})
52 |         except GitRepository.DoesNotExist:
53 |             repo = GitRepository({'project' : self.project})
54 | 
55 |         repo.path = project_path
56 | 
57 |         with self.backend.transaction():
58 |             self.backend.save(repo)
59 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/commands/update_stats.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | import logging
 5 | from collections import defaultdict
 6 | 
 7 | from checkmate.management.commands.base import BaseCommand
 8 | from ..models import GitBranch
 9 | 
10 | logger = logging.getLogger(__name__)
11 | 
12 | class Command(BaseCommand):
13 | 
14 |     def run(self):
15 | 
16 |         branches = self.backend.filter(GitBranch,{'project.pk' : self.project.pk})
17 | 
18 |         branches_by_name = dict([(branch.name,branch) for branch in branches])
19 | 
20 |         if 'default_branch' in self.project and self.project.default_branch in branches_by_name:
21 |             master_branch = branches_by_name[self.project.default_branch]
22 |         elif 'origin/master' in branches_by_name:
23 |             master_branch = branches_by_name['origin/master']
24 |         else:
25 |             logger.warning("No default branch defined for project %s" % self.project.pk)
26 |             return -1
27 | 
28 |         stats = {
29 |             'contributors' : self.project.git.repository.get_contributors(),
30 |             'branch' : master_branch.name
31 |         }
32 | 
33 |         stats['n_commits'] = sum([contributor['n_commits'] for contributor in stats['contributors']])
34 | 
35 |         self.project.stats = stats
36 |         with self.backend.transaction():
37 |             self.backend.save(self.project)
38 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/hooks/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/hooks/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/hooks/project.py:
--------------------------------------------------------------------------------
 1 | from ..models import GitSnapshot,GitBranch
 2 | import logging
 3 | 
 4 | logger = logging.getLogger(__name__)
 5 | 
 6 | def before_project_save(settings, project):
 7 |     pass
 8 | 
 9 | def before_project_reset(settings, project):
10 |     backend = project.backend
11 |     branches = backend.filter(GitBranch,{'project' : project})
12 |     logger.debug("Deleting %d branches" % len(branches))
13 |     branches.delete()
14 |     snapshots = backend.filter(GitSnapshot,{'snapshot.project' : project})
15 |     logger.debug("Deleting %d snapshots" % len(snapshots))
16 |     snapshots.delete()
17 | 	#do not call commit here, as this is done above
18 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/lib/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/lib/ssh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | ssh -F "$CONFIG_FILE" $@
3 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/models.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | from __future__ import unicode_literals
  3 | 
  4 | import os
  5 | import uuid
  6 | import time
  7 | import datetime
  8 | import logging
  9 | import copy
 10 | import traceback
 11 | 
 12 | logger = logging.getLogger(__name__)
 13 | 
 14 | from blitzdb.fields import (DateTimeField,
 15 |                             CharField,
 16 |                             IntegerField,
 17 |                             ForeignKeyField,
 18 |                             EnumField,
 19 |                             TextField,
 20 |                             ManyToManyField)
 21 | 
 22 | from checkmate.lib.models import (Snapshot,
 23 |                                   Project,
 24 |                                   BaseDocument,
 25 |                                   FileRevision,
 26 |                                   Diff,
 27 |                                   IssueOccurrence)
 28 | from .lib.repository import Repository
 29 | from checkmate.helpers.hashing import Hasher
 30 | 
 31 | class GitRepository(BaseDocument):
 32 | 
 33 |     path_ = CharField(indexed=True)
 34 |     project = ForeignKeyField('Project', backref = 'git', unique=True)
 35 |     default_branch = CharField(indexed=True)
 36 | 
 37 |     @property
 38 |     def path(self):
 39 |         return self.path_
 40 | 
 41 |     @path.setter
 42 |     def path(self, path):
 43 |         self.path_ = path
 44 | 
 45 |     def get_settings(self):
 46 |         default_branch = self.get_default_branch()
 47 |         if default_branch is None:
 48 |             return
 49 |         branches = self.repository.get_branches()
 50 |         if default_branch in branches:
 51 |             latest_commit = self.repository.get_commits(default_branch,limit = 1)[0]
 52 |             try:
 53 |                 checkmate_file_content = self.repository\
 54 |                                  .get_file_content(latest_commit['sha'],'.checkmate.yml')
 55 |                 try:
 56 |                     checkmate_settings = yaml.load(checkmate_file_content)
 57 |                     return checkmate_settings
 58 |                 except:
 59 |                     raise ValueError("Cannot parse checkmate YML file!")
 60 |             except:
 61 |                 logger.warning("No .checkmate.yml file found!")
 62 |         return
 63 | 
 64 |     @property
 65 |     def repository(self):
 66 |         if not hasattr(self,'_repository'):
 67 |             self._repository = Repository(self.path)
 68 |         return self._repository
 69 | 
 70 |     def get_snapshots(self,**kwargs):
 71 |         """
 72 |         Returns a list of snapshots in a given repository.
 73 |         """
 74 |         commits = self.repository.get_commits(**kwargs)
 75 |         snapshots = []
 76 |         for commit in commits:
 77 |             for key in ('committer_date','author_date'):
 78 |                 commit[key] = datetime.datetime.fromtimestamp(commit[key+'_ts'])
 79 |             snapshot = GitSnapshot(commit)
 80 |             hasher = Hasher()
 81 |             hasher.add(snapshot.sha)
 82 |             snapshot.hash = hasher.digest.hexdigest()
 83 |             snapshot.project = self.project
 84 |             snapshot.pk = uuid.uuid4().hex
 85 |             snapshots.append(snapshot)
 86 |         return snapshots
 87 | 
 88 |     def get_file_revisions(self,commit_sha, filters = None):
 89 | 
 90 |         files = self.repository.get_files_in_commit(commit_sha)
 91 | 
 92 |         if filters:
 93 |             for filter_func in filters:
 94 |                 files = [f for f in files if f['path'] in filter_func([ff['path'] for ff in files])]
 95 | 
 96 |         file_revisions = []
 97 |         for file_obj in files:
 98 | 
 99 |             hasher = Hasher()
100 |             file_revision = FileRevision(file_obj)
101 | 
102 |             hasher.add(file_revision.path)
103 |             hasher.add(file_revision.sha)
104 | 
105 |             file_revision.project = self.project
106 |             file_revision.hash = hasher.digest.hexdigest()
107 |             file_revision.pk = uuid.uuid4().hex
108 |             file_revision._file_content = lambda commit_sha = commit_sha, file_revision = file_revision: self.repository.get_file_content(commit_sha,file_revision.path)
109 |             file_revisions.append(file_revision)
110 |         return file_revisions
111 | 
112 |     def get_default_branch(self):
113 |         branches = self.repository.get_branches()
114 |         if self.default_branch in branches:
115 |             return self.default_branch
116 |         elif 'origin/master' in branches:
117 |             return 'origin/master'
118 |         elif branches:
119 |             return branches[0]
120 |         else:
121 |             return
122 | 
123 | class GitSnapshot(BaseDocument):
124 | 
125 |     """
126 |     """
127 | 
128 |     project = ForeignKeyField('Project',unique = False,backref = 'git_snapshots')
129 |     snapshot = ForeignKeyField('Snapshot',unique = True,backref = 'git_snapshot')
130 |     sha = CharField(indexed = True,length = 40)
131 |     hash = CharField(indexed = True,length = 64)
132 |     committer_date = DateTimeField(indexed = True)
133 |     author_date = DateTimeField(indexed = True)
134 |     author_name = CharField(length = 100)
135 |     committer_date_ts = IntegerField(indexed = True)
136 |     author_date_ts = IntegerField(indexed = True)
137 |     tree_sha = CharField(indexed = True,length = 40)
138 |     log = TextField(indexed = False)
139 | 
140 |     class Meta(BaseDocument.Meta):
141 | 
142 |         unique_together = [('project','sha')]
143 | 
144 | class GitBranch(BaseDocument):
145 | 
146 |     project = ForeignKeyField('Project',backref = 'git_branches')
147 |     name = CharField(indexed = True,length = 100)
148 |     hash = CharField(indexed = True,length = 64)
149 |     remote = CharField(indexed = True,length = 100)
150 |     last_analyzed_snapshot = ForeignKeyField('GitSnapshot')
151 |     head_snapshot = ForeignKeyField('GitSnapshot')
152 | 
153 |     class Meta(BaseDocument.Meta):
154 | 
155 |         unique_together = [('project','name')]
156 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/setup.py:
--------------------------------------------------------------------------------
 1 | from .commands.analyze import Command as AnalyzeCommand
 2 | from .commands.diff import Command as DiffCommand
 3 | from .commands.update_stats import Command as UpdateStatsCommand
 4 | from .commands.init import Command as InitCommand
 5 | 
 6 | from .models import GitSnapshot, GitBranch, GitRepository
 7 | from .hooks.project import before_project_save,before_project_reset
 8 | 
 9 | commands = {
10 |     'init' : InitCommand,
11 |     'analyze' : AnalyzeCommand,
12 |     'diff' : DiffCommand,
13 |     'update_stats' : UpdateStatsCommand
14 | }
15 | 
16 | models = {
17 |     'GitSnapshot' : GitSnapshot,
18 |     'GitBranch' : GitBranch,
19 |     'GitRepository' : GitRepository,
20 | }
21 | 
22 | hooks = {
23 |     'project.save.before' : before_project_save,
24 |     'project.reset.before' : before_project_reset
25 | }
26 | 
27 | top_level_commands = {}
28 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/__init__.py:
--------------------------------------------------------------------------------
1 | import os
2 | import tempfile
3 | import pytest
4 | import subprocess
5 | 
6 | TEST_DIRECTORY = os.path.abspath(__file__+"/../")
7 | DATA_DIRECTORY = os.path.join(TEST_DIRECTORY,"data")
8 | GIT_TEST_REPOSITORY = DATA_DIRECTORY + "/test_repository/d3py.tar.gz"
9 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/analysis/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/analysis/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/analysis/test_analysis.py:
--------------------------------------------------------------------------------
 1 | from ..helpers import RepositoryBasedTest
 2 | 
 3 | from checkmate.contrib.plugins.git.commands.analyze import Command as AnalyzeCommand
 4 | from checkmate.contrib.plugins.git.models import GitSnapshot, GitBranch
 5 | from checkmate.lib.models import Issue, IssueOccurrence
 6 | from checkmate.lib.analysis import BaseAnalyzer
 7 | 
 8 | class TestProjectAnalysis(RepositoryBasedTest):
 9 | 
10 |     def test_analyze(self):
11 |         #how to handle project-specific settings?
12 |         analyze_command = AnalyzeCommand(self.project,
13 |                                          self.settings,
14 |                                          self.backend)
15 |         analyze_command.opts['n'] = 1
16 |         analyze_command.opts['branch'] = 'origin/master'
17 |         analyze_command.run()
18 | 
19 |         snapshot = self.backend.get(GitSnapshot,{})
20 |         assert snapshot
21 |         issues = self.backend.filter(Issue,{})
22 |         assert len(issues) == 1
23 |         issue_occurrences = self.backend.filter(IssueOccurrence,{})
24 |         assert len(issue_occurrences) == 3
25 |         branch = self.backend.get(GitBranch,{})
26 |         assert branch.name == 'origin/master'
27 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/analysis/test_diffing.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from checkmate.contrib.plugins.git.commands.analyze import Command as AnalyzeCommand
 3 | from checkmate.contrib.plugins.git.models import GitSnapshot
 4 | from checkmate.lib.models import (Diff,
 5 |                                   DiffFileRevision,
 6 |                                   DiffIssueOccurrence)
 7 | 
 8 | from ..helpers import RepositoryBasedTest
 9 | 
10 | class TestProjectDiffing(RepositoryBasedTest):
11 | 
12 |     gzip_filename = "diff_project.tar.gz"
13 | 
14 |     """
15 |     Change history in repository:
16 | 
17 |     * We added a file                  - a.py
18 |     * We add a file                    - b.py
19 |     * We modify a file                 - a.py
20 |     """
21 | 
22 |     file_revision_history = [
23 |         {
24 |             'added'  : 1
25 |         },
26 |         {
27 |             'added' : 1,
28 |         },
29 |         {
30 |             'modified' : 1
31 |         },
32 |     ]
33 |     def test_number_of_snapshots(self):
34 | 
35 |         #how to handle project-specific settings?
36 |         analyze_command = AnalyzeCommand(self.project,
37 |                                          self.settings,
38 |                                          self.backend)
39 |         analyze_command.opts['n'] = 3
40 |         analyze_command.opts['branch'] = 'master'
41 |         analyze_command.run()
42 | 
43 |         repository = self.project.git.repository
44 |         git_snapshots = self.project.git.get_snapshots(branch = 'master')[::-1]
45 |         snapshots = self.backend.filter(GitSnapshot,{}).sort('committer_date',-1)
46 | 
47 |         assert len(snapshots) == 3
48 | 
49 |         for snapshot,git_snapshot in zip(snapshots,git_snapshots[:len(snapshots)]):
50 |             assert snapshot['sha'] == git_snapshot['sha']
51 | 
52 |     def test_presence_of_diffs(self):
53 | 
54 |         #how to handle project-specific settings?
55 |         analyze_command = AnalyzeCommand(self.project,
56 |                                          self.settings,
57 |                                          self.backend)
58 |         analyze_command.opts['n'] = 3
59 |         analyze_command.opts['branch'] = 'master'
60 |         analyze_command.run()
61 | 
62 |         snapshots = self.backend.filter(GitSnapshot,{}).sort('committer_date',1)
63 | 
64 |         assert len(self.backend.filter(Diff,{})) == 2
65 | 
66 |         assert len(self.backend.filter(Diff,{})) == 2
67 | 
68 |         assert len(self.backend.filter(DiffFileRevision,{})) == 2
69 |         assert len(self.backend.filter(DiffIssueOccurrence,{})) == 2
70 | 
71 |         i = 0
72 |         for last_snapshot,snapshot in zip(snapshots[:-1],snapshots[1:]):
73 |             diff = self.backend.get(Diff,{'snapshot_a.git_snapshot' : last_snapshot,
74 |                                           'snapshot_b.git_snapshot' : snapshot})
75 |             assert diff.issue_occurrences
76 | 
77 |             if i == 0:
78 |                 assert len(diff.file_revisions) == 1
79 |                 assert len(diff.file_revisions.filter({'key' : 'deleted'})) == 1
80 |             i+=1
81 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/data/diff_project.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/data/diff_project.tar.gz


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/data/project.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/data/project.tar.gz


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/data/simple_project.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/data/simple_project.tar.gz


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/data/test_repository/d3py.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/data/test_repository/d3py.tar.gz


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/git/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/git/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/git/test_git.py:
--------------------------------------------------------------------------------
 1 | from ...lib.repository import Repository
 2 | from ..helpers import RepositoryBasedTest
 3 | 
 4 | import tempfile
 5 | import os
 6 | import shutil
 7 | 
 8 | class TestRepository(RepositoryBasedTest):
 9 | 
10 |     gzip_filename = "test_repository/d3py.tar.gz"
11 | 
12 |     def test_snapshots(self):
13 |         snapshots = self.project.git.get_snapshots(branch = "origin/master")
14 | 
15 |         assert len(snapshots) == 157
16 | 
17 |         assert snapshots[0].project == self.project
18 | 
19 |     def test_file_revisions(self):
20 |         snapshot = self.project.git.get_snapshots(branch = "origin/master")[-1]
21 |         file_revisions = self.project.git.get_file_revisions(snapshot['sha'])
22 |         assert len(file_revisions) == 38
23 |         assert 'd3py/HTTPHandler.py' in [f.path for f in file_revisions]
24 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/helpers.py:
--------------------------------------------------------------------------------
 1 | from unittest import TestCase
 2 | 
 3 | from checkmate.management.commands.init import Command as InitCommand
 4 | from checkmate.contrib.plugins.git.commands.init import Command as GitInitCommand
 5 | from checkmate.contrib.plugins.git.commands.analyze import Command as AnalyzeCommand
 6 | from checkmate.contrib.plugins.git.models import GitSnapshot, GitBranch
 7 | from checkmate.lib.models import Issue, IssueOccurrence
 8 | from checkmate.lib.analysis import BaseAnalyzer
 9 | from checkmate.settings import Settings
10 | from checkmate.management.helpers import get_project_and_backend
11 | 
12 | import tempfile
13 | import shutil
14 | import os
15 | import pprint
16 | import subprocess
17 | import logging
18 | import traceback
19 | 
20 | logger = logging.getLogger(__name__)
21 | 
22 | class ExampleAnalyzer(BaseAnalyzer):
23 | 
24 |     def analyze(self, file_revision):
25 |         return {
26 |             'issues' : [
27 |                 {
28 |                     'code' : 'test',
29 |                     'location' : ( ((0,1),(10,10)), ),
30 |                     'description' : 'foo',
31 |                     'fingerprint' : 'testprint'
32 |                 }
33 |             ]
34 |         }
35 | 
36 | class RepositoryBasedTest(TestCase):
37 | 
38 |     data_path = os.path.join(os.path.abspath(__file__+"/../"),"data")
39 |     gzip_filename = "project.tar.gz"
40 | 
41 |     def setUp(self):
42 | 
43 |         self.tmpdir = tempfile.mkdtemp()
44 |         self.tmp_project_path = os.path.join(self.tmpdir,"project")
45 |         subprocess.call(['tar','-xvzf',os.path.join(self.data_path,self.gzip_filename)],
46 |                         cwd = self.tmpdir)
47 | 
48 |         self.current_path = os.getcwd()
49 |         self.settings = Settings(
50 |             analyzers = {
51 |                 'test':
52 |                     {
53 |                         'title' : 'Example',
54 |                         'class' : ExampleAnalyzer,
55 |                         'language' : 'python',
56 |                         'issues_data' : {},
57 |                     },
58 |             },
59 |             aggregators = {},
60 |             models = None,
61 |             commands = {},
62 |             plugins = {'git' : 'checkmate.contrib.plugins.git'}
63 |         )
64 | 
65 |         self.settings.initialize()
66 | 
67 |         os.chdir(self.tmp_project_path)
68 |         init_command = InitCommand(project=None,settings=self.settings)
69 |         init_command.run()
70 | 
71 | 
72 |         assert os.path.exists(os.path.join(self.tmp_project_path,'.checkmate'))
73 |         self.project,self.backend = get_project_and_backend(self.tmp_project_path, self.settings)
74 | 
75 |         git_init_command = GitInitCommand(project=self.project, settings=self.settings, backend=self.backend)
76 |         git_init_command.run()
77 | 
78 | 
79 |     def tearDown(self):
80 |         os.chdir(self.current_path)
81 |         shutil.rmtree(self.tmpdir)
82 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/lib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/git/test/lib/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/git/test/lib/test_repository.py:
--------------------------------------------------------------------------------
 1 | from ...lib.repository import Repository
 2 | from ..helpers import RepositoryBasedTest
 3 | 
 4 | import tempfile
 5 | import os
 6 | import shutil
 7 | 
 8 | class TestRepository(RepositoryBasedTest):
 9 | 
10 |     gzip_filename = "test_repository/d3py.tar.gz"
11 | 
12 |     def setUp(self):
13 |         super(TestRepository,self).setUp()
14 |         self.repository = Repository(path = self.tmp_project_path)
15 |         self.tmpdir_blank_repo = tempfile.mkdtemp()
16 |         self.blank_repository = Repository(path = self.tmpdir_blank_repo)
17 | 
18 |     def tearDown(self):
19 |         shutil.rmtree(self.tmpdir_blank_repo)
20 |         super(TestRepository,self).tearDown()
21 | 
22 |     def test_init(self):
23 | 
24 |         self.blank_repository.init()
25 |         assert os.path.exists(self.blank_repository.path+"/.git")
26 |         assert os.path.isdir(self.blank_repository.path+"/.git")
27 | 
28 |     def test_add_remote(self):
29 | 
30 |         self.blank_repository.init()
31 |         self.blank_repository.add_remote(url = self.tmp_project_path,name = "my_origin")
32 |         self.blank_repository.get_remotes()
33 |         assert self.blank_repository.get_remotes() == [{'name' : 'my_origin','url' : self.tmp_project_path}]
34 | 
35 |     def test_pull_master_from_origin(self):
36 | 
37 |         self.blank_repository.init()
38 |         self.blank_repository.add_remote(url = self.tmp_project_path,name = "my_origin")
39 |         self.blank_repository.pull("my_origin","master")
40 |         set(os.listdir(self.blank_repository.path))
41 |         assert set(['README.md','d3py','setup.py','tests'])\
42 |                .issubset(set(os.listdir(self.blank_repository.path)))
43 | 
44 |     def test_get_files_in_commit(self):
45 | 
46 |         commit_sha = 'e29a09687b91381bf96034fcf1921956177c2d54'
47 |         files_in_commit = self.repository.get_files_in_commit(commit_sha)
48 |         valid_files_in_commit = set([u'd3py/geoms/bar.py',
49 |                                      u'd3py/templates.py',
50 |                                      u'd3py/geoms/area.py',
51 |                                      u'examples/d3py_line.py',
52 |                                      u'd3py/geoms/geom.py',
53 |                                      u'd3py/__init__.py',
54 |                                      u'examples/d3py_area.py',
55 |                                      u'tests/test_javascript.py',
56 |                                      u'examples/d3py_scatter.py',
57 |                                      u'd3py/geoms/__init__.py',
58 |                                      u'examples/d3py_bar.py',
59 |                                      u'd3py/geoms/xaxis.py',
60 |                                      u'.gitignore',
61 |                                      u'd3py/d3.js',
62 |                                      u'examples/d3py_vega_scatter.py',
63 |                                      u'd3py/networkx_figure.py',
64 |                                      u'README.md',
65 |                                      u'examples/d3py_multiline.py',
66 |                                      u'examples/d3py_vega_line.py',
67 |                                      u'setup.py',
68 |                                      u'd3py/javascript.py',
69 |                                      u'd3py/css.py',
70 |                                      u'd3py/geoms/yaxis.py',
71 |                                      u'tests/test_figure.py',
72 |                                      u'd3py/geoms/line.py',
73 |                                      u'd3py/vega.py',
74 |                                      u'd3py/d3py_template.html',
75 |                                      u'd3py/pandas_figure.py',
76 |                                      u'examples/d3py_graph.py',
77 |                                      u'd3py/geoms/Readme.md',
78 |                                      u'examples/d3py_vega_area.py',
79 |                                      u'examples/d3py_vega_bar.py',
80 |                                      u'd3py/geoms/point.py',
81 |                                      u'd3py/HTTPHandler.py',
82 |                                      u'd3py/test.py',
83 |                                      u'd3py/vega_template.html',
84 |                                      u'd3py/figure.py',
85 |                                      u'd3py/geoms/graph.py'])
86 |         assert set([f['path'] for f in files_in_commit]) == valid_files_in_commit
87 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/github/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/github/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/github/commands/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/github/commands/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/github/commands/analyze_pull_requests.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from checkmate.management.commands.analyze import Command as AnalyzeCommand
 5 | from ..models import GithubProject
 6 | 
 7 | import time
 8 | import datetime
 9 | import traceback
10 | import logging
11 | 
12 | from checkmate.lib.code import CodeEnvironment
13 | 
14 | logger = logging.getLogger(__name__)
15 | 
16 | class Command(AnalyzeCommand):
17 | 
18 |     options = AnalyzeCommand.options + []
19 | 
20 |     def run(self):
21 | 
22 |         if not hasattr(self.project,'github'):
23 |             logger.error("Not a Github project!")
24 |             return -1
25 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/github/models.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | import os
 6 | import uuid
 7 | import time
 8 | import datetime
 9 | import logging
10 | import copy
11 | import traceback
12 | 
13 | logger = logging.getLogger(__name__)
14 | 
15 | from checkmate.lib.models import BaseDocument
16 | 
17 | 
18 | class Github(BaseDocument):
19 | 
20 |     pass
21 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/github/setup.py:
--------------------------------------------------------------------------------
 1 | from .commands.analyze_pull_requests import Command as AnalyzePullRequestsCommand
 2 | 
 3 | commands = {
 4 |     'analyze' : AnalyzePullRequestsCommand
 5 | }
 6 | 
 7 | models = {
 8 | }
 9 | 
10 | top_level_commands = {}
11 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/javascript/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/javascript/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/javascript/jshint/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/javascript/jshint/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/javascript/jshint/analyzer.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from __future__ import absolute_import
 5 | 
 6 | from checkmate.lib.analysis.base import BaseAnalyzer
 7 | 
 8 | import logging
 9 | import os
10 | import tempfile
11 | import json
12 | import subprocess
13 | 
14 | logger = logging.getLogger(__name__)
15 | 
16 | class JSHintAnalyzer(BaseAnalyzer):
17 | 
18 |     def __init__(self, *args, **kwargs):
19 |         super(JSHintAnalyzer, self).__init__(*args, **kwargs)
20 |         try:
21 |             result = subprocess.check_output(["jshint","--version"])
22 |         except subprocess.CalledProcessError:
23 |             logger.error("Cannot initialize JSHint analyzer: Executable is missing, please install it.")
24 |             raise
25 | 
26 |     def summarize(self,items):
27 |         pass
28 | 
29 |     def analyze(self,file_revision):
30 |         issues = []
31 |         f = tempfile.NamedTemporaryFile(delete = False)
32 |         try:
33 |             with f:
34 |                 f.write(file_revision.get_file_content())
35 |             try:
36 |                 result = subprocess.check_output(["jshint",
37 |                                                   "--filename",
38 |                                                   file_revision.path,
39 |                                                   "--reporter",
40 |                                                   os.path.join(os.path.abspath(__file__+"/.."),
41 |                                                                'js/json_reporter'),
42 |                                                   f.name])
43 |             except subprocess.CalledProcessError as e:
44 |                 if e.returncode == 2:
45 |                     result = e.output
46 |                 else:
47 |                     raise
48 |             json_result = json.loads(result)
49 |             for issue in json_result:
50 |                 location = (((issue['error']['line'],issue['error']['character']),
51 |                               (issue['error']['line'],None)),)
52 |                 issues.append({
53 |                     'code' : issue['error']['code'],
54 |                     'location' : location,
55 |                     'data' : issue['error'],
56 |                     'fingerprint' : self.get_fingerprint_from_code(file_revision,location, extra_data=issue['error'])
57 |                     })
58 | 
59 |         finally:
60 |             os.unlink(f.name)
61 |         return {'issues' : issues}
62 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/javascript/jshint/js/json_reporter.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | /*JSON reporter module, which will just return a JSON dump of the errors found in a given file*/
3 | module.exports = {
4 |   reporter: function (res) {
5 |     process.stdout.write(JSON.stringify(res,undefined,true));
6 |   }
7 | };


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/javascript/jshint/setup.py:
--------------------------------------------------------------------------------
 1 | from .analyzer import JSHintAnalyzer
 2 | from .issues_data import issues_data
 3 | 
 4 | analyzers = {
 5 |     'jshint' :
 6 |         {
 7 |             'title' : 'JSHint',
 8 |             'class' : JSHintAnalyzer,
 9 |             'language' : 'javascript',
10 |             'issues_data' : issues_data,
11 |         },
12 | }
13 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/python/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/metrics/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/python/metrics/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/metrics/analyzer.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from collections import defaultdict
 5 | from checkmate.lib.analysis.base import BaseAnalyzer
 6 | 
 7 | import logging
 8 | 
 9 | logger = logging.getLogger(__name__)
10 | 
11 | class FormatAnalyzer(BaseAnalyzer):
12 | 
13 |     def diff_summary(self,summary_a,summary_b):
14 | 
15 |         return {
16 |                 'd_number_of_lines' : summary_b['total_number_of_lines']-summary_a['total_number_of_lines'],
17 |                 'd_number_of_characters' : summary_b['total_number_of_characters']-summary_a['total_number_of_characters'],
18 |                }
19 | 
20 |     def summarize(self,items):
21 | 
22 |         stats = defaultdict(lambda : {})
23 | 
24 |         stats['total_number_of_lines'] = 0
25 |         stats['total_number_of_characters'] = 0
26 |         cnt = 0
27 | 
28 |         for item in [item['stats'] for item in items if 'stats' in item]:
29 |             if 'number_of_lines' in item and 'number_of_characters' in item:
30 |                 stats['total_number_of_lines'] += item['number_of_lines']
31 |                 stats['total_number_of_characters'] += item['number_of_characters']
32 |                 cnt += 1
33 | 
34 |         if cnt:
35 |             stats['average_number_of_lines'] = stats['total_number_of_lines'] / float(cnt)
36 |             stats['average_number_of_characters'] = stats['total_number_of_characters'] / float(cnt)
37 | 
38 |         stats['number_of_files'] = cnt
39 | 
40 |         return dict(stats)
41 | 
42 |     def analyze(self,file_revision):
43 | 
44 |         stats = {}
45 |         issues = []
46 | 
47 |         try:
48 |             file_content = file_revision.get_file_content()
49 |             stats['number_of_lines'] = len(file_content.decode("utf-8","ignore").split("\n"))
50 |             stats['number_of_characters'] = len(file_content.decode("utf-8","ignore"))
51 |         except KeyboardInterrupt:
52 |             raise
53 |         except:
54 |             logger.warning("Cannot read source file: %s" % file_revision.path)
55 |             pass
56 |         return {
57 |             'stats' : stats,
58 |             'issues' : issues,
59 |         }
60 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/metrics/issues_data.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 | 
4 | issues_data = {
5 | 
6 | }
7 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/metrics/setup.py:
--------------------------------------------------------------------------------
 1 | from .analyzer import FormatAnalyzer
 2 | from .issues_data import issues_data
 3 | 
 4 | analyzers = {
 5 |     'metrics' :
 6 |         {
 7 |             'title' : 'Code Metrics',
 8 |             'class' : FormatAnalyzer,
 9 |             'language' : 'python',
10 |             'issues_data' : issues_data,
11 |         },
12 | }
13 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pep8/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file is part of checkmate, a meta code checker written in Python.
 3 | 
 4 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
 5 | 
 6 | This program is free software: you can redistribute it and/or modify
 7 | it under the terms of the GNU Affero General Public License as
 8 | published by the Free Software Foundation, either version 3 of the
 9 | License, or (at your option) any later version.
10 | 
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | GNU Affero General Public License for more details.
15 | 
16 | You should have received a copy of the GNU Affero General Public License
17 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | """
19 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pep8/analyzer.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from __future__ import unicode_literals
  4 | from __future__ import absolute_import
  5 | import ast
  6 | import os.path
  7 | import sys
  8 | import os
  9 | import checkmate.settings as settings
 10 | from checkmate.lib.stats.mapreduce import MapReducer
 11 | from checkmate.lib.stats.helpers import directory_splitter
 12 | from checkmate.lib.analysis.base import BaseAnalyzer
 13 | 
 14 | import pep8
 15 | import tempfile
 16 | 
 17 | error_types = {
 18 |     'E1' : 'indentation',
 19 |     'E2' : 'whitespace',
 20 |     'E3' : 'blank line',
 21 |     'E4' : 'import',
 22 |     'E5' : 'line length',
 23 |     'E6' : 'statement',
 24 |     'E9' : 'runtime',
 25 |     'W1' : 'indentation warning',
 26 |     'W2' : 'whitespace warning',
 27 |     'W3' : 'blank line warning',
 28 |     'W6' : 'deprecation warning',
 29 | }
 30 | 
 31 | class Pep8Analyzer(BaseAnalyzer):
 32 | 
 33 |     def summarize(self,items):
 34 | 
 35 |         stats = {
 36 |             'n_warnings' : 0,
 37 |             'n_errors' : 0,
 38 |         }
 39 | 
 40 |         for item in [item['stats'] for item in items if 'stats' in item]:
 41 |             stats['n_warnings']+=item['n_warnings']
 42 |             stats['n_errors']+=item['n_errors']
 43 | 
 44 |         return stats
 45 | 
 46 |     def analyze(self,file_revision):
 47 |         pep8style = pep8.StyleGuide(quiet = True)
 48 |         try:
 49 |             handle,temp_filename = tempfile.mkstemp()
 50 |             fh = os.fdopen(handle,"wb")
 51 |             fh.write(file_revision.get_file_content())
 52 |             fh.close()
 53 |             pep8style.init_report(Reporter)
 54 |             result = pep8style.check_files([temp_filename])
 55 |         finally:
 56 |             os.unlink(temp_filename)
 57 |         #we add the fingerprints...
 58 |         for issue in result.issues:
 59 |             issue['fingerprint'] = self.get_fingerprint_from_code(file_revision, issue['location'], extra_data=issue['data'])
 60 |         return {'issues' : result.issues}
 61 | 
 62 | class Reporter(pep8.BaseReport):
 63 | 
 64 |     def init_file(self,filename,lines,expected,line_offset):
 65 |         pep8.BaseReport.init_file(self,filename,lines,expected,line_offset)
 66 | 
 67 |     def error(self,line_number,offset,text,check):
 68 | 
 69 |         code = int(text.strip()[1:4])
 70 | 
 71 |         if text.strip()[0] == 'E':
 72 |             issue_level = 'error'
 73 |         else:
 74 |             issue_level = 'warning'
 75 | 
 76 |         error_code = text.strip()[:2]
 77 | 
 78 |         issue = {
 79 |             'code' : text.strip()[0]+"%.4d" % code,
 80 |             'data' : {'description' : text},
 81 |             'location' : (((line_number,offset),(line_number,None)),),
 82 |         }
 83 | 
 84 |         if len(self._issues) > 100:
 85 |             if self._issues[-1]['code'] != 'TooManyIssues':
 86 |                 issue = {
 87 |                     'code' : 'TooManyIssues',
 88 |                     'data' : {},
 89 |                     'location' : (((None,None),(None,None)),),
 90 |                 }
 91 |             else:
 92 |                 return
 93 | 
 94 |         self._issues.append(issue)
 95 |         pep8.BaseReport.error(self,line_number,offset,text,check)
 96 | 
 97 |     @property
 98 |     def issues(self):
 99 |         return self._issues
100 | 
101 |     def __init__(self,*args,**kwargs):
102 |         super(Reporter,self).__init__(*args,**kwargs)
103 |         self._issues = []
104 |         self._errors = []
105 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pep8/setup.py:
--------------------------------------------------------------------------------
 1 | from .analyzer import Pep8Analyzer
 2 | from .issues_data import issues_data
 3 | 
 4 | analyzers = {
 5 |     'pep8' :
 6 |         {
 7 |             'title' : 'Pep-8',
 8 |             'class' : Pep8Analyzer,
 9 |             'language' : 'python',
10 |             'issues_data' : issues_data,
11 |         },
12 | }
13 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pyflakes/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/python/pyflakes/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pyflakes/analyzer.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | import ast
 5 | import os.path
 6 | import sys
 7 | import os
 8 | import checkmate.settings as settings
 9 | import hashlib
10 | 
11 | from checkmate.lib.stats.helpers import directory_splitter
12 | from checkmate.lib.analysis.base import BaseAnalyzer
13 | from pyflakes.reporter import Reporter as BaseReporter
14 | from pyflakes.api import check as pyflakes_check
15 | 
16 | class PyFlakesAnalyzer(BaseAnalyzer):
17 | 
18 |     def summarize(self,items):
19 | 
20 |         stats = {
21 |             'n_errors' : sum([item['stats']['n_errors'] for item in items if 'stats' in item]),
22 |         }
23 | 
24 |         return stats
25 | 
26 |     def analyze(self,file_revision):
27 |         null = open(os.devnull,"w")
28 |         reporter = Reporter(null,null)
29 |         pyflakes_check(file_revision.get_file_content(),file_revision.path,reporter)
30 |         for issue in reporter._issues:
31 |             if not issue.get('fingerprint'):
32 |                 issue['fingerprint'] = self.get_fingerprint_from_code(file_revision,issue['location'], extra_data=issue['data'])
33 |         return {'issues' : reporter._issues}
34 | 
35 | class Reporter(BaseReporter):
36 | 
37 |     def __init__(self,*args,**kwargs):
38 |         super(Reporter,self).__init__(*args,**kwargs)
39 |         self._issues = []
40 | 
41 |     def unexpectedError(self,filename,msg):
42 |         issue = {
43 |             'code' : '0000',
44 |             'data' : {'description' : unicode(msg,errors='ignore')},
45 |             'location' : (),
46 |             'fingerprint' : hashlib.sha1(msg).hexdigest()
47 |         }
48 |         self._issues.append(issue)
49 | 
50 |     def syntaxError(self,filename,msg,lineno,offset,text):
51 |         location = (((lineno,offset),(lineno,None)),)
52 |         issue = {
53 |             'code' : '0001',
54 |             'type' : 'syntax error',
55 |             'level' : 'error',
56 |             'data' : {'description' : unicode(msg,errors='ignore'),'text' : unicode(text,errors='ignore')},
57 |             'location' : location,
58 |         }
59 |         self._issues.append(issue)
60 | 
61 |     def flake(self,warning):
62 |         location = (((warning.lineno,warning.col),(warning.lineno,None)),)
63 |         issue = {
64 |             'code' : warning.__class__.__name__,
65 |             'data' : {'description' : (warning.message % warning.message_args)},
66 |             'location' : location,
67 |         }
68 |         if len(self._issues) > 100:
69 |             if self._issues[-1]['code'] != 'TooManyIssues':
70 |                 issue = {
71 |                     'code' : 'TooManyIssues',
72 |                     'data' : {},
73 |                     'fingerprint' : hashlib.sha1('TooManyIssues').hexdigest()
74 |                 }
75 |             else:
76 |                 return
77 | 
78 |         self._issues.append(issue)
79 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pyflakes/issues_data.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from __future__ import unicode_literals
 3 | 
 4 | issues_data = {
 5 |     "UndefinedName" : {
 6 |                         "title" : "undefined variable",
 7 |                         "categories" : ["correctness"],
 8 |                         "severity" : 1,
 9 |                         "description" : "%(issue.data.description)s"
10 |                       },
11 |     "ImportStarUsed" : {
12 |                         "title"  : "wildcard (*) import used",
13 |                         "categories" : ["readability","maintainability"],
14 |                         "severity" : 3,
15 |                         "description" : "%(issue.data.description)s"
16 |                         },
17 |     "UnusedImport" : {
18 |                         "title"  : "unused import",
19 |                         "categories" : ["readability","maintainability","performance"],
20 |                         "severity" : 3,
21 |                         "description" : "%(issue.data.description)s"
22 |                      },
23 |     "UnusedVariable" : {
24 |                         "title"  : "unused variable",
25 |                         "categories" : ["readability","maintainability","performance"],
26 |                         "severity" : 3,
27 |                         "description" : "%(issue.data.description)s"
28 |                         },
29 |     "RedefinedWhileUnused" : {
30 |                         "title" : "redefined while unused",
31 |                         "categories" : ["readability","maintainability","correctness","performance"],
32 |                         "severity" : 2,
33 |                         "description" : "%(issue.data.description)s"
34 |                         },
35 |     "RedefinedInListComp" : {
36 |                         "title" : "redefined in list comprehension",
37 |                         "categories" : ["correctness","readability"],
38 |                         "severity" : 2,
39 |                         "description" : "%(issue.data.description)s"
40 |                         },
41 |     "ImportShadowedByLoopVar" : {
42 |                         "title" : "import shadowed by loop variable",
43 |                         "categories" : ["correctness","maintainability"],
44 |                         "severity" : 2,
45 |                         "description" : "%(issue.data.description)s"
46 |                         },
47 |     "DoctestSyntaxError" : {
48 |                         "title" : "syntax error in doctest",
49 |                         "categories" : ["correctness"],
50 |                         "severity" : 2,
51 |                         "description" : "%(issue.data.description)s"
52 |                         },
53 |     "UndefinedExport" : {
54 |                         "title" : "undefined export",
55 |                         "categories" : ["correctness"],
56 |                         "severity" : 1,
57 |                         "description" : "%(issue.data.description)s"
58 |                         },
59 |     "UndefinedLocal" : {
60 |                         "title" : "undefined local variable",
61 |                         "categories" : ["correctness"],
62 |                         "severity" : 1,
63 |                         "description" : "%(issue.data.description)s"
64 |                         },
65 |     "Redefined" : {
66 |                         "title" : "redefined object",
67 |                         "categories" : ["maintainability","correctness"],
68 |                         "severity" : 2,
69 |                         "description" : "%(issue.data.description)s"
70 |                         }
71 | }
72 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pyflakes/setup.py:
--------------------------------------------------------------------------------
 1 | from .analyzer import PyFlakesAnalyzer
 2 | from .issues_data import issues_data
 3 | 
 4 | analyzers = {
 5 |     'pyflakes' :
 6 |         {
 7 |             'title' : 'PyFlakes',
 8 |             'name' : 'pyflakes',
 9 |             'class' : PyFlakesAnalyzer,
10 |             'language' : 'python',
11 |             'issues_data' : issues_data
12 |         },
13 | }
14 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pylint/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/contrib/plugins/python/pylint/__init__.py


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pylint/analyzer.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from __future__ import unicode_literals
  4 | from __future__ import absolute_import
  5 | from pylint.lint import PyLinter
  6 | from astroid import MANAGER, AstroidBuildingException
  7 | from pylint.reporters import BaseReporter
  8 | from astroid.builder import AstroidBuilder
  9 | 
 10 | import StringIO
 11 | import traceback
 12 | import tokenize
 13 | import tempfile
 14 | import sys
 15 | import os
 16 | 
 17 | from checkmate.lib.analysis.base import BaseAnalyzer
 18 | 
 19 | class PyLintAnalyzer(BaseAnalyzer):
 20 | 
 21 |     def diff(self,results_a,results_b):
 22 |         pass
 23 | 
 24 |     def diff_summary(self,summary_a,summary_b):
 25 |         pass
 26 | 
 27 |     def summarize(self,items):
 28 | 
 29 |         stats = {
 30 |             'average_global_note' : 0,
 31 |             'n_warnings' : 0,
 32 |             'n_errors' : 0,
 33 |         }
 34 |         cnt = 0
 35 |         for item in [item['stats'] for item in items if 'stats' in item]:
 36 |             if 'global_note' in item:
 37 |                 cnt+=1
 38 |                 stats['average_global_note']+=item['global_note']
 39 |             if 'n_warnings' in item:
 40 |                 stats['n_warnings']+=item['n_warnings']
 41 |             if 'n_errors' in item:
 42 |                 stats['n_errors']+=item['n_errors']
 43 | 
 44 |         if cnt > 0:
 45 |             stats['average_global_note']/=float(cnt)
 46 |         else:
 47 |             del stats['average_global_note']
 48 | 
 49 |         return stats
 50 | 
 51 |     def analyze(self,file_revision):
 52 |         try:
 53 |             reporter = Reporter()
 54 |             linter = Linter(reporter = reporter)
 55 |             linter.load_default_plugins()
 56 |             for unsafe_checker in ['logging','stdlib']:
 57 |                 if unsafe_checker in linter._checkers:
 58 |                     del linter._checkers[unsafe_checker]
 59 |             with open(os.devnull,"w") as devnull:
 60 |                 #pylint will print a lot of garbage when it fails, so we redirect all output to dev/null
 61 |                 try:
 62 |                     old_stdout = sys.stdout
 63 |                     old_stderr = sys.stderr
 64 |                     sys.stdout = devnull
 65 |                     sys.stderr = devnull
 66 |                     linter.check(file_revision.get_file_content(),file_revision.path)
 67 |                 finally:
 68 |                     sys.stdout = old_stdout
 69 |                     sys.stderr = old_stderr
 70 |             stats = linter.stats
 71 |             stats['by_msg'] = stats['by_msg'].items()
 72 |             if 'dependencies' in stats:
 73 |                 del stats['dependencies']
 74 |             sanitized_stats = {}
 75 |             for key,value in stats.items():
 76 |                 sanitized_stats[key] = value.items() if isinstance(value,dict) \
 77 |                     else list(value) if isinstance(value,set) else value
 78 |             issues = reporter.get_issues()
 79 |             for issue in issues:
 80 |                 issue['fingerprint'] = self.get_fingerprint_from_code(file_revision,issue['location'], extra_data=issue['data'])
 81 |             return {'stats':sanitized_stats,'issues':issues}
 82 |         except KeyboardInterrupt:
 83 |             raise
 84 |         except ImportError:
 85 |             pass
 86 |         except:
 87 |             raise
 88 | 
 89 | class Reporter(BaseReporter):
 90 | 
 91 |     """
 92 |     We reimplement the add_message function and store all incoming messages in a list.
 93 |     """
 94 | 
 95 |     def __init__(self,*args,**kwargs):
 96 |         super(Reporter,self).__init__(*args,**kwargs)
 97 |         self._messages = []
 98 | 
 99 |     def add_message(self, msg_id, location, msg):
100 |         """Client API to send a message"""
101 | 
102 |         self._messages.append((msg_id,location,msg))
103 | 
104 |     def get_issues(self):
105 |         issues = []
106 | 
107 |         cnt = 0
108 |         for msg_id,location,msg in self._messages:
109 |             cnt+=1
110 |             if cnt > 100:
111 |                 issue = {
112 |                     'code' : 'TooManyIssues',
113 |                     'data' : {},
114 |                     'location' : (((None,None),(None,None)),),
115 |                 }
116 |                 issues.append(issue)
117 |                 break
118 | 
119 |             (filename,filepath,module,line_number,offset) = location
120 | 
121 |             if msg_id.strip()[0] == 'E':
122 |                 issue_level = 'error'
123 |             else:
124 |                 issue_level = 'warning'
125 | 
126 |             issue = {
127 |                 'code' : msg_id,
128 |                 'data' : {
129 |                     'description' : msg,
130 |                 },
131 |                 'location' : (((line_number,offset),(line_number,None)),),
132 |             }
133 | 
134 |             issues.append(issue)
135 | 
136 |         return issues
137 | 
138 | 
139 |     def _display(self,layout):
140 |         pass
141 | 
142 | class Linter(PyLinter):
143 | 
144 |     """
145 |     Modified version of PyLinter, which accepts a string and a filename as input and
146 |     analyzes it using the base class.
147 |     """
148 | 
149 |     def check(self,content,filename):
150 |         self._content = content
151 |         f = tempfile.NamedTemporaryFile(delete = False)
152 |         try:
153 |             with f:
154 |                 f.write(content)
155 |             return super(Linter,self).check([f.name])
156 |         finally:
157 |             os.unlink(f.name)
158 | 


--------------------------------------------------------------------------------
/checkmate/contrib/plugins/python/pylint/setup.py:
--------------------------------------------------------------------------------
 1 | from .analyzer import PyLintAnalyzer
 2 | from .issues_data import issues_data
 3 | 
 4 | analyzers = {
 5 |     'pylint' :
 6 |         {
 7 |             'name' : 'pylint',
 8 |             'title' : 'PyLint',
 9 |             'class' : PyLintAnalyzer,
10 |             'language' : 'python',
11 |             'issues_data' : issues_data,
12 |         },
13 | }
14 | 


--------------------------------------------------------------------------------
/checkmate/helpers/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/helpers/__init__.py


--------------------------------------------------------------------------------
/checkmate/helpers/facts.py:
--------------------------------------------------------------------------------
 1 | 
 2 | class Facts(object):
 3 | 
 4 |     def __init__(self):
 5 |         self.facts = {}
 6 | 
 7 |     def set(self,*args):
 8 |         path = args[:-1]
 9 |         value = args[-1]
10 |         cd = self.facts
11 |         for i,key in enumerate(path[:-1]):
12 |             if not key in cd or not isinstance(cd[key],dict) and i < len(path)-2:
13 |                 cd[key] = {}
14 |             cd = cd[key]
15 |         cd[path[-1]] = value
16 | 
17 |     def get(self,*args):
18 |         cd = self.facts
19 |         partial_path = []
20 |         for key in args:
21 |             partial_path.append(key)
22 |             if not isinstance(cd,dict) or not key in cd:
23 |                 raise KeyError("key path %s not found" % ".".join(partial_path))
24 |             cd = cd[key]
25 |         return cd


--------------------------------------------------------------------------------
/checkmate/helpers/hashing.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | 
 3 | class Hasher(object):
 4 | 
 5 |     def __init__(self):
 6 |         self.digest = hashlib.md5()
 7 | 
 8 |     def add(self,value):
 9 |         if isinstance(value,unicode):
10 |             v = value.encode("utf-8","ignore")
11 |         elif isinstance(value,(str)):
12 |             v = unicode(value,errors = 'replace').encode("utf-8","ignore")
13 |         elif isinstance(value,(int,float,long,complex,bool)):
14 |             v = unicode(str(value),errors = 'replace').encode("utf-8","ignore")
15 |         elif isinstance(value,(tuple,list)):
16 |             for v in value:
17 |                 self.add(v)
18 |             return
19 |         elif isinstance(value,dict):
20 |             for key,v in sorted(value.items(),key = lambda x : x[0]):
21 |                 self.add(key)
22 |                 self.add(v)
23 |             return
24 |         elif value is None:
25 |             v = '1bcdadabdf0de99dbdb747e951e967c5'
26 |         else:
27 |             raise AttributeError("Unhashable type: %s" % str(type(value)))
28 | 
29 |         self.digest.update(v)
30 | 
31 |     def digest(self):
32 |         return self.digest
33 | 
34 | 
35 | def get_hash(node,fields = None,exclude = ['pk','_id'],target = 'pk'):
36 |     """
37 |     Here we generate a unique hash for a given node in the syntax tree.
38 |     """
39 | 
40 |     hasher = Hasher()
41 | 
42 |     def add_to_hash(value):
43 | 
44 |         if isinstance(value,dict):
45 |             if target in value:
46 |                 add_to_hash(value[target])
47 |             else:
48 |                 attribute_list = []
49 |                 for key,v in sorted(value.items(),key = lambda x: x[0]):
50 | 
51 |                     if (fields is not None and key not in fields) \
52 |                         or (exclude is not None and key in exclude):
53 |                         continue
54 |                     add_to_hash(key)
55 |                     add_to_hash(v)
56 |         elif isinstance(value,(tuple,list)) and value and isinstance(value[0],(dict,node_class)):
57 |             for i,v in enumerate(value):
58 |                 hasher.add(i)
59 |                 add_to_hash(v)
60 |         else:
61 |             hasher.add(value)
62 | 
63 |     add_to_hash(node)
64 | 
65 |     return hasher.digest.hexdigest()
66 | 


--------------------------------------------------------------------------------
/checkmate/helpers/issue.py:
--------------------------------------------------------------------------------
  1 | from collections import defaultdict
  2 | from checkmate.lib.stats.mapreduce import MapReducer
  3 | 
  4 | class IssuesMapReducer(MapReducer):
  5 | 
  6 |     def __init__(self,aggregators,count_column = 'count',group_by = ['language','analyzer','code']):
  7 |         self.aggregators = aggregators
  8 |         self.count_column = count_column
  9 |         self.group_by = group_by
 10 | 
 11 |     def map(self,item):
 12 |         for group in self.group_by:
 13 |             if not group in item:
 14 |                 return []
 15 |         return [(key,item) for aggregator in self.aggregators 
 16 |                 for key in aggregator(item)]
 17 | 
 18 |     def reduce(self,key,items):
 19 |         grouped_issues ={}
 20 | 
 21 |         if self.group_by:
 22 |             for item in items:
 23 |                 invalid_item = False
 24 |                 current_dict = grouped_issues
 25 |                 for group in self.group_by[:-1]:
 26 |                     if not group in item:
 27 |                         invalid_item = True
 28 |                         break
 29 |                     if not item[group] in current_dict:
 30 |                         current_dict[item[group]] = {}
 31 |                     current_dict = current_dict[item[group]]
 32 |                 if not self.group_by[-1] in item:
 33 |                     invalid_item = True
 34 |                 if invalid_item:
 35 |                     continue
 36 |                 if not item[self.group_by[-1]] in current_dict:
 37 |                     current_dict[item[self.group_by[-1]]]= [0,0]
 38 |                 cd = current_dict[item[self.group_by[-1]]]
 39 |                 cd[0]+=1
 40 |                 cd[1]+=item[self.count_column]
 41 |             return grouped_issues
 42 |         else:
 43 |             issues_sum = [0,0]
 44 |             for item in items:
 45 |                 issues_sum[0]+=1
 46 |                 issues_sum[1]+=item[self.count_column]
 47 |             return issues_sum
 48 | 
 49 | def group_issues_by_fingerprint(issues):
 50 |     """
 51 |     Groups issues by fingerprint. Grouping is done by issue code in addition.
 52 |     IMPORTANT: It is assumed that all issues come from the SAME analyzer.
 53 |     """
 54 |     issues_by_fingerprint = defaultdict(list)
 55 |     for issue in issues:
 56 |         if not 'fingerprint' in issue:
 57 |             raise AttributeError("No fingerprint defined for issue with analyzer %s and code %s!" %
 58 |                 (issue.get('analyzer','(undefined)'),issue['code']))
 59 |         fp_code = "%s:%s" % (issue['fingerprint'],issue['code'])
 60 |         if fp_code in issues_by_fingerprint:
 61 |             grouped_issue = issues_by_fingerprint[fp_code]
 62 |         else:
 63 |             grouped_issue = issue.copy()
 64 |             grouped_issue['occurrences'] = []
 65 |             if 'location' in grouped_issue:
 66 |                 del grouped_issue['location']
 67 |             issues_by_fingerprint[fp_code] = grouped_issue
 68 | 
 69 |         locations = issue.get('location',[])
 70 |         if locations:
 71 |             for i,start_stop in enumerate(locations):
 72 | 
 73 |                 occurrence = {
 74 |                     'from_row' : None,
 75 |                     'to_row' : None,
 76 |                     'from_column' : None,
 77 |                     'to_column' : None,
 78 |                     'sequence' : i
 79 |                 }
 80 | 
 81 |                 grouped_issue['occurrences'].append(occurrence)
 82 | 
 83 |                 if not isinstance(start_stop,(list,tuple)) or not len(start_stop) == 2:
 84 |                     continue
 85 | 
 86 |                 start,stop = start_stop
 87 | 
 88 |                 if isinstance(start,(list,tuple)) and len(start) == 2:
 89 |                     occurrence['from_row'] = start[0]
 90 |                     occurrence['from_column'] = start[1]
 91 | 
 92 |                 if isinstance(stop,(list,tuple)) and len(stop) == 2:
 93 |                     occurrence['to_row'] = stop[0]
 94 |                     occurrence['to_column'] = stop[1]
 95 | 
 96 |             grouped_issue['occurrences'] = sorted(grouped_issue['occurrences'],key = lambda x: (x['from_row'],x['from_column']))
 97 | 
 98 |     return issues_by_fingerprint.values()
 99 | 
100 | 


--------------------------------------------------------------------------------
/checkmate/helpers/settings.py:
--------------------------------------------------------------------------------
 1 | 
 2 | def update(d,ud):
 3 |     """
 4 |     Recursively merge the values of ud into d.
 5 |     """
 6 |     if ud is None:
 7 |         return
 8 |     for key,value in ud.items():
 9 |         if not key in d:
10 |             d[key] = value
11 |         elif isinstance(value,dict):
12 |             update(d[key],value)
13 |         else:
14 |             d[key] = value


--------------------------------------------------------------------------------
/checkmate/lib/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/lib/analysis/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 
3 | from .base import *
4 | 


--------------------------------------------------------------------------------
/checkmate/lib/analysis/base.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from __future__ import unicode_literals
  4 | import abc
  5 | from checkmate.helpers.hashing import Hasher
  6 | 
  7 | class AnalyzerSettingsError(BaseException):
  8 | 
  9 |     def __init__(self,errors):
 10 |         "Errors should be a dictionary"
 11 |         self.errors = errors
 12 | 
 13 | class BaseAnalyzer(object):
 14 | 
 15 |     """
 16 |     This abstract base class defines an analyzer, which takes file content and produces
 17 |     statistics as well as a list of issues. It is also responsible for diffing statistical
 18 |     data and issues obtained for different file revisions or snapshots.
 19 |     """
 20 | 
 21 |     def __init__(self,
 22 |                  code_environment,
 23 |                  settings=None,
 24 |                  ignore=None):
 25 |         self.code_environment = code_environment
 26 |         if settings:
 27 |             self.validate_settings(settings)
 28 |         self.settings = settings
 29 |         if ignore is not None:
 30 |             self.ignore = {}
 31 |             for code in ignore:
 32 |                 self.ignore[code] = True
 33 | 
 34 |     def get_fingerprint_from_code(self,file_revision,location, extra_data=None):
 35 |         """
 36 |         This function generates a fingerprint from a series of code snippets.
 37 | 
 38 |         Can be used by derived analyzers to generate fingerprints based on code
 39 |         if nothing better is available.
 40 |         """
 41 |         code = file_revision.get_file_content()
 42 |         if not isinstance(code,unicode):
 43 |             code = unicode(code,errors = 'ignore')
 44 |         lines = code.split(u"\n")
 45 |         s = ""
 46 |         for l in location:
 47 |             ((from_row,from_column),(to_row,to_column)) = l
 48 |             if from_column is None:
 49 |                 continue
 50 |             if from_row == to_row:
 51 |                 s+=lines[from_row-1][from_column:to_column]
 52 |             else:
 53 |                 if to_row < from_row:
 54 |                     raise ValueError("from_row must be smaller than to_row")
 55 |                 s+=lines[from_row-1][from_column:]
 56 |                 current_row = from_row+1
 57 |                 while current_row < to_row:
 58 |                     s+=lines[current_row-1]
 59 |                     current_row+=1
 60 |                 s+=lines[current_row-1][:to_column]
 61 | 
 62 |         hasher = Hasher()
 63 |         hasher.add(s)
 64 | 
 65 |         if extra_data is not None:
 66 |             hasher.add(extra_data)
 67 | 
 68 |         return hasher.digest.hexdigest()
 69 | 
 70 |     @classmethod
 71 |     def validate_settings(cls,settings):
 72 |         #should raise AnalyzerSettingsError if the settings are not valid
 73 |         raise NotImplementedError
 74 | 
 75 |     @abc.abstractmethod
 76 |     def analyze(self,file_revision):
 77 |         """
 78 |         Analyze a file and return a tuple (stats,issues) containing statistics and issues.
 79 | 
 80 |         This method should return a dictionary with one of the following entries:
 81 | 
 82 |         * issues: A list of issues found in the file revision
 83 |         * stats: Statistics about the file revision
 84 |         * depends_on: A list of dependencies for the file revision
 85 |         * provides: A list of things the file revision provides (e.g. a module),
 86 |                     to be used with the `depends_on` field.
 87 |         """
 88 |         pass
 89 | 
 90 |     def diff(self,results_a,results_b):
 91 |         pass
 92 | 
 93 |     def diff_summary(self,summary_a,summary_b):
 94 |         pass
 95 | 
 96 |     @abc.abstractmethod
 97 |     def summarize(self,items):
 98 |         """
 99 |         Aggregate a list of items containing statistical information generated by 'analyze'.
100 |         """
101 |         pass
102 | 


--------------------------------------------------------------------------------
/checkmate/lib/code/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 
3 | from checkmate.lib.code.environment import CodeEnvironment
4 | 


--------------------------------------------------------------------------------
/checkmate/lib/stats/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/lib/stats/helpers.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | def directory_splitter(path,include_filename = False):
 6 |     if include_filename:
 7 |         path_hierarchy = path.split("/")
 8 |     else:
 9 |         path_hierarchy = path.split("/")[:-1]
10 |     if path.startswith('/'):
11 |         path_hierarchy = path_hierarchy[1:]
12 |     paths = []
13 |     current_path = ''
14 |     for partial_path in path_hierarchy:
15 |         paths.append(current_path)
16 |         if current_path != '':
17 |             current_path+='/'
18 |         current_path+=partial_path
19 |     paths.append(current_path)
20 |     return paths
21 | 


--------------------------------------------------------------------------------
/checkmate/lib/stats/mapreduce.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from collections import defaultdict
 5 | import abc
 6 | 
 7 | class MapReducer(object):
 8 | 
 9 |     __metaclass__ = abc.ABCMeta
10 | 
11 |     @abc.abstractmethod
12 |     def map(self,items):
13 |         return []
14 | 
15 |     @abc.abstractmethod
16 |     def reduce(self,key,values):
17 |         return []
18 | 
19 |     def filter(self,items):
20 |         return items
21 | 
22 |     def mapreduce(self,items):
23 |         map_results = [item for sublist in [self.map(item)
24 |                        for item in self.filter(items)]
25 |                        for item in sublist if item]
26 |         grouped_results = defaultdict(lambda :[])
27 |         for key,value in map_results:
28 |             grouped_results[key].append(value)
29 |         return dict([(key,self.reduce(key,values))
30 |                      for key,values in grouped_results.items()])
31 | 


--------------------------------------------------------------------------------
/checkmate/management/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file is part of checkmate, a meta code checker written in Python.
 3 | 
 4 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
 5 | 
 6 | This program is free software: you can redistribute it and/or modify
 7 | it under the terms of the GNU Affero General Public License as
 8 | published by the Free Software Foundation, either version 3 of the
 9 | License, or (at your option) any later version.
10 | 
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | GNU Affero General Public License for more details.
15 | 
16 | You should have received a copy of the GNU Affero General Public License
17 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | """
19 | 
20 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/alembic.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals,absolute_import
 4 | 
 5 | from .base import BaseCommand
 6 | from checkmate.management.helpers import save_project_config
 7 | 
 8 | import os
 9 | import logging
10 | 
11 | logger = logging.getLogger(__name__)
12 | 
13 | """
14 | Creates a new project. The command proceeds as follows:
15 | 
16 | -We create a .checkmate directory in the current directory.
17 | -If a project already exists in the same directory, we do nothing.
18 | """
19 | 
20 | from alembic.config import Config,main
21 | from checkmate.settings import project_path
22 | 
23 | class Command(BaseCommand):
24 | 
25 |     options = BaseCommand.options
26 | 
27 |     description = """
28 |     Run Alembic migrations on a projet
29 |     """
30 | 
31 |     def run(self):
32 |         alembic_cfg = Config(os.path.join(project_path,"alembic.ini"))
33 |         main(argv = self.raw_args)
34 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/analyze.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | from .base import BaseCommand
 6 | 
 7 | from collections import defaultdict
 8 | 
 9 | import sys
10 | import os
11 | import random
12 | import os.path
13 | import copy
14 | import json
15 | import time
16 | import pprint
17 | import logging
18 | 
19 | logger = logging.getLogger(__name__)
20 | 
21 | from checkmate.lib.code import CodeEnvironment
22 | from checkmate.lib.models import Snapshot,FileRevision,Issue,IssueOccurrence
23 | 
24 | class Command(BaseCommand):
25 | 
26 |     def run(self):
27 | 
28 |         settings = self.project.settings
29 | 
30 |         logger.info("Getting file revisions...")
31 |         file_revisions = self.project.get_disk_file_revisions()
32 |         logger.info("%d file revisions" % len(file_revisions))
33 | 
34 |         snapshot = self.project.DiskSnapshot({'created_at' : time.time()})
35 | 
36 |         try:
37 |             code_environment = CodeEnvironment(self.project,
38 |                                                file_revisions,
39 |                                                global_settings = self.settings,
40 |                                                project_settings = settings)
41 |             code_environment.analyze(snapshot=snapshot,
42 |                                      save_if_empty=False)
43 |         except KeyboardInterrupt:
44 |             raise
45 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/analyzers.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/base.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | import argparse
 5 | import copy
 6 | 
 7 | class BaseCommand(object):
 8 | 
 9 |     class CommandException(BaseException):
10 |         pass
11 | 
12 |     requires_valid_project = True
13 | 
14 |     options = [
15 |         {
16 |         'name'        : '--help',
17 |         'action'      : 'store_true',
18 |         'dest'        : 'help',
19 |         'default'     : False,
20 |         'help'        : 'display this help message.'
21 |         },
22 |         {
23 |         'name'        : '--non-interactive',
24 |         'action'      : 'store_true',
25 |         'dest'        : 'non_interactive',
26 |         'default'     : False,
27 |         'help'        : 'non-interactive mode.'
28 |         },
29 |         {
30 |         'name'        : '--format',
31 |         'action'      : 'store',
32 |         'dest'        : 'format',
33 |         'default'     : 'python',
34 |         'help'        : 'the output format for the return value of the command.'
35 |         },
36 |         ]
37 | 
38 |     description = None
39 | 
40 |     def __init__(self, project, settings, backend=None, prog=None, args=None):
41 |         self.project = project
42 |         self.settings = settings
43 |         self.backend = backend
44 |         self.prog = prog
45 |         self.parse_args(args if args else [])
46 | 
47 |     def _get_parser(self):
48 |         parser = argparse.ArgumentParser(self.prog,add_help = False,description = self.description)
49 |         for opt in self.options:
50 |             c_opt = copy.deepcopy(opt)
51 |             name = c_opt['name']
52 |             del c_opt['name']
53 |             parser.add_argument(name,**c_opt)
54 |         return parser
55 | 
56 |     def parse_args(self,raw_args):
57 |         parser = self._get_parser()
58 |         args,self.extra_args = parser.parse_known_args(raw_args)
59 |         self.raw_args = raw_args
60 |         self.opts = vars(args)
61 | 
62 |     def help_message(self):
63 |         parser = self._get_parser()
64 |         return parser.format_help()
65 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/compare.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/management/commands/compare.py


--------------------------------------------------------------------------------
/checkmate/management/commands/export.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/management/commands/export.py


--------------------------------------------------------------------------------
/checkmate/management/commands/info.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/management/commands/info.py


--------------------------------------------------------------------------------
/checkmate/management/commands/init.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | from checkmate.management.helpers import save_project_config
 6 | 
 7 | import sys
 8 | import os
 9 | import os.path
10 | import json
11 | import time
12 | import uuid
13 | import logging
14 | 
15 | logger = logging.getLogger(__name__)
16 | 
17 | """
18 | Creates a new project. The command proceeds as follows:
19 | 
20 | -We create a .checkmate directory in the current directory.
21 | -If a project already exists in the same directory, we do nothing.
22 | """
23 | 
24 | class Command(BaseCommand):
25 | 
26 |     requires_valid_project = False
27 | 
28 |     options = BaseCommand.options + [
29 |         {
30 |         'name'        : '--backend',
31 |         'action'      : 'store',
32 |         'dest'        : 'backend',
33 |         'type'        : str,
34 |         'default'     : 'sql',
35 |         'help'        : 'The backend to use.'
36 |         },
37 |         {
38 |         'name'        : '--backend-opts',
39 |         'action'      : 'store',
40 |         'dest'        : 'backend_opts',
41 |         'type'        : str,
42 |         'default'     : '',
43 |         'help'        : 'Backend options (e.g. connection string).'
44 |         },
45 |         {
46 |         'name'        : '--path',
47 |         'action'      : 'store',
48 |         'dest'        : 'path',
49 |         'default'     : None,
50 |         'type'        : str,
51 |         'help'        : 'The path where to create a new project (default: current working directory)'
52 |         },
53 |         {
54 |         'name'        : '--pk',
55 |         'action'      : 'store',
56 |         'dest'        : 'pk',
57 |         'type'        : str,
58 |         'default'     : None,
59 |         'help'        : 'The primary key to use for the project',
60 |         }]
61 | 
62 |     description = """
63 |     Initializes a new checkmate project.
64 |     """
65 | 
66 |     def run(self):
67 |         logger.info("Initializing new project in the current directory.")
68 | 
69 |         project_path = self.opts['path'] or os.getcwd()
70 |         config_path = project_path+"/.checkmate"
71 | 
72 |         if os.path.exists(config_path):
73 |             logger.error("Found another project with the same path, aborting.")
74 |             return -1
75 | 
76 |         if not self.opts['backend'] in ('sql'):
77 |             logger.error("Unsupported backend: %s" % self.opts['backend'])
78 |             return -1
79 | 
80 |         config = {
81 |             'project_id' : uuid.uuid4().hex if not self.opts['pk'] else self.opts['pk'],
82 |             'project_class' : 'Project',
83 |             'backend' : {
84 |                 'driver' : self.opts['backend'],
85 |             }
86 |         }
87 | 
88 |         os.makedirs(config_path)
89 |         save_project_config(project_path,config)
90 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/issues.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | import logging
 6 | 
 7 | logger = logging.getLogger(__name__)
 8 | 
 9 | from checkmate.management.commands.base import BaseCommand
10 | from checkmate.lib.models import Issue,DiskSnapshot
11 | 
12 | class Command(BaseCommand):
13 | 
14 |     """
15 |     Returns a list of issues for the current snapshot or file revision.
16 |     """
17 | 
18 |     def run(self):
19 |         snapshot_pk = None
20 |         filenames = None
21 |         if self.extra_args:
22 |             if len(self.extra_args) == 1:
23 |                 snapshot_pk = self.extra_args[0]
24 |             else:
25 |                 snapshot_pk,filenames = self.extra_args[0],self.extra_args[1:]
26 | 
27 |         if snapshot_pk:
28 |             try:
29 |                 snapshot = self.backend.get(DiskSnapshot,
30 |                                             {'pk' : {'$regex' : r'^'+snapshot_pk}})
31 |             except DiskSnapshot.DoesNotExist:
32 |                 logger.error("Snapshot %s does not exist!" % snapshot_pk)
33 |                 return -1
34 |             except DiskSnapshot.MultipleDocumentsReturned:
35 |                 logger.error("Ambiguous key %s!" % snapshot_pk)
36 |                 return -1
37 |         else:
38 |             try:
39 |                 snapshot = self.backend.filter(DiskSnapshot,{})\
40 |                                        .sort('created_at',-1)[0]
41 |             except IndexError:
42 |                 logger.error("No snapshots in this project.")
43 |                 return -1
44 |         issues = self.backend.filter(Issue,
45 |                                      {'file_revision.pk' : {'$in' : snapshot.file_revisions}})\
46 |                              .sort('analyzer',1)
47 | 
48 |         for issue in issues:
49 |             print("%(analyzer)s\t%(code)s\t" % {'analyzer' : issue['analyzer'],
50 |                                                 'code' : issue['code']})
51 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/props/__init__.py:
--------------------------------------------------------------------------------
1 | import get,set,delete


--------------------------------------------------------------------------------
/checkmate/management/commands/props/delete.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from __future__ import unicode_literals
 3 | from checkmate.management.commands.base import BaseCommand
 4 | from checkmate.management.helpers import save_project_config
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | import uuid
12 | 
13 | class Command(BaseCommand):
14 | 
15 |     description = "Deletes a project variable"
16 | 
17 |     def run(self):
18 |         if len(self.raw_args) < 1:
19 |             sys.stderr.write("Usage: props del [name]\n")
20 |             return -1
21 |         propname = self.raw_args[0]
22 |         if not hasattr(self.project,'props'):
23 |             self.project.props = {}
24 |         if propname in self.project.props:
25 |             del self.project.props[propname]
26 |         self.backend.save(self.project)
27 |         self.backend.commit()
28 |         return 0
29 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/props/get.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from __future__ import unicode_literals
 3 | from checkmate.management.commands.base import BaseCommand
 4 | from checkmate.management.helpers import save_project_config
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | import uuid
12 | 
13 | class Command(BaseCommand):
14 | 
15 |     description = "Gets a project variable"
16 | 
17 |     def run(self):
18 |         if len(self.raw_args) < 1:
19 |             sys.stderr.write("Usage: props get [name]\n")
20 |             return -1
21 |         propname = self.raw_args[0]
22 |         if not hasattr(self.project,'props'):
23 |             self.project.props = {}
24 |         if propname in self.project.props:
25 |             print(self.project.props[propname])
26 |             return 0
27 |         else:
28 |             sys.stderr.write("Unknown property: %s\n" % propname)
29 |             return -1
30 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/props/set.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from __future__ import unicode_literals
 3 | from checkmate.management.commands.base import BaseCommand
 4 | from checkmate.management.helpers import save_project_config
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | import uuid
12 | 
13 | class Command(BaseCommand):
14 | 
15 |     description = "Sets a project variable"
16 | 
17 |     def run(self):
18 |         if len(self.raw_args) < 2:
19 |             sys.stderr.write("Usage: props set [name] [value]\n")
20 |             return -1
21 |         propname = self.raw_args[0]
22 |         propvalue = self.raw_args[1]
23 |         if not hasattr(self.project,'props'):
24 |             self.project.props = {}
25 |         self.project.props[propname] = propvalue
26 |         self.backend.save(self.project)
27 |         self.backend.commit()
28 |         return 0
29 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/reset.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | 
 6 | import logging
 7 | import sys
 8 | import os
 9 | import os.path
10 | import json
11 | import time
12 | 
13 | logger = logging.getLogger(__name__)
14 | 
15 | from checkmate.lib.models import (Snapshot,
16 |                                   FileRevision,
17 |                                   Issue,
18 |                                   IssueOccurrence,
19 |                                   Diff,
20 |                                   DiffIssueOccurrence,
21 |                                   DiffFileRevision)
22 | 
23 | class Command(BaseCommand):
24 | 
25 |     def run(self):
26 | 
27 |         logger.info("Resetting project.")
28 | 
29 |         backend = self.backend
30 |         project = self.project
31 |         with backend.transaction():
32 |             self.settings.call_hooks('project.reset.before', self.project)
33 |             diffs = self.backend.filter(Diff,{'$or' : [{'project' : self.project},
34 |                                                        {'project' : {'$exists' : False}}]})
35 |             file_revisions = self.backend.filter(FileRevision,{'project' : self.project})
36 |             backend.filter(DiffIssueOccurrence,{'diff' : {'$in' : diffs}}).delete()
37 |             backend.filter(DiffFileRevision,{'file_revision' : {'$in' : file_revisions}}).delete()
38 |             backend.filter(IssueOccurrence,{'file_revision' : {'$in' : file_revisions}}).delete()
39 |             backend.filter(Issue,{'project' : project}).delete()
40 |             diffs.delete()
41 | 
42 |             logger.info("Deleting %d file revisions" % (len(file_revisions)))
43 |             file_revisions.delete()
44 |             snapshots = backend.filter(Snapshot,{'project' : self.project})
45 |             logger.info("Deleting %d snapshots" % (len(snapshots)))
46 |             snapshots.delete()
47 | 
48 |             self.settings.call_hooks('project.reset.after', self.project)
49 |         print("Done.")
50 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/shell.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | 
 6 | import sys
 7 | 
 8 | import code
 9 | """
10 | Opens a REPL
11 | """
12 | 
13 | class Command(BaseCommand):
14 | 
15 |     def run(self):
16 |         return code.interact(local = {'backend' : self.backend,
17 |                                       'project' : self.project,
18 |                                       })
19 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/snapshots.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | 
12 | """
13 | $ checkmate stats python:metrics -- --hierarchy
14 | 
15 | """
16 | 
17 | 
18 | class Command(BaseCommand):
19 | 
20 |     def run(self):
21 |         snapshots = self.backend.filter(self.project.DiskSnapshot,{}).sort('created_at',-1)
22 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/stats.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | 
12 | """
13 | $ checkmate stats python:metrics -- --hierarchy
14 | 
15 | """
16 | 
17 | 
18 | class Command(BaseCommand):
19 | 
20 |     def run(self):
21 |         pass
22 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/summary.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | from .base import BaseCommand
 5 | 
 6 | import sys
 7 | import os
 8 | import os.path
 9 | import json
10 | import time
11 | 
12 | """
13 | """
14 | 
15 | class Command(BaseCommand):
16 | 
17 |     def run(self):
18 |         pass


--------------------------------------------------------------------------------
/checkmate/management/commands/sync.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | from .base import BaseCommand
 6 | 
 7 | from collections import defaultdict
 8 | 
 9 | import sys
10 | import os
11 | import random
12 | import os.path
13 | import copy
14 | import json
15 | import time
16 | import pprint
17 | import hashlib
18 | import logging
19 | 
20 | logger = logging.getLogger(__name__)
21 | 
22 | from checkmate.lib.code import CodeEnvironment
23 | from checkmate.helpers.issue import group_issues_by_fingerprint
24 | from checkmate.lib.models import Snapshot,FileRevision,Issue,IssueOccurrence
25 | 
26 | class Command(BaseCommand):
27 | 
28 |     """
29 |     Synchronizes the following objects with an external backend:
30 | 
31 |     * Snapshot (+FileRevisions) <- needs a unique ID
32 |     * Diff (+FileRevisions) <- needs a unique ID
33 |     * FileRevision () <- needs a unique ID
34 |     * Issue <- needs a unique ID (analyzer, code, fingerprint)
35 |     * IssueOccurrence (+Issue,FileRevision) (issue.id, file_revision.id, )
36 |     * eventually other models from plugin (e.g. GitSnapshot, GitBranch)
37 | 
38 |     Strategy:
39 | 
40 |     * First, for all objects send a list with (pk, updated_at) values to the server
41 |     * The server responds with a list of unknown/outdated objects
42 |     * The client send these objects to the server, where they are imported
43 |     * The import order should always match the dependencies between the models (i.e. first FileRevision objects, then Snapshot, then Diff objects)
44 | 
45 |     The server will check for primary key conflicts and might mingle/alter the PK values of the entities
46 | 
47 |     Maybe it would be a better strategy to define unique identifiers for each object, which the server can use for checking.
48 | 
49 |     * Snapshot (sha/...)
50 |     * Diff (snapshot_a.id, snapshot_b.id)
51 |     * FileRevision: (fr_pk)
52 |     * Issue (analyzer, code, fingerprint)
53 |     * IssueOccurrence (issue.id, file_revision.id, from_row, from_col, to_row, to_col, sequence)
54 |     * Snapshot:
55 |     """
56 | 
57 |     def run(self):
58 | 
59 |         settings = self.project.settings
60 | 
61 |         logger.info("Synchronizing analysis results...")
62 | 
63 |         """
64 |         1.)
65 |         """
66 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/trend.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/management/commands/watch.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | from __future__ import unicode_literals
 4 | 
 5 | from .base import BaseCommand
 6 | 
 7 | from collections import defaultdict
 8 | 
 9 | import sys
10 | import os
11 | import random
12 | import os.path
13 | import copy
14 | import json
15 | import time
16 | import pprint
17 | import hashlib
18 | import logging
19 | 
20 | logger = logging.getLogger(__name__)
21 | 
22 | from checkmate.lib.code import CodeEnvironment
23 | from .analze import Command as AnalyzeCommand
24 | 
25 | class Command(AnalyzeCommand):
26 | 
27 |     """
28 |     Continuously watches a project for changes and analyzes modified file revisions
29 |     """
30 | 


--------------------------------------------------------------------------------
/checkmate/management/decorators.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/checkmate/management/helpers.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | from __future__ import unicode_literals
  4 | 
  5 | import os
  6 | import re
  7 | import imp
  8 | import json
  9 | import yaml
 10 | import hashlib
 11 | import fnmatch
 12 | 
 13 | from collections import defaultdict
 14 | 
 15 | from blitzdb import SqlBackend
 16 | from sqlalchemy import create_engine
 17 | 
 18 | def get_project_path(path = None):
 19 |     if not path:
 20 |         path = os.getcwd()
 21 |     while path != "/":
 22 |         config_path = os.path.join(path,'.checkmate')
 23 |         if os.path.exists(config_path) and os.path.isdir(config_path):
 24 |             return path
 25 |         path = os.path.dirname(path)
 26 |     return None
 27 | 
 28 | def get_project_config(path):
 29 |     with open(os.path.join(path,".checkmate/config.json"),"r") as config_file:
 30 |         return json.loads(config_file.read())
 31 | 
 32 | def save_project_config(path,config):
 33 |     with open(os.path.join(path,".checkmate/config.json"),"w") as config_file:
 34 |         config_file.write(json.dumps(config))
 35 | 
 36 | def get_files_list(path,with_sha = False):
 37 |     files = []
 38 |     for (dirpath,dirnames,filenames) in os.walk(path):
 39 |         files.extend([(os.path.join(dirpath,f))[len(path):] for f in filenames])
 40 |     return files
 41 | 
 42 | def apply_filter(filename,patterns):
 43 |     return reduce(lambda x,y:x or y,[True if re.search(pattern,filename,re.UNICODE)
 44 |                                      else False for pattern in patterns],False)
 45 | 
 46 | def filter_filenames_by_analyzers(filenames,analyzers,language_patterns):
 47 |     filtered_filenames = []
 48 |     for filename in filenames:
 49 |         for analyzer_params in analyzers:
 50 |             if not analyzer_params['language'] in language_patterns:
 51 |                 continue
 52 |             language_pattern = language_patterns[analyzer_params['language']]
 53 |             if not 'patterns' in language_pattern \
 54 |             or not apply_filter(filename,language_pattern['patterns']):
 55 |                 continue
 56 |             filtered_filenames.append(filename)
 57 |             break
 58 |     return filtered_filenames
 59 | 
 60 | def filter_filenames_by_checkignore(file_paths,checkignore_patterns):
 61 | 
 62 |     filtered_file_paths = []
 63 | 
 64 |     for file_path in file_paths:
 65 |         excluded = False
 66 |         always_included = False
 67 |         for pattern in checkignore_patterns:
 68 |             if pattern.startswith("!"):
 69 |                 if fnmatch.fnmatch(file_path,pattern[1:]):
 70 |                     always_included = True
 71 |                     break
 72 |             if fnmatch.fnmatch(file_path,pattern):
 73 |                 excluded = True
 74 |         if not excluded or always_included:
 75 |             filtered_file_paths.append(file_path)
 76 |     return filtered_file_paths
 77 | 
 78 | def parse_checkmate_settings(content):
 79 |     """
 80 |     Basically a simple .yml parser that returns a simple Python dict to be used later on.
 81 |     """
 82 | 
 83 |     return yaml.load(content)
 84 | 
 85 | def parse_checkignore(content):
 86 | 
 87 |     lines = [l for l in [s.strip() for s in content.split("\n")] if l and not l[0] == '#']
 88 | 
 89 |     return lines
 90 | 
 91 | def get_project_and_backend(path, settings, echo = False,initialize_db = True):
 92 |     project_path = get_project_path(path)
 93 |     project_config = get_project_config(project_path)
 94 |     backend = get_backend(project_path,project_config,settings,echo = echo,initialize_db = initialize_db)
 95 |     project = get_project(project_path,project_config,settings,backend)
 96 |     return project,backend
 97 | 
 98 | def get_backend(project_path,project_config,settings,echo = False,initialize_db = True):
 99 |     backend_config = project_config['backend']
100 |     engine = create_engine('sqlite:///%s' % os.path.join(project_path,'.checkmate/db.sqlite'),echo=echo)
101 |     backend = SqlBackend(engine)
102 | 
103 |     if initialize_db:
104 |         backend.create_schema()
105 |         return backend
106 | 
107 |         #we run the Alembic migration script.
108 |         print("Running migrations...")
109 |         from checkmate.management.commands.alembic import Command as AlembicCommand
110 |         alembic_command = AlembicCommand(None,backend,args = ['upgrade','head'])
111 |         alembic_command.run()
112 |         print("Done running migrations...")
113 | 
114 |     return backend
115 | 
116 | def get_project(project_path,project_config,settings,backend):
117 |     project_class = project_config.get('project_class','Project')
118 |     ProjectClass = settings.models[project_class]
119 | 
120 |     try:
121 |         project = backend.get(ProjectClass,{'pk' : project_config['project_id']})
122 |     except ProjectClass.DoesNotExist:
123 |         project = ProjectClass({'pk' : project_config['project_id']})
124 |         backend.save(project)
125 |         #we retrieve the project from the DB, so that all the hooks get executed properly.
126 |         project = backend.get(ProjectClass,{'pk' : project_config['project_id']})
127 | 
128 |     project.path = project_path
129 | 
130 |     with backend.transaction():
131 |         backend.save(project)
132 | 
133 |     return project
134 | 


--------------------------------------------------------------------------------
/checkmate/migrations/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration.


--------------------------------------------------------------------------------
/checkmate/migrations/alembic.ini:
--------------------------------------------------------------------------------
 1 | # A generic, single database configuration.
 2 | 
 3 | [alembic]
 4 | # path to migration scripts
 5 | script_location = checkmate/alembic
 6 | 
 7 | # template used to generate migration files
 8 | # file_template = %%(rev)s_%%(slug)s
 9 | 
10 | # max length of characters to apply to the
11 | # "slug" field
12 | #truncate_slug_length = 40
13 | 
14 | # set to 'true' to run the environment during
15 | # the 'revision' command, regardless of autogenerate
16 | # revision_environment = false
17 | 
18 | # set to 'true' to allow .pyc and .pyo files without
19 | # a source .py file to be detected as revisions in the
20 | # versions/ directory
21 | # sourceless = false
22 | 
23 | # version location specification; this defaults
24 | # to alembic/versions.  When using multiple version
25 | # directories, initial revisions must be specified with --version-path
26 | # version_locations = %(here)s/bar %(here)s/bat alembic/versions
27 | 
28 | # the output encoding used when revision files
29 | # are written from script.py.mako
30 | # output_encoding = utf-8
31 | 
32 | #sqlalchemy.url = driver://user:pass@localhost/dbname
33 | 
34 | 
35 | # Logging configuration
36 | [loggers]
37 | keys = root,sqlalchemy,alembic
38 | 
39 | [handlers]
40 | keys = console
41 | 
42 | [formatters]
43 | keys = generic
44 | 
45 | [logger_root]
46 | level = WARN
47 | handlers = console
48 | qualname =
49 | 
50 | [logger_sqlalchemy]
51 | level = WARN
52 | handlers =
53 | qualname = sqlalchemy.engine
54 | 
55 | [logger_alembic]
56 | level = INFO
57 | handlers =
58 | qualname = alembic
59 | 
60 | [handler_console]
61 | class = StreamHandler
62 | args = (sys.stderr,)
63 | level = NOTSET
64 | formatter = generic
65 | 
66 | [formatter_generic]
67 | format = %(levelname)-5.5s [%(name)s] %(message)s
68 | datefmt = %H:%M:%S
69 | 


--------------------------------------------------------------------------------
/checkmate/migrations/env.py:
--------------------------------------------------------------------------------
 1 | from __future__ import with_statement
 2 | from alembic import context
 3 | from sqlalchemy import engine_from_config, pool
 4 | from logging.config import fileConfig
 5 | 
 6 | from blitzdb.backends.sql import Backend as SqlBackend
 7 | from checkmate.management.helpers import get_project_config,get_backend,get_project_path
 8 | 
 9 | config = context.config
10 | fileConfig(config.config_file_name)
11 | 
12 | def run_migrations_offline():
13 |     """Run migrations in 'offline' mode.
14 | 
15 |     This configures the context with just a URL
16 |     and not an Engine, though an Engine is acceptable
17 |     here as well.  By skipping the Engine creation
18 |     we don't even need a DBAPI to be available.
19 | 
20 |     Calls to context.execute() here emit the given string to the
21 |     script output.
22 | 
23 |     """
24 | 
25 |     project_path = get_project_path()
26 |     project_config = get_project_config(project_path)
27 |     backend = get_backend(project_path,project_config,initialize_db = False)
28 |     url = str(backend.engine.url)
29 |     with backend.transaction():
30 |         context.configure(
31 |             connection=backend.connection,
32 |             url=url, target_metadata=backend.metadata,
33 |             literal_binds=True)
34 | 
35 |         with context.begin_transaction():
36 |             context.run_migrations()
37 | 
38 | 
39 | def run_migrations_online():
40 |     """Run migrations in 'online' mode.
41 | 
42 |     In this scenario we need to create an Engine
43 |     and associate a connection with the context.
44 | 
45 |     """
46 |     print("Running migrations online")
47 | 
48 |     project_path = get_project_path()
49 |     project_config = get_project_config(project_path)
50 | 
51 |     backend = get_backend(project_path,project_config,initialize_db = False)
52 | 
53 |     context.configure(
54 |         connection=backend.connection,
55 |         target_metadata=backend.metadata,
56 |     )
57 | 
58 |     with context.begin_transaction():
59 |         context.run_migrations()
60 | 
61 | if context.is_offline_mode():
62 |     run_migrations_offline()
63 | else:
64 |     run_migrations_online()
65 | 


--------------------------------------------------------------------------------
/checkmate/migrations/script.py.mako:
--------------------------------------------------------------------------------
 1 | """${message}
 2 | 
 3 | Revision ID: ${up_revision}
 4 | Revises: ${down_revision | comma,n}
 5 | Create Date: ${create_date}
 6 | 
 7 | """
 8 | 
 9 | # revision identifiers, used by Alembic.
10 | revision = ${repr(up_revision)}
11 | down_revision = ${repr(down_revision)}
12 | branch_labels = ${repr(branch_labels)}
13 | depends_on = ${repr(depends_on)}
14 | 
15 | from alembic import op
16 | import sqlalchemy as sa
17 | ${imports if imports else ""}
18 | 
19 | def upgrade():
20 |     ${upgrades if upgrades else "pass"}
21 | 
22 | 
23 | def downgrade():
24 |     ${downgrades if downgrades else "pass"}
25 | 


--------------------------------------------------------------------------------
/checkmate/scripts/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file is part of checkmate, a meta code checker written in Python.
 3 | 
 4 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
 5 | 
 6 | This program is free software: you can redistribute it and/or modify
 7 | it under the terms of the GNU Affero General Public License as
 8 | published by the Free Software Foundation, either version 3 of the
 9 | License, or (at your option) any later version.
10 | 
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | GNU Affero General Public License for more details.
15 | 
16 | You should have received a copy of the GNU Affero General Public License
17 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | """
19 | 
20 | 


--------------------------------------------------------------------------------
/checkmate/scripts/manage.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- coding: utf-8 -*-
  3 | """
  4 | This file is part of checkmate, a meta code checker written in Python.
  5 | 
  6 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
  7 | 
  8 | This program is free software: you can redistribute it and/or modify
  9 | it under the terms of the GNU Affero General Public License as
 10 | published by the Free Software Foundation, either version 3 of the
 11 | License, or (at your option) any later version.
 12 | 
 13 | This program is distributed in the hope that it will be useful,
 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 | GNU Affero General Public License for more details.
 17 | 
 18 | You should have received a copy of the GNU Affero General Public License
 19 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 20 | """
 21 | 
 22 | from __future__ import unicode_literals
 23 | import sys
 24 | import gzip
 25 | import time
 26 | import six
 27 | import os
 28 | import importlib
 29 | import logging
 30 | 
 31 | root = logging.getLogger()
 32 | root.setLevel(logging.INFO)
 33 | 
 34 | ch = logging.StreamHandler(sys.stdout)
 35 | ch.setLevel(logging.INFO)
 36 | formatter = logging.Formatter('%(message)s')
 37 | ch.setFormatter(formatter)
 38 | root.addHandler(ch)
 39 | 
 40 | from types import ModuleType
 41 | 
 42 | import checkmate
 43 | 
 44 | from checkmate.management import helpers,commands
 45 | from checkmate.management.helpers import (get_project_path,
 46 |                                           get_project,
 47 |                                           get_backend,
 48 |                                           get_project_config)
 49 | 
 50 | from checkmate.settings import Settings
 51 | 
 52 | def load_command_class(settings):
 53 |     i = 1
 54 |     command_chain = []
 55 |     current_commands = settings.commands
 56 |     while True:
 57 |         if len(sys.argv) < i+1:
 58 |             sys.stderr.write("Usage: checkmate [command] [command] [...] [args]\n\nType \"checkmate help\" for help\n")
 59 |             exit(-1)
 60 |         cmd = sys.argv[i]
 61 |         command_chain.append(cmd)
 62 |         i+=1
 63 |         if not cmd in current_commands:
 64 |             sys.stderr.write("Unknown command: %s\n" % " ".join(command_chain))
 65 |             exit(-1)
 66 |         if not isinstance(current_commands[cmd],dict):
 67 |             if isinstance(current_commands[cmd],six.string_types):#it is a module/class string
 68 |                 command_module_name,command_class_name = current_commands[cmd].rsplit(".",1)
 69 |                 command_module = importlib.import_module(command_module_name)
 70 |                 return getattr(command_module,command_class_name),command_chain
 71 |             else:#it is a class
 72 |                 return current_commands[cmd],command_chain
 73 |         current_commands = current_commands[cmd]
 74 | 
 75 | def main():
 76 | 
 77 |     project_path = get_project_path()
 78 | 
 79 |     settings = Settings()
 80 |     settings.update(settings.load(project_path=project_path))
 81 |     settings.initialize()
 82 | 
 83 |     if project_path:
 84 |         project_config = get_project_config(project_path)
 85 |         backend = get_backend(project_path, project_config, settings)
 86 |         project = get_project(project_path, project_config, settings, backend)
 87 |     else:
 88 |         project = None
 89 |         backend = None
 90 | 
 91 |     CommandClass,command_chain = load_command_class(settings)
 92 | 
 93 |     if CommandClass.requires_valid_project and project is None:
 94 |         sys.stderr.write("Cannot find a checkmate project in the current directory tree, aborting.\n")
 95 |         exit(-1)
 96 | 
 97 |     command = CommandClass(project,settings,
 98 |                            backend=backend,
 99 |                            prog = sys.argv[0]+" "+" ".join(command_chain),
100 |                            args = sys.argv[1+len(command_chain):])
101 |     try:
102 |         if 'help' in command.opts and command.opts['help']:
103 |             print(command.help_message())
104 |             exit(0)
105 |         result = command.run()
106 |         if hasattr(command,'serialize'):
107 |             result_str = command.serialize(result,'text')
108 |             print(result_str)
109 |     except KeyboardInterrupt:
110 |         print("[CTRL-C pressed, aborting]")
111 |         exit(-1)
112 | 
113 | if __name__ == '__main__':
114 |     main()
115 | 


--------------------------------------------------------------------------------
/checkmate/settings/__init__.py:
--------------------------------------------------------------------------------
1 | DEBUG = True
2 | 
3 | from .base import *
4 | 


--------------------------------------------------------------------------------
/checkmate/settings/base.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | from __future__ import unicode_literals
  3 | 
  4 | import logging
  5 | import sys
  6 | import traceback
  7 | import os
  8 | import importlib
  9 | import yaml
 10 | 
 11 | from . import defaults
 12 | 
 13 | logger = logging.getLogger(__name__)
 14 | project_path = os.path.dirname(os.path.dirname(__file__))
 15 | 
 16 | def update_recursively(d, ud, overwrite=True):
 17 |     for key, value in ud.items():
 18 |         if key not in d:
 19 |             d[key] = value
 20 |         elif isinstance(value,dict):
 21 |             update_recursively(d[key], value)
 22 |         else:
 23 |             if key in d and not overwrite:
 24 |                 return
 25 |             d[key] = value
 26 | 
 27 | class Settings(object):
 28 | 
 29 |     """
 30 |     Contains all relevant global settings:
 31 | 
 32 |     * Commands
 33 |     * Analyzers
 34 |     * Aggregators
 35 |     * Plugins
 36 |     * Language patterns
 37 |     * Models
 38 | 
 39 |     The global settings should not be confused with the project-specific
 40 |     settings, which contain e.g. specific configuration options for the
 41 |     individual analyzers.
 42 |     """
 43 | 
 44 |     def __init__(self,
 45 |                  commands=None,
 46 |                  analyzers=None,
 47 |                  aggregators=None,
 48 |                  plugins=None,
 49 |                  models=None,
 50 |                  hooks=None,
 51 |                  language_patterns=None):
 52 | 
 53 |         self.plugins = plugins if plugins is not None else defaults.plugins.copy()
 54 |         self.hooks = hooks if hooks is not None else defaults.hooks.copy()
 55 |         self.commands = commands if commands is not None else defaults.commands.copy()
 56 |         self.analyzers = analyzers if analyzers is not None else defaults.analyzers.copy()
 57 |         self.aggregators = aggregators if aggregators is not None else defaults.aggregators.copy()
 58 |         self.models = models if models is not None else defaults.models.copy()
 59 |         self.language_patterns = language_patterns if language_patterns is not None else defaults.language_patterns.copy()
 60 | 
 61 |     def initialize(self):
 62 |         logger.debug("Initializing checkmate settings...")
 63 |         self.load_plugins()
 64 | 
 65 |     def call_hooks(self, name,*args,**kwargs):
 66 |         if name in self.hooks:
 67 |             for hook in self.hooks[name]:
 68 |                 hook(self, *args, **kwargs)
 69 | 
 70 |     def load_plugin(self, module,name = None):
 71 |         logger.info("Loading plugin: %s" % name)
 72 |         if hasattr(module,'analyzers'):
 73 |             self.analyzers.update(module.analyzers)
 74 |         if hasattr(module,'commands'):
 75 |             if name is None:
 76 |                 raise AttributeError("You must specify a name for your plugin if you defined new commands!")
 77 |             self.commands.update({name : module.commands})
 78 |         if hasattr(module,'hooks'):
 79 |             for key,value in module.hooks.items():
 80 |                 self.hooks[key].append(value)
 81 |         if hasattr(module,'models'):
 82 |             self.models.update(module.models)
 83 |         if hasattr(module,'top_level_commands'):
 84 |             self.commands.update(module.top_level_commands)
 85 | 
 86 |     def load_plugins(self, abort_on_error=False,verbose=True):
 87 |         for name,module_name in self.plugins.items():
 88 |             try:
 89 |                 module = importlib.import_module(module_name+'.setup')
 90 |                 self.load_plugin(module,name)
 91 |             except BaseException as e:
 92 |                 logger.error("Cannot import plugin %s (module %s)" % (name,module_name))
 93 |                 if verbose:
 94 |                     logger.error(traceback.format_exc())
 95 |                 if abort_on_error:
 96 |                     raise
 97 | 
 98 |     def update(self, settings):
 99 |         if settings is None:
100 |             return
101 |         for key in ('plugins',
102 |                     'analyzers',
103 |                     'aggregators',
104 |                     'language_patterns',
105 |                     'commands',
106 |                     'models'):
107 |             if key in settings:
108 |                 update_recursively(getattr(self,key), settings[key])
109 | 
110 |     def load(self, project_path=None):
111 |         home = os.path.expanduser('~')
112 |         possible_config_paths = [home,os.path.join(os.getcwd())]
113 |         if project_path is not None:
114 |             possible_config_paths.append(project_path)
115 |         d = {}
116 |         for possible_config_path in possible_config_paths:
117 |             print(possible_config_path)
118 |             possible_config_filename = os.path.join(possible_config_path,'.checkmate.yml')
119 |             if os.path.exists(possible_config_filename) and os.path.isfile(possible_config_filename):
120 |                 with open(possible_config_filename,'r') as config_file:
121 |                     update_recursively(d,yaml.load(config_file.read()))
122 |         return d
123 | 


--------------------------------------------------------------------------------
/checkmate/settings/defaults.py:
--------------------------------------------------------------------------------
 1 | from checkmate.lib.stats.helpers import directory_splitter
 2 | from checkmate.lib.models import (Project,
 3 |                                   Snapshot,
 4 |                                   DiskSnapshot,
 5 |                                   FileRevision,
 6 |                                   Issue)
 7 | 
 8 | from collections import defaultdict
 9 | 
10 | """
11 | Default settings values
12 | """
13 | 
14 | hooks = defaultdict(list)
15 | 
16 | plugins = {
17 |            'pep8' : 'checkmate.contrib.plugins.python.pep8',
18 |            'pylint' : 'checkmate.contrib.plugins.python.pylint',
19 |            'pyflakes' : 'checkmate.contrib.plugins.python.pyflakes',
20 |            'jshint' : 'checkmate.contrib.plugins.javascript.jshint',
21 |            'metrics' : 'checkmate.contrib.plugins.python.metrics',
22 |            'git' : 'checkmate.contrib.plugins.git'
23 |            }
24 | 
25 | language_patterns = { 'python':
26 |                         {
27 |                             'name' : 'Python',
28 |                             'patterns' : [u'\.py$',u'\.pyw$'],
29 |                         },
30 |                       'javascript' : {
31 |                             'name' : 'Javascript',
32 |                             'patterns' : [u'\.js$'],
33 |                       },
34 |                       'php' : {
35 |                             'name' : 'PHP',
36 |                             'patterns' : [u'\.php$'],
37 |                       },
38 |                       'ruby' : {
39 |                             'name' : 'Ruby',
40 |                             'patterns' : [u'\.rb'],
41 |                       },
42 |                     }
43 | 
44 | analyzers = {}
45 | 
46 | commands = {
47 |     'alembic' : 'checkmate.management.commands.alembic.Command',
48 |     'init' : 'checkmate.management.commands.init.Command',
49 |     'analyze' : 'checkmate.management.commands.analyze.Command',
50 |     'reset' : 'checkmate.management.commands.reset.Command',
51 |     'shell' : 'checkmate.management.commands.shell.Command',
52 |     'summary' : 'checkmate.management.commands.summary.Command',
53 |     'snapshots' : 'checkmate.management.commands.snapshots.Command',
54 |     'issues' : 'checkmate.management.commands.issues.Command',
55 |     'props' : {
56 |         'get' : 'checkmate.management.commands.props.get.Command',
57 |         'set' : 'checkmate.management.commands.props.set.Command',
58 |         'delete' : 'checkmate.management.commands.props.delete.Command'
59 |     }
60 | }
61 | 
62 | models = {
63 |     'Project' : Project,
64 |     'Snapshot' : Snapshot,
65 |     'DiskSnapshot' : DiskSnapshot,
66 |     'FileRevision' : FileRevision,
67 |     'Issue' : Issue,
68 | }
69 | 
70 | aggregators = {
71 |     'directory' :
72 |         {
73 |             'mapper' : lambda file_revision:directory_splitter(file_revision['path'],include_filename=True)
74 |         }
75 | }
76 | 
77 | checkignore = """*/site-packages/*
78 | */dist-packages/*
79 | */build/*
80 | */eggs/*
81 | */migrations/*
82 | */alembic/versions/*
83 | """
84 | 


--------------------------------------------------------------------------------
/checkmate/test/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file is part of checkmate, a meta code checker written in Python.
 3 | 
 4 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
 5 | 
 6 | This program is free software: you can redistribute it and/or modify
 7 | it under the terms of the GNU Affero General Public License as
 8 | published by the Free Software Foundation, either version 3 of the
 9 | License, or (at your option) any later version.
10 | 
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | GNU Affero General Public License for more details.
15 | 
16 | You should have received a copy of the GNU Affero General Public License
17 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | """
19 | 
20 | 


--------------------------------------------------------------------------------
/checkmate/test/data/project.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/test/data/project.tar.gz


--------------------------------------------------------------------------------
/checkmate/test/data/simple_project.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/test/data/simple_project.tar.gz


--------------------------------------------------------------------------------
/checkmate/test/diff/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/test/diff/__init__.py


--------------------------------------------------------------------------------
/checkmate/test/diff/test_basic_diff.py:
--------------------------------------------------------------------------------
  1 | from checkmate.lib.models import (Diff,
  2 |                                   DiffFileRevision,
  3 |                                   ProjectIssueClass,
  4 |                                   IssueClass,
  5 |                                   Issue,
  6 |                                   IssueOccurrence,
  7 |                                   FileRevision,
  8 |                                   Snapshot,
  9 |                                   DiffIssueOccurrence)
 10 | 
 11 | from checkmate.lib.code.environment import CodeEnvironment
 12 | 
 13 | from ..helpers import ProjectBasedTest
 14 | 
 15 | class TestDiffing(ProjectBasedTest):
 16 | 
 17 |     def test_simple_diff(self):
 18 |         snapshot_1 = Snapshot({'project' : self.project, 'hash' : 'snapshot_1'})
 19 |         file_revision_1 = FileRevision({'path' : 'foo.py','hash' : '1:foo.py', 'language' : 'python'})
 20 | 
 21 |         issue_class_1 = IssueClass({'code' : 'wildcard','analyzer' : 'example','severity' : 2})
 22 |         project_issue_class_1 = ProjectIssueClass({'project' : self.project,
 23 |                                                    'issue_class' : issue_class_1,
 24 |                                                    'enabled' : True})
 25 |         issue_1 = Issue({'code' : 'wildcard','analyzer' : 'example','fingerprint' : '1','project' : self.project})
 26 | 
 27 |         issue_1_occurrence = IssueOccurrence({'issue' : issue_1,
 28 |                                               'file_revision' : file_revision_1,
 29 |                                               'from_row' : 1,'from_column' : 0,
 30 |                                               'to_row' : 1,'to_column' : None})
 31 | 
 32 |         snapshot_1.file_revisions = [file_revision_1]
 33 | 
 34 |         with self.backend.transaction():
 35 |             self.backend.save(snapshot_1)
 36 |             self.backend.save(issue_class_1)
 37 |             self.backend.save(project_issue_class_1)
 38 |             self.backend.save(issue_1)
 39 |             self.backend.save(issue_1_occurrence)
 40 |             self.backend.commit()
 41 | 
 42 |         snapshot_2 = Snapshot({'project' : self.project, 'hash' : 'snapshot_2'})
 43 |         file_revision_2 = FileRevision({'path' : 'bar.py','hash' : '2:bar.py','language':'python'})
 44 |         snapshot_2.file_revisions = [file_revision_1,file_revision_2]
 45 |         issue_class_2 = IssueClass({'code' : 'format','analyzer' : 'example','severity' : 1})
 46 |         project_issue_class_2 = ProjectIssueClass({'project' : self.project,
 47 |                                                    'issue_class' : issue_class_2,
 48 |                                                    'enabled' : True})
 49 |         issue_2 = Issue({'code' : 'format','analyzer' : 'example','fingerprint' : '1','project' : self.project})
 50 |         issue_2_occurrence = IssueOccurrence({'issue' : issue_2,
 51 |                                               'file_revision' : file_revision_2,
 52 |                                               'from_row' : 2,'from_column' : 0,
 53 |                                               'to_row' : 3,'to_column' : None})
 54 | 
 55 |         with self.backend.transaction():
 56 |             self.backend.save(snapshot_2)
 57 |             self.backend.save(issue_class_2)
 58 |             self.backend.save(project_issue_class_2)
 59 |             self.backend.save(issue_2_occurrence)
 60 |             self.backend.save(issue_2)
 61 | 
 62 |         environment = CodeEnvironment(project = self.project,
 63 |                                       global_settings = self.settings,
 64 |                                       project_settings = {},
 65 |                                       file_revisions = [])
 66 | 
 67 |         #We make a simple diff
 68 |         diff,diff_file_revisions,diff_issue_occurrences = environment.diff_snapshots(snapshot_1,snapshot_2)
 69 | 
 70 |         #we expect one added file revision with 1 added issue occurrence
 71 |         assert len(diff_file_revisions) == 1
 72 |         assert len(diff_issue_occurrences) == 1
 73 |         assert diff_file_revisions[0].key == 'added'
 74 |         assert diff_file_revisions[0].file_revision == file_revision_2
 75 |         assert diff_issue_occurrences[0].key == 'added'
 76 |         assert diff_issue_occurrences[0].issue_occurrence == issue_2_occurrence
 77 | 
 78 |         snapshot_3 = Snapshot({'project' : self.project, 'hash' : 'snapshot_3'})
 79 |         file_revision_3 = FileRevision({'path' : 'bar.py','hash' : '3:bar.py','language' : 'python'})
 80 |         snapshot_3.file_revisions = [file_revision_1,file_revision_3]
 81 |         issue_2_occurrence_2 = IssueOccurrence({'issue' : issue_2,
 82 |                                               'file_revision' : file_revision_3,
 83 |                                               'from_row' : 2,'from_column' : 0,
 84 |                                               'to_row' : 3,'to_column' : None})
 85 |         issue_2_occurrence_3 = IssueOccurrence({'issue' : issue_2,
 86 |                                                 'file_revision' : file_revision_3,
 87 |                                                 'from_row' : 3,'from_column' :4,
 88 |                                                 'to_row' : 5,'to_column' : 8})
 89 | 
 90 |         self.backend.save(issue_2_occurrence_2)
 91 |         self.backend.save(issue_2_occurrence_3)
 92 |         self.backend.save(snapshot_3)
 93 | 
 94 |         #We make a simple diff of the next snapshot
 95 |         diff,diff_file_revisions,diff_issue_occurrences = environment.diff_snapshots(snapshot_2,snapshot_3)
 96 | 
 97 |         #again, we expect one file revision and one issue occurrence associated with the diff
 98 |         assert len(diff_file_revisions) == 1
 99 |         assert len(diff_issue_occurrences) == 1
100 | 
101 |         assert diff_file_revisions[0].key == 'modified'
102 |         assert diff_issue_occurrences[0].key == 'added'
103 | 
104 |         issues_count_by_severity = diff.get_issues_count(by_severity=True)
105 | 
106 |         assert issues_count_by_severity['added'][1] == 1
107 |         assert issues_count_by_severity['fixed'] == {}
108 | 
109 |         issues_count = diff.get_issues_count()
110 | 
111 |         assert issues_count['added'] == 1
112 |         assert issues_count['fixed'] == 0
113 | 
114 |         summarized_issues = diff.summarize_issues()
115 | 
116 |         assert 'added' in summarized_issues
117 |         assert '' in summarized_issues['added']
118 |         assert 'python' in summarized_issues['added']['']
119 |         assert 'example' in summarized_issues['added']['']['python']
120 |         assert 'format' in summarized_issues['added']['']['python']['example']
121 |         assert summarized_issues['added']['']['python']['example']['format'] == [1,1] 
122 |         assert 'fixed' in summarized_issues and not summarized_issues['fixed']
123 | 


--------------------------------------------------------------------------------
/checkmate/test/helpers.py:
--------------------------------------------------------------------------------
 1 | from unittest import TestCase
 2 | 
 3 | from checkmate.management.commands.init import Command as InitCommand
 4 | from checkmate.management.helpers import get_project_and_backend
 5 | from checkmate.settings import Settings
 6 | 
 7 | import tempfile
 8 | import shutil
 9 | import os
10 | 
11 | 
12 | class ProjectBasedTest(TestCase):
13 | 
14 |     def setUp(self):
15 | 
16 |         self.tmpdir = tempfile.mkdtemp()
17 |         self.tmp_project_path = os.path.join(self.tmpdir,"basic_project")
18 |         os.makedirs(self.tmp_project_path)
19 | 
20 |         self.settings = Settings(
21 |             analyzers = {},
22 |             aggregators = {},
23 |             commands = {}
24 |         )
25 | 
26 |         self.settings.initialize()
27 | 
28 |         self.current_path = os.getcwd()
29 | 
30 |         os.chdir(self.tmp_project_path)
31 |         init_command = InitCommand(None,None)
32 |         init_command.run()
33 | 
34 |         assert os.path.exists(os.path.join(self.tmp_project_path,'.checkmate'))
35 | 
36 |         self.project,self.backend = get_project_and_backend(self.tmp_project_path,self.settings)
37 | 
38 |     def tearDown(self):
39 |         os.chdir(self.current_path)
40 |         shutil.rmtree(self.tmpdir)
41 | 


--------------------------------------------------------------------------------
/checkmate/test/settings/__init__.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file is part of checkmate, a meta code checker written in Python.
 3 | 
 4 | Copyright (C) 2015 Andreas Dewes, QuantifiedCode UG
 5 | 
 6 | This program is free software: you can redistribute it and/or modify
 7 | it under the terms of the GNU Affero General Public License as
 8 | published by the Free Software Foundation, either version 3 of the
 9 | License, or (at your option) any later version.
10 | 
11 | This program is distributed in the hope that it will be useful,
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | GNU Affero General Public License for more details.
15 | 
16 | You should have received a copy of the GNU Affero General Public License
17 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 | """
19 | 
20 | import os
21 | 
22 | TEST_DIRECTORY = os.path.abspath(__file__+"/../")
23 | 
24 | DATA_DIRECTORY = TEST_DIRECTORY + "/data"
25 | GIT_TEST_REPOSITORY = DATA_DIRECTORY + "/git/test_repository/d3py.tar.gz"


--------------------------------------------------------------------------------
/checkmate/test/settings/test_analyzers.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/test/settings/test_analyzers.py


--------------------------------------------------------------------------------
/checkmate/test/settings/test_checkignore.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/checkmate/test/settings/test_checkignore.py


--------------------------------------------------------------------------------
/contributing/README.md:
--------------------------------------------------------------------------------
  1 | ## How to contribute
  2 | 
  3 | Contributions are very welcome, and they are greatly appreciated! Every little bit helps, and credit will always be given.
  4 | 
  5 | ### Contributor Licence Agreement
  6 | 
  7 | We are asking all past and future contributors to sign a Contributor License Agreement (CLA). Every contributor of non-trivial amounts of code (more than just a line or two) to checkmate is required to sign a CLA. If somebody is unable to sign the CLA, the contribution (e.g., code, documentation, translations) has unfortunately to be removed from checkmate.
  8 | 
  9 | The CLA ensures that QuantifiedCode has clear licensing for all contributions to checkmate, which in turn lets us guarantee to users that we have no "stray" intellectual property or differently-licensed material.
 10 | 
 11 | **Where do I sign? What's next?**
 12 | 
 13 | 1. Download a copy of the CLA:
 14 | 
 15 |     * [Individual Contributor License Agreement (PDF)](https://github.com/quantifiedcode/checkmate/raw/master/contributing/icla.pdf): If you're working on checkmate as an individual, this is the form you should use.
 16 |     * [Entity Contributor License Agreement (PDF)](https://github.com/quantifiedcode/checkmate/raw/master/contributing/ecla.pdf): If you're working on checkmate as part of your job, you and your employer will need to download and sign this form.
 17 | 
 18 | 2. Print out the CLA and sign it.
 19 | 
 20 | 3. Send the CLA to QuantifiedCode by scanning and emailing the document to [cla@quantifiedcode.com](cla@quantifiedcode.com)
 21 | 
 22 | ### Type of contributions
 23 | 
 24 | #### Report Bugs
 25 | Report bugs at [https://github.com/quantifiedcode/checkmate/issues](https://github.com/quantifiedcode/checkmate/issues).
 26 | 
 27 | If you are reporting a bug, please include:
 28 | 
 29 | * The trackeback of the error
 30 | * Your operating system name and version
 31 | * Any details about your local setup that might be helpful in troubleshooting
 32 | * Detailed steps to reproduce the bug
 33 | * A screenshots (if useful)
 34 | 
 35 | #### Fix Bugs
 36 | Go through the [Github issues](https://github.com/quantifiedcode/checkmate/issues). Anything that is tagged as "bug" is open to whoever wants to implement it.
 37 | 
 38 | #### Add new features
 39 | Go through the  [Github issues](https://github.com/quantifiedcode/checkmate/issues). Anything tagged as "feature" is open to whoever wants to implement it.
 40 | 
 41 | #### Write Documentation
 42 | Checkmate can always get more documentation, whether as part of the official checkmate [https://docs.quantifiedcode.com](https://docs.quantifiedcode.com), in docstrings, or even on the web in blog posts,
 43 | articles, and such.
 44 | 
 45 | #### Submit Feedback and Propose Features
 46 | The best way to send feedback is to file an issue at [https://github.com/quantifiedcode/checkmate/issues](https://github.com/quantifiedcode/checkmate/issues). Additionally, you can reach out to our [team](https://www.quantifiedcode.com/team). We are looking forward getting in touch with you!
 47 | 
 48 | If you are proposing a feature:
 49 | * Detailed description of the feature to be implemented
 50 | * [User story](https://en.wikipedia.org/wiki/User_story) (if applicable)
 51 | * Keep the scope as narrow as possible, to make it easier to implement
 52 | * Remember that this is a volunteer-driven project, and that contributions are welcome :)
 53 | 
 54 | ## Get Started!
 55 | Are you ready to contribute? Here's how to set up `checkmate` for local development.
 56 | 
 57 | 1. First, make sure [MongoDB](http://docs.mongodb.org/manual/installation/) is installed on your machine.
 58 | 
 59 | 2. Fork the `checkmate` repo on GitHub.
 60 | 
 61 | 3. Clone your fork locally:
 62 | 
 63 |         $ git clone git@github.com:<your_github_user_name>/checkmate.git
 64 | 
 65 | 4. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development:
 66 | 
 67 |         $ mkvirtualenv checkmate
 68 |         $ cd checkmate/
 69 |         $ python setup.py
 70 | 
 71 | 5. Create a separate branch for each issues in your local development environment:
 72 | 
 73 |         $ git checkout -b issue/<issue_id>_<issue_title>
 74 | 
 75 |         Example:$ git checkout -b issue/112_add_jslint
 76 | 
 77 | 6. Now, make your changes locally.
 78 | 
 79 | 7. When you're done with your changes, please commit and push them to your branch:
 80 | 
 81 |         $ git add .
 82 |         $ git commit -m "Fix <issue_id>: detailed description of your changes."
 83 |         $ git push origin issue/<issue_id>_<issue_title>
 84 | 
 85 | 8. Submit a Pull Request through the GitHub website.
 86 | 
 87 | ## Pull Request Guidelines
 88 | 
 89 | Before you submit a Pull Request, check that it meets these guidelines:
 90 | 
 91 | 1. Check on [https://www.quantifiedcode.com/app#/project/gh:quantifiedcode:checkmate](Quantifiedcode) whether your code is free of errors (no login required).
 92 | 
 93 | 2. The Pull Request should include tests.
 94 | 
 95 | 3. If the Pull Request adds functionality, also the docs should be updated. Put your new functionality into a function with a docstring, and add the feature to the list in README.rst.
 96 | 
 97 | 4. The Pull Request should work for Python 2.6, 2.7, and 3.3, and for PyPy. Check [https://travis-ci.org/quantifiedcode/checkmate/pull_requests](https://travis-ci.org/quantifiedcode/checkmate/pull_requests) and make sure that the tests pass for all supported Python versions.
 98 | 
 99 | ## Tips
100 | 
101 | To run a subset of tests:
102 | 
103 |     $ python -m unittest tests.test_checkmate
104 | 


--------------------------------------------------------------------------------
/contributing/ecla.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/contributing/ecla.pdf


--------------------------------------------------------------------------------
/contributing/icla.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/contributing/icla.pdf


--------------------------------------------------------------------------------
/docs/LICENCE.md:
--------------------------------------------------------------------------------
1 | ../LICENCE.md


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for Sphinx documentation
  2 | #
  3 | 
  4 | # You can set these variables from the command line.
  5 | SPHINXOPTS    =
  6 | SPHINXBUILD   = sphinx-build
  7 | PAPER         =
  8 | BUILDDIR      = build
  9 | 
 10 | # User-friendly check for sphinx-build
 11 | ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
 12 | $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
 13 | endif
 14 | 
 15 | # Internal variables.
 16 | PAPEROPT_a4     = -D latex_paper_size=a4
 17 | PAPEROPT_letter = -D latex_paper_size=letter
 18 | ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
 19 | # the i18n builder cannot share the environment and doctrees with the others
 20 | I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
 21 | 
 22 | .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
 23 | 
 24 | help:
 25 | 	@echo "Please use \`make <target>' where <target> is one of"
 26 | 	@echo "  html       to make standalone HTML files"
 27 | 	@echo "  dirhtml    to make HTML files named index.html in directories"
 28 | 	@echo "  singlehtml to make a single large HTML file"
 29 | 	@echo "  pickle     to make pickle files"
 30 | 	@echo "  json       to make JSON files"
 31 | 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 32 | 	@echo "  qthelp     to make HTML files and a qthelp project"
 33 | 	@echo "  devhelp    to make HTML files and a Devhelp project"
 34 | 	@echo "  epub       to make an epub"
 35 | 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 36 | 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 37 | 	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
 38 | 	@echo "  text       to make text files"
 39 | 	@echo "  man        to make manual pages"
 40 | 	@echo "  texinfo    to make Texinfo files"
 41 | 	@echo "  info       to make Texinfo files and run them through makeinfo"
 42 | 	@echo "  gettext    to make PO message catalogs"
 43 | 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 44 | 	@echo "  xml        to make Docutils-native XML files"
 45 | 	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
 46 | 	@echo "  linkcheck  to check all external links for integrity"
 47 | 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 48 | 
 49 | clean:
 50 | 	rm -rf $(BUILDDIR)/*
 51 | 
 52 | html:
 53 | 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 54 | 	@echo
 55 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 56 | 
 57 | dirhtml:
 58 | 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 59 | 	@echo
 60 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 61 | 
 62 | singlehtml:
 63 | 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 64 | 	@echo
 65 | 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 66 | 
 67 | pickle:
 68 | 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 69 | 	@echo
 70 | 	@echo "Build finished; now you can process the pickle files."
 71 | 
 72 | json:
 73 | 	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
 74 | 	@echo
 75 | 	@echo "Build finished; now you can process the JSON files."
 76 | 
 77 | htmlhelp:
 78 | 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 79 | 	@echo
 80 | 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 81 | 	      ".hhp project file in $(BUILDDIR)/htmlhelp."
 82 | 
 83 | qthelp:
 84 | 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 85 | 	@echo
 86 | 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 87 | 	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 88 | 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Checkmate.qhcp"
 89 | 	@echo "To view the help file:"
 90 | 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Checkmate.qhc"
 91 | 
 92 | devhelp:
 93 | 	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
 94 | 	@echo
 95 | 	@echo "Build finished."
 96 | 	@echo "To view the help file:"
 97 | 	@echo "# mkdir -p $$HOME/.local/share/devhelp/Checkmate"
 98 | 	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Checkmate"
 99 | 	@echo "# devhelp"
100 | 
101 | epub:
102 | 	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
103 | 	@echo
104 | 	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
105 | 
106 | latex:
107 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
108 | 	@echo
109 | 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
110 | 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
111 | 	      "(use \`make latexpdf' here to do that automatically)."
112 | 
113 | latexpdf:
114 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
115 | 	@echo "Running LaTeX files through pdflatex..."
116 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
117 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
118 | 
119 | latexpdfja:
120 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
121 | 	@echo "Running LaTeX files through platex and dvipdfmx..."
122 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
123 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
124 | 
125 | text:
126 | 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
127 | 	@echo
128 | 	@echo "Build finished. The text files are in $(BUILDDIR)/text."
129 | 
130 | man:
131 | 	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
132 | 	@echo
133 | 	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
134 | 
135 | texinfo:
136 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
137 | 	@echo
138 | 	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
139 | 	@echo "Run \`make' in that directory to run these through makeinfo" \
140 | 	      "(use \`make info' here to do that automatically)."
141 | 
142 | info:
143 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
144 | 	@echo "Running Texinfo files through makeinfo..."
145 | 	make -C $(BUILDDIR)/texinfo info
146 | 	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
147 | 
148 | gettext:
149 | 	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
150 | 	@echo
151 | 	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
152 | 
153 | changes:
154 | 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
155 | 	@echo
156 | 	@echo "The overview file is in $(BUILDDIR)/changes."
157 | 
158 | linkcheck:
159 | 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
160 | 	@echo
161 | 	@echo "Link check complete; look for any errors in the above output " \
162 | 	      "or in $(BUILDDIR)/linkcheck/output.txt."
163 | 
164 | doctest:
165 | 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
166 | 	@echo "Testing of doctests in the sources finished, look at the " \
167 | 	      "results in $(BUILDDIR)/doctest/output.txt."
168 | 
169 | xml:
170 | 	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
171 | 	@echo
172 | 	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
173 | 
174 | pseudoxml:
175 | 	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
176 | 	@echo
177 | 	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
178 | 


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
1 | ../README.md


--------------------------------------------------------------------------------
/docs/_themes/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.pyo
3 | .DS_Store
4 | 


--------------------------------------------------------------------------------
/docs/_themes/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010 by Armin Ronacher.
 2 | 
 3 | Some rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms of the theme, with or
 6 | without modification, are permitted provided that the following conditions
 7 | are met:
 8 | 
 9 | * Redistributions of source code must retain the above copyright
10 |   notice, this list of conditions and the following disclaimer.
11 | 
12 | * Redistributions in binary form must reproduce the above
13 |   copyright notice, this list of conditions and the following
14 |   disclaimer in the documentation and/or other materials provided
15 |   with the distribution.
16 | 
17 | * The names of the contributors may not be used to endorse or
18 |   promote products derived from this software without specific
19 |   prior written permission.
20 | 
21 | We kindly ask you to only use these themes in an unmodified manner just
22 | for Flask and Flask-related products, not for unrelated projects.  If you
23 | like the visual style and want to use it for your own projects, please
24 | consider making some larger changes to the themes (such as changing
25 | font faces, sizes, colors or margins).
26 | 
27 | THIS THEME IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 | ARISING IN ANY WAY OUT OF THE USE OF THIS THEME, EVEN IF ADVISED OF THE
37 | POSSIBILITY OF SUCH DAMAGE.
38 | 


--------------------------------------------------------------------------------
/docs/_themes/README:
--------------------------------------------------------------------------------
 1 | Flask Sphinx Styles
 2 | ===================
 3 | 
 4 | This repository contains sphinx styles for Flask and Flask related
 5 | projects.  To use this style in your Sphinx documentation, follow
 6 | this guide:
 7 | 
 8 | 1. put this folder as _themes into your docs folder.  Alternatively
 9 |    you can also use git submodules to check out the contents there.
10 | 2. add this to your conf.py:
11 | 
12 |    sys.path.append(os.path.abspath('_themes'))
13 |    html_theme_path = ['_themes']
14 |    html_theme = 'flask'
15 | 
16 | The following themes exist:
17 | 
18 | - 'flask' - the standard flask documentation theme for large
19 |   projects
20 | - 'flask_small' - small one-page theme.  Intended to be used by
21 |   very small addon libraries for flask.
22 | 
23 | The following options exist for the flask_small theme:
24 | 
25 |    [options]
26 |    index_logo = ''              filename of a picture in _static
27 |                                 to be used as replacement for the
28 |                                 h1 in the index.rst file.
29 |    index_logo_height = 120px    height of the index logo
30 |    github_fork = ''             repository name on github for the
31 |                                 "fork me" badge
32 | 


--------------------------------------------------------------------------------
/docs/_themes/flask/layout.html:
--------------------------------------------------------------------------------
 1 | {%- extends "basic/layout.html" %}
 2 | {%- block extrahead %}
 3 |   {{ super() }}
 4 |   <link href="http://netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
 5 |   {% if theme_touch_icon %}
 6 |   <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
 7 |   {% endif %}
 8 |   <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">
 9 | {% endblock %}
10 | {%- block relbar2 %}{% endblock %}
11 | {% block header %}
12 |   {{ super() }}
13 |   {% if pagename == 'index' %}
14 |   <div class=indexwrapper>
15 |   {% endif %}
16 | {% endblock %}
17 | {%- block footer %}
18 |   <div class="footer">
19 |     &copy; Copyright {{ copyright }}.
20 |     Created using <a href="http://sphinx.pocoo.org/">Sphinx</a>.
21 |   </div>
22 |   {% if pagename == 'index' %}
23 |   </div>
24 |   {% endif %}
25 | {%- endblock %}
26 | 


--------------------------------------------------------------------------------
/docs/_themes/flask/relations.html:
--------------------------------------------------------------------------------
 1 | <h3>Related Topics</h3>
 2 | <ul>
 3 |   <li><a href="{{ pathto(master_doc) }}">Documentation overview</a><ul>
 4 |   {%- for parent in parents %}
 5 |   <li><a href="{{ parent.link|e }}">{{ parent.title }}</a><ul>
 6 |   {%- endfor %}
 7 |     {%- if prev %}
 8 |       <li>Previous: <a href="{{ prev.link|e }}" title="{{ _('previous chapter')
 9 |         }}">{{ prev.title }}</a></li>
10 |     {%- endif %}
11 |     {%- if next %}
12 |       <li>Next: <a href="{{ next.link|e }}" title="{{ _('next chapter')
13 |         }}">{{ next.title }}</a></li>
14 |     {%- endif %}
15 |   {%- for parent in parents %}
16 |   </ul></li>
17 |   {%- endfor %}
18 |   </ul></li>
19 | </ul>
20 | 


--------------------------------------------------------------------------------
/docs/_themes/flask/theme.conf:
--------------------------------------------------------------------------------
 1 | [theme]
 2 | inherit = basic
 3 | stylesheet = flasky.css
 4 | pygments_style = flask_theme_support.FlaskyStyle
 5 | 
 6 | [options]
 7 | index_logo = ''
 8 | index_logo_height = 120px
 9 | touch_icon = 
10 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/layout.html:
--------------------------------------------------------------------------------
 1 | {% extends "basic/layout.html" %}
 2 | {% block header %}
 3 |   {{ super() }}
 4 |   {% if pagename == 'index' %}
 5 |   <div class=indexwrapper>
 6 |   {% endif %}
 7 | {% endblock %}
 8 | {% block footer %}
 9 |   {% if pagename == 'index' %}
10 |   </div>
11 |   {% endif %}
12 | {% endblock %}
13 | {# do not display relbars #}
14 | {% block relbar1 %}{% endblock %}
15 | {% block relbar2 %}
16 |   {% if theme_github_fork %}
17 |     <a href="http://github.com/{{ theme_github_fork }}"><img style="position: fixed; top: 0; right: 0; border: 0;"
18 |     src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub" /></a>
19 |   {% endif %}
20 | {% endblock %}
21 | {% block sidebar1 %}{% endblock %}
22 | {% block sidebar2 %}{% endblock %}
23 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/static/flasky.css_t:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * flasky.css_t
  3 |  * ~~~~~~~~~~~~
  4 |  *
  5 |  * Sphinx stylesheet -- flasky theme based on nature theme.
  6 |  *
  7 |  * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
  8 |  * :license: BSD, see LICENSE for details.
  9 |  *
 10 |  */
 11 |  
 12 | @import url("basic.css");
 13 |  
 14 | /* -- page layout ----------------------------------------------------------- */
 15 |  
 16 | body {
 17 |     font-family: 'Georgia', serif;
 18 |     font-size: 17px;
 19 |     color: #000;
 20 |     background: white;
 21 |     margin: 0;
 22 |     padding: 0;
 23 | }
 24 | 
 25 | div.documentwrapper {
 26 |     float: left;
 27 |     width: 100%;
 28 | }
 29 | 
 30 | div.bodywrapper {
 31 |     margin: 40px auto 0 auto;
 32 |     width: 700px;
 33 | }
 34 | 
 35 | hr {
 36 |     border: 1px solid #B1B4B6;
 37 | }
 38 |  
 39 | div.body {
 40 |     background-color: #ffffff;
 41 |     color: #3E4349;
 42 |     padding: 0 30px 30px 30px;
 43 | }
 44 | 
 45 | img.floatingflask {
 46 |     padding: 0 0 10px 10px;
 47 |     float: right;
 48 | }
 49 |  
 50 | div.footer {
 51 |     text-align: right;
 52 |     color: #888;
 53 |     padding: 10px;
 54 |     font-size: 14px;
 55 |     width: 650px;
 56 |     margin: 0 auto 40px auto;
 57 | }
 58 |  
 59 | div.footer a {
 60 |     color: #888;
 61 |     text-decoration: underline;
 62 | }
 63 |  
 64 | div.related {
 65 |     line-height: 32px;
 66 |     color: #888;
 67 | }
 68 | 
 69 | div.related ul {
 70 |     padding: 0 0 0 10px;
 71 | }
 72 |  
 73 | div.related a {
 74 |     color: #444;
 75 | }
 76 |  
 77 | /* -- body styles ----------------------------------------------------------- */
 78 |  
 79 | a {
 80 |     color: #004B6B;
 81 |     text-decoration: underline;
 82 | }
 83 |  
 84 | a:hover {
 85 |     color: #6D4100;
 86 |     text-decoration: underline;
 87 | }
 88 | 
 89 | div.body {
 90 |     padding-bottom: 40px; /* saved for footer */
 91 | }
 92 |  
 93 | div.body h1,
 94 | div.body h2,
 95 | div.body h3,
 96 | div.body h4,
 97 | div.body h5,
 98 | div.body h6 {
 99 |     font-family: 'Garamond', 'Georgia', serif;
100 |     font-weight: normal;
101 |     margin: 30px 0px 10px 0px;
102 |     padding: 0;
103 | }
104 | 
105 | {% if theme_index_logo %}
106 | div.indexwrapper h1 {
107 |     text-indent: -999999px;
108 |     background: url({{ theme_index_logo }}) no-repeat center center;
109 |     height: {{ theme_index_logo_height }};
110 | }
111 | {% endif %}
112 |  
113 | div.body h2 { font-size: 180%; }
114 | div.body h3 { font-size: 150%; }
115 | div.body h4 { font-size: 130%; }
116 | div.body h5 { font-size: 100%; }
117 | div.body h6 { font-size: 100%; }
118 |  
119 | a.headerlink {
120 |     color: white;
121 |     padding: 0 4px;
122 |     text-decoration: none;
123 | }
124 |  
125 | a.headerlink:hover {
126 |     color: #444;
127 |     background: #eaeaea;
128 | }
129 |  
130 | div.body p, div.body dd, div.body li {
131 |     line-height: 1.4em;
132 | }
133 | 
134 | div.admonition {
135 |     background: #fafafa;
136 |     margin: 20px -30px;
137 |     padding: 10px 30px;
138 |     border-top: 1px solid #ccc;
139 |     border-bottom: 1px solid #ccc;
140 | }
141 | 
142 | div.admonition p.admonition-title {
143 |     font-family: 'Garamond', 'Georgia', serif;
144 |     font-weight: normal;
145 |     font-size: 24px;
146 |     margin: 0 0 10px 0;
147 |     padding: 0;
148 |     line-height: 1;
149 | }
150 | 
151 | div.admonition p.last {
152 |     margin-bottom: 0;
153 | }
154 | 
155 | div.highlight{
156 |     background-color: white;
157 | }
158 | 
159 | dt:target, .highlight {
160 |     background: #FAF3E8;
161 | }
162 | 
163 | div.note {
164 |     background-color: #eee;
165 |     border: 1px solid #ccc;
166 | }
167 |  
168 | div.seealso {
169 |     background-color: #ffc;
170 |     border: 1px solid #ff6;
171 | }
172 |  
173 | div.topic {
174 |     background-color: #eee;
175 | }
176 |  
177 | div.warning {
178 |     background-color: #ffe4e4;
179 |     border: 1px solid #f66;
180 | }
181 |  
182 | p.admonition-title {
183 |     display: inline;
184 | }
185 |  
186 | p.admonition-title:after {
187 |     content: ":";
188 | }
189 | 
190 | pre, tt {
191 |     font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
192 |     font-size: 0.85em;
193 | }
194 | 
195 | img.screenshot {
196 | }
197 | 
198 | tt.descname, tt.descclassname {
199 |     font-size: 0.95em;
200 | }
201 | 
202 | tt.descname {
203 |     padding-right: 0.08em;
204 | }
205 | 
206 | img.screenshot {
207 |     -moz-box-shadow: 2px 2px 4px #eee;
208 |     -webkit-box-shadow: 2px 2px 4px #eee;
209 |     box-shadow: 2px 2px 4px #eee;
210 | }
211 | 
212 | table.docutils {
213 |     border: 1px solid #888;
214 |     -moz-box-shadow: 2px 2px 4px #eee;
215 |     -webkit-box-shadow: 2px 2px 4px #eee;
216 |     box-shadow: 2px 2px 4px #eee;
217 | }
218 | 
219 | table.docutils td, table.docutils th {
220 |     border: 1px solid #888;
221 |     padding: 0.25em 0.7em;
222 | }
223 | 
224 | table.field-list, table.footnote {
225 |     border: none;
226 |     -moz-box-shadow: none;
227 |     -webkit-box-shadow: none;
228 |     box-shadow: none;
229 | }
230 | 
231 | table.footnote {
232 |     margin: 15px 0;
233 |     width: 100%;
234 |     border: 1px solid #eee;
235 | }
236 | 
237 | table.field-list th {
238 |     padding: 0 0.8em 0 0;
239 | }
240 | 
241 | table.field-list td {
242 |     padding: 0;
243 | }
244 | 
245 | table.footnote td {
246 |     padding: 0.5em;
247 | }
248 | 
249 | dl {
250 |     margin: 0;
251 |     padding: 0;
252 | }
253 | 
254 | dl dd {
255 |     margin-left: 30px;
256 | }
257 |  
258 | pre {
259 |     padding: 0;
260 |     margin: 15px -30px;
261 |     padding: 8px;
262 |     line-height: 1.3em;
263 |     padding: 7px 30px;
264 |     background: #eee;
265 |     border-radius: 2px;
266 |     -moz-border-radius: 2px;
267 |     -webkit-border-radius: 2px;
268 | }
269 | 
270 | dl pre {
271 |     margin-left: -60px;
272 |     padding-left: 60px;
273 | }
274 | 
275 | tt {
276 |     background-color: #ecf0f3;
277 |     color: #222;
278 |     /* padding: 1px 2px; */
279 | }
280 | 
281 | tt.xref, a tt {
282 |     background-color: #FBFBFB;
283 | }
284 | 
285 | a:hover tt {
286 |     background: #EEE;
287 | }
288 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/theme.conf:
--------------------------------------------------------------------------------
 1 | [theme]
 2 | inherit = basic
 3 | stylesheet = flasky.css
 4 | nosidebar = true
 5 | pygments_style = flask_theme_support.FlaskyStyle
 6 | 
 7 | [options]
 8 | index_logo = ''
 9 | index_logo_height = 120px
10 | github_fork = ''
11 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_theme_support.py:
--------------------------------------------------------------------------------
 1 | # flasky extensions.  flasky pygments style based on tango style
 2 | from pygments.style import Style
 3 | from pygments.token import Keyword, Name, Comment, String, Error, \
 4 |      Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
 5 | 
 6 | 
 7 | class FlaskyStyle(Style):
 8 |     background_color = "#f8f8f8"
 9 |     default_style = ""
10 | 
11 |     styles = {
12 |         # No corresponding class for the following:
13 |         #Text:                     "", # class:  ''
14 |         Whitespace:                "underline #f8f8f8",      # class: 'w'
15 |         Error:                     "#a40000 border:#ef2929", # class: 'err'
16 |         Other:                     "#000000",                # class 'x'
17 | 
18 |         Comment:                   "italic #8f5902", # class: 'c'
19 |         Comment.Preproc:           "noitalic",       # class: 'cp'
20 | 
21 |         Keyword:                   "bold #004461",   # class: 'k'
22 |         Keyword.Constant:          "bold #004461",   # class: 'kc'
23 |         Keyword.Declaration:       "bold #004461",   # class: 'kd'
24 |         Keyword.Namespace:         "bold #004461",   # class: 'kn'
25 |         Keyword.Pseudo:            "bold #004461",   # class: 'kp'
26 |         Keyword.Reserved:          "bold #004461",   # class: 'kr'
27 |         Keyword.Type:              "bold #004461",   # class: 'kt'
28 | 
29 |         Operator:                  "#582800",   # class: 'o'
30 |         Operator.Word:             "bold #004461",   # class: 'ow' - like keywords
31 | 
32 |         Punctuation:               "bold #000000",   # class: 'p'
33 | 
34 |         # because special names such as Name.Class, Name.Function, etc.
35 |         # are not recognized as such later in the parsing, we choose them
36 |         # to look the same as ordinary variables.
37 |         Name:                      "#000000",        # class: 'n'
38 |         Name.Attribute:            "#c4a000",        # class: 'na' - to be revised
39 |         Name.Builtin:              "#004461",        # class: 'nb'
40 |         Name.Builtin.Pseudo:       "#3465a4",        # class: 'bp'
41 |         Name.Class:                "#000000",        # class: 'nc' - to be revised
42 |         Name.Constant:             "#000000",        # class: 'no' - to be revised
43 |         Name.Decorator:            "#888",           # class: 'nd' - to be revised
44 |         Name.Entity:               "#ce5c00",        # class: 'ni'
45 |         Name.Exception:            "bold #cc0000",   # class: 'ne'
46 |         Name.Function:             "#000000",        # class: 'nf'
47 |         Name.Property:             "#000000",        # class: 'py'
48 |         Name.Label:                "#f57900",        # class: 'nl'
49 |         Name.Namespace:            "#000000",        # class: 'nn' - to be revised
50 |         Name.Other:                "#000000",        # class: 'nx'
51 |         Name.Tag:                  "bold #004461",   # class: 'nt' - like a keyword
52 |         Name.Variable:             "#000000",        # class: 'nv' - to be revised
53 |         Name.Variable.Class:       "#000000",        # class: 'vc' - to be revised
54 |         Name.Variable.Global:      "#000000",        # class: 'vg' - to be revised
55 |         Name.Variable.Instance:    "#000000",        # class: 'vi' - to be revised
56 | 
57 |         Number:                    "#990000",        # class: 'm'
58 | 
59 |         Literal:                   "#000000",        # class: 'l'
60 |         Literal.Date:              "#000000",        # class: 'ld'
61 | 
62 |         String:                    "#4e9a06",        # class: 's'
63 |         String.Backtick:           "#4e9a06",        # class: 'sb'
64 |         String.Char:               "#4e9a06",        # class: 'sc'
65 |         String.Doc:                "italic #8f5902", # class: 'sd' - like a comment
66 |         String.Double:             "#4e9a06",        # class: 's2'
67 |         String.Escape:             "#4e9a06",        # class: 'se'
68 |         String.Heredoc:            "#4e9a06",        # class: 'sh'
69 |         String.Interpol:           "#4e9a06",        # class: 'si'
70 |         String.Other:              "#4e9a06",        # class: 'sx'
71 |         String.Regex:              "#4e9a06",        # class: 'sr'
72 |         String.Single:             "#4e9a06",        # class: 's1'
73 |         String.Symbol:             "#4e9a06",        # class: 'ss'
74 | 
75 |         Generic:                   "#000000",        # class: 'g'
76 |         Generic.Deleted:           "#a40000",        # class: 'gd'
77 |         Generic.Emph:              "italic #000000", # class: 'ge'
78 |         Generic.Error:             "#ef2929",        # class: 'gr'
79 |         Generic.Heading:           "bold #000080",   # class: 'gh'
80 |         Generic.Inserted:          "#00A000",        # class: 'gi'
81 |         Generic.Output:            "#888",           # class: 'go'
82 |         Generic.Prompt:            "#745334",        # class: 'gp'
83 |         Generic.Strong:            "bold #000000",   # class: 'gs'
84 |         Generic.Subheading:        "bold #800080",   # class: 'gu'
85 |         Generic.Traceback:         "bold #a40000",   # class: 'gt'
86 |     }
87 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/__init__.py:
--------------------------------------------------------------------------------
 1 | """Sphinx ReadTheDocs theme.
 2 | 
 3 | From https://github.com/ryan-roemer/sphinx-bootstrap-theme.
 4 | 
 5 | """
 6 | import os
 7 | 
 8 | VERSION = (0, 1, 5)
 9 | 
10 | __version__ = ".".join(str(v) for v in VERSION)
11 | __version_full__ = __version__
12 | 
13 | 
14 | def get_html_theme_path():
15 |     """Return list of HTML theme paths."""
16 |     cur_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
17 |     return cur_dir
18 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | <div role="navigation" aria-label="breadcrumbs navigation">
 2 |   <ul class="wy-breadcrumbs">
 3 |     <li><a href="{{ pathto(master_doc) }}">Docs</a> &raquo;</li>
 4 |       {% for doc in parents %}
 5 |           <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
 6 |       {% endfor %}
 7 |     <li>{{ title }}</li>
 8 |       <li class="wy-breadcrumbs-aside">
 9 |         {% if display_github %}
10 |           <a href="https://github.com/{{ github_user }}/{{ github_repo }}/blob/{{ github_version }}{{ conf_py_path }}{{ pagename }}.rst" class="fa fa-github"> Edit on GitHub</a>
11 |         {% elif display_bitbucket %}
12 |           <a href="https://bitbucket.org/{{ bitbucket_user }}/{{ bitbucket_repo }}/src/{{ bitbucket_version}}{{ conf_py_path }}{{ pagename }}.rst" class="fa fa-bitbucket"> Edit on Bitbucket</a>
13 |         {% elif show_source and has_source and sourcename %}
14 |           <a href="{{ pathto('_sources/' + sourcename, true)|e }}" rel="nofollow"> View page source</a>
15 |         {% endif %}
16 |       </li>
17 |   </ul>
18 |   <hr/>
19 | </div>
20 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {% if next or prev %}
 3 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 4 |       {% if next %}
 5 |         <a href="{{ next.link|e }}" class="btn btn-neutral float-right" title="{{ next.title|striptags|e }}"/>Next <span class="fa fa-arrow-circle-right"></span></a>
 6 |       {% endif %}
 7 |       {% if prev %} 
 8 |         <a href="{{ prev.link|e }}" class="btn btn-neutral" title="{{ prev.title|striptags|e }}"><span class="fa fa-arrow-circle-left"></span> Previous</a>
 9 |       {% endif %}
10 |     </div>
11 |   {% endif %}
12 | 
13 |   <hr/>
14 | 
15 |   <div role="contentinfo">
16 |     <p>
17 |     All content licensed under a <a href="http://creativecommons.org/licenses/by-nc/4.0/">Creative Commons Attribution-NonCommercial License</a>
18 |     </p>
19 |   </div>
20 | 
21 |   {% trans %}<a href="https://github.com/snide/sphinx_rtd_theme">Sphinx theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a> - Last modified {{last_updated}} {% endtrans %}
22 | </footer>
23 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/layout.html:
--------------------------------------------------------------------------------
  1 | {# TEMPLATE VAR SETTINGS #}
  2 | {%- set url_root = pathto('', 1) %}
  3 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
  4 | {%- if not embedded and docstitle %}
  5 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
  6 | {%- else %}
  7 |   {%- set titlesuffix = "" %}
  8 | {%- endif %}
  9 | 
 10 | {% set css_files = css_files + ['_static/css/ribbon.css'] %}
 11 |  
 12 | <!DOCTYPE html>
 13 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
 14 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
 15 | <head>
 16 |   <meta charset="utf-8">
 17 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 18 |   {% block htmltitle %}
 19 |   <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
 20 |   {% endblock %}
 21 | 
 22 |   {# FAVICON #}
 23 |   {% if favicon %}
 24 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
 25 |   {% endif %}
 26 | 
 27 |   {# CSS #}
 28 |   <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>
 29 | 
 30 |   {# OPENSEARCH #}
 31 |   {% if not embedded %}
 32 |     {% if use_opensearch %}
 33 |       <link rel="search" type="application/opensearchdescription+xml" title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}" href="{{ pathto('_static/opensearch.xml', 1) }}"/>
 34 |     {% endif %}
 35 | 
 36 |   {% endif %}
 37 | 
 38 |   {# RTD hosts this file, so just load on non RTD builds #}
 39 |   {% if not READTHEDOCS %}
 40 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
 41 |   {% endif %}
 42 | 
 43 |   {% for cssfile in css_files %}
 44 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 45 |   {% endfor %}
 46 | 
 47 |   {%- block linktags %}
 48 |     {%- if hasdoc('about') %}
 49 |         <link rel="author" title="{{ _('About these documents') }}"
 50 |               href="{{ pathto('about') }}"/>
 51 |     {%- endif %}
 52 |     {%- if hasdoc('genindex') %}
 53 |         <link rel="index" title="{{ _('Index') }}"
 54 |               href="{{ pathto('genindex') }}"/>
 55 |     {%- endif %}
 56 |     {%- if hasdoc('search') %}
 57 |         <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}"/>
 58 |     {%- endif %}
 59 |     {%- if hasdoc('copyright') %}
 60 |         <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}"/>
 61 |     {%- endif %}
 62 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}"/>
 63 |     {%- if parents %}
 64 |         <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}"/>
 65 |     {%- endif %}
 66 |     {%- if next %}
 67 |         <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}"/>
 68 |     {%- endif %}
 69 |     {%- if prev %}
 70 |         <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}"/>
 71 |     {%- endif %}
 72 |   {%- endblock %}
 73 |   {%- block extrahead %} {% endblock %}
 74 | 
 75 |   {# Keep modernizr in head - http://modernizr.com/docs/#installing #}
 76 |   <script src="https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/modernizr.min.js"></script>
 77 | 
 78 | </head>
 79 | 
 80 | <body class="wy-body-for-nav" role="document">
 81 | 
 82 |   <div class="wy-grid-for-nav">
 83 | 
 84 |     {# SIDE NAV, TOGGLES ON MOBILE #}
 85 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 86 |       <div class="wy-side-nav-search">
 87 |         <a href="{{ pathto(master_doc) }}" class="fa fa-home"> {{ project }}</a>
 88 |         {% include "searchbox.html" %}
 89 |       </div>
 90 | 
 91 |       <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 92 |         {% set toctree = toctree(maxdepth=2, collapse=False, includehidden=True) %}
 93 |         {% if toctree %}
 94 |             {{ toctree }}
 95 |         {% else %}
 96 |             <!-- Local TOC -->
 97 |             <div class="local-toc">{{ toc }}</div>
 98 |         {% endif %}
 99 |       </div>
100 |       &nbsp;
101 |     </nav>
102 | 
103 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
104 | 
105 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
106 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
107 |         <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
108 |         <a href="{{ pathto(master_doc) }}">{{ project }}</a>
109 |       </nav>
110 | 
111 | 
112 |       {# PAGE CONTENT #}
113 |       <div class="wy-nav-content">
114 |         <div class="rst-content">
115 |           {% include "breadcrumbs.html" %}
116 |           <div role="main">
117 |           <p style="text-align:right; color:#999;">Like this project? <a href="http://github.com/adewes/blitzdb"><i class="fa fa-code-fork"></i> it on <i class="fa fa-github"></i></a></p>
118 | 
119 |             {% block body %}{% endblock %}
120 |           </div>
121 |           {% include "footer.html" %}
122 |         </div>
123 |       </div>
124 | 
125 |     </section>
126 | 
127 |   </div>
128 |   {% include "versions.html" %}
129 | 
130 |   {% if not embedded %}
131 | 
132 |     <script type="text/javascript">
133 |         var DOCUMENTATION_OPTIONS = {
134 |             URL_ROOT:'{{ url_root }}',
135 |             VERSION:'{{ release|e }}',
136 |             COLLAPSE_INDEX:false,
137 |             FILE_SUFFIX:'{{ '' if no_search_suffix else file_suffix }}',
138 |             HAS_SOURCE:  {{ has_source|lower }}
139 |         };
140 |     </script>
141 |     {%- for scriptfile in script_files %}
142 |       <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
143 |     {%- endfor %}
144 | 
145 |   {% endif %}
146 | 
147 |   {# RTD hosts this file, so just load on non RTD builds #}
148 |   {% if not READTHEDOCS %}
149 |     <script type="text/javascript" src="{{ pathto('_static/js/theme.js', 1) }}"></script>
150 |   {% endif %}
151 | 
152 |   {# STICKY NAVIGATION #}
153 |   {% if theme_sticky_navigation %}
154 |   <script type="text/javascript">
155 |       jQuery(function () {
156 |           SphinxRtdTheme.StickyNav.enable();
157 |       });
158 |   </script>
159 |   {% endif %}
160 | 
161 |   {%- block footer %} {% endblock %}
162 | 
163 | </body>
164 | </html>
165 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/layout_old.html:
--------------------------------------------------------------------------------
  1 | {#
  2 |     basic/layout.html
  3 |     ~~~~~~~~~~~~~~~~~
  4 | 
  5 |     Master layout template for Sphinx themes.
  6 | 
  7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
  8 |     :license: BSD, see LICENSE for details.
  9 | #}
 10 | {%- block doctype -%}
 11 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 12 |   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 13 | {%- endblock %}
 14 | {%- set reldelim1 = reldelim1 is not defined and ' &raquo;' or reldelim1 %}
 15 | {%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
 16 | {%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
 17 |                          (sidebars != []) %}
 18 | {%- set url_root = pathto('', 1) %}
 19 | {# XXX necessary? #}
 20 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
 21 | {%- if not embedded and docstitle %}
 22 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
 23 | {%- else %}
 24 |   {%- set titlesuffix = "" %}
 25 | {%- endif %}
 26 | 
 27 | {%- macro relbar() %}
 28 |     <div class="related">
 29 |       <h3>{{ _('Navigation') }}</h3>
 30 |       <ul>
 31 |         {%- for rellink in rellinks %}
 32 |         <li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
 33 |           <a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
 34 |              {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
 35 |           {%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
 36 |         {%- endfor %}
 37 |         {%- block rootrellink %}
 38 |         <li><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
 39 |         {%- endblock %}
 40 |         {%- for parent in parents %}
 41 |           <li><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
 42 |         {%- endfor %}
 43 |         {%- block relbaritems %} {% endblock %}
 44 |       </ul>
 45 |     </div>
 46 | {%- endmacro %}
 47 | 
 48 | {%- macro sidebar() %}
 49 |       {%- if render_sidebar %}
 50 |       <div class="sphinxsidebar">
 51 |         <div class="sphinxsidebarwrapper">
 52 |           {%- block sidebarlogo %}
 53 |           {%- if logo %}
 54 |             <p class="logo"><a href="{{ pathto(master_doc) }}">
 55 |               <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
 56 |             </a></p>
 57 |           {%- endif %}
 58 |           {%- endblock %}
 59 |           {%- if sidebars != None %}
 60 |             {#- new style sidebar: explicitly include/exclude templates #}
 61 |             {%- for sidebartemplate in sidebars %}
 62 |             {%- include sidebartemplate %}
 63 |             {%- endfor %}
 64 |           {%- else %}
 65 |             {#- old style sidebars: using blocks -- should be deprecated #}
 66 |             {%- block sidebartoc %}
 67 |             {%- include "localtoc.html" %}
 68 |             {%- endblock %}
 69 |             {%- block sidebarrel %}
 70 |             {%- include "relations.html" %}
 71 |             {%- endblock %}
 72 |             {%- block sidebarsourcelink %}
 73 |             {%- include "sourcelink.html" %}
 74 |             {%- endblock %}
 75 |             {%- if customsidebar %}
 76 |             {%- include customsidebar %}
 77 |             {%- endif %}
 78 |             {%- block sidebarsearch %}
 79 |             {%- include "searchbox.html" %}
 80 |             {%- endblock %}
 81 |           {%- endif %}
 82 |         </div>
 83 |       </div>
 84 |       {%- endif %}
 85 | {%- endmacro %}
 86 | 
 87 | {%- macro script() %}
 88 |     <script type="text/javascript">
 89 |       var DOCUMENTATION_OPTIONS = {
 90 |         URL_ROOT:    '{{ url_root }}',
 91 |         VERSION:     '{{ release|e }}',
 92 |         COLLAPSE_INDEX: false,
 93 |         FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
 94 |         HAS_SOURCE:  {{ has_source|lower }}
 95 |       };
 96 |     </script>
 97 |     {%- for scriptfile in script_files %}
 98 |     <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
 99 |     {%- endfor %}
100 | {%- endmacro %}
101 | 
102 | {%- macro css() %}
103 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
104 |     <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
105 |     {%- for cssfile in css_files %}
106 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
107 |     {%- endfor %}
108 | {%- endmacro %}
109 | 
110 | <html xmlns="http://www.w3.org/1999/xhtml">
111 |   <head>
112 |     <meta http-equiv="Content-Type" content="text/html; charset={{ encoding }}" />
113 |     {{ metatags }}
114 |     {%- block htmltitle %}
115 |     <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
116 |     {%- endblock %}
117 |     {{ css() }}
118 |     {%- if not embedded %}
119 |     {{ script() }}
120 |     {%- if use_opensearch %}
121 |     <link rel="search" type="application/opensearchdescription+xml"
122 |           title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
123 |           href="{{ pathto('_static/opensearch.xml', 1) }}"/>
124 |     {%- endif %}
125 |     {%- if favicon %}
126 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
127 |     {%- endif %}
128 |     {%- endif %}
129 | {%- block linktags %}
130 |     {%- if hasdoc('about') %}
131 |     <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
132 |     {%- endif %}
133 |     {%- if hasdoc('genindex') %}
134 |     <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
135 |     {%- endif %}
136 |     {%- if hasdoc('search') %}
137 |     <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
138 |     {%- endif %}
139 |     {%- if hasdoc('copyright') %}
140 |     <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
141 |     {%- endif %}
142 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}" />
143 |     {%- if parents %}
144 |     <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}" />
145 |     {%- endif %}
146 |     {%- if next %}
147 |     <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
148 |     {%- endif %}
149 |     {%- if prev %}
150 |     <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
151 |     {%- endif %}
152 | {%- endblock %}
153 | {%- block extrahead %} {% endblock %}
154 |   </head>
155 |   <body>
156 | {%- block header %}{% endblock %}
157 | 
158 | {%- block relbar1 %}{{ relbar() }}{% endblock %}
159 | 
160 | {%- block content %}
161 |   {%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}
162 | 
163 |     <div class="document">
164 |   {%- block document %}
165 |       <div class="documentwrapper">
166 |       {%- if render_sidebar %}
167 |         <div class="bodywrapper">
168 |       {%- endif %}
169 |           <div class="body">
170 |             {% block body %} {% endblock %}
171 |           </div>
172 |       {%- if render_sidebar %}
173 |         </div>
174 |       {%- endif %}
175 |       </div>
176 |   {%- endblock %}
177 | 
178 |   {%- block sidebar2 %}{{ sidebar() }}{% endblock %}
179 |       <div class="clearer"></div>
180 |     </div>
181 | {%- endblock %}
182 | 
183 | {%- block relbar2 %}{{ relbar() }}{% endblock %}
184 | 
185 | {%- block footer %}
186 |     <div class="footer">
187 |     {%- if show_copyright %}
188 |       {%- if hasdoc('copyright') %}
189 |         {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
190 |       {%- else %}
191 |         {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
192 |       {%- endif %}
193 |     {%- endif %}
194 |     {%- if last_updated %}
195 |       {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
196 |     {%- endif %}
197 |     {%- if show_sphinx %}
198 |       {% trans sphinx_version=sphinx_version|e %}Created using <a href="http://sphinx-doc.org/">Sphinx</a> {{ sphinx_version }}.{% endtrans %}
199 |     {%- endif %}
200 |     </div>
201 |     <p>asdf asdf asdf asdf 22</p>
202 | {%- endblock %}
203 |   </body>
204 | </html>
205 | 
206 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/search.html:
--------------------------------------------------------------------------------
 1 | {#
 2 |     basic/search.html
 3 |     ~~~~~~~~~~~~~~~~~
 4 | 
 5 |     Template for the search page.
 6 | 
 7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
 8 |     :license: BSD, see LICENSE for details.
 9 | #}
10 | {%- extends "layout.html" %}
11 | {% set title = _('Search') %}
12 | {% set script_files = script_files + ['_static/searchtools.js'] %}
13 | {% block footer %}
14 |   <script type="text/javascript">
15 |     jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
16 |   </script>
17 |   {# this is used when loading the search index using $.ajax fails,
18 |      such as on Chrome for documents on localhost #}
19 |   <script type="text/javascript" id="searchindexloader"></script>
20 |   {{ super() }}
21 | {% endblock %}
22 | {% block body %}
23 |   <noscript>
24 |   <div id="fallback" class="admonition warning">
25 |     <p class="last">
26 |       {% trans %}Please activate JavaScript to enable the search
27 |       functionality.{% endtrans %}
28 |     </p>
29 |   </div>
30 |   </noscript>
31 | 
32 |   {% if search_performed %}
33 |     <h2>{{ _('Search Results') }}</h2>
34 |     {% if not search_results %}
35 |       <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
36 |     {% endif %}
37 |   {% endif %}
38 |   <div id="search-results">
39 |   {% if search_results %}
40 |     <ul>
41 |     {% for href, caption, context in search_results %}
42 |       <li>
43 |         <a href="{{ pathto(item.href) }}">{{ caption }}</a>
44 |         <p class="context">{{ context|e }}</p>
45 |       </li>
46 |     {% endfor %}
47 |     </ul>
48 |   {% endif %}
49 |   </div>
50 | {% endblock %}
51 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/searchbox.html:
--------------------------------------------------------------------------------
1 | <div role="search">
2 |   <form id ="rtd-search-form" class="wy-form" action="{{ pathto('search') }}" method="get">
3 |     <input type="text" name="q" placeholder="Search docs" />
4 |     <input type="hidden" name="check_keywords" value="yes" />
5 |     <input type="hidden" name="area" value="default" />
6 |   </form>
7 | </div>
8 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-weight:normal;font-style:normal;src:url("../font/fontawesome_webfont.eot");src:url("../font/fontawesome_webfont.eot?#iefix") format("embedded-opentype"),url("../font/fontawesome_webfont.woff") format("woff"),url("../font/fontawesome_webfont.ttf") format("truetype"),url("../font/fontawesome_webfont.svg#FontAwesome") format("svg")}.fa:before{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;text-decoration:inherit}a .fa{display:inline-block;text-decoration:inherit}li .fa{display:inline-block}li .fa-large:before,li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-0.8em}ul.fas li .fa{width:0.8em}ul.fas li .fa-large:before,ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before{content:"\f02d"}.icon-book:before{content:"\f02d"}.fa-caret-down:before{content:"\f0d7"}.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;border-top:solid 10px #343131;font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:before,.rst-versions .rst-current-version:after{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book{float:left}.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:gray;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:solid 1px #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px}.rst-versions.rst-badge .icon-book{float:none}.rst-versions.rst-badge .fa-book{float:none}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book{float:left}.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge .rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width: 768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}img{width:100%;height:auto}}
2 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/css/ribbon.css:
--------------------------------------------------------------------------------
1 | @media(max-width:768px)
2 | {
3 |     .github_ribbon
4 |     {
5 |         display:none;
6 |     }    
7 | }
8 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/docs/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/js/theme.js:
--------------------------------------------------------------------------------
 1 | $( document ).ready(function() {
 2 |     // Shift nav in mobile when clicking the menu.
 3 |     $(document).on('click', "[data-toggle='wy-nav-top']", function() {
 4 |       $("[data-toggle='wy-nav-shift']").toggleClass("shift");
 5 |       $("[data-toggle='rst-versions']").toggleClass("shift");
 6 |     });
 7 |     // Close menu when you click a link.
 8 |     $(document).on('click', ".wy-menu-vertical .current ul li a", function() {
 9 |       $("[data-toggle='wy-nav-shift']").removeClass("shift");
10 |       $("[data-toggle='rst-versions']").toggleClass("shift");
11 |     });
12 |     $(document).on('click', "[data-toggle='rst-current-version']", function() {
13 |       $("[data-toggle='rst-versions']").toggleClass("shift-up");
14 |     });  
15 |     // Make tables responsive
16 |     $("table.docutils:not(.field-list)").wrap("<div class='wy-table-responsive'></div>");
17 | });
18 | 
19 | window.SphinxRtdTheme = (function (jquery) {
20 |     var stickyNav = (function () {
21 |         var navBar,
22 |             win,
23 |             stickyNavCssClass = 'stickynav',
24 |             applyStickNav = function () {
25 |                 if (navBar.height() <= win.height()) {
26 |                     navBar.addClass(stickyNavCssClass);
27 |                 } else {
28 |                     navBar.removeClass(stickyNavCssClass);
29 |                 }
30 |             },
31 |             enable = function () {
32 |                 applyStickNav();
33 |                 win.on('resize', applyStickNav);
34 |             },
35 |             init = function () {
36 |                 navBar = jquery('nav.wy-nav-side:first');
37 |                 win    = jquery(window);
38 |             };
39 |         jquery(init);
40 |         return {
41 |             enable : enable
42 |         };
43 |     }());
44 |     return {
45 |         StickyNav : stickyNav
46 |     };
47 | }($));
48 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/theme.conf:
--------------------------------------------------------------------------------
1 | [theme]
2 | inherit = basic
3 | stylesheet = css/theme.css
4 | 
5 | [options]
6 | typekit_id = hiw1hhg
7 | analytics_id = 
8 | sticky_navigation = False
9 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/versions.html:
--------------------------------------------------------------------------------
 1 | {% if READTHEDOCS %}
 2 | {# Add rst-badge after rst-versions for small badge style. #}
 3 |   <div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
 4 |     <span class="rst-current-version" data-toggle="rst-current-version">
 5 |       <span class="fa fa-book"> Read the Docs</span>
 6 |       v: {{ current_version }}
 7 |       <span class="fa fa-caret-down"></span>
 8 |     </span>
 9 |     <div class="rst-other-versions">
10 |       <dl>
11 |         <dt>Versions</dt>
12 |         {% for slug, url in versions %}
13 |           <dd><a href="{{ url }}">{{ slug }}</a></dd>
14 |         {% endfor %}
15 |       </dl>
16 |       <dl>
17 |         <dt>Downloads</dt>
18 |         {% for type, url in downloads %}
19 |           <dd><a href="{{ url }}">{{ type }}</a></dd>
20 |         {% endfor %}
21 |       </dl>
22 |       <dl>
23 |         <dt>On Read the Docs</dt>
24 |           <dd>
25 |             <a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">Project Home</a>
26 |           </dd>
27 |           <dd>
28 |             <a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">Builds</a>
29 |           </dd>
30 |       </dl>
31 |       <hr/>
32 |       Free document hosting provided by <a href="http://www.readthedocs.org">Read the Docs</a>.
33 | 
34 |     </div>
35 |   </div>
36 | {% endif %}
37 | 
38 | 


--------------------------------------------------------------------------------
/docs/license.txt:
--------------------------------------------------------------------------------
1 | This checkmate documentation is licensed under the Creative Commons 
2 | Attribution-NonCommercial-ShareAlike 4.0 International License. 
3 | To view a copy of this license, visit 
4 | http://creativecommons.org/licenses/by-nc-sa/4.0/.
5 | 


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
  1 | @ECHO OFF
  2 | 
  3 | REM Command file for Sphinx documentation
  4 | 
  5 | if "%SPHINXBUILD%" == "" (
  6 | 	set SPHINXBUILD=sphinx-build
  7 | )
  8 | set BUILDDIR=build
  9 | set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source
 10 | set I18NSPHINXOPTS=%SPHINXOPTS% source
 11 | if NOT "%PAPER%" == "" (
 12 | 	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
 13 | 	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
 14 | )
 15 | 
 16 | if "%1" == "" goto help
 17 | 
 18 | if "%1" == "help" (
 19 | 	:help
 20 | 	echo.Please use `make ^<target^>` where ^<target^> is one of
 21 | 	echo.  html       to make standalone HTML files
 22 | 	echo.  dirhtml    to make HTML files named index.html in directories
 23 | 	echo.  singlehtml to make a single large HTML file
 24 | 	echo.  pickle     to make pickle files
 25 | 	echo.  json       to make JSON files
 26 | 	echo.  htmlhelp   to make HTML files and a HTML help project
 27 | 	echo.  qthelp     to make HTML files and a qthelp project
 28 | 	echo.  devhelp    to make HTML files and a Devhelp project
 29 | 	echo.  epub       to make an epub
 30 | 	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
 31 | 	echo.  text       to make text files
 32 | 	echo.  man        to make manual pages
 33 | 	echo.  texinfo    to make Texinfo files
 34 | 	echo.  gettext    to make PO message catalogs
 35 | 	echo.  changes    to make an overview over all changed/added/deprecated items
 36 | 	echo.  xml        to make Docutils-native XML files
 37 | 	echo.  pseudoxml  to make pseudoxml-XML files for display purposes
 38 | 	echo.  linkcheck  to check all external links for integrity
 39 | 	echo.  doctest    to run all doctests embedded in the documentation if enabled
 40 | 	goto end
 41 | )
 42 | 
 43 | if "%1" == "clean" (
 44 | 	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
 45 | 	del /q /s %BUILDDIR%\*
 46 | 	goto end
 47 | )
 48 | 
 49 | 
 50 | %SPHINXBUILD% 2> nul
 51 | if errorlevel 9009 (
 52 | 	echo.
 53 | 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
 54 | 	echo.installed, then set the SPHINXBUILD environment variable to point
 55 | 	echo.to the full path of the 'sphinx-build' executable. Alternatively you
 56 | 	echo.may add the Sphinx directory to PATH.
 57 | 	echo.
 58 | 	echo.If you don't have Sphinx installed, grab it from
 59 | 	echo.http://sphinx-doc.org/
 60 | 	exit /b 1
 61 | )
 62 | 
 63 | if "%1" == "html" (
 64 | 	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
 65 | 	if errorlevel 1 exit /b 1
 66 | 	echo.
 67 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
 68 | 	goto end
 69 | )
 70 | 
 71 | if "%1" == "dirhtml" (
 72 | 	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
 73 | 	if errorlevel 1 exit /b 1
 74 | 	echo.
 75 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
 76 | 	goto end
 77 | )
 78 | 
 79 | if "%1" == "singlehtml" (
 80 | 	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
 81 | 	if errorlevel 1 exit /b 1
 82 | 	echo.
 83 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
 84 | 	goto end
 85 | )
 86 | 
 87 | if "%1" == "pickle" (
 88 | 	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
 89 | 	if errorlevel 1 exit /b 1
 90 | 	echo.
 91 | 	echo.Build finished; now you can process the pickle files.
 92 | 	goto end
 93 | )
 94 | 
 95 | if "%1" == "json" (
 96 | 	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
 97 | 	if errorlevel 1 exit /b 1
 98 | 	echo.
 99 | 	echo.Build finished; now you can process the JSON files.
100 | 	goto end
101 | )
102 | 
103 | if "%1" == "htmlhelp" (
104 | 	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
105 | 	if errorlevel 1 exit /b 1
106 | 	echo.
107 | 	echo.Build finished; now you can run HTML Help Workshop with the ^
108 | .hhp project file in %BUILDDIR%/htmlhelp.
109 | 	goto end
110 | )
111 | 
112 | if "%1" == "qthelp" (
113 | 	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
114 | 	if errorlevel 1 exit /b 1
115 | 	echo.
116 | 	echo.Build finished; now you can run "qcollectiongenerator" with the ^
117 | .qhcp project file in %BUILDDIR%/qthelp, like this:
118 | 	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Checkmate.qhcp
119 | 	echo.To view the help file:
120 | 	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Checkmate.ghc
121 | 	goto end
122 | )
123 | 
124 | if "%1" == "devhelp" (
125 | 	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
126 | 	if errorlevel 1 exit /b 1
127 | 	echo.
128 | 	echo.Build finished.
129 | 	goto end
130 | )
131 | 
132 | if "%1" == "epub" (
133 | 	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
134 | 	if errorlevel 1 exit /b 1
135 | 	echo.
136 | 	echo.Build finished. The epub file is in %BUILDDIR%/epub.
137 | 	goto end
138 | )
139 | 
140 | if "%1" == "latex" (
141 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
142 | 	if errorlevel 1 exit /b 1
143 | 	echo.
144 | 	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
145 | 	goto end
146 | )
147 | 
148 | if "%1" == "latexpdf" (
149 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
150 | 	cd %BUILDDIR%/latex
151 | 	make all-pdf
152 | 	cd %BUILDDIR%/..
153 | 	echo.
154 | 	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
155 | 	goto end
156 | )
157 | 
158 | if "%1" == "latexpdfja" (
159 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
160 | 	cd %BUILDDIR%/latex
161 | 	make all-pdf-ja
162 | 	cd %BUILDDIR%/..
163 | 	echo.
164 | 	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
165 | 	goto end
166 | )
167 | 
168 | if "%1" == "text" (
169 | 	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
170 | 	if errorlevel 1 exit /b 1
171 | 	echo.
172 | 	echo.Build finished. The text files are in %BUILDDIR%/text.
173 | 	goto end
174 | )
175 | 
176 | if "%1" == "man" (
177 | 	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
178 | 	if errorlevel 1 exit /b 1
179 | 	echo.
180 | 	echo.Build finished. The manual pages are in %BUILDDIR%/man.
181 | 	goto end
182 | )
183 | 
184 | if "%1" == "texinfo" (
185 | 	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
186 | 	if errorlevel 1 exit /b 1
187 | 	echo.
188 | 	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
189 | 	goto end
190 | )
191 | 
192 | if "%1" == "gettext" (
193 | 	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
194 | 	if errorlevel 1 exit /b 1
195 | 	echo.
196 | 	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
197 | 	goto end
198 | )
199 | 
200 | if "%1" == "changes" (
201 | 	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
202 | 	if errorlevel 1 exit /b 1
203 | 	echo.
204 | 	echo.The overview file is in %BUILDDIR%/changes.
205 | 	goto end
206 | )
207 | 
208 | if "%1" == "linkcheck" (
209 | 	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
210 | 	if errorlevel 1 exit /b 1
211 | 	echo.
212 | 	echo.Link check complete; look for any errors in the above output ^
213 | or in %BUILDDIR%/linkcheck/output.txt.
214 | 	goto end
215 | )
216 | 
217 | if "%1" == "doctest" (
218 | 	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
219 | 	if errorlevel 1 exit /b 1
220 | 	echo.
221 | 	echo.Testing of doctests in the sources finished, look at the ^
222 | results in %BUILDDIR%/doctest/output.txt.
223 | 	goto end
224 | )
225 | 
226 | if "%1" == "xml" (
227 | 	%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml
228 | 	if errorlevel 1 exit /b 1
229 | 	echo.
230 | 	echo.Build finished. The XML files are in %BUILDDIR%/xml.
231 | 	goto end
232 | )
233 | 
234 | if "%1" == "pseudoxml" (
235 | 	%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml
236 | 	if errorlevel 1 exit /b 1
237 | 	echo.
238 | 	echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.
239 | 	goto end
240 | )
241 | 
242 | :end
243 | 


--------------------------------------------------------------------------------
/docs/source/_static/img/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/quantifiedcode/checkmate/1a4d010c8ef25c678d8d14dc8e37a9bed1883ca2/docs/source/_static/img/logo.png


--------------------------------------------------------------------------------
/docs/source/api/commands.rst:
--------------------------------------------------------------------------------
 1 | Management Commands
 2 | ===================
 3 | 
 4 | `checkmate` provides various management commands for analyzing code, displaying analysis results
 5 | and exporting data.
 6 | 
 7 | analyze
 8 | _______
 9 | 
10 | Analyzes a given snapshot of a project and stores the results in the database.
11 | 
12 | summary
13 | _______
14 | 
15 | Prints a summary of a given snapshot analysis.
16 | 
17 | issues summary
18 | ______________
19 | 
20 | Prints details about issues in a given snapshot
21 | 
22 | issues list
23 | ___________
24 | 
25 | issues trend
26 | ____________
27 | 
28 | 
29 | Git Integration
30 | ===============
31 | 
32 | All of the commands above can be prefixed with `git` to make them work on a git repository. For
33 | more detailed information about available options, have a look at the :doc:`git integration </integrations/git>` documentation.
34 | 
35 | 


--------------------------------------------------------------------------------
/docs/source/api/concepts.rst:
--------------------------------------------------------------------------------
 1 | Core Concepts
 2 | =============
 3 | 
 4 | This document gives a brief overview of the main concepts and models that Checkmate uses to analyze your code.
 5 | 
 6 | Checkmate uses a document-oriented data model to store information about a given project. The underlying model is very simple and allows us to model projects managed through various version control systems such as git. The model defines the following classes:
 7 | 
 8 | Project
 9 | -------
10 | 
11 | A project contains the information about a given code repository, e.g. file revisions, snapshots, issues and diffs. This will create a `.checkmate` folder
12 | either in your current working directory, or, if you call it inside a git repository, in the directory that
13 | contains the `.git` folder. You project consists of all files contained in the directory that contains 
14 | the `.checkmate` folder (including all subdirectories).
15 | 
16 | Snapshot
17 | --------
18 | 
19 | A snapshot represents the state of your entire project or a subset of the project at a given point. This can be
20 | e.g. a certain git commit or just the local state of the project directory at a given time. Snapshots are generated
21 | through the `checkmate analyze` command.
22 |  
23 | File Revision
24 | -------------
25 | 
26 | A file revision describe the state of a file at a given point. It contains both statistics as well as a list of
27 | issues for the given file. To create a snapshot, several file revisions are bundled together.
28 | 
29 | .. warning::
30 | 
31 |    The concept of a file revision used here is more general than that of e.g. Git or Subversion. Most importantly, two file revisions can have the exact same content and still be considered as different. This is for example the case if file A imports a function from file B. Since A depends on B, changes in B will possibly impact the functionality defined in A. Thus, whenever file B changes we will check file A (even if it hasn't changed itself) and
32 |    create a new file revision for it.
33 | 
34 | Issue
35 | -----
36 | 
37 | An issue is a description of a particular code problem. Each issue description provides an issue code and analyzer
38 | name, as well as information about the location of the issue (i.e. file revisions and line numbers). The issue's meta-data (e.g. severity, categories, ...) is stored externally. An issue is always associated with a given file revision. Multiple occurences of the same issue type will usually get bundled together, i.e. only one issue document will be created for all occurences of that issue in a given file.
39 | 
40 | Commands
41 | --------
42 | 
43 | All of checkmate's functionality is exposed through **commands**. All commands inherit form a `:ref:BaseCommand`
44 | class and accept a range of parameters. Currently there are commands to deal with file-based projects, as well as 
45 | `git` projects.
46 | 
47 | Command Chaining
48 | ----------------
49 | 
50 | Often we want to combine several individual commands into a chain. As an example, we could use the
51 | `git` command to select a number of snapshots, then use the `analyze` command to analyze them and
52 | finally send a summary of the analysis via e-mail using the `email` command. In the shell world, the
53 | pipe (`|`) operator is used for sending the output of one command as input to another command.
54 | 
55 | In checkmate, the command parser performs this function by looking for a command name in the sequence
56 | of parameters. It then executes each command in turn, providing it the options that have been specified
57 | to it as well as the output of the previous command(s) as its input. For example,
58 | 
59 | .. code::
60 | 
61 |     checkmate git --branch master --n 4 analyze --analyzers pylint
62 | 
63 | would first execute the `git` command with parameters `branch=master` and `n=4` and then the `analyze`
64 | command with the parameters `analyzers=pylint` as well as the output of the `git` command.
65 | 
66 | Event Hooks
67 | -----------
68 | 
69 | Commands can emit events to which plugins can attach themselves via hooks. The purpose of these hooks
70 | is to allow the plugin to intercept, work with and possibly modify the state of a command at a given
71 | moment. Events and hooks work as follows:
72 | 
73 | * To emit an event, a `Command` class just calls the `emit` function of the `BaseCommand` class,
74 |   which accepts a `name` argument as well as an arbitrary number of additional parameters.
75 |   The return value of that call is a dictionary that contains the return values of all handler
76 |   functions that responded to the event, where the key corresponds to the name of the plugin.
77 | * A plugin can subscribe to various hooks by specifying a `hooks` dictionary in its `setup` module.
78 |   The keys in this dictionary should correspond to the name of the hooks that the plugin wants to
79 |   listen to and the values to the return values of the function calls.
80 |   If one of the hook functions throws an exception it will be recorded. When all hook functions
81 |   have been executed, a `HookException` exception will be thrown that contains a dictionary with
82 |   the individual exceptions thrown by all hook functions.
83 | * When an event is emitted, each hook function listening to that event will be called with the
84 |   following arguments:
85 | 
86 |     * The command instance that has emitted the event call
87 |     * The parameters that the command has passed to the event function
88 | 


--------------------------------------------------------------------------------
/docs/source/api/dependencies.rst:
--------------------------------------------------------------------------------
 1 | Dependency Management
 2 | =====================
 3 | 
 4 | Checkmate allows analyzers to define file revision dependencies. This allows to see exactly which
 5 | other file revisions might be affected by a change in a given file revision. The format for
 6 | defining a dependency is as follows:
 7 | 
 8 | .. code::
 9 | 
10 |     {
11 |         'type' : 'import',
12 |         'module' : 'foo.bar',
13 |         'imported_names' : ['foo','bar','baz'],
14 |     }
15 | 
16 | Here, we know that the given module imports another module named `foo.bar`, and more specifically
17 | that it imports the three names `foo`, `bar` and `baz` from that module. Now if in a given analysis,
18 | the file revision that resolves to the module has been modified, we know that we will also have to
19 | analyze the dependent file revision.
20 | 
21 | The dependency resolution process is thus as follows:
22 | 
23 | * For a given snapshot, we generate a list of all modified file revisions.
24 | * For all other file revisions, we check the dependencies and resolve them to file revisions.
25 | * If an unmodified file revision has a dependency that maps to a modified one, we add it to the
26 |   list of modified file revisions.
27 | * We repeat this process until no new files have been added to the list of modified files.
28 | 
29 | Dependency Resolution
30 | =====================
31 | 
32 | To resolve dependencies, we need to know about the Python module system. Information about import
33 | paths and additional, external dependencies will be read from the project whenever possible. You can
34 | also specify these within the `.checkmate.yml` file.
35 | 
36 | 


--------------------------------------------------------------------------------
/docs/source/api/index.rst:
--------------------------------------------------------------------------------
 1 | API
 2 | ===
 3 | 
 4 | Checkmate is designed in a way that makes it easy to use it both as a command line tool, or as a library.
 5 | 
 6 | Before you dive into the details of the API, be sure to read the section on the :doc:`core concepts <concepts>`, which
 7 | will give you a high-level overview of the library. 
 8 | 
 9 | 
10 | .. toctree::
11 |     :hidden:
12 |     :maxdepth: 1
13 | 
14 |     Core Concepts <concepts>
15 |     Commands <commands>


--------------------------------------------------------------------------------
/docs/source/api/plugins.rst:
--------------------------------------------------------------------------------
1 | Writing Plugins
2 | ===============


--------------------------------------------------------------------------------
/docs/source/contents.rst.inc:
--------------------------------------------------------------------------------
 1 | 
 2 | .. toctree::
 3 |     :hidden:
 4 |     :maxdepth: 2
 5 | 
 6 |     Welcome <self>
 7 |     Tutorials <tutorials/index>
 8 |     API <api/index>
 9 |     Integrations <integrations/index>
10 | 


--------------------------------------------------------------------------------
/docs/source/index.rst:
--------------------------------------------------------------------------------
  1 | :orphan:
  2 | 
  3 | .. title:: Welcome to Checkmate!
  4 | 
  5 | .. raw:: html
  6 | 
  7 |    <h1><i class="fa fa-check-circle" style="color:#0a5;"></i> Welcome to Checkmate!</h1>
  8 | 
  9 | **Checkmate** is Python tool for code quality management. It gives you a global overview of the code
 10 | quality in your project and provides you with actionable insights and advice.
 11 | 
 12 | Motivation
 13 | ----------
 14 | 
 15 | Most current command-line tools for code quality management overburden the user
 16 | with too much information, are hard to set up and adapt to the users needs and do not provide enough actionable insight.
 17 | 
 18 | Checkmate is an attempt to change this: 
 19 | 
 20 | * It doesn't overwhelm your with tons of irrelevant information. 
 21 | * It provides clear, actionable advice and a global view of your code quality.
 22 | * It wraps several code checking tools, providing a consolidated view on their data.
 23 | 
 24 | Key Features
 25 | """"""""""""
 26 | 
 27 | * Global statistics and issue lists for your project.
 28 | * Actionable, prioritized advice on how to improve the code.
 29 | * Built-in support of popular code checkers (**pep8**, **pylint** and **pyflakes**)
 30 | * Easily extendable and adaptable to your needs.
 31 | * Tracking of metrics and issues over time.
 32 | * Automatic versioning of your source files.
 33 | * Built-in support for git repositories.
 34 | 
 35 | Installation
 36 | ------------
 37 | 
 38 | The easiest way to install checkmate is via **pip** or **easy_install**:
 39 | 
 40 | .. code-block:: bash
 41 | 
 42 |     pip install 7s-checkmate
 43 | 
 44 | or
 45 | 
 46 | .. code-block:: bash
 47 | 
 48 |     easy_install 7s-checkmate
 49 | 
 50 | Alternatively, you can just download the source from Github and install it manually by running (in the project directory):
 51 | 
 52 | .. code-block:: bash
 53 | 
 54 |     git clone git@github.com:adewes/checkmate.git
 55 |     cd checkmate
 56 |     python setup.py build
 57 |     sudo python setup.py install
 58 | 
 59 | Quickstart
 60 | ----------
 61 | 
 62 | After installation, you should have a new **checkmate** command available in your shell. The command line interface (CLI) of checkmate is similar to that of **git**, so if you're familiar with the latter you should feel at home pretty fast.
 63 | 
 64 | 
 65 | Creating a new project
 66 | """"""""""""""""""""""
 67 | 
 68 | To create a new checkmate project, just go to your project folder and type:
 69 | 
 70 | .. code-block:: bash
 71 |     
 72 |     checkmate init
 73 | 
 74 | If run inside a git repository, this will create a new checkmate project in the root folder of the git project. Otherwise it will create a project in the current directory. Like *git*, *checkmate* keeps all its files in a *.checkmate* folder.
 75 | 
 76 | Analyzing your code
 77 | """""""""""""""""""
 78 | 
 79 | To analyze your projects and produce metrics and issue lists, simply type:
 80 | 
 81 | .. code-block:: bash
 82 |     
 83 |     checkmate analyze
 84 | 
 85 | This will generate of relevant files in your project, analyze them and generate a summary of the results. You can use on of the following commands to work with the results of the analysis:
 86 | 
 87 | .. code-block:: bash
 88 | 
 89 |     #Shows a summary of statistics and issues for your project
 90 |     checkmate summary
 91 |     #Show a list of issues for your project
 92 |     checkmate issues
 93 |     #Show a summary of the statistics & metrics of your project
 94 |     checkmate stats
 95 | 
 96 | There are some other commands you might find useful, for more information about the available commands or a specific command, just type
 97 | 
 98 | .. code-block:: bash
 99 | 
100 |     #Provides an overview of all commands and options
101 |     checkmate help
102 |     #Provides information about a specific command
103 |     checkmate help [command name]
104 | 
105 | .. raw:: html
106 | 
107 |     <a href="https://github.com/adewes/checkmate"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://github-camo.global.ssl.fastly.net/652c5b9acfaddf3a9c326fa6bde407b87f7be0f4/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f6f72616e67655f6666373630302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_orange_ff7600.png"></a>
108 | 
109 | .. include:: contents.rst.inc
110 | 


--------------------------------------------------------------------------------
/docs/source/integrations/git.rst:
--------------------------------------------------------------------------------
 1 | Git Integration
 2 | ===============
 3 | 
 4 | Checkmate plays nicely with the *git* version control system. All command working with git repositories are contained in
 5 | the **git** command group, for example:
 6 | 
 7 | .. code-block:: bash
 8 | 
 9 |     #analyzes the last commits from a git project
10 |     checkmate git analyze
11 | 
12 |     #resets a git project
13 |     checkmate git reset
14 | 
15 | Setting Up SSH
16 | --------------
17 | 
18 | Checkmate can use user-provided SSH keys to access git repositories over SSH. For this, `checkmate.lib.git.repository.fetch` 
19 | overrides the default SSH agent with `checkmate/lib/git/ssh`, which passes in the identity file given to `fetch`.
20 | 
21 | .. warning::
22 | 
23 |     For security reasons, you should disable all default identities for the user that runs this command, since your SSH client
24 |     will otherwise try all keys available to this user when accessing a repository, thereby possibly compromising the security
25 |     of your private repositories
26 | 
27 | SSH config
28 | ------------------
29 | 
30 | By default, the SSH agent invoked by the `fetch` command will generate and use a configuration file that looks like this:
31 | 
32 | .. code-block:: bash
33 | 
34 |     Host *
35 |          StrictHostKeyChecking no
36 |          IdentityFile [path/to/identity/file]
37 |          IdentitiesOnly yes
38 | 
39 | Here,`StrictHostKeyChecking` is disabled and `IdentitiesOnly` enabled. The identity file is the file given through the `identity_file` parameter of the `fetch` method.


--------------------------------------------------------------------------------
/docs/source/integrations/index.rst:
--------------------------------------------------------------------------------
 1 | Integrations
 2 | ============
 3 | 
 4 | Checkmate is designed to play nicely with a range of version control systems. Currently, only a git backend has been implemented.
 5 | 
 6 | .. toctree::
 7 |     :hidden:
 8 |     :maxdepth: 2
 9 | 
10 |     Git <./git>


--------------------------------------------------------------------------------
/docs/source/tutorials/basic.rst:
--------------------------------------------------------------------------------
1 | Basics
2 | ======


--------------------------------------------------------------------------------
/docs/source/tutorials/index.rst:
--------------------------------------------------------------------------------
1 | Tutorials
2 | =========
3 | 
4 | .. toctree::
5 |     :hidden:
6 |     :maxdepth: 2
7 | 
8 |     Basic Tutorial <basic>
9 | 


--------------------------------------------------------------------------------
/requirements-docs.txt:
--------------------------------------------------------------------------------
1 | sphinx
2 | 


--------------------------------------------------------------------------------
/requirements-test.txt:
--------------------------------------------------------------------------------
1 | pytest
2 | 
3 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | pylint
 2 | pyflakes
 3 | chardet
 4 | pep8
 5 | six
 6 | cffi
 7 | blitzdb
 8 | sqlalchemy
 9 | pyyaml
10 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | from distutils.core import setup
 3 | from setuptools import find_packages
 4 | 
 5 | setup(name='checkmate',
 6 | version='0.2.0',
 7 | author=u'Andreas Dewes - QuantifiedCode UG (haftungsbeschränkt)',
 8 | author_email = 'andreas@quantifiedcode.com',
 9 | license = 'MIT',
10 | install_requires = """
11 | pylint
12 | pyflakes
13 | pep8
14 | six
15 | chardet
16 | blitzdb
17 | pyyaml
18 | sqlalchemy
19 | """,
20 | entry_points = {
21 |         'console_scripts': [
22 |                'checkmate = checkmate.scripts.manage:main',
23 |         ],
24 |     },
25 | url='https://github.com/quantifiedcode/checkmate',
26 | packages=find_packages(),
27 | zip_safe = False,
28 | description='A meta-code checker written in Python.',
29 | long_description="""
30 | Checkmate is a cross-language (meta-)tool for static code analysis, written in Python.
31 | Unlike other tools, it provides a global overview of the code quality in a project and aims
32 | to provide clear, actionable insights to the user.
33 | 
34 | Documentation
35 | =============
36 | 
37 | The documentation can be found `here <https://docs.quantifiedcode.com/checkmate>`.
38 | 
39 | Source Code
40 | ===========
41 | 
42 | The source code can be found on `Github <https://github.com/quantifiedcode/checkmate>`.
43 | 
44 | Changelog
45 | =========
46 | 
47 | * 0.2.0: Beta-release
48 | """
49 | )
50 | 


--------------------------------------------------------------------------------