dang 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  metadata.gz: ffabe3af990c95e65060e84baa3aafbc4e5f2819b2d42a2a95eb05d49c4db064bbf853f8983d4f2ba6bbf8f0ec19c39c5a8744ab2f7ddeb15b8e6a2c9179eed2
+  data.tar.gz: a41454e0e02dddc883a99c484972336edd08ac4d7b36277454c0b0dbfae041e03cb3d14c46fb0755fdcf6bfa7f7ed6ab89e43fc2832b51987641ff5d3bad9daa
+SHA1: 
+  metadata.gz: 2678da64cfb92588a3140913f902176929bba2fb
+  data.tar.gz: 31398bcdeb3a87e0de26ad2063becd441c377e2a

data/.autotest

@@ -0,0 +1,12 @@
+# require 'autotest/restart'
+# 
+# Autotest.add_hook :initialize do |at|
+#   at.clear_mappings
+# 
+#   at.add_mapping %r%/^lib/(.*)\.rb$% do |_, m|
+#     possible = File.basename(m[1])
+#     files_matching %r%^test/.*test_#{possible}\.rb$%
+#   end
+# 
+#   at.add_mapping(%r%^test/.*\.rb$%) {|filename, _| filename }
+# end

data/History.md

@@ -0,0 +1,5 @@
+=== 0.1.0 / 2011-02-15
+
+* 1 major enhancement
+
+  * Conception!

data/Manifest.txt

@@ -0,0 +1,10 @@
+.autotest
+History.md
+Manifest.txt
+README.md
+Rakefile
+bin/dang
+lib/dang.rb
+lib/dang/dang.rb
+lib/dang/parser.rb
+lib/dang/parser.kpeg

data/README.md

@@ -0,0 +1,95 @@
+# Dang
+
+https://github.com/veganstraightedge/dang
+
+## Description
+
+Another dang templating language.
+
+## Build Status
+
+[![Build Status](https://travis-ci.org/veganstraightedge/dang.png?branch=master)](https://travis-ci.org/veganstraightedge/dang)
+
+## Features
+
+* CSS selectors for HTML tags
+* Not as noisy syntax than ERB
+* Not quite as elegant as [HAML](http://haml-lang.com)
+* No %s in the codez
+* More closers than HAML
+* A lot is based on / inspired by [HAML](http://haml.info)
+
+## Synopsis
+
+    <b BOLD b> => <b>BOLD</b>
+
+## Current Version
+
+0.1.0
+
+## Requirements
+
+* [rake](https://github.com/jimweirich/rake)
+* [kpeg](https://github.com/evanphx/kpeg)
+* [hoe](https://github.com/seattlerb/hoe)
+* [minitest](https://github.com/seattlerb/minitest)
+
+## Installation
+
+### Gemfile
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dang'
+```
+
+### Manual
+
+Or install it yourself as:
+
+```bash
+gem install dang
+```
+
+You may need to use `sudo` to install it manually.
+
+## Developers
+
+After checking out the source, run:
+
+```bash
+bundle
+```
+
+This task will install any missing dependencies, run the tests/specs, and generate the RDoc.
+
+## Authors
+
+  * Shane Becker / [@veganstraightedge](https://github.com/veganstraightedge)
+  * Evan Phoenix / [@evanphx](https://github.com/evanphx)
+
+## Contributing
+
+1. Fork it
+2. Get it running
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Write your code and **specs**
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request
+
+If you find bugs, have feature requests or questions, please
+[file an issue](https://github.com/veganstraightedge/dang).
+
+## License
+
+**PUBLIC DOMAIN**
+
+Your heart is as free as the air you breathe. <br>
+The ground you stand on is liberated territory.
+
+In legal text, Dang is dedicated to the public domain
+using Creative Commons -- CC0 1.0 Universal.
+
+[http://creativecommons.org/publicdomain/zero/1.0](http://creativecommons.org/publicdomain/zero/1.0 "Creative Commons &mdash; CC0 1.0 Universal")

data/Rakefile

@@ -0,0 +1,30 @@
+require "rubygems"
+require "hoe"
+
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :doofus, :git, :minitest
+
+Hoe.spec "dang" do
+  developer "Shane Becker", "veganstraightedge@gmail.com"
+
+  self.extra_rdoc_files = Dir["*.rdoc"]
+  self.history_file     = "History.md"
+  self.readme_file      = "README.md"
+end
+
+task :parser do
+  sh "ruby -I../kpeg/lib ../kpeg/bin/kpeg -o lib/dang/parser.rb -f -n Dang::Parser -s lib/dang/parser.kpeg"
+end
+
+$:.unshift "."
+$:.unshift "./lib"
+
+task :default => :spec
+
+task :spec do
+  Dir[File.dirname(__FILE__) + "/spectory/**/*_spec.rb"].each do |path|
+    require path
+  end
+
+  Minitest.autorun
+end

data/bin/dang

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'dang'
+require 'optparse'
+
+to_eval = nil
+path = nil
+
+opt = OptionParser.new do |o|
+  o.on "-e STR", "Evaluate the string as Dang" do |s|
+    to_eval = s
+  end
+end
+
+opt.parse! ARGV
+
+if to_eval
+  puts Dang.it(to_eval)
+
+else
+  path = ARGV.shift
+  if !path
+    raise "Specify -e or a path to a file"
+  end
+  puts Dang.it(File.read(path))
+end

data/lib/dang.rb

@@ -0,0 +1,4 @@
+class Dang
+end
+
+require 'dang/dang'

data/lib/dang/dang.rb

@@ -0,0 +1,40 @@
+require 'stringio'
+
+require 'rubygems'
+require 'kpeg'
+
+require 'dang/parser'
+
+class Dang
+  VERSION = '1.0.0.rc1'
+
+  @filters = {}
+
+  class << self
+    def it(str, env=nil)
+      parser = Dang::Parser.new(str, true)
+      unless parser.parse
+        io = StringIO.new
+        parser.show_error(io)
+        raise io.string
+      end
+
+      parser.output(env)
+    end
+
+    def register_filter(name, filter)
+      @filters[name] = filter
+    end
+
+    def run_filter(name, text)
+      if filter = @filters[name]
+        return filter[text]
+      else
+        raise "Unknown filter: \"#{name}\""
+      end
+    end
+  end
+
+  # A default filter.
+  register_filter "raw", proc { |str| str }
+end

data/lib/dang/parser.kpeg

@@ -0,0 +1,240 @@
+%% name = Dang::Parser
+
+%% {
+  def initialize(str, debug=false)
+    setup_parser(str, debug)
+    @doctype = nil
+    @output = ""
+  end
+
+  DOC_TYPES = {
+    "html"                 => "<!doctype html>",
+    "html5"                => "<!doctype html>",
+    "html4"                => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+    "html4 transitional"   => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+    "html4 strict"         => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
+    "html4 frameset"       => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
+
+    "xhtml 1"              => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+    "xhtml 1 transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+    "xhtml 1 strict"       => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+    "xhtml 1 frameset"     => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+    "xhtml 1.1"            => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+    "xhtml 1.1 basic"      => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
+    "xhtml 1.2 mobile"     => '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
+    "xhtml rdfa"           => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">',
+    "xhtml 5"              => '<!DOCTYPE html>',
+
+    "xml iso-8859-1"       => "<?xml version='1.0' encoding='iso-8859-1' ?>"
+  }
+
+  def html_doctype
+    return "" unless @doctype
+
+    unless DOC_TYPES.key? @doctype
+      warn "doctype '#{@doctype}' not understood, using 'html'"
+      @doctype = "html"
+    end
+
+    DOC_TYPES[@doctype].dup
+  end
+
+  def output(env=nil)
+    doctype = html_doctype
+
+    strings = @output.flatten.map do |i|
+      case i
+      when Literal
+        "_out << #{i.str.dump}"
+      when Code
+        if i.print
+          "_out << (#{i.str}).to_s"
+        else
+          i.str
+        end
+      when Filter
+        "_out << Dang.run_filter('#{i.name}', #{i.str.dump}).to_s"
+      end
+    end
+
+    code = "_out = '';\n" + strings.join(";") + ";_out"
+
+    out = eval(code, env || binding).strip
+
+    if doctype.empty?
+      str = out
+    else
+      if out.empty?
+        str = doctype
+      else
+        str = doctype << "\n" << out
+      end
+    end
+
+    str
+  end
+
+  def attrs(at,sel=[])
+    out = []
+    classes = []
+
+    (at+sel).each do |key,val|
+      if key == "class"
+        classes.unshift val
+      elsif val == true
+        out << "#{key}"
+      else
+        out << "#{key}='#{val}'"
+      end
+    end
+
+    unless classes.empty?
+      out.unshift "class='#{classes.join(' ')}'"
+    end
+
+    out.join(' ')
+  end
+
+  class Literal
+    def initialize(str)
+      @str = str
+    end
+
+    attr_reader :str
+  end
+
+  class Code
+    def initialize(str, print)
+      @str = str
+      @print = print
+    end
+
+    attr_reader :str, :print
+  end
+
+  class Filter
+    def initialize(name, str)
+      @name = name
+      @str = str
+    end
+
+    attr_reader :name, :str
+  end
+
+  def joinm(*elems)
+    elems.map do |i|
+      if i.kind_of? String
+        Literal.new(i)
+      else
+        i
+      end
+    end
+  end
+
+  def join(f,b)
+    f = Literal.new(f) if f.kind_of? String
+    b = Literal.new(b) if b.kind_of? String
+
+    if b.kind_of? Array
+      [f] + b
+    else
+      [f,b]
+    end
+  end
+
+  def code(str, print=true)
+    Code.new(str, print)
+  end
+}
+
+  space = " " | "\t"
+     bs = " " | "\t" | "\n"
+      - = bs+
+    eol = "\n"
+    eof = !.
+   rest = < (!eol .)* > (eol | eof) { text }
+
+doctype = "!!!" space* rest:r { @doctype = r.empty? ? "html" : r }
+
+   name = < /[a-zA-Z0-9_\-:]+/ > { text }
+  start = "<" name:n { n }
+    pts = space+ { "" }
+        | < eol bs* > { text }
+
+    end = name:n ">" { n }
+  slash = - "/>"
+
+ marker = start | "<!" | (- end)
+  chunk = < (!marker .)* > { text }
+
+rclose = "->"
+  ruby = "<-" < (!rclose .)* > rclose { code(text, false) }
+
+pclose = "=>"
+  puby = "<=" < (!pclose .)* > pclose { code(text) }
+
+   part = ruby | puby| filter | comment | tag | chunk
+   body = part:p body:b { join(p,b) }
+        | part
+
+    key = name
+        | "'" < /[^'\n]*/ > "'" { text }
+
+    val = "'" < /[^'\n]*/ > "'" { text }
+        | < (!"]" .)* > { text }
+
+  dattr = "[" key:k "=" val:v "]" { "data-#{k}='#{v}'" }
+ dattrs = dattr:a dattrs:l { "#{a} #{l}" }
+        | dattr
+
+   attr = "[data" dattrs:t "]" { [t,true] }
+        | "[" key:k "=" val:v "]" { [k, v] }
+        | "[" key:k "]" { [k,true] }
+  attrs = attr:a attrs:l { [a] + l }
+        | attr:a { [a] }
+
+  cc_if = /[iI][fF]/
+ cc_end = /[eE][nN][dD][iI][fF]/
+comment = "<!" space+ < "[" space* cc_if (!"]" .)* "]" > space+ "!>"
+          { "<!--#{text}>" }
+        |  "<!" space+ < "[" space* cc_end (!"]" .)* "]" > space+ "!>"
+          { "<!#{text}-->" }
+        | "<!" < (!"!>" .)*  > "!>"
+          { "<!--#{text}-->" }
+
+ simple = /[a-zA-Z0-9_\-]+/
+ select = "#" < simple > { ["id", text] }
+        | "." < simple > { ["class", text] }
+
+selects = select:s selects:t { [s] + t }
+        | select:s { [s] }
+
+end_filter(n) = bs* < /[a-zA-Z]+/ > &{ n == text } ":>"
+
+filter = "<:" name:n bs* < (!end_filter(n) .)* > end_filter(n)
+         { Filter.new(n, text) }
+
+    tag = start:l slash { "<#{l} />" }
+        | start:l space+ end:r { "<#{l}></#{r}>" }
+        | start:l attrs:a slash
+          { "<#{l} #{attrs(a)} />" }
+        | start:l selects:t slash
+          { "<#{l} #{attrs(t)} />" }
+        | start:l selects:t attrs:a slash
+          { "<#{l} #{attrs(t,a)} />" }
+        | start:l attrs:a space+ end:r
+          { "<#{l} #{attrs(a)}></#{r}>" }
+        | start:l selects:t space+ end:r
+          { "<#{l} #{attrs(t)}></#{r}>" }
+        | start:l selects:t attrs:a space+ end:r
+          { "<#{l} #{attrs(t,a)}></#{r}>" }
+        | start:l selects:t attrs:a pts body:b pts:es end:r
+          { joinm "<#{l} #{attrs(a,t)}>",b,es,"</#{r}>" }
+        | start:l attrs:a pts body:b pts:es end:r
+          { joinm "<#{l} #{attrs(a)}>", b, es, "</#{r}>" }
+        | start:l selects:t pts:s body:b pts:es end:r
+          { joinm "<#{l} #{attrs(t)}>",s, b, es, "</#{r}>" }
+        | start:l pts:s body:b pts:es end:r
+          { joinm "<#{l}>", s, b, es, "</#{r}>" }
+
+  root = doctype? body:b eof { @output = join(b,"") }