html-to-haml 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15bb392209552a1c2c5ed225486c98bb620bdb1c
+  data.tar.gz: 3b55b8c57a4577aed92b1766ffabb5ec6f0eb0e4
+SHA512:
+  metadata.gz: c251c16238f91a8123f7d4f36a5a1516a5668ce43a0fe78be96915ce8d28134b1251632de2cf12d34528235e5767b3f53f5fa27fce1dfb8459581a115dbbb09b
+  data.tar.gz: f048b0b54befe18ff66d807f699664537954e803f67ae48003b963c1e39dc180e69f2fc0ba96f66c59367e39a3e5987a6abd0e93d692a1c510f4b972595cc22c

data/lib/html_to_haml/converter.rb

@@ -0,0 +1,45 @@
+require_relative './use_cases/html/conversion_use_case'
+require_relative './use_cases/erb/basic_conversion_use_case'
+require_relative './use_cases/non_html_selector_blocks/style_conversion_use_case'
+require_relative './use_cases/non_html_selector_blocks/script_conversion_use_case'
+
+module HtmlToHaml
+  class Converter
+    def initialize(html)
+      @html = html
+    end
+
+    def convert
+      whitespace_free_html = remove_html_whitespace(html: @html)
+      erb_converted_haml = Erb::BasicConversionUseCase.new(whitespace_free_html).convert
+      haml = NonHtmlSelectorBlocks::StyleConversionUseCase.new(erb_converted_haml).convert
+      haml = NonHtmlSelectorBlocks::ScriptConversionUseCase.new(haml).convert
+      Html::ConversionUseCase.new(haml, remove_whitespace: false).convert
+    end
+
+    private
+
+    def remove_html_whitespace(html:)
+      html.gsub(/#{html_with_important_whitespace}|^\s*|\n/) do |matching_html|
+        case matching_html
+          when /#{html_with_important_whitespace}/
+            initial_indentation = matching_html.gsub("\n", '').match(/^\s*/).to_s
+            matching_html.gsub(/^#{initial_indentation}/, "\n")
+          else
+            ""
+        end
+      end
+    end
+
+    def html_with_important_whitespace
+      important_whitespace_classes.map do |klass|
+        "^\\s*<#{klass::HTML_TAG_NAME}.*?>(.|\n)*?<\/#{klass::HTML_TAG_NAME}>"
+      end.join("|")
+    end
+
+    def important_whitespace_classes
+      [NonHtmlSelectorBlocks::ScriptConversionUseCase,
+      NonHtmlSelectorBlocks::StyleConversionUseCase]
+    end
+  end
+end

data/lib/html_to_haml/helpers/haml_whitespace_cleaner.rb

@@ -0,0 +1,9 @@
+module HtmlToHaml
+  module HamlWhitespaceCleaner
+    private
+
+    def remove_haml_whitespace(haml:)
+      haml.lstrip.gsub(/\n\s*\n/, "\n")
+    end
+  end
+end

data/lib/html_to_haml/html_to_haml.rb

@@ -0,0 +1,16 @@
+module HtmlToHaml
+  INDENTATION_AMOUNT = 2
+
+  class ParseError < RuntimeError
+  end
+
+  module Html
+    class ParseError < HtmlToHaml::ParseError
+    end
+  end
+
+  module Erb
+    class ParseError < HtmlToHaml::ParseError
+    end
+  end
+end

data/lib/html_to_haml/tools/erb/control_flow_matcher.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+
+module HtmlToHaml
+  module Erb
+    class ControlFlowMatcher
+      include Singleton
+
+      CONTROL_FLOW_MIDDLE_OF_LINE_KEYWORDS = ["do"]
+      CONTROL_FLOW_BEGINNING_OF_LINE_KEYWORDS = ["if", "unless"]
+      CONTROL_FLOW_CONTINUE_KEYWORDS = ["elsif", "else", "when"]
+
+      def begin_case_statement?(erb:)
+        matches_keywords_at_beginning_of_line?(erb: erb, keywords: ["case"])
+      end
+
+      def begin_indented_control_flow?(erb:)
+        matches_keywords?(erb: erb, keywords: CONTROL_FLOW_MIDDLE_OF_LINE_KEYWORDS) ||
+            matches_keywords_at_beginning_of_line?(erb: erb, keywords: CONTROL_FLOW_BEGINNING_OF_LINE_KEYWORDS)
+      end
+
+      def continue_indented_control_flow?(erb:)
+        matches_keywords_at_beginning_of_line?(erb: erb, keywords: CONTROL_FLOW_CONTINUE_KEYWORDS)
+      end
+
+      def end_of_block?(erb:)
+        erb_without_strings(erb: erb) =~ /\s*-\send/
+      end
+
+      private
+
+      def matches_keywords_at_beginning_of_line?(erb:, keywords:)
+        erb_without_strings(erb: erb) =~ /\s*(-|=)\s*(#{keywords.join("|")})(\s|$)/
+      end
+
+      def matches_keywords?(erb:, keywords:)
+        erb_without_strings(erb: erb) =~ /\s*(-|=)(.*)\s+(#{keywords.join("|")})(\s|$)/
+      end
+
+      def erb_without_strings(erb:)
+        erb.gsub(/".*?"/, '').gsub(/'.*?'/, '')
+      end
+    end
+  end
+end
+

data/lib/html_to_haml/tools/erb/indentation_tracker.rb

@@ -0,0 +1,37 @@
+module HtmlToHaml
+  module Erb
+    class IndentationTracker
+      attr_accessor :indentation_level
+      attr_reader :indentation_amount, :case_statement_level
+      def initialize(indentation_level:, indentation_amount:)
+        @indentation_level = indentation_level
+        @indentation_amount = indentation_amount
+        @case_statement_level = []
+      end
+
+      def begin_case_statement
+        self.indentation_level += indentation_amount * 2
+        case_statement_level << indentation_level
+      end
+
+      def add_indentation
+        self.indentation_level += indentation_amount
+      end
+
+      def end_block
+        if indentation_level == @case_statement_level.last
+          case_statement_level.pop
+          self.indentation_level -= indentation_amount * 2
+        else
+          self.indentation_level -= indentation_amount
+        end
+      end
+
+      # I may allow people to use this for nested case statements,
+      # but reserve the right to be snarky about it when they do.
+      def nested_case_statement?
+        case_statement_level.length > 1
+      end
+    end
+  end
+end

data/lib/html_to_haml/tools/html/attribute_handler.rb

@@ -0,0 +1,53 @@
+module HtmlToHaml
+  module Html
+    class AttributeHandler
+      HTML_ONLY_ATTRIBUTE_REGEX = /=['"][^#\{]*['"]/
+
+      def initialize
+        @ids = []
+        @classes = []
+        @plain_attributes = []
+      end
+
+      def add_attribute(attr:)
+        if use_id_syntax?(attr: attr)
+          @ids += extract_attribute_value(attr: attr).split(' ')
+        elsif use_class_syntax?(attr: attr)
+          @classes += extract_attribute_value(attr: attr).split(' ')
+        else
+          @plain_attributes << attr.strip.gsub(/=/, ': ')
+        end
+      end
+
+      def attributes_string
+        "#{format_ids}#{format_classes}#{format_attributes}"
+      end
+
+      private
+
+      def use_id_syntax?(attr:)
+        attr =~ /id#{HTML_ONLY_ATTRIBUTE_REGEX}/
+      end
+
+      def use_class_syntax?(attr:)
+        attr =~ /class#{HTML_ONLY_ATTRIBUTE_REGEX}/
+      end
+
+      def extract_attribute_value(attr:)
+        attr.gsub(/.*=['"](.*)['"]/, '\1').strip
+      end
+
+      def format_attributes
+       @plain_attributes.empty? ? '' : "{ #{@plain_attributes.join(', ')} }"
+      end
+
+      def format_ids
+        @ids.empty? ? '' : "##{@ids.join('#')}"
+      end
+
+      def format_classes
+        @classes.empty? ? '' : ".#{@classes.join('.')}"
+      end
+    end
+  end
+end

data/lib/html_to_haml/tools/html/indentation_tracker.rb

@@ -0,0 +1,31 @@
+require_relative '../../html_to_haml'
+
+module HtmlToHaml::Html
+  class IndentationTracker
+    def initialize(indentation_amount:)
+      @indentation_level = 0
+      @inside_self_closing_tag = false
+      @indentation_amount = indentation_amount
+    end
+
+    def start_html_tag
+      @indentation_level += @indentation_amount unless @inside_self_closing_tag
+      @inside_self_closing_tag = false
+    end
+
+    def start_self_closing_tag
+      @inside_self_closing_tag = true
+    end
+
+    def close_html_tag
+      @indentation_level -= @indentation_amount
+      if @indentation_level < 0
+        raise ParseError, 'The html is malformed and is attempting to close an html tag that was never started'
+      end
+    end
+
+    def indentation
+      " " * @indentation_level
+    end
+  end
+end

data/lib/html_to_haml/tools/non_html_selector_blocks/indentation_tracker.rb

@@ -0,0 +1,35 @@
+module HtmlToHaml
+  module NonHtmlSelectorBlocks
+    class IndentationTracker
+      attr_reader :indented, :adjust_whitespace
+
+      def initialize(indented:, adjust_whitespace:)
+        @indented = indented
+        @reset_adjust_whitespace = false
+        @adjust_whitespace = adjust_whitespace
+      end
+
+      def indent
+        return if indented
+        @indented = true
+        @reset_adjust_whitespace = true
+      end
+
+      def outdent
+        return unless indented
+        @indented = false
+        @adjust_whitespace = false
+        @reset_adjust_whitespace = false
+      end
+
+      def adjust_whitespace?(reset_value: adjust_whitespace)
+        if @reset_adjust_whitespace
+          @reset_adjust_whitespace = false
+          @adjust_whitespace = reset_value
+        else
+          @adjust_whitespace
+        end
+      end
+    end
+  end
+end

data/lib/html_to_haml/tools/non_html_selector_blocks/tag_type_matchers.rb

@@ -0,0 +1,35 @@
+module HtmlToHaml
+  module NonHtmlSelectorBlocks
+    module TagTypeMatchers
+      TAG_TYPE_REGEX = "type=('|\")(.*?)('|\")"
+      TAG_TYPE_FROM_REGEX = '\2'
+
+      private
+
+      def opening_tag?(tag:, in_block:)
+        !in_block && tag =~ /#{opening_tag_regex}/
+      end
+
+      def opening_tag_regex
+        "<#{self.class::HTML_TAG_NAME}.*?>"
+      end
+
+      def closing_tag?(tag:, in_block:)
+        in_block && tag =~ /#{closing_tag_regex}/
+      end
+
+      def closing_tag_regex
+        "<\/#{self.class::HTML_TAG_NAME}>"
+      end
+
+      def tag_type(tag:)
+        specified_tag_type(tag: tag) || self.class::DEFAULT_TAG_TYPE
+      end
+
+      def specified_tag_type(tag:)
+        type_match = tag.match(/#{self.class::TAG_TYPE_REGEX}/)
+        type_match && type_match.to_s.gsub(/#{self.class::TAG_TYPE_REGEX}/, self.class::TAG_TYPE_FROM_REGEX).split('/').last
+      end
+    end
+  end
+end

data/lib/html_to_haml/use_cases/erb/basic_conversion_use_case.rb

@@ -0,0 +1,39 @@
+require_relative '../../html_to_haml'
+require_relative '../../helpers/haml_whitespace_cleaner'
+require_relative 'indentation_conversion_use_case'
+
+module HtmlToHaml::Erb
+  class BasicConversionUseCase
+    include HtmlToHaml::HamlWhitespaceCleaner
+
+    def initialize(erb)
+      @erb = erb
+    end
+
+    def convert
+      sanitized_erb = remove_newlines_within_erb_statements(erb: @erb)
+      erb = convert_syntax(erb: sanitized_erb)
+      haml = convert_indentation(erb: erb)
+      remove_haml_whitespace(haml: haml)
+    end
+
+    private
+
+    def remove_newlines_within_erb_statements(erb:)
+      erb.gsub(/<%(.*?)\n(.*?)%>/) do |erb_statement|
+        erb_statement.gsub("\n", " ")
+      end
+    end
+
+    def convert_syntax(erb:)
+      erb.gsub(/\s*?\n?(<%=|<%-|<%)\s?/) do |erb_selector|
+        erb_selector_index = erb_selector =~ /-|=/
+        erb_selector_index ? "\n#{erb_selector[erb_selector_index]} " : "\n- "
+      end.gsub(/\s?(-%>|%>)/, "\n")
+    end
+
+    def convert_indentation(erb:)
+      IndentationConversionUseCase.instance.convert_indentation(erb: erb)
+    end
+  end
+end

data/lib/html_to_haml/use_cases/erb/indentation_conversion_use_case.rb

@@ -0,0 +1,85 @@
+require 'singleton'
+require 'forwardable'
+require_relative '../../html_to_haml'
+require_relative '../../tools/erb/indentation_tracker'
+require_relative '../../tools/erb/control_flow_matcher'
+
+module HtmlToHaml::Erb
+  class IndentationConversionUseCase
+    include Singleton
+    extend ::Forwardable
+
+    SNARKY_COMMENT_FOR_HAVING_NESTED_CASE_STATEMENTS = <<-HAML
+/ It looks like this is the start of a nested case statement
+/ Are you REALLY sure you want or need one? Really?
+/ This converter will convert it for you below, but you should
+/ seriously rethink your code right now.
+    HAML
+
+    def convert_indentation(erb:)
+      indentation_converter = new_indentation_converter
+      erb.split("\n").map do |erb_line|
+        indentation = indentation_for_line_or_error(erb: erb_line, indentation_level: indentation_converter.indentation_level)
+        adjust_indentation_level(erb: erb_line, indentation_converter: indentation_converter)
+        construct_haml_line(erb: erb_line, indentation: indentation, indentation_converter: indentation_converter)
+      end.join
+    end
+
+    private
+
+    def_delegators :control_flow_matcher, :begin_case_statement?,
+                   :begin_indented_control_flow?, :end_of_block?,
+                   :continue_indented_control_flow?
+
+    def adjust_indentation_level(erb:, indentation_converter:)
+      if begin_case_statement?(erb: erb)
+        indentation_converter.begin_case_statement
+      elsif begin_indented_control_flow?(erb: erb)
+        indentation_converter.add_indentation
+      elsif end_of_block?(erb: erb)
+        indentation_converter.end_block
+      end
+    end
+
+    def indentation_for_line_or_error(erb:, indentation_level:)
+      adjusted_indentation_level = adjusted_indentation_level_for_line(erb: erb, indentation_level: indentation_level)
+      if adjusted_indentation_level < 0
+        raise ParseError, 'The erb is malformed. Please make sure you have the correct number of "end" statements'
+      else
+        " " * adjusted_indentation_level
+      end
+    end
+
+    def adjusted_indentation_level_for_line(erb:, indentation_level:)
+      if continue_indented_control_flow?(erb: erb)
+        indentation_level - HtmlToHaml::INDENTATION_AMOUNT
+      else
+        indentation_level
+      end
+    end
+
+    def construct_haml_line(erb:, indentation:, indentation_converter:)
+      indentation_adjusted_haml_line = "#{indentation}"
+      if begin_nested_case_statement?(erb: erb, indentation_converter: indentation_converter)
+        indentation_adjusted_haml_line << nested_case_statement_commentary(indentation: indentation)
+      end
+      indentation_adjusted_haml_line << "#{erb}\n" unless end_of_block?(erb: erb)
+    end
+
+    def begin_nested_case_statement?(erb:, indentation_converter:)
+      begin_case_statement?(erb: erb) && indentation_converter.nested_case_statement?
+    end
+
+    def nested_case_statement_commentary(indentation:)
+      SNARKY_COMMENT_FOR_HAVING_NESTED_CASE_STATEMENTS.gsub("\n", "\n#{indentation}")
+    end
+
+    def new_indentation_converter
+      IndentationTracker.new(indentation_level: 0, indentation_amount: HtmlToHaml::INDENTATION_AMOUNT)
+    end
+
+    def control_flow_matcher
+      ControlFlowMatcher.instance
+    end
+  end
+end

data/lib/html_to_haml/use_cases/html/attribute_conversion_use_case.rb

@@ -0,0 +1,48 @@
+require 'singleton'
+require_relative '../../html_to_haml'
+require_relative '../../tools/html/attribute_handler'
+
+module HtmlToHaml::Html
+  class AttributeConversionUseCase
+    include Singleton
+
+    HAML_TAG_LINES = "^\s*%(.*)$"
+    MULTILINE_ERB_ATTRIBUTES_REGEX = /^\s*%.*[a-zA-Z1-9]+?=('|")[^'"]*\s*\n\s*=.*\n\s*[^'"]*("|')/
+
+    def convert_attributes(html:)
+      erb_converted_html = remove_erb_newlines(html: html)
+      erb_converted_html.gsub(/#{HAML_TAG_LINES}/) do |matched_elem|
+        haml_with_replaced_attributes(haml: matched_elem)
+      end
+    end
+
+    private
+
+    def haml_with_replaced_attributes(haml:)
+      attribute_handler = AttributeHandler.new
+      haml_without_attributes = haml.gsub(/\s*([a-zA-Z1-9]+?)=('|").*?('|")/) do |matched_elem|
+        # This could go into the AttributeHandler, but at the moment this is the only place
+        # that is aware of the erb syntax and that makes the AttributeHandler more isolated.
+        attr = escape_erb_attributes(attr: matched_elem)
+        attribute_handler.add_attribute(attr: attr)
+        ''
+      end
+      "#{haml_without_attributes}#{attribute_handler.attributes_string}"
+    end
+
+    def remove_erb_newlines(html:)
+      # Erb attributes may be malformed to have their own line and a '=' in front
+      # (if the html already went through the erb converter)
+      # This changes them back into something that can be updated above
+      html.gsub(MULTILINE_ERB_ATTRIBUTES_REGEX) do |erb_attr|
+        erb_attr.gsub(/\n\s*(=|.*?'|.*?")/, ' \1')
+      end
+    end
+
+    def escape_erb_attributes(attr:)
+      attr.gsub(/=('|")(.*?)\s*=\s*([^\s]*)(\s*.*)('|")/, '=\1\2 #{\3}\4\5') # put erb text inside #{} globally
+          .gsub(/('|")\s*#\{(.*)\}\s*('|")/, '\2') # Remove strings and #{} around simple erb expressions (with no non-erb)
+          .gsub(/\s('|")$/, '\1')  # Get rid of any extra whitespace.
+    end
+  end
+end

data/lib/html_to_haml/use_cases/html/comment_conversion_use_case.rb

@@ -0,0 +1,34 @@
+require_relative '../../html_to_haml'
+
+module HtmlToHaml::Html
+  class CommentConversionUseCase
+    HTML_COMMENT_REGEX = "<!--(.|\n)*?-->"
+    HTML_USING_HAML_COMMENT_SYNTAX = "^\s*\/"
+
+    def initialize(html)
+      @html = html
+    end
+
+    def convert
+      haml = @html.gsub(/#{HTML_COMMENT_REGEX}|#{HTML_USING_HAML_COMMENT_SYNTAX}/) do |comment|
+        case comment
+          when /#{HTML_COMMENT_REGEX}/
+            "\n/ #{format_html_comment_for_haml(comment: comment)}\n"
+          when /#{HTML_USING_HAML_COMMENT_SYNTAX}/
+            escape_misleading_forward_slash(comment: comment)
+        end
+      end
+      haml.gsub(/\n\s*\n/, "\n")
+    end
+
+    private
+
+    def format_html_comment_for_haml(comment:)
+      comment.gsub(/\n\s*/, "\n/ ")[4..-4].strip
+    end
+
+    def escape_misleading_forward_slash(comment:)
+      comment.gsub(/^(\s*)\//, '\1\/')
+    end
+  end
+end

data/lib/html_to_haml/use_cases/html/conversion_use_case.rb

@@ -0,0 +1,19 @@
+require_relative '../../html_to_haml'
+require_relative './attribute_conversion_use_case'
+require_relative './comment_conversion_use_case'
+require_relative './default_conversion_use_case'
+
+module HtmlToHaml::Html
+  class ConversionUseCase
+    def initialize(html, remove_whitespace: true)
+      @html = html
+      @remove_whitespace = remove_whitespace
+    end
+
+    def convert
+      html_with_haml_comments = CommentConversionUseCase.new(@html).convert
+      haml = DefaultConversionUseCase.new(html_with_haml_comments, remove_whitespace: @remove_whitespace).convert
+      AttributeConversionUseCase.instance.convert_attributes(html: haml)
+    end
+  end
+end

data/lib/html_to_haml/use_cases/html/default_conversion_use_case.rb

@@ -0,0 +1,73 @@
+require_relative '../../html_to_haml'
+require_relative '../../helpers/haml_whitespace_cleaner'
+require_relative '../../tools/html/indentation_tracker'
+
+module HtmlToHaml::Html
+  class DefaultConversionUseCase
+    include HtmlToHaml::HamlWhitespaceCleaner
+
+    HAML_SYMBOL_REGEX = ">\s*(\/|-|=)"
+    ERB_LINE_REGEX = "\n\s*(-|=).*$"
+    CLOSING_HTML_REGEX = "<\/.*?>"
+    # For self-closing html tags that aren't self-closing by default
+    SELF_CLOSING_HTML_REGEX = "\/>"
+    SELF_CLOSING_TAGS = %w(area base br col command embed hr img input keygen link meta param source track wbr)
+
+    def initialize(html, remove_whitespace: true)
+      # Since Haml uses whitespace in a way html doesn't, this starts by stripping
+      # whitespace to start the next gsub with a clean slate. Unless the caller opts
+      # out.
+      @html = if remove_whitespace
+                remove_html_whitespace(html: html)
+              else
+                html
+              end
+    end
+
+    def convert
+      indentation_tracker = IndentationTracker.new(indentation_amount: HtmlToHaml::INDENTATION_AMOUNT)
+      haml = @html.gsub(/#{ERB_LINE_REGEX}|#{CLOSING_HTML_REGEX}|#{SELF_CLOSING_HTML_REGEX}|#{self_closing_tag_regex}|#{HAML_SYMBOL_REGEX}|<|>|\n/) do |matched_elem|
+        adjust_indentation_level(html: matched_elem, indentation_tracker: indentation_tracker)
+        start_of_line = "\n#{indentation_tracker.indentation}"
+        case matched_elem
+          when /#{ERB_LINE_REGEX}/
+            "#{start_of_line}#{matched_elem[1..-1]}"
+          when /#{self_closing_tag_regex}/
+            "#{start_of_line}%#{matched_elem[1..-1]}"
+          when /#{HAML_SYMBOL_REGEX}/
+            "#{start_of_line}#{matched_elem[1..-1].insert(-2, "\\")}"
+          when "<"
+            "#{start_of_line}%"
+          else
+            start_of_line
+        end
+      end
+      remove_haml_whitespace(haml: haml)
+    end
+
+    def self_closing_tag_regex
+      "<#{SELF_CLOSING_TAGS.join('|<')}\\s"
+    end
+
+    private
+
+    def adjust_indentation_level(html:, indentation_tracker:)
+      case html
+        when /#{CLOSING_HTML_REGEX}/
+          indentation_tracker.close_html_tag
+        when /#{self_closing_tag_regex}/
+          indentation_tracker.start_self_closing_tag
+        when ">", /#{HAML_SYMBOL_REGEX}/
+          indentation_tracker.start_html_tag
+      end
+    end
+
+    def remove_html_whitespace(html:)
+      html.gsub(/^\s*/, "").delete("\n")
+    end
+
+    def remove_haml_whitespace(haml:)
+      haml.lstrip.gsub(/(\n\s*)\n\s*%/, '\1%').gsub(/\n\s*\n/, "\n")
+    end
+  end
+end

data/lib/html_to_haml/use_cases/non_html_selector_blocks/basic_conversion_use_case.rb

@@ -0,0 +1,74 @@
+require_relative '../../html_to_haml'
+require_relative '../../helpers/haml_whitespace_cleaner'
+require_relative '../../tools/non_html_selector_blocks/indentation_tracker'
+require_relative '../../tools/non_html_selector_blocks/tag_type_matchers'
+
+module HtmlToHaml
+  module NonHtmlSelectorBlocks
+    class BasicConversionUseCase
+      include HtmlToHaml::HamlWhitespaceCleaner
+      include TagTypeMatchers
+
+      RUBY_HAML_REGEX = "\n\s*=.*\n"
+
+      def initialize(special_html)
+        @special_html = special_html
+      end
+
+      def convert
+        indentation_tracker = IndentationTracker.new(indented: false, adjust_whitespace: false)
+        haml = @special_html.gsub(/#{opening_tag_regex}|#{closing_tag_regex}|#{RUBY_HAML_REGEX}|(\n\s*)/) do |tag|
+          replace_tag_value(tag: tag, indentation_tracker: indentation_tracker)
+        end
+        remove_haml_whitespace(haml: haml)
+      end
+
+      private
+
+      def replace_tag_value(tag:, indentation_tracker:)
+        if opening_tag?(tag: tag, in_block: indentation_tracker.indented)
+          open_tag(tag: tag, indentation_tracker: indentation_tracker)
+        elsif closing_tag?(tag: tag, in_block: indentation_tracker.indented)
+          close_tag(indentation_tracker: indentation_tracker)
+        elsif use_string_interpolation?(tag: tag, in_block: indentation_tracker.indented)
+          string_interpolated_ruby(tag: tag)
+        elsif adjust_whitespace?(tag: tag, indentation_tracker: indentation_tracker)
+          "#{tag}#{indentation}"
+        else
+          tag
+        end
+      end
+
+      def open_tag(tag:, indentation_tracker:)
+        indentation_tracker.indent
+        opening_tag(tag: tag)
+      end
+
+      def opening_tag(tag:)
+        ":#{tag_type(tag: tag)}\n#{indentation}"
+      end
+
+      def close_tag(indentation_tracker:)
+        indentation_tracker.outdent
+        "\n"
+      end
+
+      def use_string_interpolation?(tag:, in_block:)
+        in_block && tag =~ /#{RUBY_HAML_REGEX}/
+      end
+
+      def string_interpolated_ruby(tag:)
+        "\#{#{tag.strip[1..-1].strip}}"
+      end
+
+      def adjust_whitespace?(indentation_tracker:, tag:)
+        tag_indented = tag.include?(indentation)
+        tag =~ /\n/ && indentation_tracker.adjust_whitespace?(reset_value: !tag_indented)
+      end
+
+      def indentation
+        " " * HtmlToHaml::INDENTATION_AMOUNT
+      end
+    end
+  end
+end

data/lib/html_to_haml/use_cases/non_html_selector_blocks/script_conversion_use_case.rb

@@ -0,0 +1,16 @@
+require_relative 'basic_conversion_use_case'
+
+module HtmlToHaml
+  module NonHtmlSelectorBlocks
+    class ScriptConversionUseCase < BasicConversionUseCase
+      HTML_TAG_NAME = "script"
+      DEFAULT_TAG_TYPE = "javascript"
+
+      private
+
+      def opening_tag?(tag:, in_block:)
+        super && tag !~ (/\ssrc=['"]/)
+      end
+    end
+  end
+end

data/lib/html_to_haml/use_cases/non_html_selector_blocks/style_conversion_use_case.rb

@@ -0,0 +1,10 @@
+require_relative 'basic_conversion_use_case'
+
+module HtmlToHaml
+  module NonHtmlSelectorBlocks
+    class StyleConversionUseCase < BasicConversionUseCase
+      HTML_TAG_NAME = "style"
+      DEFAULT_TAG_TYPE = "css"
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: html-to-haml
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Natasha Hull-Richter
+autorequire: html_to_haml/converter.rb
+bindir: bin
+cert_chain: []
+date: 2016-05-06 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  This app takes in html and erb code and turns it into haml. It supports script and style tags
+                     and html comments as well.
+email: nhull-richter@pivotal.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/html_to_haml/converter.rb
+- lib/html_to_haml/helpers/haml_whitespace_cleaner.rb
+- lib/html_to_haml/html_to_haml.rb
+- lib/html_to_haml/tools/erb/control_flow_matcher.rb
+- lib/html_to_haml/tools/erb/indentation_tracker.rb
+- lib/html_to_haml/tools/html/attribute_handler.rb
+- lib/html_to_haml/tools/html/indentation_tracker.rb
+- lib/html_to_haml/tools/non_html_selector_blocks/indentation_tracker.rb
+- lib/html_to_haml/tools/non_html_selector_blocks/tag_type_matchers.rb
+- lib/html_to_haml/use_cases/erb/basic_conversion_use_case.rb
+- lib/html_to_haml/use_cases/erb/indentation_conversion_use_case.rb
+- lib/html_to_haml/use_cases/html/attribute_conversion_use_case.rb
+- lib/html_to_haml/use_cases/html/comment_conversion_use_case.rb
+- lib/html_to_haml/use_cases/html/conversion_use_case.rb
+- lib/html_to_haml/use_cases/html/default_conversion_use_case.rb
+- lib/html_to_haml/use_cases/non_html_selector_blocks/basic_conversion_use_case.rb
+- lib/html_to_haml/use_cases/non_html_selector_blocks/script_conversion_use_case.rb
+- lib/html_to_haml/use_cases/non_html_selector_blocks/style_conversion_use_case.rb
+homepage: https://github.com/NatashaHull/html-to-haml.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A program that turns html.erb code into haml code.
+test_files: []