hum 0.0.1 → 0.0.2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
 ## 0.0.1
 
-* Initial release
+* Initial release
+
+## 0.0.2
+
+* Added support for .sass and .scss files, added more tests

data/README.md

@@ -1,35 +1,76 @@
 # Hum
 
-Hum generates HTML from your SASS or CSS.
+Hum generates HTML from your SASS, SCSS or CSS.
 
 `gem install hum`
 
-Here's an example of what he can do:
+## SASS to HTML
 
-    #He'll eat this CSS
-    .foo{
-      border-width: 1px;
-    }
-    .foo .bar{
-      font-size: 12px;
-    }
-    .foo .bar p{
-      color: black;
-    }
+`hum [stylesheet].sass`
+
+		#He'll eat this SASS
+		.foo
+			color: white
+			.bar
+				color: black
+				.baz
+					color: red
 
     #And crap out this HTML
-    <div class="foo">
-      <div class="bar">
-        <p></p>
-      </div>
-    </div>
+		<div class="foo">
+			<div class="bar">
+				<div class="baz"></div>
+			</div>
+		</div>
+
+## SCSS to HTML
+
+`hum [stylesheet].scss`
+
+		#He'll eat this SCSS
+		.foo {
+			color: white;
+			.bar {
+				color: black;
+				.baz {
+					color: red;
+				}
+			}
+		}
 
-To do that run
+		#And crap out this HTML
+		<div class="foo">
+			<div class="bar">
+				<div class="baz"></div>
+			</div>
+		</div>
+
+## CSS to HTML
 
 `hum [stylesheet].css`
 
-You can also watch a directory for changes by using
+		#He'll eat this CSS
+		.foo{
+			border-width: 1px;
+		}
+		.foo .bar{
+			font-size: 12px;
+		}
+		.foo .bar p{
+			color: black;
+		}
+
+		#And crap out this HTML
+		<div class="foo">
+			<div class="bar">
+				<div class="baz"></div>
+			</div>
+		</div>
+
+You can also watch a directory for changes to your SASS and SCSS files by using
 
 `hum --watch`
 
-He can't generate HTML from SASS directly yet, so you must specify a CSS file.
+## Notes
+
+Just so you know, hum doesn't work well with mixins that include selectors yet.

data/hum.gemspec

@@ -18,7 +18,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'sass'
-  s.add_dependency 'haml'
-  s.add_dependency 'fssm'
+  s.add_dependency 'sass', '>= 3.1.12'
+  s.add_dependency 'haml', '>= 3.1.4'
+  s.add_dependency 'fssm', '>= 0.2.7'
+  s.add_dependency 'colored', '>= 1.2'
 end

data/lib/hum/array.rb

@@ -28,34 +28,57 @@ class Array
       found = self.find_line(line_number)
     end
 
-    #return the right parent
-    found
+    #return the right parent line
+    found[:line]
   end
   
-  #find the children from a line to a hash
-  def find_all_kids(line, to_line, kids = [])
+  def find_kids(hash, kids = [])
+    
+    #get the next line number
+    next_line = hash[:line] + 1
+    
+    #find the next one
+    found = self.find_line(next_line)
+    
+    until found.nil? or hash[:tab] == found[:tab]
       
-    #find the parent
-    parent = self.find_line(line)
+      #collect it
+      kids << found[:line]
+      
+      #increment
+      next_line += 1
+      
+      #find the next one
+      found = self.find_line(next_line)
+    end
     
-    #target the line number
-    line_number = line + 1
+    #return all kids
+    kids
+  end
+  
+  def find_extra_kids(hash, kids = [])
     
-    #find the first found
-    found = self.find_line(line_number)
+    #find the parent
+    parent = self.find_line(hash[:parent])
     
-    until found.nil? or line_number == to_line or parent[:tab] == found[:tab]
-      #add the line to the array
-      kids << found
+    #target the next line
+    next_line = hash[:parent] + 1
+
+    #find the next line
+    found = self.find_line(next_line)
+    
+    until found.nil? or next_line == hash[:line] or parent[:tab] == found[:tab]
       
-      #increment the line number
-      line_number += 1
+      #collect it
+      kids << found[:line]
       
-      #find the new found
-      found = self.find_line(line_number)
+      #increment
+      next_line += 1
+      
+      #find the next one
+      found = self.find_line(next_line)
     end
     
-    #return the kids
     kids
   end
 end

data/lib/hum/engine.rb

@@ -1,9 +1,13 @@
 require 'rubygems'
 require 'haml'
 require 'sass'
+require 'sass/exec'
 require 'sass/css'
 require 'hum/string'
 require 'hum/array'
+require 'colored'
+require 'optparse'
+require 'fileutils'
 
 module Hum
   #Hum
@@ -17,25 +21,43 @@ module Hum
         #the array that holds the parsed CSS
         @tree = []
         
+        @input_path = file
+        
         #the name of the input file
         @input_name = File.basename(file)
         
         #read the input file
         @input_file = File.open(file, 'r')
         
+        @directory = File.dirname(file)
+        
         #the output path
         @output_path = File.absolute_path(file).gsub(/\..*/, ".html")
         
         #the name of the output file
         @output_name = File.basename(@output_path)
+      end
+      
+      def run
+        run_haml
         
         #create the output file
         @output_file = File.open(@output_path, "w")
+        
+        #output the html
+        @output_file.write(output_html)
+        
+        #close the input file
+        @input_file.close()
+        
+        #close the output file
+        @output_file.close()
+        
+        puts "updated #{@output_name}!".green
       end
       
-      #runs through all the commands
-      def run
-        #renders SASS from CSS
+      def run_haml
+        #render SASS from CSS
         render_sass
         
         #remove property value pairs
@@ -49,84 +71,101 @@ module Hum
         
         #generate HAML
         output_haml
-        
-        #output the html
-        @output_file.write(output_html)
-        
-        #close the input file
-        @input_file.close()
-        
-        #close the output file
-        @output_file.close()
-
-        puts "updated #{@output_name}!\n"
       end
       
       def render_sass
-        return _render_sass
-      end
-      
-      def clean_sass
-        return _clean_sass
-      end
-      
-      def build_hashes
-        return _build_hashes
-      end
-      
-      def render_haml_tags
-        return _render_haml_tags
-      end
-      
-      def output_haml
-        return _output_haml
-      end
-      
-      def output_html
-        return _output_html
-      end
-      
-
-      private
-      
-      
-      def _render_sass
-        
-        #if input file is scss, output CSS and convert to SASS
-        #if input file is sass, output CSS and continue
-        #if input file is CSS, do below
-        
-        #convert to SASS
+        #read content
         content = @input_file.read
+
         #remove all comments
         content.gsub!(/\/\*([\s\S]*?)\*\//, "")
-        #render sass
-        @sass = Sass::CSS.new(content).render(:sass)
+
+        #if CSS render SASS
+        if @input_name.match(/\.css/)
+          @sass = Sass::CSS.new(content).render(:sass)
+
+        #if SCSS convert to SASS
+        elsif @input_name.match(/\.scss/)
+          @sass = ::Sass::Engine.new(content, { :cache => false, :read_cache => true, :syntax => :scss }).to_tree.send("to_sass")
+
+        #if sass keep as it
+        elsif @input_name.match(/\.sass/)
+          @sass = content
+
+        #if nothing then put error
+        else
+          puts "Hum only works with .scss, .sass and .css files.".red
+          exit 1
+        end
       end
       
-      def _clean_sass
+      def clean_sass
         #remove all property: value; pairs
         @sass.gsub!((/.*: .*/), "")
+        
         #remove duplicate new lines
         @sass.gsub!((/\n+/), "\n")
       end
       
-      def _build_hashes
+      def build_hashes
+        
         i = 1
+        
         #parse into an array of hashes
         @sass.each do |code| 
           hash = { 
             :line =>    i, 
             :select =>  _grab_select(code), 
-            :tab =>     _grab_tab(code) 
+            :tab =>     _grab_tab(code),
+            :parent =>   nil,
+            :kids =>    []
           }
           @tree << hash
           i += 1
         end
+        
+        #mark all parent selectors
         _check_for_parents
+        
+        #collect all kids
+        _collect_kids
+        
+        #process all tags of parent selectors
+        _process_parents
+        
+        #process all tabs
+        _process_tabs
+        
         @tree
       end
       
+      def render_haml_tags
+        #in each line
+        @tree.each do |hash|
+          hash[:haml] = []
+          
+          #for each selector
+          hash[:select].each do |tag|
+            
+            #convert the tag to a HAML tag
+            hash[:haml].push(_grab_haml_tag(tag))
+          end         
+        end
+        @tree
+      end
+      
+      def output_haml
+        return _output_haml
+      end
+      
+      def output_html
+        #convert HAML to HAML
+        @html = Haml::Engine.new(@haml).render
+        @html
+      end
+
+      private
+      
       def _check_for_parents
         #in each line
         @tree.each do |hash|
@@ -138,88 +177,76 @@ module Hum
             if code.match("&")
               
               #find the parent
-              hash[:parent] = @tree.find_parent(hash)[:line]
-              
-              #find all the kids
-              _check_for_kids(hash)
+              hash[:parent] = @tree.find_parent(hash)
               
             end
-          }#end of hash[:select]
-          
-        end #end of @tree.each
-        
-        _process_parents_and_kids
-     
+          }
+        end
       end
       
-      def _process_parents_and_kids
-        
-        #look for all parents & kids and modify them
+      def _collect_kids
+        #in each line
         @tree.each do |hash|
           
-          #if the hash has a parent
-          if hash[:parent]
+          #if hash has a parent
+          if !hash[:parent].nil?
+            
+            #find all the kids
+            hash[:kids] = @tree.find_kids(hash)
+          end
+          
+        end
+      end
+
+      def _process_parents
+        #in each line
+        @tree.each { |hash|
+          
+          #if the hash has a parent          
+          if !hash[:parent].nil?
             
-            #find the parent
+            #find it
             parent = @tree.find_line(hash[:parent])
             
-            #if the selector array is only one
             if parent[:select].length == 1
               
-              #replace the & with the parent selector
-              hash[:select].each do |elm|
+              #and replace the &
+              hash[:select].each { |elm|
                 elm.gsub!("&", parent[:select].first)
-              end
+              }
               
-              #update the tab to the parent tab
-              hash[:tab] = parent[:tab]
             end
             
-            #if this hash has any kids
-            if hash[:kids]
+          end 
+        }
+      end
+
+      def _process_tabs
+        #in each line
+        @tree.each { |hash|
+          
+          #if there is a parent
+          if !hash[:parent].nil?
+            
+            #reduce tab by 1
+            hash[:tab] -= 1
+            
+            #if there are kids
+            if !hash[:kids].empty?
               
-              #loop through each kid
-              hash[:kids].each do |kid|
+              #for each kid
+              hash[:kids].each { |kid|
                 
-                #find the kid
+                #find it
                 child = @tree.find_line(kid)
                 
-                #and decrease the tab by one
+                #and reduce it by one
                 child[:tab] -= 1
-              end
+                
+              }
             end
-            
           end
-        end
-        
-      end
-      
-      def _check_for_kids(of_this_hash)
-        
-        #target the line number
-        line_number = of_this_hash[:line] + 1
-
-        #find the line
-        found = @tree.find_line(line_number)
-        
-        #finds the children
-        until found.nil? or found[:tab] <= of_this_hash[:tab]
-          
-          #only create a kids hash if there are kids
-          if of_this_hash[:kids].nil?
-            of_this_hash[:kids] = []
-          end
-           
-          #add the line to the kids array
-          of_this_hash[:kids] << found[:line]
-          
-          #go up the tree
-          line_number += 1
-
-          #find the line
-          found = @tree.find_line(line_number)
-        end
-        
+        }
       end
       
       def _grab_select(code)
@@ -241,16 +268,6 @@ module Hum
         end
       end
       
-      def _render_haml_tags
-        @tree.each do |code|
-          code[:haml] = []
-          code[:select].each do |tag|
-            code[:haml].push(_grab_haml_tag(tag))
-          end         
-        end
-        @tree
-      end
-      
       def _grab_haml_tag(code)
         #give all classes that start with . or # a DIV element
         if code.match(/^\./) or code.match(/^\#/)
@@ -259,105 +276,115 @@ module Hum
           tag = "%" + code
         end
         
-        #give all descending tags a %
+        #give all descending tags a %, there's probably a better way to do this
         if tag.match(" ")
           tag = tag.gsub(" ", " %")
         end
+        
+        if tag.match("%.")
+          tag = tag.gsub("%.", "%div.")
+        end
+        
+        if tag.match("%#")
+          tag = tag.gsub("%#", "%div#")
+        end
+        
         tag
       end
       
       #Output the HAML
       def _output_haml
+        
         #convert to HAML
         @haml = "%html\n"
         @haml += "\t%head\n"
-        @haml += "\t\t%link{:type => 'text/css', :rel => 'stylesheet', :href => '#{@input_name}'}\n"
-        #@haml += "\t\t:javascript\n"
-        #@haml += "\t\t\tsetTimeout(function(){ parent.location.reload(true); }, 3000)\n"
+        @haml += "\t\t%link{:type => 'text/css', :rel => 'stylesheet', :href => '#{@input_name.gsub(/\..*/, ".css")}'}\n"
         @haml += "\t%body\n"
+        
+        #time to build the HAML
         @tree.each do |hash| 
+          extra = []
           
-          #empty the kids
-          kids = []
-          tabs = "\t\t"
-          
-          #set the base tab
-          if hash[:tab] > 0
-            tabs += "\t" * hash[:tab]
-          end
-          
-          #if this code was generated from a parent, find the kids
+          #if there's a parent, find the extra kids
           if !hash[:parent].nil?
-            kids = @tree.find_all_kids(hash[:parent], hash[:line])
+            extra = @tree.find_extra_kids(hash)
           end
           
+          #for each generate the HAML line
           hash[:haml].each { |haml_tag| 
             
-            @haml += _generate_haml_line(tabs, haml_tag, hash)
+            #if no extra, just normal
+            if extra.empty?  
+              @haml += _generate_haml_line(haml_tag, hash)
             
-            #if there were kids
-            if kids.length != 0
-              kids.each { |hash|
+            #else extra
+            else  
               
-                #reset the base tab
-                tabs = "\t\t"
-
-                #set the base tab
-                tabs += "\t" * hash[:tab]
-            
-                hash[:haml].each do |haml_tag|
-                  #generate the HAML
-                  @haml += _generate_haml_line(tabs, haml_tag, hash)
-                end
+              #this hash has extra kids
+              hash[:extra] = true
+              
+              @haml += _generate_haml_line(haml_tag, hash)
+              
+              #for each kid
+              extra.each { |line|
                 
+                #get the hash
+                extra_hash = @tree.find_line(line)
+                
+                #for each generate the HAML line
+                extra_hash[:haml].each do |haml_tag|
+                  
+                  #do it
+                  @haml += _generate_haml_line(haml_tag, extra_hash)
+                end
               }
             end
+
           }
         end
         @haml
       end
       
-      def _generate_haml_line(tabs, element, hash, haml = "")
+      def _generate_haml_line(element, hash, haml = "")
 
         #handle a string of descending selectors
         if element.match(" ")
+          
+          tabs = "\t\t" + "\t" * hash[:tab]
+          count = 0
 
-          #so we can give the right indent
-          tabs = "\t"
-          add_tab = 0
-
-          #collect the descending selectors
+          #collect all tags
           nests = element.split(" ")
 
-          #loop through them and generate the HAML
+          #for each tag
           nests.each do |nest| 
             
-            tabs += "\t"
+            if count != 0
+              tabs += "\t"
+            end
 
-            #if this is the last descending selector, add content
-            if add_tab == nests.length - 1
+            #if this is the last one, check for content
+            if count == nests.length - 1
               haml += tabs + nest + _grab_content(hash) 
 
-            #add a new line
+            #else add a new line
             else
               haml += tabs + nest + "\n"
             end
 
-            add_tab += 1
+            count += 1
           end
 
         #otherwise per normal
         else
           
-          #if the hash is from a parent
-          if !hash[:parent].nil?
-            tabs = "\t\t" + "\t" * @tree.find_line(hash[:parent])[:tab]
-          end
+          #make tabs
+          tabs = "\t\t" + "\t" * hash[:tab]
           
+          #make HAML
           haml += tabs + element + _grab_content(hash) 
         end
-        
-        #returns HAML
+
         haml
       end
       
@@ -367,35 +394,23 @@ module Hum
         #find the next hash
         next_hash = @tree.find_line(hash[:line] + 1)
         
-        #pick the content
-        if !next_hash.nil? && next_hash[:tab] > hash[:tab]
+        #if it has kids, add a new line
+        if !next_hash.nil? and next_hash[:tab] > hash[:tab]
           found = "\n"
+        
+        #else put in content
         else
           found = " Inner content\n"
         end
-     
-        #if the hash has a parent
-        if !hash[:parent].nil?
-          
-          #find the kids
-          kids = @tree.find_all_kids(hash[:parent], hash[:line])
-          
-          #if there are no kids
-          if !kids.empty?
-            found = "\n"
-          end
-          
+        
+        #if kids, it's a new line
+        if hash[:kids].length > 0 or hash[:extra] == true
+          found = "\n"          
         end
         
         found
-        
       end
       
-      def _output_html
-        #convert HAML to HAML
-        @html = Haml::Engine.new(@haml).render
-        @html
-      end
   end
   
 end