huml 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c226fb793dde84c7b77e8471bf67da803940ed78
+  data.tar.gz: a4c0c772b4f03f9f6a34d35cf28c037553314c82
+SHA512:
+  metadata.gz: d50a2ecc4b9cd32dd2d0f11fa4e38fe7e13b07d69a23a39c43fddfe613e21adb11cd1571a504d72d9366095cea28aace224c3723c143a50684099851bcde7f5c
+  data.tar.gz: 4b5e1c96db2ae6ea90917a797900ed1b451c719c083e5e832360c10e004c6b4522669cd9d01b23099fa04654a15ac046edcb738c7dc33fc0ed0230629326a395

data/.gitignore

@@ -0,0 +1,5 @@
+doc
+*.swp
+*.swo
+.rspec
+*.huml

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    huml (0.0.1)
+      temple
+      treetop
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    polyglot (0.3.5)
+    rake (10.2.2)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.0)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.1)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.0)
+    temple (0.6.7)
+    treetop (1.5.3)
+      polyglot (~> 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  huml!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,28 @@
+# Huml
+
+Huml is a template engine derived from [Haml](github.com/haml/haml).
+Like the relationship between Sass and Scss, Huml uses braces for nesting structure
+when Haml uses indentations.
+
+## Formatting
+
+    doctype 5
+    %html {
+
+      %head {
+        %script(type="text/javascript" src="app.js")
+        %link(rel="stylesheet" type="text/css" media="all")
+      }
+
+      %body {
+        %div.container {
+          %h3.header = "page header"
+          %p(style="background-color: #fff;") = "Lorem Ipsum is simply dummy text of the printing and typesetting industry."
+        }
+      }
+
+    }
+
+## License
+
+MIT (X11) License 2014 shelling

data/Rakefile

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/huml

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'huml'
+
+puts eval(Huml::Engine.new.call(File.open(ARGV[0]).read))

data/huml.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + "/lib/huml/version"
+require "date"
+
+Gem::Specification.new do |s|
+  s.name          = 'huml'
+  s.version       = Huml::VERSION
+  s.date          = Date.today.to_s
+
+  s.authors       = ['shelling']
+  s.email         = ['navyblueshellingford@gmail.com']
+  s.homepage      = 'https://github.com/shelling/huml'
+  s.description   = 'Huml is to Haml what Scss is to Sass'
+  s.summary       = 'Huml'
+
+  s.require_paths = ['lib']
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.license       = 'MIT'
+
+  s.add_runtime_dependency 'temple'
+  s.add_runtime_dependency 'treetop'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+end

data/lib/huml.rb

@@ -0,0 +1,95 @@
+module Huml
+  require "huml/version"
+  require "treetop"
+  require "huml/parser"
+  autoload :Engine, "huml/engine"
+
+  class Parser < Treetop::Runtime::CompiledParser
+    include Huml
+
+    def initialize(options = {})
+      super()
+    end
+
+    def call(string)
+      if result = parse(string)
+        result.tokenize
+      else
+        raise Exception, self.failure_reason
+      end
+    end
+  end
+
+  class Top < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:multi].push(doctype.empty? ? [:multi] : doctype.tokenize)
+              .concat( html.empty? ? [[:multi]] : html.tokenize )
+    end
+  end
+
+  class Block < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:html, :tag, name.text_value.to_sym,
+        [:html, :attrs].concat(selector_list.tokenize).concat(attributes.empty? ? [] : attributes.tokenize),
+        [:multi].concat(html.empty? ? [] : html.tokenize)]
+    end
+  end
+
+  class Assignment < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:html, :tag, name.text_value.to_sym,
+        [:html, :attrs].concat(selector_list.tokenize).concat(attributes.empty? ? [] : attributes.tokenize),
+        string.tokenize]
+    end
+  end
+
+  class Atom < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:html, :tag, name.text_value.to_sym,
+        [:html, :attrs].concat(selector_list.tokenize).concat(attributes.empty? ? [] : attributes.tokenize)]
+    end
+  end
+
+  class HTML < Treetop::Runtime::SyntaxNode
+    def tokenize
+      elements.map { |e| e.tokenize }
+    end
+  end
+
+  class Doctype < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:html, :doctype, typestring.text_value]
+    end
+  end
+
+  class SelectorList < Treetop::Runtime::SyntaxNode
+    TYPES = { "." => :class, "#" => :id }
+    def tokenize
+      elements.map { |e| [:html, :attr, TYPES[e.type.text_value], [:static, e.name.text_value]] }
+    end
+  end
+
+  class Attributes < Treetop::Runtime::SyntaxNode
+    def tokenize
+      pairs.elements.map(&:tokenize)
+    end
+  end
+
+  class Pair < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:html, :attr, attr.text_value.to_sym, value.tokenize]
+    end
+  end
+
+  class Space < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:newline] if text_value =~ /[\r\n]/
+    end
+  end
+
+  class String < Treetop::Runtime::SyntaxNode
+    def tokenize
+      [:static, literal.text_value]
+    end
+  end
+end

data/lib/huml/engine.rb

@@ -0,0 +1,15 @@
+require "temple"
+
+module Huml
+  class Engine < ::Temple::Engine
+    use Huml::Parser
+    use Temple::HTML::AttributeMerger
+    use Temple::HTML::AttributeRemover
+    use Temple::HTML::Pretty
+    filter    :ControlFlow
+    filter    :StaticMerger
+    filter    :DynamicInliner
+    generator :ArrayBuffer
+  end
+end
+

data/lib/huml/parser.treetop

@@ -0,0 +1,45 @@
+grammar Huml
+
+  rule top
+    space doctype:doctype? space html <Top>
+  end
+
+  rule block
+    '%' name:[a-zA-Z0-9]+ selector_list attributes:attributes? space '{' space html space '}' space <Block>
+    /
+    '%' name:[a-zA-Z0-9]+ selector_list attributes:attributes? space '=' space string space <Assignment>
+    /
+    '%' name:[a-zA-Z0-9]+ selector_list attributes:attributes? space <Atom>
+  end
+
+  rule doctype
+    "doctype " [ \t]* typestring:([a-zA-Z0-9]*) <Doctype>
+  end
+
+  rule selector_list
+    (type:[.#] name:[a-zA-Z0-9-]+)* <SelectorList>
+  end
+
+  rule attributes
+    '(' space pairs:pair* ')' <Attributes>
+  end
+
+  rule pair
+    attr:([a-zA-Z0-9]+) space '=' space value:string space <Pair>
+  end
+
+  rule space
+    [\s]* <Space>
+  end
+
+  rule html
+    block* <HTML>
+  end
+
+  rule string
+    '"' literal:([a-zA-Z0-9_!@#$%:;/\-\s\.]*) '"' <String>
+    /
+    "'" literal:([a-zA-Z0-9_!@#$%:;/\-\s\.]*) "'" <String>
+  end
+
+end

data/lib/huml/version.rb

@@ -0,0 +1,3 @@
+module Huml
+  VERSION = '0.0.1'
+end

data/spec/huml/engine_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Huml::Engine do
+  subject { Huml::Engine.new }
+
+  it "outputs basic html structure" do
+    expect(eval(subject.call("doctype 5\n %html {  }"))).to eq("<!DOCTYPE html>\n<html></html>")
+  end
+
+  it "outputs a divider with its content" do
+    expect(eval(subject.call("%div = 'content'"))).to eq("<div>\n  content\n</div>")
+  end
+end

data/spec/huml/parser_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Huml::Parser do
+  subject { Huml::Parser.new }
+
+  it "allows blank document" do
+    expect(subject.parse("  ").tokenize).to eq([:multi, [:multi], [:multi]])
+  end
+
+  it "can recognize space" do
+    expect(subject.parse("\r", root: :space).tokenize).to eq([:newline])
+    expect(subject.parse("\n", root: :space).tokenize).to eq([:newline])
+    expect(subject.parse("  ", root: :space).tokenize).to eq(nil)
+    expect(subject.parse("\t", root: :space).tokenize).to eq(nil)
+    expect(subject.parse("  \t", root: :space).tokenize).to eq(nil)
+    expect(subject.parse("  \t\n\r", root: :space).tokenize).to eq([:newline])
+  end
+
+  it "can recognize doctype" do
+    expect(subject.parse("doctype 5", root: :doctype).tokenize).to eq([:html, :doctype, "5"])
+    expect(subject.parse(" doctype 5 ").tokenize).to eq([:multi, [:html, :doctype, "5"], [:multi]])
+  end
+
+  it "can recognize block" do
+    expect(subject.parse("%div {}", root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs], [:multi]])
+    expect(subject.parse("%div {}").tokenize).to eq([:multi, [:multi], [:html, :tag, :div, [:html, :attrs], [:multi]]])
+    expect(subject.parse("%div {} %div {}", root: :html).tokenize).to eq([[:html, :tag, :div, [:html, :attrs], [:multi]],
+                                                                          [:html, :tag, :div, [:html, :attrs], [:multi]]])
+    expect(subject.parse("%div {} %div {}").tokenize).to eq([:multi, [:multi],
+                                                                          [:html, :tag, :div, [:html, :attrs], [:multi]],
+                                                                          [:html, :tag, :div, [:html, :attrs], [:multi]]])
+  end
+
+  it "recognizes blocks inside a block" do
+    expect(subject.parse("%div { %p {} %p {} }", root: :block).tokenize).to eq([:html, :tag, :div,
+                                                                                  [:html, :attrs],
+                                                                                  [:multi,
+                                                                                    [:html, :tag, :p, [:html, :attrs], [:multi]],
+                                                                                    [:html, :tag, :p, [:html, :attrs], [:multi]] ]])
+  end
+
+  it "recognizes css class list" do
+    expect(subject.parse(".foo", root: :selector_list).tokenize).to eq([[:html, :attr, :class, [:static, "foo"]]])
+    expect(subject.parse(".foo.bar.baz", root: :selector_list).tokenize).to eq([[:html, :attr, :class, [:static, "foo"]],
+                                                                                [:html, :attr, :class, [:static, "bar"]],
+                                                                                [:html, :attr, :class, [:static, "baz"]]])
+  end
+
+  it "recognizes css id list" do
+    expect(subject.parse("#foo", root: :selector_list).tokenize).to eq([[:html, :attr, :id,    [:static, "foo"]]])
+  end
+
+  it "recognizes id and class list" do
+    expect(subject.parse(".foo#bar", root: :selector_list).tokenize).to eq([[:html, :attr, :class, [:static, "foo"]],
+                                                                            [:html, :attr, :id,    [:static, "bar"]]])
+  end
+
+  it "recognizes a block with selectors" do
+    expect(subject.parse("%div.foo#bar {}", root: :block).tokenize).to eq([:html, :tag, :div,
+                                                                            [:html, :attrs,
+                                                                              [:html, :attr, :class, [:static, "foo"]],
+                                                                              [:html, :attr, :id   , [:static, "bar"]]],
+                                                                              [:multi]])
+  end
+
+  it "recognizes a literal string" do
+    expect(subject.parse('"hello world"', root: :string).tokenize).to eq([:static, "hello world"])
+    expect(subject.parse("'hello world'", root: :string).tokenize).to eq([:static, "hello world"])
+  end
+
+  it "recognizes string composed of characters with hyphen" do
+    expect(subject.parse('"col-xs-6"', root: :string).tokenize).to eq([:static, "col-xs-6"])
+  end
+
+  it "recognizes string composed of characters with underscore" do
+    expect(subject.parse('"foo_bar"', root: :string).tokenize).to eq([:static, "foo_bar"])
+  end
+
+  it "recognizes a fragment of css" do
+    expect(subject.parse('"background-color: #fff;"'))
+  end
+
+  it "recognizes a block containing a string" do
+    expect(subject.parse('%div = "string here"', root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs], [:static, "string here"]])
+  end
+
+  it "recognizes a pair" do
+    expect(subject.parse('src = "foo.png"', root: :pair).tokenize).to eq([:html, :attr, :src, [:static, "foo.png"]])
+  end
+
+  it "recognizes attributes" do
+    expect(subject.parse('( src = "foo.png" alt = "foo image" )', root: :attributes).tokenize).to eq([[:html, :attr, :src, [:static, "foo.png"]], [:html, :attr, :alt, [:static, "foo image"]]])
+  end
+
+  it "recognizes a block with attributes" do
+    expect(subject.parse('%div(class="foo") {}', root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs, [:html, :attr, :class, [:static, "foo"]]], [:multi]])
+  end
+
+  it "recognizes a assignment with attributes" do
+    expect(subject.parse('%div(class="foo") = "string here"', root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs, [:html, :attr, :class, [:static, "foo"]]], [:static, "string here"]])
+  end
+
+  it "recognizes a atomic element" do
+    expect(subject.parse('%div', root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs]])
+    expect(subject.parse('%div()', root: :block).tokenize).to eq([:html, :tag, :div, [:html, :attrs]])
+    expect(subject.parse('%div(class="foo")', root: :block).tokenize).to eq([:html, :tag, :div,
+                                                                              [:html, :attrs,
+                                                                                [:html, :attr, :class, [:static, "foo"]]]])
+    expect(subject.parse('%div.foo#bar(role="sidebar")', root: :block).tokenize).to eq([:html, :tag, :div,
+                                                                                          [:html, :attrs,
+                                                                                            [:html, :attr, :class, [:static, "foo"]],
+                                                                                            [:html, :attr, :id, [:static, "bar"]],
+                                                                                            [:html, :attr, :role, [:static, "sidebar"]]]])
+  end
+
+  it "recognizes multiple atomic elements" do
+    expect(subject.parse("%div()\n%div()", root: :html).tokenize).to eq([[:html, :tag, :div, [:html, :attrs]], [:html, :tag, :div, [:html, :attrs]]])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'huml'
+
+RSpec.configure do |config|
+  config.order = "random"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: huml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- shelling
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: temple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Huml is to Haml what Scss is to Sass
+email:
+- navyblueshellingford@gmail.com
+executables:
+- huml
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/huml
+- examples/simple.huml
+- huml.gemspec
+- lib/huml.rb
+- lib/huml/engine.rb
+- lib/huml/parser.treetop
+- lib/huml/version.rb
+- spec/huml/engine_spec.rb
+- spec/huml/parser_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/shelling/huml
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Huml
+test_files:
+- spec/huml/engine_spec.rb
+- spec/huml/parser_spec.rb
+- spec/spec_helper.rb