From 5747e5fa90cb29aaa49bb0377f7e658cc4552e0a Mon Sep 17 00:00:00 2001 From: flaviut Date: Sat, 31 May 2014 21:16:18 -0400 Subject: [PATCH] Add formatting css and reorganize --- .gitignore | 2 + Rules | 6 +- content/book.json | 18 ----- content/case.md | 8 +- content/for_iterators.md | 24 +++--- content/getting_started.md | 20 ++--- content/hello_world.md | 8 +- content/if_else_while.md | 4 +- content/index.md | 4 +- content/numbers.md | 4 +- content/objects.md | 4 +- content/oop_macro.md | 12 +-- content/stylesheet.css | 101 ----------------------- content/stylesheets/main.css | 141 +++++++++++++++++++++++++++++++++ content/stylesheets/syntax.css | 72 +++++++++++++++++ content/toc.md | 26 +++--- content/varargs.md | 20 ++--- content/variables/page.md | 12 +-- content/variables/result.md | 8 +- layouts/default.html | 3 +- lib/default.rb | 10 +++ 21 files changed, 308 insertions(+), 199 deletions(-) delete mode 100644 content/book.json delete mode 100644 content/stylesheet.css create mode 100644 content/stylesheets/main.css create mode 100644 content/stylesheets/syntax.css diff --git a/.gitignore b/.gitignore index e38d486..4f37b0d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,5 @@ nohup.out output/ tmp/ +crash.log + diff --git a/Rules b/Rules index cf6e573..4aa17f7 100644 --- a/Rules +++ b/Rules @@ -18,8 +18,10 @@ compile '*' do filter :kramdown layout 'blank' elsif item[:extension] == 'md' - filter :kramdown - filter :colorize_syntax, :default_colorizer => :pygmentsrb + filter :kramdown, {:input => 'GFM'} + filter :colorize_syntax, :default_colorizer => :pygmentize + filter :code_class_simplfier + filter :relativize_paths, :type => :html layout 'default' elsif item[:extension] == 'css' # don’t filter stylesheets diff --git a/content/book.json b/content/book.json deleted file mode 100644 index a89774f..0000000 --- a/content/book.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "title": "Nimrod by Example", - "description": "A book of short examples of Nimrod features", - "github": null, - "githubHost": "https://github.com/", - "plugins": [], - "links": { - "home": "http://nimrod-lang.org/", - "about": false, - "issues": null, - "contribute": null, - "sharing": { - "google": false, - "facebook": false, - "twitter": false - } - } -} \ No newline at end of file diff --git a/content/case.md b/content/case.md index 27df99d..b1f748d 100644 --- a/content/case.md +++ b/content/case.md @@ -7,7 +7,7 @@ Nimrod also supports case statements, which are like switches in other languages * case statements, like most things, are actually expressions * It is required that every possible case be covered -~~~ Nimrod +``` nimrod case "charlie" of "alfa": echo "A" @@ -38,11 +38,11 @@ proc positiveOrNegative(num: int): string = "impossible" echo positiveOrNegative(-1) -~~~ +``` -~~~ +``` console $ nimrod c -r ./case_stmts.nim C Consonant negative -~~~ \ No newline at end of file +``` \ No newline at end of file diff --git a/content/for_iterators.md b/content/for_iterators.md index 088f171..17371c0 100644 --- a/content/for_iterators.md +++ b/content/for_iterators.md @@ -6,7 +6,7 @@ Nimrod has first class iterators and syntax to use them, for loops. The `continu When iterating over an object with one item, Nimrod will call an iterator called `items` with the first parameter the type you want to iterate over. The same thing happens when iterating with two items, but in that case, the `pairs` iterator is called. -~~~ nimrod +``` nimrod type TRange = object low: int @@ -24,18 +24,18 @@ iterator pairs(range: TRange): tuple[a: int, b: char] = for i, c in TRange(low: 1, high: 3): echo c -~~~ -~~~ +``` +``` console $ nimrod c -r items_pair.nim b c d -~~~ +``` ## Inline Iterators Inline iterators basically take the body of the for loop and inline it into the iterator. This means that they do not have any overhead from function calling, but if carelessly created may increase code size dramatically. -~~~ nimrod +``` nimrod iterator countTo(n: int): int = var i = 0 while i <= n: @@ -44,8 +44,8 @@ iterator countTo(n: int): int = for i in countTo(5): echo i -~~~ -~~~ +``` +```console $ nimrod c -r ./inline_iter.nim 0 1 @@ -53,13 +53,13 @@ $ nimrod c -r ./inline_iter.nim 3 4 5 -~~~ +``` ## Closure Iterators Closure iterators hold on to their state and can be resumed at any time. The `finished()` function can be used to check if there are any more elements available in the iterator. -~~~ nimrod +``` nimrod proc countTo(n: int): iterator(): int = return iterator (): int = var i = 0 @@ -81,10 +81,10 @@ let countTo9 = countTo(9) for i in countTo9: output.add($i) echo output -~~~ -~~~ +``` +```console $ nimrod c -r ./closure_iter.nim 0 12345678910111213141516171819200 0123456789 -~~~ \ No newline at end of file +``` \ No newline at end of file diff --git a/content/getting_started.md b/content/getting_started.md index 5403dfc..b7dee72 100644 --- a/content/getting_started.md +++ b/content/getting_started.md @@ -19,15 +19,15 @@ Once you have downloaded the appropriate distribution and extracted the files so ## Downloading from Git To install Nimrod from git, ensure that you have gcc installed on Windows, Linux, and BSDs and clang on Mac. Afterwards, run the following series of commands to download and bootstrap Nimrod: -~~~ -git clone -b master git://github.com/Araq/Nimrod.git -cd Nimrod -git clone --depth 1 git://github.com/nimrod-code/csources -cd csources -sh build.sh # Replace with build.bat on windows -cd .. -bin/nimrod c koch -./koch boot -d:release -~~~ +```console +$ git clone -b master git://github.com/Araq/Nimrod.git +$ cd Nimrod +$ git clone --depth 1 git://github.com/nimrod-code/csources +$ cd csources +$ sh build.sh # Replace with build.bat on windows +$ cd .. +$ bin/nimrod c koch +$ ./koch boot -d:release +``` Once compiled, you may want to add the `bin` directory to your path for easy access. \ No newline at end of file diff --git a/content/hello_world.md b/content/hello_world.md index 7d6bdb3..2bc029f 100644 --- a/content/hello_world.md +++ b/content/hello_world.md @@ -2,16 +2,16 @@ The code for a simple hello world program is as follows: -~~~ Nimrod +``` nimrod echo "Hello World" -~~~ +``` To compile and execute the program, the following command should be run -~~~ +``` console $ nimrod c -r --verbosity:0 ./helloworld.nim Hello World -~~~ +``` The command has several elements: diff --git a/content/if_else_while.md b/content/if_else_while.md index 6e3bed4..a5568bc 100644 --- a/content/if_else_while.md +++ b/content/if_else_while.md @@ -4,7 +4,7 @@ Nimrod many different control flow constructs, including the standard `if`s, `el When inside a loop or block, it is possible to use `continue` or `break` any point, where `continue` skips to the next iteration and `break` ends the loop. The break statement can also receive the name of the block to break out of, so it is possible to break out of nested loops. -~~~ Nimrod +``` nimrod import strutils let answer = 4 # Chosen by a fair dice roll, @@ -25,4 +25,4 @@ block busyloops: while true: while true: break busyloops -~~~ \ No newline at end of file +``` \ No newline at end of file diff --git a/content/index.md b/content/index.md index a0ed5f9..f6ecfd9 100644 --- a/content/index.md +++ b/content/index.md @@ -1,6 +1,6 @@ Nimrod is a powerful statically typed language that allows the programmer expressiveness without compromising run-time performance. -~~~ nimrod +``` nimrod import tables, strutils var wordFrequencies = initTable[string, int] @@ -17,4 +17,4 @@ for word, frequency in wordFrequencies: mostFrequentWord = word echo "The most frequent word is '", word, "'" -~~~ \ No newline at end of file +``` \ No newline at end of file diff --git a/content/numbers.md b/content/numbers.md index 6e77dc7..bd36131 100644 --- a/content/numbers.md +++ b/content/numbers.md @@ -10,13 +10,13 @@ To indicate the size of an integer literal, append `u` or `i` and the size you'd Integers can also have `0[xX]`, `0o`, `0[Bb]` prepended to indicate a hex, octal, or binary literal, respectively. Underscores are also valid in literals, and can help with readability. -~~~ nimrod +``` nimrod let a: int8 = 0x7F # Works b: uint8 = 0x1111_1111 # Works d = 0xFF # type is int c: uint8 = 256 # Compile time error -~~~ +``` Precedence rules are the same as most other languages, but instead of `^`, `&`, `|`, `>>`, `<<`, the `xor`, `and`, `or`, `shr`, `shl` operators are used, respectively. diff --git a/content/objects.md b/content/objects.md index 699947a..4d93e83 100644 --- a/content/objects.md +++ b/content/objects.md @@ -2,7 +2,7 @@ In Nimrod, objects are like structs from C family languages and define a grouping of fields. -~~~ nimrod +``` nimrod type Animal* = object name*, genus*, species*: string @@ -35,4 +35,4 @@ let spot = PAnimal(name: "Spot", # Same as before, only pointer value is unchangeable spot.age = 2 -~~~ +``` diff --git a/content/oop_macro.md b/content/oop_macro.md index fa97214..bc7b311 100644 --- a/content/oop_macro.md +++ b/content/oop_macro.md @@ -2,7 +2,7 @@ # OOP Macro This is the code that we currently must write to use OOP in nimrod: -~~~nimrod +```nimrod type Animal = ref object {.inheritable.} name: string @@ -15,11 +15,11 @@ method vocalize(self: Dog): string = "woof" type Cat = ref object of Animal method vocalize(self: Cat): string = "meow" -~~~ +``` All these typedefs and `self: T` parameters are repetitive, so it'd be good to write a macro to mask them. Something like this would be best: -~~~nimrod +```nimrod class(Animal of TObject): var name: string method vocalize: string = "..." @@ -38,9 +38,9 @@ proc run_test() = pets.add Dog(name: "ruffles") assert(@["meow", "woof"] == @[pets[0].vocalize, pets[1].vocalize]) -~~~ +``` -~~~nimrod +```nimrod import macros macro class*(): stmt {.immediate.} = @@ -214,4 +214,4 @@ class(Cat of Animal) do: run_test() echo "Tests passed!" -~~~ \ No newline at end of file +``` \ No newline at end of file diff --git a/content/stylesheet.css b/content/stylesheet.css deleted file mode 100644 index 7d8c8ac..0000000 --- a/content/stylesheet.css +++ /dev/null @@ -1,101 +0,0 @@ -* { - margin: 0; - padding: 0; - - font-family: Georgia, Palatino, serif; -} - -body { - background: #fff; -} - -a { - text-decoration: none; -} - -a:link, -a:visited { - color: #f30; -} - -a:hover { - color: #f90; -} - -#main { - position: absolute; - - top: 40px; - left: 280px; - - width: 500px; -} - -#main h1 { - font-size: 40px; - font-weight: normal; - - line-height: 40px; - - letter-spacing: -1px; -} - -#main p { - margin: 20px 0; - - font-size: 15px; - - line-height: 20px; -} - -#main ul, #main ol { - margin: 20px; -} - -#main li { - font-size: 15px; - - line-height: 20px; -} - -#main ul li { - list-style-type: square; -} - -#sidebar { - position: absolute; - - top: 40px; - left: 20px; - width: 200px; - - padding: 20px 20px 0 0; - - border-right: 1px solid #ccc; - - text-align: right; -} - -#sidebar h2 { - text-transform: uppercase; - - font-size: 13px; - - color: #333; - - letter-spacing: 1px; - - line-height: 20px; -} - -#sidebar ul { - list-style-type: none; - - margin: 20px 0; -} - -#sidebar li { - font-size: 14px; - - line-height: 20px; -} diff --git a/content/stylesheets/main.css b/content/stylesheets/main.css new file mode 100644 index 0000000..54c8ac6 --- /dev/null +++ b/content/stylesheets/main.css @@ -0,0 +1,141 @@ +* { + margin: 0; + padding: 0; + + font-family: Georgia, Palatino, serif; + box-sizing: border-box; +} + +body { + background: #E6E6E6; + color: #2B2B2B; + text-rendering: optimizelegibility; +} + +a { + text-decoration: none; +} + +a:link, +a:visited { + color: #DE1B1B; +} + +a:hover { + color: #FE3B3B; +} + +#main { + position: absolute; + + top: 40px; + left: 255px; + + max-width: 600px; +} + +#main h1 { + font-size: 40px; + font-weight: normal; + + line-height: 40px; + + letter-spacing: -1px; +} + +#main p { + margin: 20px 0; + + font-size: 15px; + + line-height: 20px; +} + +#main ul, #main ol { + margin: 20px; +} + +#main li { + font-size: 15px; + + line-height: 20px; +} + +#main ul li { + list-style-type: square; +} + +#main table, th, td { + border-collapse: collapse; + border: 1px solid #CCC; + background-color: #EEEEEE; + padding: 3px; + + font-size: 15px; + line-height: 20px; +} + +#main code, code * { + font-family: Monaco,Menlo,Consolas,"Courier New",monospace; +} + +#main code { + border-radius: 3px; + border: 1px solid #CCC; + background-color: #EEEEEE; + padding: 0px 3px; +} + +#main pre code { /* Block Code */ + display: block; + word-wrap: break-word; + overflow: auto; + + white-space: pre-wrap; /* css-3 */ + white-space: -moz-pre-wrap; /* Mozilla, since 1999 */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + word-wrap: break-word; /* Internet Explorer 5.5+ */ + + border-radius: 3px; + border: 1px solid #CCC; + background-color: #EEEEEE; + padding: 20px 10px; + font-size: 15px; + margin: 30px 5px +} + +#main span.line-numbers { + display: none; +} + +#sidebar { + position: absolute; + + top: 40px; + left: 20px; + width: 175px; + + padding: 20px 20px 0 0; + + border-right: 1px solid #ccc; +} + +#sidebar h2 { + text-transform: uppercase; + font-size: 13px; + color: #333; + letter-spacing: 1px; + line-height: 20px; +} + +#sidebar ul { + position: relative; + left: 30px; + list-style: decimal-leading-zero; +} + +#sidebar li { + font-size: 14px; + line-height: 20px; +} diff --git a/content/stylesheets/syntax.css b/content/stylesheets/syntax.css new file mode 100644 index 0000000..caefe52 --- /dev/null +++ b/content/stylesheets/syntax.css @@ -0,0 +1,72 @@ +/* pygments-css colorful */ +.codehilite .hll { background-color: #ffffcc } +.codehilite .c { color: #808080 } /* Comment */ +.codehilite .err { color: #F00000; background-color: #F0A0A0 } /* Error */ +.codehilite .k { color: #008000; font-weight: bold } /* Keyword */ +.codehilite .o { color: #303030 } /* Operator */ +.codehilite .cm { color: #808080 } /* Comment.Multiline */ +.codehilite .cp { color: #507090 } /* Comment.Preproc */ +.codehilite .c1 { color: #808080 } /* Comment.Single */ +.codehilite .cs { color: #cc0000; font-weight: bold } /* Comment.Special */ +.codehilite .gd { color: #A00000 } /* Generic.Deleted */ +.codehilite .ge { font-style: italic } /* Generic.Emph */ +.codehilite .gr { color: #FF0000 } /* Generic.Error */ +.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.codehilite .gi { color: #00A000 } /* Generic.Inserted */ +.codehilite .go { color: #808080 } /* Generic.Output */ +.codehilite .gp { + color: #c65d09; + font-weight: bold; + /* NOTE: Hacks to allow copy-paste */ + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} /* Generic.Prompt */ +.codehilite .gs { font-weight: bold } /* Generic.Strong */ +.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.codehilite .gt { color: #0040D0 } /* Generic.Traceback */ +.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.codehilite .kp { color: #003080; font-weight: bold } /* Keyword.Pseudo */ +.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.codehilite .kt { color: #303090; font-weight: bold } /* Keyword.Type */ +.codehilite .m { color: #6000E0; font-weight: bold } /* Literal.Number */ +.codehilite .s { background-color: #fff0f0 } /* Literal.String */ +.codehilite .na { color: #0000C0 } /* Name.Attribute */ +.codehilite .nb { color: #007020 } /* Name.Builtin */ +.codehilite .nc { color: #B00060; font-weight: bold } /* Name.Class */ +.codehilite .no { color: #003060; font-weight: bold } /* Name.Constant */ +.codehilite .nd { color: #505050; font-weight: bold } /* Name.Decorator */ +.codehilite .ni { color: #800000; font-weight: bold } /* Name.Entity */ +.codehilite .ne { color: #F00000; font-weight: bold } /* Name.Exception */ +.codehilite .nf { color: #0060B0; font-weight: bold } /* Name.Function */ +.codehilite .nl { color: #907000; font-weight: bold } /* Name.Label */ +.codehilite .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */ +.codehilite .nt { color: #007000 } /* Name.Tag */ +.codehilite .nv { color: #906030 } /* Name.Variable */ +.codehilite .ow { color: #000000; font-weight: bold } /* Operator.Word */ +.codehilite .w { color: #bbbbbb } /* Text.Whitespace */ +.codehilite .mf { color: #6000E0; font-weight: bold } /* Literal.Number.Float */ +.codehilite .mh { color: #005080; font-weight: bold } /* Literal.Number.Hex */ +.codehilite .mi { color: #0000D0; font-weight: bold } /* Literal.Number.Integer */ +.codehilite .mo { color: #4000E0; font-weight: bold } /* Literal.Number.Oct */ +.codehilite .sb { background-color: #fff0f0 } /* Literal.String.Backtick */ +.codehilite .sc { color: #0040D0 } /* Literal.String.Char */ +.codehilite .sd { color: #D04020 } /* Literal.String.Doc */ +.codehilite .s2 { background-color: #fff0f0 } /* Literal.String.Double */ +.codehilite .se { color: #606060; font-weight: bold; background-color: #fff0f0 } /* Literal.String.Escape */ +.codehilite .sh { background-color: #fff0f0 } /* Literal.String.Heredoc */ +.codehilite .si { background-color: #e0e0e0 } /* Literal.String.Interpol */ +.codehilite .sx { color: #D02000; background-color: #fff0f0 } /* Literal.String.Other */ +.codehilite .sr { color: #000000; background-color: #fff0ff } /* Literal.String.Regex */ +.codehilite .s1 { background-color: #fff0f0 } /* Literal.String.Single */ +.codehilite .ss { color: #A06000 } /* Literal.String.Symbol */ +.codehilite .bp { color: #007020 } /* Name.Builtin.Pseudo */ +.codehilite .vc { color: #306090 } /* Name.Variable.Class */ +.codehilite .vg { color: #d07000; font-weight: bold } /* Name.Variable.Global */ +.codehilite .vi { color: #3030B0 } /* Name.Variable.Instance */ +.codehilite .il { color: #0000D0; font-weight: bold } /* Literal.Number.Integer.Long */ diff --git a/content/toc.md b/content/toc.md index bfb2df8..ccd6564 100644 --- a/content/toc.md +++ b/content/toc.md @@ -1,16 +1,16 @@ ## Summary -* [Getting Started](getting_started/) -* [Hello World](hello_world/) -* [Numbers](numbers/) -* [Variables](variables/page/) - * [Result](variables/result/) -* [Objects](objects/) -* [Enums](enums/) -* [If, Else, While, Block](if_else_while/) -* [Case Statements](case/) -* [For Loops & Iterators](for_iterators/) -* [Exceptions](exceptions/) +* [Getting Started](/getting_started/) +* [Hello World](/hello_world/) +* [Numbers](/numbers/) +* [Variables](/variables/page/) + * [Result](/variables/result/) +* [Objects](/objects/) +* [Enums](/enums/) +* [If, Else, While, Block](/if_else_while/) +* [Case Statements](/case/) +* [For Loops & Iterators](/for_iterators/) +* [Exceptions](/exceptions/) * [Functions]() -* [Varargs](varargs/) -* [OOP Macro](oop_macro/) +* [Varargs](/varargs/) +* [OOP Macro](/oop_macro/) diff --git a/content/varargs.md b/content/varargs.md index 69cddbc..00a7107 100644 --- a/content/varargs.md +++ b/content/varargs.md @@ -2,41 +2,41 @@ Standard varargs simply allows you to pass multiple parameters to your function. -~~~ nimrod +``` nimrod proc printThings(things: varargs[string]) = for thing in things: echo thing printThings "words", "to", "print" -~~~ -~~~ +``` +```console $ nimrod c -r ./varargs1.nim words to print -~~~ +``` However, trying to run -~~~ nimrod +``` nimrod printThings 1, "string", @[1, 2, 3] -~~~ +``` will fail to compile because the compiler won't coerce anything into strings. Luckily enough, there is a tool to fix this, the coercing varargs: -~~~ nimrod +``` nimrod proc printThings(things: varargs[string, `$`]) = for thing in things: echo thing printThings "thing 1", 2, @[4, 5, 6] -~~~ +``` -~~~ +```console $ nimrod c -r ./varargs2.nim thing 1 2 @[4, 5, 6] -~~~ +``` It works by finding a function `` `$` `` that returns string for each argument type, and applying it to each argument. \ No newline at end of file diff --git a/content/variables/page.md b/content/variables/page.md index d3ba06d..9b30422 100644 --- a/content/variables/page.md +++ b/content/variables/page.md @@ -2,7 +2,7 @@ Nimrod supports three different types of variables, `let`, `var`, and `const`. As with most things, multiple variables can be declared in the same section. -~~~ nimrod +``` nimrod proc getAlphabet(): string = result = "" for letter in 'a'..'z': @@ -23,22 +23,22 @@ b.inc # This is also fine. c.add "bar" # This will result in an error. d.inc # As will this. -~~~ +``` -~~~ +``` console $ nimrod c --verbosity:2 ./assignment.nim a20.nim(19, 0) Error: for a 'var' type a variable needs to be passed c.add "bar" # This will result in an error. ^ -~~~ +``` Without `--verbosity:2` only the error will be shown. A `const` variable's value will be evaluated at compile-time, so if you inspect the C sources, you'll see the following line: -~~~ C +``` c STRING_LITERAL(TMP129, "abcdefghijklmnopqrstuvwxyz", 26); -~~~ +``` The limitation with this is that procedures which are evaluated at compile-time cannot interface with C because there is no compile-time foreign function interface at this time. diff --git a/content/variables/result.md b/content/variables/result.md index c3f9fb0..82b950d 100644 --- a/content/variables/result.md +++ b/content/variables/result.md @@ -2,19 +2,19 @@ The `result` variable is a special variable that serves as an implicit return variable. This is useful because in most cases, the control flow semantics of the `return` statement are unneeded. `result` is initialized with the default value for a given return type, so the following code starts as `0`, before being initialized to `number`: -~~~ nimrod +``` nimrod proc `**`(number, power: int): int = result = number for i in 1..power: result *= number -~~~ +``` A possible gotcha is declaring a variable called result and expecting it to have the same semantics. -~~~ nimrod +``` nimrod proc unexpected(): int = var result = 5 result += 5 echo unexpected() # Prints 0, not 10 -~~~ +``` diff --git a/layouts/default.html b/layouts/default.html index f62af5e..e9ea412 100644 --- a/layouts/default.html +++ b/layouts/default.html @@ -3,7 +3,8 @@ A Brand New nanoc Site - <%= @item[:title] %> - + + diff --git a/lib/default.rb b/lib/default.rb index a4df0cc..e5d1ef6 100644 --- a/lib/default.rb +++ b/lib/default.rb @@ -1,2 +1,12 @@ # All files in the 'lib' directory will be loaded # before nanoc starts compiling. + +class CodeClassSimplfier < Nanoc::Filter + identifier :code_class_simplfier + type :text + + def run(content, params={}) + return content.dup.gsub!(/"language-\w+?"/, "codehilite") + end + +end \ No newline at end of file