RubyGems - hamlet - Versions diffs - 0.1 - Mend

hamlet 0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

data/.gitignore +1 -0
data/Gemfile +25 -0
data/LICENSE +21 -0
data/README.md +52 -0
data/Rakefile +57 -0
data/bin/hamletrb +7 -0
data/extra/slim-mode.el +409 -0
data/extra/test.hamlet +50 -0
data/hamlet.gemspec +36 -0
data/lib/hamlet.rb +7 -0
data/lib/hamlet/engine.rb +3 -0
data/lib/hamlet/parser.rb +147 -0
data/lib/hamlet/template.rb +19 -0
data/test/rails/Rakefile +7 -0
data/test/rails/app/controllers/application_controller.rb +3 -0
data/test/rails/app/controllers/parents_controller.rb +84 -0
data/test/rails/app/controllers/slim_controller.rb +32 -0
data/test/rails/app/helpers/application_helper.rb +2 -0
data/test/rails/app/models/child.rb +3 -0
data/test/rails/app/models/parent.rb +4 -0
data/test/rails/app/views/layouts/application.html.slim +10 -0
data/test/rails/app/views/parents/_form.html.slim +7 -0
data/test/rails/app/views/parents/edit.html.slim +1 -0
data/test/rails/app/views/parents/new.html.slim +1 -0
data/test/rails/app/views/parents/show.html.slim +5 -0
data/test/rails/app/views/slim/_partial.html.slim +1 -0
data/test/rails/app/views/slim/content_for.html.slim +7 -0
data/test/rails/app/views/slim/erb.html.erb +1 -0
data/test/rails/app/views/slim/integers.html.slim +1 -0
data/test/rails/app/views/slim/nil.html.slim +1 -0
data/test/rails/app/views/slim/no_layout.html.slim +1 -0
data/test/rails/app/views/slim/normal.html.slim +1 -0
data/test/rails/app/views/slim/partial.html.slim +2 -0
data/test/rails/app/views/slim/variables.html.slim +1 -0
data/test/rails/config.ru +4 -0
data/test/rails/config/application.rb +45 -0
data/test/rails/config/boot.rb +10 -0
data/test/rails/config/database.yml +4 -0
data/test/rails/config/environment.rb +5 -0
data/test/rails/config/environments/development.rb +26 -0
data/test/rails/config/environments/production.rb +49 -0
data/test/rails/config/environments/test.rb +35 -0
data/test/rails/config/initializers/backtrace_silencers.rb +7 -0
data/test/rails/config/initializers/inflections.rb +10 -0
data/test/rails/config/initializers/mime_types.rb +5 -0
data/test/rails/config/initializers/secret_token.rb +7 -0
data/test/rails/config/initializers/session_store.rb +8 -0
data/test/rails/config/locales/en.yml +5 -0
data/test/rails/config/routes.rb +60 -0
data/test/rails/db/migrate/20101220223037_parents_and_children.rb +17 -0
data/test/rails/script/rails +6 -0
data/test/rails/test/helper.rb +10 -0
data/test/rails/test/test_slim.rb +77 -0
data/test/slim/helper.rb +200 -0
data/test/slim/test_chain_manipulation.rb +42 -0
data/test/slim/test_code_blocks.rb +68 -0
data/test/slim/test_code_escaping.rb +53 -0
data/test/slim/test_code_evaluation.rb +281 -0
data/test/slim/test_code_output.rb +159 -0
data/test/slim/test_code_structure.rb +95 -0
data/test/slim/test_embedded_engines.rb +141 -0
data/test/slim/test_html_escaping.rb +40 -0
data/test/slim/test_html_structure.rb +438 -0
data/test/slim/test_parser_errors.rb +107 -0
data/test/slim/test_pretty.rb +75 -0
data/test/slim/test_ruby_errors.rb +187 -0
data/test/slim/test_sections.rb +90 -0
data/test/slim/test_slim_template.rb +118 -0
data/test/slim/test_text_interpolation.rb +78 -0
data/test/slim/test_wrapper.rb +39 -0
metadata +230 -0

data/.gitignore ADDED Viewed

	@@ -0,0 +1 @@
1	+ Gemfile.lock

data/Gemfile ADDED Viewed

@@ -0,0 +1,25 @@
+source :rubygems
+gemspec
+if ENV['TEMPLE'] == 'master'
+   gem 'temple', :git => 'git://github.com/judofyr/temple.git'
+end
+if ENV['RAILS']
+  if ENV['RAILS'] == 'master'
+    gem 'rails', :git => 'git://github.com/rails/rails.git'
+    # FIXME: Rails Gemfile is invalid!
+    gem 'journey', :git => 'git://github.com/rails/journey.git'
+  else
+    gem 'rails', "= #{ENV['RAILS']}"
+  end
+  if defined?(JRUBY_VERSION)
+    gem 'jdbc-sqlite3'
+    gem 'activerecord-jdbc-adapter'
+    gem 'activerecord-jdbcsqlite3-adapter'
+  else
+    gem 'sqlite3-ruby'
+  end
+end

data/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+The MIT License
+Copyright (c) 2010 Slim Team
+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:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+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.

data/README.md ADDED Viewed

@@ -0,0 +1,52 @@
+Hamlet is a template language whose goal is to reduce HTML syntax to the essential parts.
+# Syntax
+``` html
+<body>
+    <p>Some paragraph.
+    <ul data-attr=list>
+        <li>Item 1
+        <li>Item 2
+```
+That Hamlet snippet is equivalent to:
+``` html
+<body>
+  <p>Some paragraph.</p>
+  <ul data-attr="list">
+    <li>Item 1</li>
+    <li>Item 2</li>
+  </ul>
+</body>
+```
+see, it is just HTML! Designers love Hamlet because it is just HTML! Closing tags are inferred from whitespace.
+## Details
+You can see the [original hamlet templating langauge](http://www.yesodweb.com/book/templates) and the
+[javascript port](hamlet: https://github.com/gregwebs/hamlet.js).
+This Hamlet works on top of [slim](https://github.com/stonean/slim/). Please see [slim documentation](http://slim-lang.com). There is one important difference: hamlet always defers to HTML syntax. In slim you have:
+    p data-attr=foo Text
+      | More Text
+In hamlet you have:
+    <p data-attr=foo>Text
+      More Text
+## Whitespace
+This is currently a bit of a Slim Frankenstein, but I added the same syntax that hamlet.js uses to indicate whitespace: a closing bracket
+    <p>   White space to the left
+      >   White space to the left again
+## Limitations
+I just hacked this up the other day - let me know if there are any issues. After some more experience using Slim's syntax I plan on trying to reduce the total available syntax.

data/Rakefile ADDED Viewed

@@ -0,0 +1,57 @@
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue Exception => e
+end
+require 'rake/testtask'
+desc 'Run Slim benchmarks! (default parameters slow=false iterations=1000)'
+task :bench, :iterations, :slow do
+  ruby('benchmarks/run.rb')
+end
+Rake::TestTask.new('test') do |t|
+  t.libs << 'lib' << 'test/slim'
+  t.test_files = FileList['test/slim/test_*.rb']
+  t.verbose = true
+end
+Rake::TestTask.new('test:rails') do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['test/rails/test/test_*.rb']
+  t.verbose = true
+end
+task 'test:ci' do |t|
+  Rake::Task[ENV['TASK']].execute
+end
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'lib' << 'test/slim'
+    t.test_files = FileList['test/slim/test_*.rb']
+    t.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: gem install rcov"
+  end
+end
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.files = %w(lib/**/*.rb)
+  end
+rescue LoadError
+  task :yard do
+    abort "YARD is not available. In order to run yard, you must: gem install yard"
+  end
+end
+desc "Generate Documentation"
+task :doc => :yard
+task :default => 'test'

data/bin/hamletrb ADDED Viewed

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'slim/command'
+cmd = Slim::Command.new(ARGV)
+cmd.run

data/extra/slim-mode.el ADDED Viewed

@@ -0,0 +1,409 @@
+;;; slim-mode.el --- Major mode for editing Slim files
+;; Copyright (c) 2007, 2008 Nathan Weizenbaum
+;; Modified slightly for Slim by Daniel Mendler
+;; Author: Nathan Weizenbaum
+;; URL: http://github.com/stonean/slim
+;; Version: 1.0
+;; Keywords: markup, language
+;;; Commentary:
+;; Because Slim's indentation schema is similar
+;; to that of YAML and Python, many indentation-related
+;; functions are similar to those in yaml-mode and python-mode.
+;; TODO: This whole file has to be reworked to provide optimal support
+;; for Slim. This is only a slightly adapted haml version.
+;; To install, save this on your load path and add the following to
+;; your .emacs file:
+;;
+;; (require 'slim-mode)
+;;; Code:
+(eval-when-compile (require 'cl))
+;; User definable variables
+(defgroup slim nil
+  "Support for the Slim template language."
+  :group 'languages
+  :prefix "slim-")
+(defcustom slim-mode-hook nil
+  "Hook run when entering Slim mode."
+  :type 'hook
+  :group 'slim)
+(defcustom slim-indent-offset 2
+  "Amount of offset per level of indentation."
+  :type 'integer
+  :group 'slim)
+(defcustom slim-backspace-backdents-nesting t
+  "Non-nil to have `slim-electric-backspace' re-indent all code
+nested beneath the backspaced line be re-indented along with the
+line itself."
+  :type 'boolean
+  :group 'slim)
+(defface slim-tab-face
+  '((((class color)) (:background "hotpink"))
+    (t (:reverse-video t)))
+  "Face to use for highlighting tabs in Slim files."
+  :group 'faces
+  :group 'slim)
+(defvar slim-indent-function 'slim-indent-p
+  "This function should look at the current line and return true
+if the next line could be nested within this line.")
+(defvar slim-block-openers
+  `("^ *\\([\\.#a-z][^ \t]*\\)\\(\\[.*\\]\\)?[ \t]*$"
+    "^ *[-=].*do[ \t]*\\(|.*|[ \t]*\\)?$"
+    ,(concat "^ *-[ \t]*\\("
+             (regexp-opt '("if" "unless" "while" "until" "else"
+                           "begin" "elsif" "rescue" "ensure" "when"))
+             "\\)")
+    "^ *|"
+    "^ */"
+    "^ *[a-z0-9_]:")
+  "A list of regexps that match lines of Slim that could have
+text nested beneath them.")
+;; Font lock
+;; Helper for nested block (comment, embedded, text)
+(defun slim-nested-re (re)
+  (concat "^\\( *\\)" re "\n\\(?:\\(?:\\1 .*\\)\n\\)*"))
+(defconst slim-font-lock-keywords
+  `((,(slim-nested-re "/.*")              0 font-lock-comment-face)                 ;; Comment block
+    (,(slim-nested-re "[a-z0-9_]+:")      0 font-lock-string-face)                  ;; Embedded block
+    (,(slim-nested-re "[\|'`].*")         0 font-lock-string-face)                  ;; Text block
+    ("^!.*"                               0 font-lock-constant-face)                ;; Directive
+    ("^ *\\(\t\\)"                        1 'slim-tab-face)
+    ("\\('[^']*'\\)"                      1 font-lock-string-face append)           ;; Single quote string TODO
+    ("\\(\"[^\"]*\"\\)"                   1 font-lock-string-face append)           ;; Double quoted string TODO
+    ("@[a-z0-9_]+"                        0 font-lock-variable-name-face append)    ;; Class variable TODO
+    ("^ *\\(#[a-z0-9_]+\/?\\)"            1 font-lock-keyword-face)                 ;; #id
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)"          1 font-lock-type-face)                    ;; .class
+    ("^ *\\([a-z0-9_]+\/?\\)"             1 font-lock-function-name-face)           ;; div
+    ("^ *\\(#[a-z0-9_]+\/?\\)"            (1 font-lock-keyword-face)                ;; #id.class
+     ("\\.[a-z0-9_]+" nil nil             (0 font-lock-type-face)))
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)"          (1 font-lock-type-face)                   ;; .class.class
+     ("\\.[a-z0-9_]+" nil nil             (0 font-lock-type-face)))
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)"          (1 font-lock-type-face)                   ;; .class#id
+     ("\\#[a-z0-9_]+" nil nil             (0 font-lock-keyword-face)))
+    ("^ *\\([a-z0-9_]+\/?\\)"             (1 font-lock-function-name-face)          ;; div.class
+     ("\\.[a-z0-9_]+" nil nil             (0 font-lock-type-face)))
+    ("^ *\\([a-z0-9_]+\/?\\)"             (1 font-lock-function-name-face)          ;; div#id
+     ("\\#[a-z0-9_]+" nil nil             (0 font-lock-keyword-face)))
+    ("^ *\\(\\(==?|-\\) .*\\)"            1 font-lock-preprocessor-face prepend)    ;; ==, =, -
+    ("^ *[\\.#a-z0-9_]+\\(==? .*\\)"      1 font-lock-preprocessor-face prepend)))  ;; tag ==, tag =
+(defconst slim-embedded-re "^ *[a-z0-9_]+:")
+(defconst slim-comment-re  "^ */")
+(defun* slim-extend-region ()
+  "Extend the font-lock region to encompass embedded engines and comments."
+  (let ((old-beg font-lock-beg)
+        (old-end font-lock-end))
+    (save-excursion
+      (goto-char font-lock-beg)
+      (beginning-of-line)
+      (unless (or (looking-at slim-embedded-re)
+                  (looking-at slim-comment-re))
+        (return-from slim-extend-region))
+      (setq font-lock-beg (point))
+      (slim-forward-sexp)
+      (beginning-of-line)
+      (setq font-lock-end (max font-lock-end (point))))
+    (or (/= old-beg font-lock-beg)
+        (/= old-end font-lock-end))))
+;; Mode setup
+(defvar slim-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (modify-syntax-entry ?: "." table)
+    (modify-syntax-entry ?_ "w" table)
+    table)
+  "Syntax table in use in slim-mode buffers.")
+(defvar slim-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [backspace] 'slim-electric-backspace)
+    (define-key map "\C-?" 'slim-electric-backspace)
+    (define-key map "\C-c\C-f" 'slim-forward-sexp)
+    (define-key map "\C-c\C-b" 'slim-backward-sexp)
+    (define-key map "\C-c\C-u" 'slim-up-list)
+    (define-key map "\C-c\C-d" 'slim-down-list)
+    (define-key map "\C-c\C-k" 'slim-kill-line-and-indent)
+    map))
+;;;###autoload
+(define-derived-mode slim-mode fundamental-mode "Slim"
+  "Major mode for editing Slim files.
+\\{slim-mode-map}"
+  (set-syntax-table slim-mode-syntax-table)
+  (add-to-list 'font-lock-extend-region-functions 'slim-extend-region)
+  (set (make-local-variable 'font-lock-multiline) t)
+  (set (make-local-variable 'indent-line-function) 'slim-indent-line)
+  (set (make-local-variable 'indent-region-function) 'slim-indent-region)
+  (set (make-local-variable 'parse-sexp-lookup-properties) t)
+  (setq comment-start "/")
+  (setq indent-tabs-mode nil)
+  (setq font-lock-defaults '((slim-font-lock-keywords) nil t)))
+;; Useful functions
+(defun slim-comment-block ()
+  "Comment the current block of Slim code."
+  (interactive)
+  (save-excursion
+    (let ((indent (current-indentation)))
+      (back-to-indentation)
+      (insert "/")
+      (newline)
+      (indent-to indent)
+      (beginning-of-line)
+      (slim-mark-sexp)
+      (slim-reindent-region-by slim-indent-offset))))
+(defun slim-uncomment-block ()
+  "Uncomment the current block of Slim code."
+  (interactive)
+  (save-excursion
+    (beginning-of-line)
+    (while (not (looking-at slim-comment-re))
+      (slim-up-list)
+      (beginning-of-line))
+    (slim-mark-sexp)
+    (kill-line 1)
+    (slim-reindent-region-by (- slim-indent-offset))))
+;; Navigation
+(defun slim-forward-through-whitespace (&optional backward)
+  "Move the point forward at least one line, until it reaches
+either the end of the buffer or a line with no whitespace.
+If `backward' is non-nil, move the point backward instead."
+  (let ((arg (if backward -1 1))
+        (endp (if backward 'bobp 'eobp)))
+    (loop do (forward-line arg)
+          while (and (not (funcall endp))
+                     (looking-at "^[ \t]*$")))))
+(defun slim-at-indent-p ()
+  "Returns whether or not the point is at the first
+non-whitespace character in a line or whitespace preceding that
+character."
+  (let ((opoint (point)))
+    (save-excursion
+      (back-to-indentation)
+      (>= (point) opoint))))
+(defun slim-forward-sexp (&optional arg)
+  "Move forward across one nested expression.
+With `arg', do it that many times.  Negative arg -N means move
+backward across N balanced expressions.
+A sexp in Slim is defined as a line of Slim code as well as any
+lines nested beneath it."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (and (< arg 0) (not (slim-at-indent-p)))
+      (back-to-indentation)
+    (while (/= arg 0)
+      (let ((indent (current-indentation)))
+        (loop do (slim-forward-through-whitespace (< arg 0))
+              while (and (not (eobp))
+                         (not (bobp))
+                         (> (current-indentation) indent)))
+        (back-to-indentation)
+        (setq arg (+ arg (if (> arg 0) -1 1)))))))
+(defun slim-backward-sexp (&optional arg)
+  "Move backward across one nested expression.
+With ARG, do it that many times.  Negative arg -N means move
+forward across N balanced expressions.
+A sexp in Slim is defined as a line of Slim code as well as any
+lines nested beneath it."
+  (interactive "p")
+  (slim-forward-sexp (if arg (- arg) -1)))
+(defun slim-up-list (&optional arg)
+  "Move out of one level of nesting.
+With ARG, do this that many times."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (while (> arg 0)
+    (let ((indent (current-indentation)))
+      (loop do (slim-forward-through-whitespace t)
+            while (and (not (bobp))
+                       (>= (current-indentation) indent)))
+      (setq arg (- arg 1))))
+  (back-to-indentation))
+(defun slim-down-list (&optional arg)
+  "Move down one level of nesting.
+With ARG, do this that many times."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (while (> arg 0)
+    (let ((indent (current-indentation)))
+      (slim-forward-through-whitespace)
+      (when (<= (current-indentation) indent)
+        (slim-forward-through-whitespace t)
+        (back-to-indentation)
+        (error "Nothing is nested beneath this line"))
+      (setq arg (- arg 1))))
+  (back-to-indentation))
+(defun slim-mark-sexp ()
+  "Marks the next Slim block."
+  (let ((forward-sexp-function 'slim-forward-sexp))
+    (mark-sexp)))
+(defun slim-mark-sexp-but-not-next-line ()
+  "Marks the next Slim block, but puts the mark at the end of the
+last line of the sexp rather than the first non-whitespace
+character of the next line."
+  (slim-mark-sexp)
+  (set-mark
+   (save-excursion
+     (goto-char (mark))
+     (forward-line -1)
+     (end-of-line)
+     (point))))
+;; Indentation and electric keys
+(defun slim-indent-p ()
+  "Returns true if the current line can have lines nested beneath it."
+  (loop for opener in slim-block-openers
+        if (looking-at opener) return t
+        finally return nil))
+(defun slim-compute-indentation ()
+  "Calculate the maximum sensible indentation for the current line."
+  (save-excursion
+    (beginning-of-line)
+    (if (bobp) 0
+      (slim-forward-through-whitespace t)
+      (+ (current-indentation)
+         (if (funcall slim-indent-function) slim-indent-offset
+           0)))))
+(defun slim-indent-region (start end)
+  "Indent each nonblank line in the region.
+This is done by indenting the first line based on
+`slim-compute-indentation' and preserving the relative
+indentation of the rest of the region.
+If this command is used multiple times in a row, it will cycle
+between possible indentations."
+  (save-excursion
+    (goto-char end)
+    (setq end (point-marker))
+    (goto-char start)
+    (let (this-line-column current-column
+          (next-line-column
+           (if (and (equal last-command this-command) (/= (current-indentation) 0))
+               (* (/ (- (current-indentation) 1) slim-indent-offset) slim-indent-offset)
+             (slim-compute-indentation))))
+      (while (< (point) end)
+        (setq this-line-column next-line-column
+              current-column (current-indentation))
+        ;; Delete whitespace chars at beginning of line
+        (delete-horizontal-space)
+        (unless (eolp)
+          (setq next-line-column (save-excursion
+                                   (loop do (forward-line 1)
+                                         while (and (not (eobp)) (looking-at "^[ \t]*$")))
+                                   (+ this-line-column
+                                      (- (current-indentation) current-column))))
+          ;; Don't indent an empty line
+          (unless (eolp) (indent-to this-line-column)))
+        (forward-line 1)))
+    (move-marker end nil)))
+(defun slim-indent-line ()
+  "Indent the current line.
+The first time this command is used, the line will be indented to the
+maximum sensible indentation.  Each immediately subsequent usage will
+back-dent the line by `slim-indent-offset' spaces.  On reaching column
+0, it will cycle back to the maximum sensible indentation."
+  (interactive "*")
+  (let ((ci (current-indentation))
+        (cc (current-column))
+        (need (slim-compute-indentation)))
+    (save-excursion
+      (beginning-of-line)
+      (delete-horizontal-space)
+      (if (and (equal last-command this-command) (/= ci 0))
+          (indent-to (* (/ (- ci 1) slim-indent-offset) slim-indent-offset))
+        (indent-to need)))
+      (if (< (current-column) (current-indentation))
+          (forward-to-indentation 0))))
+(defun slim-reindent-region-by (n)
+  "Add N spaces to the beginning of each line in the region.
+If N is negative, will remove the spaces instead.  Assumes all
+lines in the region have indentation >= that of the first line."
+  (let ((ci (current-indentation)))
+    (save-excursion
+      (replace-regexp (concat "^" (make-string ci ? ))
+                      (make-string (max 0 (+ ci n)) ? )
+                      nil (point) (mark)))))
+(defun slim-electric-backspace (arg)
+  "Delete characters or back-dent the current line.
+If invoked following only whitespace on a line, will back-dent
+the line and all nested lines to the immediately previous
+multiple of `slim-indent-offset' spaces.
+Set `slim-backspace-backdents-nesting' to nil to just back-dent
+the current line."
+  (interactive "*p")
+  (if (or (/= (current-indentation) (current-column))
+          (bolp)
+          (looking-at "^[ \t]+$"))
+      (backward-delete-char arg)
+    (save-excursion
+      (let ((ci (current-column)))
+        (beginning-of-line)
+        (if slim-backspace-backdents-nesting
+            (slim-mark-sexp-but-not-next-line)
+          (set-mark (save-excursion (end-of-line) (point))))
+        (slim-reindent-region-by (* (- arg) slim-indent-offset))
+        (back-to-indentation)
+        (pop-mark)))))
+(defun slim-kill-line-and-indent ()
+  "Kill the current line, and re-indent all lines nested beneath it."
+  (interactive)
+  (beginning-of-line)
+  (slim-mark-sexp-but-not-next-line)
+  (kill-line 1)
+  (slim-reindent-region-by (* -1 slim-indent-offset)))
+(defun slim-indent-string ()
+  "Return the indentation string for `slim-indent-offset'."
+  (mapconcat 'identity (make-list slim-indent-offset " ") ""))
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.slim$" . slim-mode))
+;; Setup/Activation
+(provide 'slim-mode)
+;;; slim-mode.el ends here