haml_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d8e1da7981dd07cc815bdbc297e870a4ac6112b
+  data.tar.gz: 2194786147cc3fd76d711695ab52e94fa4aafdf6
+SHA512:
+  metadata.gz: 3e43dcd816b101a1809c61cc64a8bd49e1505cbc8b78df5daa565c377717227b003853fea553a89ed017c1513a5a0fecebe3a7341bb2fa7dbe42c279e0c1f4fe
+  data.tar.gz: a9a087e3f0969c6b221cca84234c32cc9d3f7cb7ad4b958144996396996d0551f27783567fca63b56d4078507c55952bb6c2cfe6f32e247dc5b008741ddb3b37

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+spec/examples.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+sudo: false
+rvm:
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in haml_parser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kohei Suzuki
+
+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

@@ -0,0 +1,73 @@
+# HamlParser
+[![Gem Version](https://badge.fury.io/rb/haml_parser.svg)](http://badge.fury.io/rb/haml_parser)
+[![Build Status](https://travis-ci.org/eagletmt/haml_parser.svg?branch=master)](https://travis-ci.org/eagletmt/haml_parser)
+[![Coverage Status](https://coveralls.io/repos/eagletmt/haml_parser/badge.svg?branch=master&service=github)](https://coveralls.io/github/eagletmt/haml_parser?branch=master)
+[![Code Climate](https://codeclimate.com/github/eagletmt/haml_parser/badges/gpa.svg)](https://codeclimate.com/github/eagletmt/haml_parser)
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/haml_parser`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'haml_parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install haml_parser
+
+## Usage
+
+```ruby
+parser = HamlParser::Parser.new(filename: 'input.haml')
+ast = parser.call(File.read('input.haml'))
+```
+
+Simple CLI interface is also available.
+
+```
+% cat input.haml
+%p hello world
+% haml_parser input.haml
+#<struct HamlParser::Ast::Root
+ children=
+  [#<struct HamlParser::Ast::Element
+    children=[],
+    tag_name="p",
+    static_class="",
+    static_id="",
+    attributes="",
+    oneline_child=
+     #<struct HamlParser::Ast::Text
+      text="hello world",
+      escape_html=true,
+      filename="in.haml",
+      lineno=1>,
+    self_closing=false,
+    nuke_inner_whitespace=false,
+    nuke_outer_whitespace=false,
+    filename="in.haml",
+    lineno=1>]>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eagletmt/haml_parser.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "haml_parser"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/haml_parser

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'haml_parser/cli'
+
+HamlParser::CLI.start(ARGV)

data/haml_parser.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haml_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "haml_parser"
+  spec.version       = HamlParser::VERSION
+  spec.authors       = ["Kohei Suzuki"]
+  spec.email         = ["eagletmt@gmail.com"]
+
+  spec.summary       = %q{Parser of Haml template language}
+  spec.description   = %q{Parser of Haml template language}
+  spec.homepage      = "https://github.com/eagletmt/haml_parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 3.3.0"
+  spec.add_development_dependency "simplecov"
+end

data/lib/haml_parser.rb

@@ -0,0 +1,5 @@
+require "haml_parser/version"
+
+module HamlParser
+  # Your code goes here...
+end

data/lib/haml_parser/ast.rb

@@ -0,0 +1,157 @@
+module HamlParser
+  module Ast
+    module HasChildren
+      def initialize(*)
+        super
+        self.children ||= []
+      end
+
+      def <<(ast)
+        self.children << ast
+      end
+
+      def to_h
+        super.merge(children: children.map(&:to_h))
+      end
+    end
+
+    class Root < Struct.new(:children)
+      include HasChildren
+
+      def to_h
+        super.merge(type: 'root')
+      end
+    end
+
+    class Doctype < Struct.new(:doctype, :filename, :lineno)
+      def to_h
+        super.merge(type: 'doctype')
+      end
+    end
+
+    class Element < Struct.new(
+      :children,
+      :tag_name,
+      :static_class,
+      :static_id,
+      :attributes,
+      :oneline_child,
+      :self_closing,
+      :nuke_inner_whitespace,
+      :nuke_outer_whitespace,
+      :filename,
+      :lineno,
+    )
+      include HasChildren
+
+      def initialize(*)
+        super
+        self.static_class ||= ''
+        self.static_id ||= ''
+        self.attributes ||= ''
+        self.self_closing ||= false
+        self.nuke_inner_whitespace ||= false
+        self.nuke_outer_whitespace ||= false
+      end
+
+      def to_h
+        super.merge(
+          type: 'element',
+          oneline_child: oneline_child && oneline_child.to_h,
+        )
+      end
+    end
+
+    class Script < Struct.new(
+      :children,
+      :script,
+      :escape_html,
+      :preserve,
+      :filename,
+      :lineno,
+    )
+      include HasChildren
+
+      def initialize(*)
+        super
+        if self.escape_html.nil?
+          self.escape_html = true
+        end
+        if self.preserve.nil?
+          self.preserve = false
+        end
+      end
+
+      def to_h
+        super.merge(type: 'script')
+      end
+    end
+
+    class SilentScript < Struct.new(:children, :script, :mid_block_keyword, :filename, :lineno)
+      include HasChildren
+
+      def initialize(*)
+        super
+        if self.mid_block_keyword.nil?
+          self.mid_block_keyword = false
+        end
+      end
+
+      def to_h
+        super.merge(type: 'silent_script')
+      end
+    end
+
+    class HtmlComment < Struct.new(:children, :comment, :conditional, :filename, :lineno)
+      include HasChildren
+
+      def initialize(*)
+        super
+        self.comment ||= ''
+        self.conditional ||= ''
+      end
+
+      def to_h
+        super.merge(type: 'html_comment')
+      end
+    end
+
+    class HamlComment < Struct.new(:children, :filename, :lineno)
+      include HasChildren
+
+      def to_h
+        super.merge(type: 'haml_comment')
+      end
+    end
+
+    class Text < Struct.new(:text, :escape_html, :filename, :lineno)
+      def initialize(*)
+        super
+        if self.escape_html.nil?
+          self.escape_html = true
+        end
+      end
+
+      def to_h
+        super.merge(type: 'text')
+      end
+    end
+
+    class Filter < Struct.new(:name, :texts, :filename, :lineno)
+      def initialize(*)
+        super
+        self.texts ||= []
+      end
+
+      def to_h
+        super.merge(type: 'filter')
+      end
+    end
+
+    class Empty < Struct.new(:filename, :lineno)
+      def to_h
+        super.merge(type: 'empty')
+      end
+    end
+  end
+end

data/lib/haml_parser/cli.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+
+module HamlParser
+  class CLI
+    def self.start(argv)
+      new.start(argv)
+    end
+
+    def start(argv)
+      formatter = 'pretty'
+      OptionParser.new.tap do |parser|
+        parser.version = VERSION
+        parser.on('-f FORMAT', '--format FORMAT', 'Select formatter') { |v| formatter = v }
+      end.parse!(argv)
+
+      require 'haml_parser/parser'
+      argv.each do |file|
+        format(parse_file(file), formatter)
+      end
+    end
+
+    def parse_file(file)
+      HamlParser::Parser.new(filename: file).call(File.read(file))
+    end
+
+    private
+
+    def format(ast, formatter)
+      case formatter
+      when 'pretty'
+        require 'pp'
+        pp ast
+      when 'pry'
+        require 'pry'
+        Pry::ColorPrinter.pp ast
+      when 'json'
+        require 'json'
+        puts JSON.generate(ast.to_h)
+      else
+        abort "Unknown formatter: #{formatter}"
+      end
+    end
+  end
+end

data/lib/haml_parser/element_parser.rb

@@ -0,0 +1,235 @@
+require 'strscan'
+require 'haml_parser/ast'
+require 'haml_parser/utils'
+require 'haml_parser/ruby_multiline'
+require 'haml_parser/script_parser'
+require 'haml_parser/error'
+
+module HamlParser
+  class ElementParser
+    def initialize(line_parser)
+      @line_parser = line_parser
+    end
+
+    ELEMENT_REGEXP = /\A%([-:\w]+)([-:\w.#]*)(.+)?\z/o
+
+    def parse(text)
+      m = text.match(ELEMENT_REGEXP)
+      unless m
+        syntax_error!('Invalid element declaration')
+      end
+
+      element = Ast::Element.new
+      element.filename = @line_parser.filename
+      element.lineno = @line_parser.lineno
+      element.tag_name = m[1]
+      element.static_class, element.static_id = parse_class_and_id(m[2])
+      rest = m[3] || ''
+
+      element.attributes, rest = parse_attributes(rest)
+      element.nuke_inner_whitespace, element.nuke_outer_whitespace, rest = parse_nuke_whitespace(rest)
+      element.self_closing, rest = parse_self_closing(rest)
+      element.oneline_child = ScriptParser.new(@line_parser).parse(rest)
+
+      element
+    end
+
+    private
+
+    def parse_class_and_id(class_and_id)
+      classes = []
+      id = ''
+      scanner = StringScanner.new(class_and_id)
+      until scanner.eos?
+        unless scanner.scan(/([#.])([-:_a-zA-Z0-9]+)/)
+          syntax_error!('Illegal element: classes and ids must have values.')
+        end
+        case scanner[1]
+        when '.'
+          classes << scanner[2]
+        when '#'
+          id = scanner[2]
+        end
+      end
+
+      [classes.join(' '), id]
+    end
+
+    OLD_ATTRIBUTE_BEGIN = '{'
+    NEW_ATTRIBUTE_BEGIN = '('
+
+    def parse_attributes(rest)
+      old_attributes = ''
+      new_attributes = ''
+
+      loop do
+        case rest[0]
+        when OLD_ATTRIBUTE_BEGIN
+          unless old_attributes.empty?
+            break
+          end
+          old_attributes, rest = parse_old_attributes(rest)
+        when NEW_ATTRIBUTE_BEGIN
+          unless new_attributes.empty?
+            break
+          end
+          new_attributes, rest = parse_new_attributes(rest)
+        else
+          break
+        end
+      end
+
+      attributes = old_attributes
+      unless new_attributes.empty?
+        if attributes.empty?
+          attributes = new_attributes
+        else
+          attributes << ", " << new_attributes
+        end
+      end
+      [attributes, rest]
+    end
+
+    def parse_old_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        depth = Utils.balance(s, '{', '}', depth)
+        if depth == 0
+          attr = s.pre_match + s.matched
+          return [attr[1, attr.size-2], s.rest]
+        else
+          if /,\s*\z/ === text && @line_parser.has_next?
+            text << "\n" << @line_parser.next_line
+          else
+            syntax_error!('Unmatched brace')
+          end
+        end
+      end
+    end
+
+    def parse_new_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        pre_pos = s.pos
+        depth = Utils.balance(s, '(', ')', depth)
+        if depth == 0
+          t = s.string.byteslice(pre_pos ... s.pos-1)
+          return [parse_new_attribute_list(t), s.rest]
+        else
+          if @line_parser.has_next?
+            text << "\n" << @line_parser.next_line
+          else
+            syntax_error!('Unmatched paren')
+          end
+        end
+      end
+    end
+
+    def parse_new_attribute_list(text)
+      s = StringScanner.new(text)
+      attributes = []
+      until s.eos?
+        name = scan_key(s)
+        s.skip(/\s*/)
+
+        if scan_operator(s)
+          s.skip(/\s*/)
+          value = scan_value(s)
+        else
+          value = 'true'
+        end
+        spaces = s.scan(/\s*/)
+        line_count = spaces.count("\n")
+
+        attributes << "#{name.inspect} => #{value},#{"\n" * line_count}"
+      end
+      attributes.join
+    end
+
+    def scan_key(scanner)
+      scanner.scan(/[-:\w]+/).tap do |name|
+        unless name
+          syntax_error!('Invalid attribute list (missing attribute name)')
+        end
+      end
+    end
+
+    def scan_operator(scanner)
+      scanner.skip(/=/)
+    end
+
+    def scan_value(scanner)
+      if quote = scanner.scan(/["']/)
+        scan_quoted_value(scanner, quote)
+      else
+        scan_variable_value(scanner)
+      end
+    end
+
+    def scan_quoted_value(scanner, quote)
+      re = /((?:\\.|\#(?!\{)|[^#{quote}\\#])*)(#{quote}|#\{)/
+      pos = scanner.pos
+      loop do
+        unless scanner.scan(re)
+          syntax_error!('Invalid attribute list (mismatched quotation)')
+        end
+        if scanner[2] == quote
+          break
+        end
+        depth = Utils.balance(scanner, '{', '}')
+        if depth != 0
+          syntax_error!('Invalid attribute list (mismatched interpolation)')
+        end
+      end
+      str = scanner.string.byteslice(pos-1 .. scanner.pos-1)
+
+      # Even if the quote is single, string interpolation is performed in Haml.
+      str[0] = '"'
+      str[-1] = '"'
+      str
+    end
+
+    def scan_variable_value(scanner)
+      scanner.scan(/(@@?|\$)?\w+/).tap do |var|
+        unless var
+          syntax_error!('Invalid attribute list (invalid variable name)')
+        end
+      end
+    end
+
+    def parse_nuke_whitespace(rest)
+      m = rest.match(/\A(><|<>|[><])(.*)\z/)
+      if m
+        nuke_whitespace = m[1]
+        [
+          nuke_whitespace.include?('<'),
+          nuke_whitespace.include?('>'),
+          m[2],
+        ]
+      else
+        [false, false, rest]
+      end
+    end
+
+    def parse_self_closing(rest)
+      if rest[0] == '/'
+        if rest.size > 1
+          syntax_error!("Self-closing tags can't have content")
+        end
+        [true, '']
+      else
+        [false, rest]
+      end
+    end
+
+    def syntax_error!(message)
+      raise Error.new(message, @line_parser.lineno)
+    end
+  end
+end