haml2erb 0.2.0

data/README.rdoc

@@ -0,0 +1,58 @@
+= haml2erb Rails Plugin
+
+haml2erb is a tool for converting {Haml markup}[http://haml-lang.com/] to Erb markup.
+
+<b>Latest version:</b> 0.2.0
+
+* API documentation (coming soon)
+* {Source code} [http://github.com/cgoddard/haml2erb/]
+* {Bug tracker} [http://github.com/cgoddard/haml2erb/issues]
+
+Tested on Ruby 1.9.1 and Ruby 1.8.7
+
+=== Installing and loading haml2erb
+
+haml2erb is currently distributed as a Rails plugin.
+
+Simply move the main haml2erb directory into the vendor/plugins directory of your Rails application.
+
+=== Using haml2erb
+
+From the Rails console or application, call the Haml2Erb.convert method to have haml
+markup translated into erb.
+
+==== Example: Simple conversion
+  Haml2Erb.convert('.foo')
+  # => "<div class='foo'>\n</div>\n"
+
+=== Not supported yet
+
+Parsing of tag internal string interpolations, such as:
+#my_div{ class: "box #{extra_classes}" }
+
+Coming soon though ...
+
+== Licenses
+
+==== haml2erb code and documentation (MIT license)
+
+  Copyright (c) 2010 Chris Goddard
+  
+  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/haml2erb.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'haml2erb/version'
+
+Gem::Specification.new do |s|
+  s.name = "haml2erb"
+  s.version = Haml2Erb::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = 'Louis Sivillo'
+  s.email = ['louis.sivillo@gmail.com']
+
+  s.summary = 'Haml to ERB Converter'
+  s.description = 'Haml to ERB Converter'
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'mixology'
+end

data/lib/haml2erb.rb

@@ -0,0 +1,15 @@
+require 'haml2erb/railtie' if defined?(Rails::Railtie)
+require 'haml2erb/erb_writer'
+require 'haml2erb/parser'
+require 'haml2erb/version'
+
+module Haml2Erb
+    
+  def self.convert(text)
+    parser = Haml2Erb::HamlParser.new
+    writer = Haml2Erb::ErbWriter.new
+    parser.parse(text, writer)
+    writer.output_to_string
+  end
+  
+end

data/lib/haml2erb/erb_writer.rb

@@ -0,0 +1,51 @@
+module Haml2Erb
+  class ErbWriter
+
+    def initialize
+      @processed = ''
+      @tag_stack = [ ]
+    end
+
+    def <<(line_options)
+
+      close_tags(line_options[:indent])
+      @tag_stack.push(line_options[:element_type]) if line_options[:element_type]
+
+      @processed << ("  " * line_options[:indent]) if line_options[:indent]
+      @processed << "<#{line_options[:element_type].to_s}" if line_options[:element_type]
+      @processed << " id='#{line_options[:element_id].to_s}'" if line_options[:element_id]
+      @processed << " class='#{[*line_options[:element_class]].join(' ')}'" if line_options[:element_class]
+      line_options[:element_attributes] && line_options[:element_attributes].keys.each do |attribute_key|
+        @processed << " #{attribute_key}='#{line_options[:element_attributes][attribute_key]}'"
+      end
+      @processed << ">" if line_options[:element_type]
+
+      case(line_options[:content_type])
+      when :text
+        @processed << (line_options[:contents] || "")
+      when :ruby
+        @processed << ("<%= " + line_options[:contents] + " %>")
+      when :mixed
+        @processed << ('<%= "' + line_options[:contents] + '" %>')
+      end
+
+      close_tags(line_options[:indent], :separate_line => false) if line_options[:contents]
+      @processed << "\n"
+    end
+
+    def output_to_string
+      close_tags(0)
+      @processed
+    end
+
+    private
+
+    def close_tags(current_indent, options = { :separate_line => true })
+      while(@tag_stack.size > current_indent)
+        @processed << ("  " * (@tag_stack.size - 1)) if options[:separate_line] == true
+        @processed << "</#{@tag_stack.pop.to_s}>"
+        @processed << "\n" if options[:separate_line] == true
+      end
+    end
+  end
+end

data/lib/haml2erb/lexer.rb

@@ -0,0 +1,28 @@
+require 'haml2erb/tokens'
+
+module Haml2Erb
+  class HamlLexer
+
+    attr_reader :input
+
+    def load_input(text)
+      @input = text
+    end
+
+    def peek(klass)
+      #puts "peek #{klass} #{@input}"
+      klass.match(@input)
+    end
+
+    def pop(klass)
+      #puts "pop #{klass} #{@input}"
+      token = klass.match(@input)
+      @input.gsub!(/^#{Regexp.escape(token.matched)}/, '') # removed matched portion from the string
+      token
+    end
+
+    def end_input?
+      @input.strip.empty? ? true : false
+    end
+  end
+end

data/lib/haml2erb/mixins/comerging.rb

@@ -0,0 +1,22 @@
+module Haml2Erb
+  module Mixins
+    module CoMerging
+      def comerge
+        # NOT IMPLEMENTED YET
+        fail "comerge command not implemented yet"
+      end
+
+      # inclusive merge that combines results of two hashes when merging
+      def comerge! hash_b
+        hash_a = self
+        hash_b.respond_to?(:each_pair) && hash_b.each_pair do |k,v|
+          hash_a[k] = hash_a[k] ?
+            (hash_a[k].respond_to?(:push) ?
+              hash_a[k].push(v) :
+              [ hash_a[k], v ]) :
+            v
+        end
+      end
+    end
+  end
+end

data/lib/haml2erb/parser.rb

@@ -0,0 +1,69 @@
+require 'haml2erb/lexer'
+require 'haml2erb/tokens'
+require 'haml2erb/mixins/comerging'
+require 'mixology'
+
+module Haml2Erb
+  class HamlParser
+
+    ParsingError = Class.new(StandardError)
+
+    def initialize
+      @lexer = Haml2Erb::HamlLexer.new
+    end
+
+    def parse(unprocessed, writer)
+      @line_number = 0
+      # process incoming text one line at a time
+      unprocessed.each_line do |line|
+        @line_number += 1
+        options = { }.mixin Haml2Erb::Mixins::CoMerging
+        @lexer.load_input(line)
+
+        # handle indent
+        if(@lexer.peek(Haml2Erb::Tokens::Indent))
+          options.merge!(@lexer.pop(Haml2Erb::Tokens::Indent).options)
+        end
+        options.merge!(:indent => 0) unless options[:indent]
+
+        # handle initial tag attributes
+        while(@lexer.peek(Haml2Erb::Tokens::InitialAttribute))
+          options.comerge!(@lexer.pop(Haml2Erb::Tokens::InitialAttribute).options)
+        end
+        options[:element_type] = :div if((options[:element_id] || options[:element_class]) && !options[:element_type])
+
+        # handle interior element attributes
+        if(@lexer.peek(Haml2Erb::Tokens::AttributesStart))
+          @lexer.pop(Haml2Erb::Tokens::AttributesStart)
+          options[:element_attributes] = { }
+          while(!@lexer.peek(Haml2Erb::Tokens::AttributesEnd))
+            if(@lexer.peek(Haml2Erb::Tokens::InnerAttributeQuoted))
+              options[:element_attributes].merge!(@lexer.pop(Haml2Erb::Tokens::InnerAttributeQuoted).options[:element_attribute])
+            elsif(@lexer.peek(Haml2Erb::Tokens::InnerAttributeRuby))
+              options[:element_attributes].merge!(@lexer.pop(Haml2Erb::Tokens::InnerAttributeRuby).options[:element_attribute])
+            elsif(@lexer.peek(Haml2Erb::Tokens::InnerAttributeNumber))
+              options[:element_attributes].merge!(@lexer.pop(Haml2Erb::Tokens::InnerAttributeNumber).options[:element_attribute])
+            else
+              raise 'unrecognized inner attribute'
+            end
+          end
+          @lexer.pop(Haml2Erb::Tokens::AttributesEnd)
+        end
+
+        # handle element contents
+        if(@lexer.peek(Haml2Erb::Tokens::ContentsStart))
+          options.merge!(@lexer.pop(Haml2Erb::Tokens::ContentsStart).options)
+        end
+        options[:content_type] = :text unless options[:content_type]
+
+        if(@lexer.peek(Haml2Erb::Tokens::Contents))
+          options.merge!(:contents => @lexer.pop(Haml2Erb::Tokens::Contents).matched)
+        end
+
+        writer << options
+      end
+    rescue => error
+      raise ParsingError, "Haml2Erb had trouble parsing line #{@line_number} with input '#{@lexer.input}' remaining: #{error.to_s}", error.backtrace
+    end
+  end
+end

data/lib/haml2erb/railtie.rb

@@ -0,0 +1,7 @@
+module Haml2Erb
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.join(File.dirname(__FILE__), '..', '..', 'tasks/haml2erb.rake')
+    end
+  end
+end

data/lib/haml2erb/tokens.rb

@@ -0,0 +1,110 @@
+module Haml2Erb
+  module Tokens
+
+    class Token
+      attr_reader :options, :matched
+
+      def initialize(matched, options = {})
+        @matched = matched
+        @options = options
+      end
+
+      def self.match(text)
+        match_data = @regex.match(text)
+        match_data ? self.new(match_data.to_s) : nil
+      end
+    end
+
+    class Indent < Token
+      @regex = /^(\s\s)+/
+
+      def self.match(text)
+        match_data = @regex.match(text)
+        match_data ? self.new(match_data.to_s, :indent => (match_data.to_s.size / 2)) : nil
+      end
+    end
+
+    class AttributesStart < Token
+      @regex = /^\{\s*/
+    end
+
+    class AttributesEnd < Token
+      @regex = /^\s*\}/
+    end
+
+    class ContentsStart < Token
+      @regex = /^((\s+)|(==\s*)|(=\s*))/
+
+      def self.match(text)
+        match_data = @regex.match(text)
+        if match_data
+          @return_token = case match_data[1][0,1]
+          when ' ' then self.new(match_data.to_s, :content_type => :text)
+          when '='
+            match_data[1][1,1] == '=' ? self.new(match_data.to_s, :content_type => :mixed) : self.new(match_data.to_s, :content_type => :ruby)
+          end
+        else
+          @return_token = nil
+        end
+        @return_token
+      end
+    end
+
+    class Contents < Token
+      @regex = /^.+$/
+
+      def self.match(text)
+        text.gsub!(/\\\-/, "-")
+        match_data = @regex.match(text)
+        match_data ? self.new(match_data.to_s) : nil
+      end
+    end
+
+    class InitialAttribute < Token
+      @regex = /^([%#\.])(\w+)/
+
+      def self.match(text)
+        match_data = @regex.match(text)
+        if match_data
+          @return_token = case match_data[1]
+          when '%' then self.new(match_data.to_s, :element_type => match_data[2])
+          when '#' then self.new(match_data.to_s, :element_id => match_data[2])
+          when '.' then self.new(match_data.to_s, :element_class => match_data[2])
+          end
+        else
+          @return_token = nil
+        end
+        @return_token
+      end
+    end
+
+    class InnerAttributeQuoted < Token
+      @regex = /^,?\s*:?['"]?([\w-]+)['"]?(:|(\s*=>))\s*['"]([^'"]+)['"]\s*/
+      def self.match(text)
+        match_data = @regex.match(text)
+        if(match_data) 
+          value = match_data[4].gsub(/#\{([^\}]+?)\}/, '<%= \1 %>') # replace #{ value } with <%= value %>
+          self.new(match_data.to_s, :element_attribute => { match_data[1] => value })
+        else
+          nil
+        end
+      end
+    end
+
+    class InnerAttributeRuby < Token
+      @regex = /^,?\s*:?['"]?([\w-]+)['"]?(:|(\s*=>))\s*([^'"\s][^,\s]+)\s*/
+      def self.match(text)
+        match_data = @regex.match(text)
+        match_data ? self.new(match_data.to_s, :element_attribute => { match_data[1] => "<%= #{match_data[4]} %>" }) : nil
+      end
+    end
+
+    class InnerAttributeNumber < Token
+      @regex = /^,?\s*:?['"]?([\w-]+)['"]?(:|(\s*=>))\s*(\d+)\s*/
+      def self.match(text)
+        match_data = @regex.match(text)
+        match_data ? self.new(match_data.to_s, :element_attribute => { match_data[1] => match_data[4] }) : nil
+      end
+    end
+  end
+end

data/lib/haml2erb/version.rb

@@ -0,0 +1,3 @@
+module Haml2Erb
+  VERSION = "0.2.0"
+end

data/tasks/haml2erb.rake

@@ -0,0 +1,7 @@
+desc "This task will take the supplied .haml input file and convert it to .erb.  It will remove the original .haml file and create a new .erb file"
+task :haml2erb, :filename, :needs => :environment do |t, args|
+  output_file = args[:filename].gsub(/\.haml/, '.erb')
+  p output_file
+  File.open(output_file, 'w') { |f| f.write Haml2Erb.convert(File.open(args[:filename], 'r').read) }
+  FileUtils.rm_r args[:filename]
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: haml2erb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Louis Sivillo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mixology
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Haml to ERB Converter
+email: 
+- louis.sivillo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- haml2erb.gemspec
+- lib/haml2erb.rb
+- lib/haml2erb/erb_writer.rb
+- lib/haml2erb/lexer.rb
+- lib/haml2erb/mixins/comerging.rb
+- lib/haml2erb/parser.rb
+- lib/haml2erb/railtie.rb
+- lib/haml2erb/tokens.rb
+- lib/haml2erb/version.rb
+- tasks/haml2erb.rake
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Haml to ERB Converter
+test_files: []
+