Skip to content
master
Switch branches/tags
Go to file
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
src
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

README.rst

Build Status

spor

A system for anchoring metadata in external files to source code.

spor lets you define metadata for elements of your source code. The metadata is kept in a separate file from your source code, meaning that you don't need to clutter your source file with extra information encoded into comments. To accomplish this while dealing with the fact that source code changes over time, spor uses various "anchoring" techniques to keep the metadata in sync with the source code (or let you know when they become unmanageably out of sync).

Quickstart

Spor is written in rust, so you build it with cargo:

$ cargo build

Before you can use spor to anchor metadata to files, you need to initialize a repository with the init command:

$ spor init

This is very similar in spirit to git init. It creates a new directory in your current directory called .spor, and this is where spor will keep the information it needs.

Now you can create anchors. Suppose you've got a file, example.py, like this:

# example.py


def func(x):
    return x * 2

You can anchor metadata to line 4 (the function definition) by specifying the starting offset and anchor width like this:

$ echo "{\"meta\": \"data\"}" | spor add example.py 32 12 10
You don't have to pipe the metadata into the add command. If you don't, spor will pop up an editor so that you can enter the metadata there.

The 10 at the end specifies the size of the "context" around the anchored code that we use for updating anchors.

This will associate the dictionary {meta: data} with the code return x * 2. You can see this metadata by using the list command:

$ spor list example.py
example.py:32 => {'meta': 'data'}

The metadata can be any valid YAML. spor doesn't look at the data at all, so it's entirely up to you to decide what goes there.

Motivation

My main motivation for this tool comes from my work on the mutation testing tool Cosmic Ray. CR users need to be able to specify sections of their source code which should not be mutated, or which should only be mutated in specific ways. Rather than having them embed these processing directives in the source code, I thought it would be cleaner and neater to let them do so with a separate metadata file.

Features

spor needs support for the following functionality:

  1. Add/edit/delete metadata to a specific range of text in a source file
  2. Query existing metadata
  3. Automatically update metadata when possible, or report errors when not
  4. Provide facilities facilities for "updating" metadata with new anchoring data

The design needs to be sensitive to both human users (i.e. since they may need to manually work with the metadata from time to time) as well as programmatic users. I'm sure the design will evolve as we go, so I'm going to try to keep it simple and explicit at first.

Ideally spor will work on any programming language (and, really, any text document), though its initial target will be Python source code.

Tests

Use cargo to run the tests:

$ cargo test

Notes

The field of "anchoring" is not new, and there's some existing work we need to pay attention to:

About

externalized source code metadata

Resources

License

Releases

No releases published

Packages

No packages published