ouvrages-haml2erb 0.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2011 Chris Goddard, Louis Sivillo
+
+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.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/lib/haml2erb/erb_writer.rb

@@ -0,0 +1,68 @@
+module Haml2Erb
+  class ErbWriter
+
+    def initialize
+      @processed = ''
+      @tag_stack = [ ]
+    end
+
+    def <<(line_options)
+
+      else_block = (line_options[:content_type] == :ruby_run and (line_options[:contents] =~ /^\s*else\s*$/ or line_options[:contents] =~ /^\s*elsif\s/))
+      ruby_block = (line_options[:content_type] == :ruby_run and (line_options[:contents] =~ / do(\s*\|[\w\d_,\s]+\|)?$/ or line_options[:contents] =~ /^\s*if / or else_block))
+      close_tags(line_options[:indent], :incoming_else_block => else_block)
+      @tag_stack.push(line_options[:element_type]) if line_options[:element_type] and !line_options[:self_closing_tag]
+      @tag_stack.push(:ruby_block) if ruby_block
+
+      @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[:self_closing_tag]
+      @processed << ">" if line_options[:element_type]
+
+      case(line_options[:content_type])
+      when :text
+        @processed << (line_options[:contents] || "")
+      when :ruby
+        @processed << ("<%= " + line_options[:contents] + " %>")
+      when :ruby_run
+        @processed << ("<% " + line_options[:contents] + " %>")
+      when :mixed
+        @processed << ('<%= "' + line_options[:contents] + '" %>')
+      end
+
+      close_tags(line_options[:indent], :separate_line => false) if line_options[:contents] and !line_options[:self_closing_tag] and !ruby_block
+      @processed << "\n"
+    end
+
+    def output_to_string
+      close_tags(0)
+      @processed
+    end
+
+    private
+
+    def close_tags(current_indent, options = {})
+      options = { :separate_line => true }.merge(options)
+      while(@tag_stack.size > current_indent)
+        indent = @tag_stack.size - 1
+        stack_item = @tag_stack.pop
+        if stack_item == :ruby_block
+          unless options[:incoming_else_block]
+            @processed << ("  " * (indent)) if options[:separate_line] == true
+            @processed << "<% end %>"
+            @processed << "\n" if options[:separate_line] == true
+          end
+        else
+          @processed << ("  " * (indent)) if options[:separate_line] == true
+          @processed << "</#{stack_item.to_s}>"
+          @processed << "\n" if options[:separate_line] == true
+        end
+      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,77 @@
+require 'haml2erb/lexer'
+require 'haml2erb/tokens'
+require 'haml2erb/mixins/comerging'
+
+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
+        next if line =~ /^\s*$/
+        options = { }
+        class << options
+          include Haml2Erb::Mixins::CoMerging
+        end
+        @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
+
+        if(@lexer.peek(Haml2Erb::Tokens::SelfClosingTag))
+          @lexer.pop(Haml2Erb::Tokens::SelfClosingTag)
+          options[:self_closing_tag] = true
+        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.inspect} 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,148 @@
+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 SelfClosingTag < Token
+      @regex = /^\//
+    end
+
+    class ContentsStart < Token
+      @regex = /^((\s+)|(==\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 => (match_data[1][0,1] == '-' ? :ruby_run : :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*([^'"])/
+      def self.match(text)
+        match_data = @regex.match(text)
+        if match_data
+          ruby = match_data[4]
+          match = match_data.to_s
+          remaining = text[match.size..-1]
+          stack = []
+          remaining.split(//).each do |chr|
+            case chr
+            when /[\[\{\(]/
+              stack.push chr
+              ruby << chr
+              match << chr
+            when /[\]\}\)]/
+              if stack.empty?
+                break
+              else
+                stack.pop
+                ruby << chr
+                match << chr
+              end
+            when ','
+              if stack.empty?
+                break
+              else
+                ruby << chr
+                match << chr
+              end
+            else
+              ruby << chr
+              match << chr
+            end
+          end
+          self.new(match, :element_attribute => { match_data[1] => "<%= #{ruby} %>" })
+        else
+          nil
+        end
+      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.3"
+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/ouvrages-haml2erb.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'haml2erb/version'
+
+Gem::Specification.new do |s|
+  s.name = "ouvrages-haml2erb"
+  s.version = Haml2Erb::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Ouvrages', 'Louis Sivillo']
+  s.email = ['contact@ouvrages-web.fr']
+
+  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"]
+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,59 @@
+--- !ruby/object:Gem::Specification
+name: ouvrages-haml2erb
+version: !ruby/object:Gem::Version
+  version: '0.3'
+  prerelease: 
+platform: ruby
+authors:
+- Ouvrages
+- Louis Sivillo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-15 00:00:00.000000000 Z
+dependencies: []
+description: Haml to ERB Converter
+email:
+- contact@ouvrages-web.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.rdoc
+- 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
+- ouvrages-haml2erb.gemspec
+- tasks/haml2erb.rake
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Haml to ERB Converter
+test_files: []
+has_rdoc: