sloplint 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 846ce6e663bb01d1dd3e054f328eaccb423745aeb34def94b8ce33253d960c23
-  data.tar.gz: f165880bb800c66a57d88ffd7e9876c4426a7607a6f4b68582d8f0365c728956
+  metadata.gz: 2dff756c71ef10086a95d721978cb5bd0f3a73ae28f46637f91b13b016aa461b
+  data.tar.gz: 543c0b9005b4e7b90d35c5595ee812f77d849513163d222b1ae04cb8fa48b8c0
 SHA512:
-  metadata.gz: ef1d295149a0b032fc000795316d385331a679aa246dcf4177c902a4589745e91f63d728e7a5b6ceb0c5323902c3079b1e588580f5bbbc08e07f9a19d2560a00
-  data.tar.gz: bd0530c68b5dac9587580b79fffdd52bfed59ab847c18ecd1e3a164c906cd6f745cb7409278283876b3dcdf5ba7309459b422e047cc73c2406984569b6215bfa
+  metadata.gz: 537e1d987a39cb4b9c488b69ea4aa7e5381b3594d9565eb78324640389e6eae7fa9cf47c6c93921048b396de24178b969f6ac36685dec2606845c9e00694b543
+  data.tar.gz: 9d4d9845f6a540954446dd2a5513cd0dc0fd9c28a8e689ac6a64a975f03bf68e1478c62be96e2d09ac1784e83bb421c667898f88e89aceb6a63d729ffce17270

data/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project are documented here. Format loosely
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [Unreleased]
+
+## [0.3.0] - 2026-08-02
+
+- New rule `load-bearing` (`rhetorical-tic`, `warning`): "load-bearing" used
+  as a borrowed metaphor for anything important, outside its literal
+  construction sense (a wall, a column, a beam). Guards on both sides —
+  a building noun right after it, or the predicate form ("the wall is
+  load-bearing") — leave the construction sense clean.
+- New rule `is-is` (`rhetorical-tic`, `warning`): the doubled copula, "what it
+  is is a mistake" / "the thing is, is that...". No anchor needed -- the bare
+  pattern scored 0 hits across ~1.9M words of public-domain and modern prose.
+- `exactly-the` replaced by the broader `exact-exactly` (`rhetorical-tic`,
+  now `info`): flags "exact/exactly" generally, not just the fixed "exactly
+  the point/kind/problem/…" phrase shape, with an allowlist for the places
+  it's doing real work (numbers, times, same/opposite/way/etc.). Severity
+  drops to `info` because a common word will still slip through on cases
+  the allowlist hasn't seen yet.
+- `thats-not-nothing` replaced by the broader `not-nothing`
+  (`rhetorical-tic`, `warning`): catches the "is not nothing" litotes
+  regardless of subject ("Fifty basis points is not nothing"), not only
+  the demonstrative-subject form ("that's not nothing"). Personal-subject
+  litotes ("he was not nothing to her") and the "there is not nothing"
+  philosophy frame are allowlisted as legitimate human use.
+- `underscores-highlights` broadened (`puffery`, still `info`): "underscores
+  the need for", "underscored how fragile", and "underscoring the urgency"
+  now match, not only the fixed "underscores/highlights/emphasizes its/the/
+  their importance/significance" phrase. The character-noun sense
+  ("a leading underscore", snake_case) stays excluded.
+
 ## [0.2.0] - 2026-07-28
 
 - `is-real-and-not` and `worth-naming` move from `warning` to `info`. Both

data/README.md

@@ -51,10 +51,10 @@ $ printf 'The report is a rich tapestry of vibrant detail.\nThat is exactly the
     why: Travel-brochure adjectives and phrases that models reach for and careful writers avoid.
     fix: Replace with a concrete, specific detail or cut it.
 
--:2:9: warning exactly-the  "exactly the point/kind/problem/…" is an overused LLM emphasis tic.
-    excerpt: …tapestry of vibrant detail. That is [exactly the point] I keep making about it.
-    why: 'exactly the X' is a model intensifier that a careful writer rarely leans on.
-    fix: Drop 'exactly the'; state the point without the intensifier.
+-:2:9: info exact-exactly  "exact/exactly" is reflexive emphasis unless it names something checkable.
+    excerpt: …tapestry of vibrant detail. That is [exactly] the point I keep making about it.
+    why: Models reach for 'exact/exactly' as filler emphasis on a claim with nothing to check; it earns its place only next to a number, a name, or a stated identity.
+    fix: Cut it, or replace with the number, name, or match it's supposed to be precise about.
 ```
 
 The brackets mark the match; the rest is there so you can see what you're fixing without opening the file — including *why*, so an agent doesn't have to run `explain` separately to decide whether a flag is worth acting on.
@@ -128,9 +128,9 @@ An unknown id or category in `--select`/`--ignore` is a usage error (exit 2, nam
 
 ## The rule catalog
 
-27 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
+29 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
 
-- **rhetorical-tic** (16) the cadence patterns: `no-x-no-y`, `no-x-no-y-frag`, `thats-the-whole`, `thats-how-x`, `announced-takeaway`, `exactly-the`, `you-already-know`, `sit-with-that`, `thats-not-nothing`, and more.
+- **rhetorical-tic** (18) the cadence patterns: `no-x-no-y`, `no-x-no-y-frag`, `thats-the-whole`, `thats-how-x`, `announced-takeaway`, `exact-exactly`, `load-bearing`, `you-already-know`, `sit-with-that`, `not-nothing`, `is-is` (doubled copula), and more.
 - **puffery** (5) Wikipedia's "signs of AI writing": `puffery-words` (vibrant, nestled, groundbreaking, in the heart of), `rich-tapestry`, `vital-role`, `stands-serves-as`, `underscores-highlights`.
 - **structure** (5) `not-just-x-but-y`, `not-x-but-y` (the bare corrective), `em-dash` (any em dash), `em-dash-overuse` (three or more in one paragraph), and `rule-of-three`.
 - **hedging** (1) `vague-attribution`: "some critics argue," "it is widely regarded."

data/docs/SPEC.md

@@ -275,7 +275,8 @@ false-positive risk, which none has demonstrated.
 | `is-real-and-not` | "the X is real, and/not…", "is the real … and it" | skip "real estate/time"; `info` |
 | `the-punchline-is` | "the punchline is/:/?" | |
 | `worth-naming` | "worth naming", "it's worth naming that…", "Worth naming:" | skip "naming names"; `info` |
-| `thats-not-nothing` | "that/this/it/which is not nothing" | |
+| `not-nothing` | copula + "not nothing" litotes, any subject | skip personal/there subjects |
+| `is-is` | doubled copula: "what it is is …", "the thing is, is that …" | comma optional |
 
 ### puffery (Wikipedia: Signs of AI writing)
 
@@ -284,7 +285,7 @@ Single flat rule per word-cluster, matched as whole words:
 - `puffery-words` — boasts a, vibrant, rich (history/cultural/tapestry), nestled (gated to a following in/among/between, so the literal verb — a head nestled against a shoulder — doesn't count), in the heart of (gated to a place object), groundbreaking, renowned, diverse array, breathtaking, natural beauty, stands as a testament, indelible mark, deeply rooted.
 - `stands-serves-as` — "stands as / serves as", "is a testament/reminder to".
 - `vital-role` — "plays a (vital/crucial/pivotal/significant/key) role".
-- `underscores-highlights` — "underscores/highlights/emphasizes its (importance/significance)".
+- `underscores-highlights` — "underscore(s)" + determiner and "underscored/underscoring" anywhere (the emphasis verb); "highlights/emphasizes its (importance/significance)" stays narrow.
 - `rich-tapestry` — "rich tapestry", "tapestry of".
 
 ### structure

data/lib/sloplint/rules.rb

@@ -33,9 +33,8 @@ module Sloplint
       examples_bad: ["No fluff, no filler, no jargon."],
       examples_ok: ["No parking on Sundays."],
       rationale: "Asyndetic negation chains are a signature model cadence, near-absent from " \
-                 "human prose at any length -- 24 hits in 1.02M words across Austen, Melville, " \
-                 "Madison, Thoreau, and Emerson combined. A careful writer occasionally stacks " \
-                 "two (and, rarely, more), but a model reaches for the pattern constantly."
+                 "human prose at any length. A careful writer occasionally stacks two (and, " \
+                 "rarely, more), but a model reaches for the pattern constantly."
     ),
     Rule.new(
       id: "no-x-no-y-frag",
@@ -76,11 +75,9 @@ module Sloplint
       ],
       rationale: "The fragment form of the same cadence, and the weaker signal of the two: the " \
                  "comma chain is one authored sentence, while this is just short sentences in " \
-                 "sequence, which human prose also does. It scored 1 hit in a 744k-word " \
-                 "five-book probe (Hamilton's 'no common coin; no common judicatory', itself " \
-                 "the chain in question), so it is rare in careful writing -- but a deliberate " \
-                 "staccato run ('No one moved. No one spoke.') has the identical shape and is " \
-                 "not a tell. Treat a flag here as a question, not a verdict."
+                 "sequence, which human prose also does. It's rare in careful writing, but a " \
+                 "deliberate staccato run ('No one moved. No one spoke.') has the identical " \
+                 "shape and is not a tell. Treat a flag here as a question, not a verdict."
     ),
     Rule.new(
       id: "thats-the-whole",
@@ -215,27 +212,141 @@ module Sloplint
                  "which sense it's in."
     ),
     Rule.new(
-      id: "thats-not-nothing",
+      id: "not-nothing",
       category: "rhetorical-tic",
       severity: "warning",
-      pattern: /\b(?:that|this|it|which)(?:'s| is)\s+not\s+nothing\b/i,
-      message: '"…that\'s not nothing" is a stock LLM understatement.',
+      # Two branches: spelled-out copula with an optional captured subject, and
+      # the contracted "X's not nothing". The optional subject + skip: is the
+      # load-bearing idiom -- skip: only sees matched text, so the personal
+      # subjects a human litotes takes (I/he/she/we/you/they) must be inside
+      # the match to be dropped there. The contracted branch captures the word
+      # before 's for the same reason ("she's not nothing" must reach the
+      # skip). "there" is guarded too: "there is/there's not nothing" is the
+      # philosophy frame or dialect, not the closer. "not for nothing" and
+      # "something and not nothing" never match at all -- the copula must sit
+      # adjacent to "not nothing". Token gaps cross a hard-wrapped line but
+      # never a paragraph break, so a paragraph ending "...was not" cannot weld
+      # onto one starting "Nothing ...".
+      pattern: /\b(?:(?:i|he|she|we|you|they|there)(?:[ \t]|\r?\n(?![ \t]*\r?\n))+)?
+                 (?:am|is|are|was|were)(?:[ \t]|\r?\n(?![ \t]*\r?\n))+
+                 not(?:[ \t]|\r?\n(?![ \t]*\r?\n))+nothing\b
+                |\b[\w-]+['’]s(?:[ \t]|\r?\n(?![ \t]*\r?\n))+
+                 not(?:[ \t]|\r?\n(?![ \t]*\r?\n))+nothing\b/ix,
+      skip: [/\A(?:i|he|she|we|you|they|there)\b/i],
+      message: '"…is not nothing" is a stock LLM understatement.',
       suggestion: "State the magnitude directly instead of the litotes.",
-      examples_bad: ["We cut latency in half, and that's not nothing."],
-      examples_ok: ["That is not enough to matter."],
-      rationale: "The 'not nothing' litotes is a recognizable model closer."
+      examples_bad: [
+        "We cut latency in half, and that's not nothing.",
+        "Fifty basis points is not nothing.",
+        "Three years of runway is not nothing.",
+        "A million users is not nothing.",
+        "The margin was not nothing.",
+        # Hard-wrapped Markdown: same paragraph, still the tell.
+        "The gain was not\nnothing, the report said."
+      ],
+      examples_ok: [
+        "That is not enough to matter.",
+        # Personal-subject litotes is a human literary move, not the closer
+        # tic -- spelled out and contracted.
+        "She told him he was not nothing to her.",
+        "She's not nothing to me, whatever they say.",
+        # "not for nothing": the intervening word breaks adjacency.
+        "It was not for nothing that he trained all winter.",
+        # The philosophy frame, both shapes it takes.
+        "Why is there something and not nothing?",
+        "There is not nothing; being persists.",
+        # Dialect double negative, not the litotes.
+        "There's not nothing we can do.",
+        # A paragraph break never welds a match.
+        "The answer was not\n\nNothing prepared us for it."
+      ],
+      rationale: "The 'not nothing' litotes is a recognizable model closer; the subject " \
+                 "varies ('that's not nothing', 'fifty basis points is not nothing') but " \
+                 "the move is the same. Personal subjects are carved out: 'he was not " \
+                 "nothing to her' is a human literary litotes, not the closer."
     ),
 
     Rule.new(
-      id: "exactly-the",
+      id: "exact-exactly",
+      category: "rhetorical-tic",
+      severity: "info",
+      pattern: /\bexact(?:ly)?\b(?!\s*(?:(?:the\s+)?(?:same|opposite|science|change|replica|copy|location|coordinates|way)\b|[$\d]|noon\b|midnight\b|o'?\s*clock\b))/i,
+      message: '"exact/exactly" is reflexive emphasis unless it names something checkable.',
+      suggestion: "Cut it, or replace with the number, name, or match it's supposed to be precise about.",
+      examples_bad: [
+        "That's exactly the point.", "We proved exactly the point we needed.",
+        "This is exactly the kind of thing we warned about.",
+        "That's the exact problem with the old system.",
+        "That's exactly right.", "I know exactly why this happened."
+      ],
+      examples_ok: [
+        "She folded it exactly the way he showed her.",
+        "The bill came to exactly $42.",
+        "We agreed on the exact same design.",
+        "It's not an exact science.",
+        "Please bring exact change for the bus.",
+        "The museum built an exact replica of the ship.",
+        "This is an exact copy of the original.",
+        "He wanted the exact opposite of what she suggested.",
+        "Rescue teams pinpointed the exact location of the wreck.",
+        "GPS gave us the exact coordinates of the site.",
+        "The train left at exactly noon.",
+        "They agreed to meet at exactly midnight.",
+        "The meeting starts at exactly 3 o'clock.",
+        "She has exacting standards for her students."
+      ],
+      rationale: "Models reach for 'exact/exactly' as filler emphasis on a claim with nothing to " \
+                 "check; it earns its place only next to a number, a name, or a stated identity."
+    ),
+    Rule.new(
+      id: "load-bearing",
       category: "rhetorical-tic",
       severity: "warning",
-      pattern: /\b(?:(?:that's|this is|it's)\s+)?exactly\s+the\s+(?:point|kind|type|sort|problem|question|issue|opposite|reason|thing|tension)\b/i,
-      message: '"exactly the point/kind/problem/…" is an overused LLM emphasis tic.',
-      suggestion: "Drop 'exactly the'; state the point without the intensifier.",
-      examples_bad: ["That's exactly the point.", "We proved exactly the point we needed."],
-      examples_ok: ["She folded it exactly the way he showed her."],
-      rationale: "'exactly the X' is a model intensifier that a careful writer rarely leans on."
+      # Two guards, both structural, over the same noun list so they can't
+      # drift apart. Forward: a physical building part right after it is the
+      # literal sense, checked with a negative lookahead. Backward: the
+      # predicate form ("the wall is load-bearing") is literal too, but a
+      # fixed-width lookbehind covering this many noun x tense combinations
+      # trips a real Ruby/Onigmo lookbehind bug on some inputs (RegexpError
+      # at match time, not compile time -- reproduced on em-dash's own
+      # fixtures). Pulling the noun+copula into the pattern itself as an
+      # optional leading group sidesteps lookbehind entirely: when present,
+      # it's captured as part of the match, and skip: (which only ever sees
+      # matched text, never surrounding context) drops it there instead.
+      pattern: /\b(?:(?:wall|column|beam|post|pillar|joist|stud|masonry|partition|
+                        structure|frame|footing|foundation|member)s?\s+
+                     (?:is|are|was|were)\s+)?
+                load[-\s]?bearing\b
+                (?!\s+(?:wall|column|beam|post|pillar|joist|stud|masonry|partition|
+                         structure|frame|footing|foundation|member)s?\b)/ix,
+      skip: [/\A(?:wall|column|beam|post|pillar|joist|stud|masonry|partition|
+                   structure|frame|footing|foundation|member)s?\s+
+                (?:is|are|was|were)\s+load/ix],
+      message: '"load-bearing" outside construction is a borrowed metaphor.',
+      suggestion: "Say what the thing holds up, or what breaks without it.",
+      examples_bad: [
+        "That comma is load-bearing.",
+        "The load-bearing assumption is that users read the docs.",
+        "Half the argument rests on one load-bearing word.",
+        "This paragraph is the load-bearing part of the essay.",
+        "Trust was the load-bearing element of the whole deal.",
+        "The qualifier is doing load bearing work here."
+      ],
+      examples_ok: [
+        "They knocked out a load-bearing wall during the remodel.",
+        "The inspector flagged a cracked load-bearing column.",
+        "Steel load-bearing beams replaced the old timber.",
+        "The load-bearing masonry dates to 1890.",
+        "Those columns are load-bearing.",
+        "The interior wall is load-bearing, so it stays.",
+        "The beam is load-bearing.",
+        "That stud was load-bearing, so removing it needed a header beam.",
+        "Those joists were load-bearing, engineers confirmed after inspection.",
+        "The masonry was load-bearing in the original 1890 structure."
+      ],
+      rationale: "'Load-bearing' is a construction term for a wall or column that holds up the " \
+                 "structure. Models borrow it as a metaphor for anything important, which just " \
+                 "restates the sentence's importance without saying what actually holds it up."
     ),
     Rule.new(
       id: "thats-how-x",
@@ -271,6 +382,41 @@ module Sloplint
       rationale: "Labelling a claim as the portable lesson does the persuading that the claim " \
                  "should be doing — a model habit borrowed from thought-leader prose."
     ),
+    Rule.new(
+      id: "is-is",
+      category: "rhetorical-tic",
+      severity: "warning",
+      # No anchor needed -- the doubled copula alone scored 0 across ~1.9M words.
+      # The comma is allowed because "What it is, is a mystery" grates the same
+      # way. Sentence and clause punctuation still block the weld ("what it is.
+      # Is that…", "here's what it is: is anyone…"), and \b on both ends keeps
+      # the pattern out of "his island". \s+ needs no paragraph-break guard: a
+      # false match would need a paragraph that begins with "is ".
+      pattern: /\bis,?\s+is\b/i,
+      message: 'Doubled copula ("is is" / "is, is") — spoken cadence on the page.',
+      suggestion: "Drop the cleft and say it straight, or delete the second 'is'.",
+      examples_bad: [
+        "What this really is is a bet on distribution.",
+        "What it is is a rounding error with a press release.",
+        "What it is, is a failure of nerve.",
+        "The thing is, is that nobody checked the logs."
+      ],
+      examples_ok: [
+        # Walden: the cleft with a single copula, which is ordinary English.
+        "We have heard of this virtue, but we know not what it is.",
+        # Sentence and clause punctuation can't be welded across.
+        "I know what it is. Is that a problem?",
+        "Here's what it is: is anyone actually reading this?",
+        # Both \b anchors matter -- "his island" contains the literal string "is is".
+        "He sailed to his island at dawn."
+      ],
+      rationale: "Three things produce a doubled copula and all three read as unedited. The " \
+                 "wh-cleft ('what it is is a mistake') is grammatical -- 'what it is' is the " \
+                 "subject and the second 'is' is the verb -- and it is the model's version, a " \
+                 "frame that stages a definition instead of asserting one, the same move as " \
+                 "'the punchline is'. The NP form ('the thing is, is that') is the true double " \
+                 "copula and a spoken disfluency. The third is a typo."
+    ),
 
     # ── puffery ───────────────────────────────────────────────────────────
     Rule.new(
@@ -335,12 +481,50 @@ module Sloplint
       id: "underscores-highlights",
       category: "puffery",
       severity: "info",
-      pattern: /\b(?:underscores|highlights|emphasizes)\s+(?:its|the|their)\s+(?:importance|significance)\b/i,
-      message: '"underscores/highlights its importance" is stock AI framing.',
+      # "underscored/underscoring" are unambiguously the verb and flag bare.
+      # "underscore/underscores" is also the character noun (a leading
+      # underscore, snake_case docs), so those forms require a following
+      # determiner/wh-word -- the frame the emphasis verb takes, which the
+      # noun never precedes. That guard also skips bare-noun objects
+      # ("underscores concerns about"), an accepted miss: widening the frame
+      # to catch them readmits the noun sense. Token gaps cross a
+      # hard-wrapped line but never a paragraph break. highlights/emphasizes
+      # stay narrowed to the importance/significance frame -- both verbs are
+      # too common in ordinary prose to match broadly.
+      pattern: /\bunderscor(?:ed|ing)\b
+               |\bunderscores?(?:[ \t]|\r?\n(?![ \t]*\r?\n))+
+                 (?:a|an|the|its|his|her|their|our|your|my|this|that|these|those|what|why|how|just)\b
+               |\b(?:highlights|emphasizes)\s+(?:its|the|their)\s+(?:importance|significance)\b/ix,
+      message: '"underscores" as emphasis (or "highlights/emphasizes its importance") is stock AI framing.',
       suggestion: "Show why it matters rather than asserting that it does.",
-      examples_bad: ["This underscores its importance to the field."],
-      examples_ok: ["She highlights the key line in yellow."],
-      rationale: "The 'underscores its importance' move asserts significance without earning it."
+      examples_bad: [
+        "This underscores its importance to the field.",
+        "The delay underscores the need for better tooling.",
+        "The outage underscored how fragile the pipeline was.",
+        "Underscoring the urgency, the board met twice.",
+        "The results underscore a deeper problem with the method.",
+        "The report underscores just how far behind we are.",
+        "It underscores that the market has moved on.",
+        "The essay highlights its importance at length.",
+        "This emphasizes the significance of early testing."
+      ],
+      examples_ok: [
+        "Replace each space with an underscore.",
+        "Variable names use underscores instead of dashes.",
+        "The underscore character separates words in snake case.",
+        "Prefix private methods with a leading underscore.",
+        "Ruby numeric literals accept underscores for readability.",
+        "Two underscores mark a dunder method in Python.",
+        "She highlights the key line in yellow.",
+        "The paper emphasizes the method, not the results.",
+        # A paragraph break never welds the noun onto the next sentence.
+        "Numbers accept underscores\n\nThe next section covers floats."
+      ],
+      rationale: "Models reach for 'underscore' as an all-purpose emphasis verb -- findings " \
+                 "underscore, outages underscore -- asserting significance without earning it. " \
+                 "Sincere journalistic and academic use exists, hence info: a flag means the " \
+                 "move is present, not that it's slop. The character noun never takes the " \
+                 "verb's frame and stays out."
     ),
     Rule.new(
       id: "rich-tapestry",
@@ -397,8 +581,8 @@ module Sloplint
                  "copula, which is the specific shape models overuse. Correlative 'not only… " \
                  "but' joining two verb phrases or clauses, without a preceding copula, is " \
                  "ordinary and common in formal human prose; requiring the escalation word " \
-                 "keeps those out. 'not because… but because' scored 2 hits in a 744k-word " \
-                 "five-book probe (Austen, Melville, Hamilton/Madison, Thoreau, Emerson)."
+                 "keeps those out. The same logic covers 'not because A, but because B': the " \
+                 "escalation word is what marks it deliberate."
     ),
     Rule.new(
       id: "not-x-but-y",
@@ -464,9 +648,9 @@ module Sloplint
       ],
       rationale: "The bare 'is not A but B' corrective is the 'not just… but' move with the " \
                  "escalation word dropped, and models reach for it constantly. It is the " \
-                 "noisiest rule in the catalog by design: a loose version scored 174 hits in a " \
-                 "744k-word five-book probe, and the narrowings here cut that to 15 -- but not " \
-                 "all 15 are correctives. Some are concessions with an elided subject (Walden's " \
+                 "noisiest rule in the catalog by design: a loose version scored 174 hits " \
+                 "before narrowing, cut to 15 here -- but not all 15 are correctives. Some " \
+                 "are concessions with an elided subject (Walden's " \
                  "'It was not lonely, but made all the earth lonely beneath it'), which no " \
                  "surface pattern can tell apart from the real thing. Hence info: a flag here " \
                  "means 'this has the shape', not 'this is slop'."

data/lib/sloplint/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sloplint
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sloplint
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Benjamin Jackson