chore: remove addRules and addFunctions

docs/getting-started/rulesets.md

@@ -18,6 +18,7 @@ rules:
       function: truthy
 ```
 
+Spectral has a built-in set of functions such as `truthy` or `pattern`, which you can reference in your rules.
 The example above adds a single rule that checks that tags objects have a description property defined.
 
 Running `spectral lint` on the following object with the ruleset above will result in an error being reported, since the tag does not have a description:

docs/guides/javascript.md

@@ -180,143 +180,6 @@ The OpenAPI rules are opinionated. There might be some rules that you prefer to
 
 ## Advanced
 
-### Creating a custom rule
-
-Spectral has a built-in set of functions which you can reference in your rules. This example uses the `RuleFunction.PATTERN` to create a rule that checks that all property values are in snake case.
-
-```javascript
-const { Spectral } = require('@stoplight/spectral');
-
-const spectral = new Spectral();
-
-spectral.addRules({
-  snake_case: {
-    description: 'Checks for snake case pattern',
-
-    // evaluate every property
-    given: '$..*',
-
-    then: {
-      function: 'pattern',
-      functionOptions: {
-        match: '^[a-z]+[a-z0-9_]*[a-z0-9]+$',
-      },
-    },
-  },
-});
-
-// run!
-spectral.run({name: 'helloWorld',}).then(results => {
-  console.log(results);
-});
-```
-
-[Try it out!](https://repl.it/@ChrisMiaskowski/spectral-pattern-example)
-
-```bash
-[
-    {
-        "code": "snake_case",
-        "message": "Checks for snake case pattern",
-        "path": [
-            "name"
-        ],
-        "severity": 1,
-        "range": {
-            "start": {
-                "line": 1,
-                "character": 10
-            },
-            "end": {
-                "line": 1,
-                "character": 22
-            }
-        }
-    }
-]
-```
-
-### Creating a custom function
-
-Sometimes the built-in functions don't cover your use case. This example creates a custom function, `customNotThatFunction`, and then uses it within a rule, `openapi_not_swagger`. The custom function checks that you are not using a specific string (e.g., "Swagger") and suggests what to use instead (e.g., "OpenAPI").
-
-```javascript
-const { Spectral } = require('@stoplight/spectral');
-
-// custom function
-const customNotThatFunction = (targetValue, options) => {
-  const { match, suggestion } = options;
-
-  if (targetValue && targetValue.match(new RegExp(match))) {
-    // return the single error
-    return [
-      {
-        message: `Use ${suggestion} instead of ${match}!`,
-      },
-    ];
-  }
-};
-
-const spectral = new Spectral();
-
-spectral.addFunctions({
-  notThat: customNotThatFunction,
-});
-
-spectral.addRules({
-  openapi_not_swagger: {
-    description: 'Checks for use of Swagger, and suggests OpenAPI.',
-
-    // check every property
-    given: '$..*',
-
-    then: {
-      // reference the function we added!
-      function: 'notThat',
-
-      // pass it the options it needs
-      functionOptions: {
-        match: 'Swagger',
-        suggestion: 'OpenAPI',
-      },
-    },
-  },
-});
-
-// run!
-spectral.run({description: 'Swagger is pretty cool!',}).then(results => {
-  console.log(JSON.stringify(results, null, 4));
-});
-```
-
-[Try it out!](https://repl.it/@ChrisMiaskowski/spectral-custom-function-example)
-
-```bash
-# Outputs a single result since we are using the term `Swagger` in our object
-[
-    {
-        "code": "openapi_not_swagger",
-        "message": "Checks for use of Swagger, and suggests OpenAPI.",
-        "path": [
-            "description"
-        ],
-        "severity": 1,
-        "range": {
-            "start": {
-                "line": 1,
-                "character": 17
-            },
-            "end": {
-                "line": 1,
-                "character": 42
-            }
-        }
-    }
-]
-```
-
-For more information on creating rules, read about [rulesets](../getting-started/rulesets.md).
-
 ### Creating a custom format
 
 Spectral supports two core formats: `oas2` and `oas3`. Using `registerFormat` you can add support for autodetecting other formats. You might want to do this for a ruleset which is run against multiple major versions of description format like RAML v0.8 and v1.0.

docs/migration-guides/5.0.md

@@ -0,0 +1,51 @@
+# Spectral v4 to v5 Migration Guide
+
+Our docs have been updated, so you can always refer to them. To make the transition less painful,
+this migration guide covers the most notable changes.
+
+### I use Spectral programmatically via API...
+
+1. addFunctions and addRules have been removed
+
+We strongly encourage everyone to write rulesets, therefore the new preferred way to load a ruleset is via `loadRuleset`.
+
+**Spectral v4**:
+
+```js
+const { oas3Functions, rules: oas3Rules } = require('@stoplight/spectral/dist/rulesets/oas3');
+
+const spectral = new Spectral();
+spectral.addFunctions(oas3Functions);
+spectral.addFunctions(oas3Rules);
+spectral.run(myOpenApiDocument)
+  .then(results => {
+    console.log('here are the results', results);
+  });
+```
+
+**Spectral v5**:
+
+```js
+const { Spectral } = require('@stoplight/spectral');
+
+const spectral = new Spectral();
+spectral.loadRuleset('spectral:oas')
+  .then(() => spectral.run(myOpenApiDocument))
+  .then(results => {
+    console.log('here are the results', results);
+  });
+```
+
+Alternatively, if your ruleset is stored in a plain JSON file, you can also consider using `setRuleset`, as follows
+
+```js
+const { Spectral } = require('@stoplight/spectral');
+const ruleset = require('./my-ruleset.json');
+
+const spectral = new Spectral();
+spectral.setRuleset(ruleset);
+spectral.run(myOpenApiDocument)
+  .then(results => {
+    console.log('here are the results', results);
+  });
+```

src/spectral.ts

@@ -13,7 +13,6 @@ import {
   parseWithPointers as parseYAMLWithPointers,
   YamlParserResult,
 } from '@stoplight/yaml';
-import deprecated from 'deprecated-decorator';
 import { merge, set } from 'lodash';
 
 import { STATIC_ASSETS } from './assets';
@@ -132,33 +131,15 @@ export class Spectral {
     return (await this.runWithResolved(target, opts)).results;
   }
 
-  @deprecated('loadRuleset', '4.1')
-  public addFunctions(functions: FunctionCollection) {
-    this._addFunctions(functions);
-  }
-
-  public _addFunctions(functions: FunctionCollection) {
-    Object.assign(this.functions, functions);
-  }
-
   public setFunctions(functions: FunctionCollection) {
     empty(this.functions);
 
-    this._addFunctions({ ...defaultFunctions, ...functions });
-  }
-
-  @deprecated('loadRuleset', '4.1')
-  public addRules(rules: RuleCollection) {
-    this._addRules(rules);
+    Object.assign(this.functions, { ...defaultFunctions, ...functions });
   }
 
   public setRules(rules: RuleCollection) {
     empty(this.rules);
 
-    this._addRules({ ...rules });
-  }
-
-  private _addRules(rules: RuleCollection) {
     for (const name in rules) {
       if (!rules.hasOwnProperty(name)) continue;
       const rule = rules[name];