html_mockup 0.4.0 → 0.5.0

data/lib/html_mockup/cli.rb

@@ -6,29 +6,32 @@ require 'fileutils'
 include FileUtils
 
 require File.dirname(__FILE__) + "/template"
+require File.dirname(__FILE__) + "/project"
 require File.dirname(__FILE__) + "/w3c_validator"
 
 module HtmlMockup
   class Cli < Thor
     desc "serve [directory]","Serve directory as HTML, defaults to current directory"
     method_options :port => :string, # Defaults to 9000
-                   :partial_path => :string, # Defaults to [directory]/../partials
-                   :validate => :boolean, # Automatically validate all HTML responses @ the w3c
+                   :html_path => :string, # The document root, defaults to "[directory]/html"
+                   :partial_path => :string, # Defaults to [directory]/partials
                    :handler => :string # The handler to use (defaults to mongrel)
-    def serve(path=".")
-      require File.dirname(__FILE__) + '/server'
+    def serve(path=".")      
+      # Load the project, it should take care of all the paths
+      @project = initialize_project(path, options)
       
-      @path,@partial_path = template_paths(path,options["partial_path"])
+      server = @project.server
       
-      server_options = {}
-      server_options[:Port] = options["port"] || "9000"
-            
-      server = Server.new(@path,@partial_path,options,server_options)
-          
-      puts "Running HtmlMockup with #{server.handler.inspect} on port #{server_options[:Port]}"
-      puts "  Taking partials from #{@partial_path} (#{HtmlMockup::Template.partial_files(@partial_path).size} found)"
+      puts "Running HtmlMockup with #{server.handler.inspect} on port #{server.port}"
+      puts banner(@project) 
       
-      server.run
+      server.run!
+    end
+    
+    desc "release [directory]", "Create a release for the project"
+    def release(path=".")
+      project = initialize_project(path, options)
+      project.release.run!
     end
     
     desc "validate [directory/file]", "Validates the file or all HTML in directory"
@@ -84,72 +87,35 @@ module HtmlMockup
       end
     end
     
-    desc "convert [directory]","Inject all partials, into all HTML files within directory"
-    method_options :partial_path => :string, # Defaults to [directory]/../partials
-                   :filter => :string # What files should be converted defaults to **/*.html
-    def convert(path=".")
-      path,partial_path = template_paths(path,options["partial_path"])
-      filter = options["filter"] || "**/*.html"      
-      puts "Converting #{filter} in #{path}"
-      puts "  Taking partials from #{partial_path} (#{HtmlMockup::Template.partial_files(partial_path).size} found)"
-      
-      if path.directory?
-      	Dir.glob("#{path}/#{filter}").each do |file|
-      		puts "  Converting file: " + file
-          HtmlMockup::Template.open(file, :partial_path => partial_path).save
-      	end
-      else
-        HtmlMockup::Template.open(path, :partial_path => partial_path).save
-      end	
-      
-    end
-    
     desc "extract [source_path] [target_path]", "Extract a fully relative html mockup into target_path. It will expand all absolute href's, src's and action's into relative links if they are absolute"
-    method_options :partial_path => :string, # Defaults to [directory]/../partials
+    method_options :partial_path => :string, # Defaults to [directory]/partials
                    :filter => :string # What files should be converted defaults to **/*.html
-    def extract(source_path=".",target_path="../out")
-      require 'hpricot'
-      source_path,target_path = Pathname.new(source_path),Pathname.new(target_path)
-      source_path,partial_path = template_paths(source_path,options["partial_path"])
-      filter = options["filter"] || "**/*.html"
-      raise "Target #{target_path} already exists, please choose a new directory to extract into" if target_path.exist?
-      
-      mkdir_p(target_path)
-      target_path = target_path.realpath
-      
-      # Copy source to target first, we'll overwrite the templates later on.
-      cp_r(source_path.children,target_path)
-      
-      Dir.chdir(source_path) do
-        Dir.glob(filter).each do |file_name|
-          source = HtmlMockup::Template.open(file_name, :partial_path => partial_path).render
-          cur_dir = Pathname.new(file_name).dirname
-          up_to_root = File.join([".."] * (file_name.split("/").size - 1))
-          doc = Hpricot(source)
-          %w{src href action}.each do |attribute|
-            (doc/"*[@#{attribute}]").each do |tag|
-              next unless tag[attribute] =~ /\A\//
-              if true_file = resolve_path(cur_dir + up_to_root + tag[attribute].sub(/\A\//,""))
-                tag[attribute] = true_file.relative_path_from(cur_dir).to_s
-              else
-                puts "Could not resolve link #{tag[attribute]} in #{file_name}"
-              end
-            end
-          end
-
-          File.open(target_path + file_name,"w"){|f| f.write(doc.to_original_html) }
-        end
-      end      
+    def extract(source_path=".", target_path="../out")
+      project = initialize_project(source_path)
+      extractor = HtmlMockup::Extractor.new(project, target_path)
+      puts "Extracting mockup"
+      puts banner(project)
+      extractor.run!
     end
     
     protected
     
-    def template_paths(path,partial_path=nil)
-      path = Pathname.new(path)
-      partial_path = partial_path && Pathname.new(partial_path) || (path + "../partials/").realpath
-      [path,partial_path]
+    def banner(project)
+      puts "  Html: \"#{project.html_path}\""
+      puts "  Partials: \"#{project.partial_path}\" (#{HtmlMockup::Template.partial_files(project.partial_path).size} found)"      
     end
     
+    # TODO: handle options
+    def initialize_project(path, options={})
+      
+      if((Pathname.new(path) + "../partials").exist?)
+        puts "[ERROR]: Don't use the \"html\" path, use the project base path instead"
+        exit(1)
+      end
+      
+      Project.new(path)
+    end
+
     def w3cvalidate(file)
       validator = W3CValidator.new(File.read(file))
       validator.validate!  
@@ -160,19 +126,6 @@ module HtmlMockup
       validator.valid
     end
     
-    def resolve_path(path)
-      path = Pathname.new(path) unless path.kind_of?(Pathname)
-      # Append index.html/index.htm/index.rhtml if it's a diretory
-      if path.directory?
-        search_files = %w{.html .htm}.map!{|p| path + "index#{p}" }
-      # If it ends with a slash or does not contain a . and it's not a directory
-      # try to add .html/.htm/.rhtml to see if that exists.
-      elsif (path.to_s =~ /\/$/) || (path.to_s =~ /^[^.]+$/)
-        search_files = [path.to_s + ".html", path.to_s + ".htm"].map!{|p| Pathname.new(p) }
-      else
-        search_files = [path]
-      end
-      search_files.find{|p| p.exist? }  
-    end    
+ 
   end
 end

data/lib/html_mockup/extractor.rb

@@ -0,0 +1,100 @@
+require 'hpricot'
+
+module HtmlMockup
+  class Extractor
+    
+    attr_reader :project, :target_path
+    
+    def initialize(project, target_path)
+      @project = project
+      @target_path = Pathname.new(target_path)
+    end
+    
+    def run!
+      target_path = self.target_path
+      source_path, partial_path = self.project.html_path, self.project.partial_path
+      
+      
+      filter = "**/*.html"
+      raise ArgumentError, "Target #{target_path} already exists, please choose a new directory to extract into" if target_path.exist?
+      
+      mkdir_p(target_path)
+      target_path = target_path.realpath
+      
+      # Copy source to target first, we'll overwrite the templates later on.
+      cp_r(source_path.children, target_path)
+      
+      Dir.chdir(source_path) do
+        Dir.glob(filter).each do |file_name|
+          source = HtmlMockup::Template.open(file_name, :partial_path => partial_path).render
+          cur_dir = Pathname.new(file_name).dirname
+          up_to_root = File.join([".."] * (file_name.split("/").size - 1))
+          doc = Hpricot(source)
+          %w{src href action}.each do |attribute|
+            (doc/"*[@#{attribute}]").each do |tag|
+              converted_url = convert_relative_url_to_absolute_url(tag[attribute], cur_dir,  up_to_root)
+              
+              case converted_url
+              when String
+                tag[attribute] = converted_url
+              when nil
+                puts "Could not resolve link #{tag[attribute]} in #{file_name}"
+              end
+            end
+          end
+
+          File.open(target_path + file_name,"w"){|f| f.write(doc.to_original_html) }
+        end
+      end           
+    end
+
+    
+    protected
+    
+    # @return [false, nil, String] False if it can't be converted, nil if it can't be resolved and the converted string if it can be resolved.
+    def convert_relative_url_to_absolute_url(url, cur_dir, up_to_root)
+      # Skip if the url doesn't start with a / (but not with //)
+      return false unless url =~ /\A\/[^\/]/
+              
+      # Strip off anchors
+      anchor = nil
+      url.gsub!(/(#.+)\Z/) do |r|
+        anchor = r
+        ""
+      end
+              
+      # Strip off query strings
+      query = nil
+      url.gsub!(/(\?.+)\Z/) do |r|
+        query = r
+        ""
+      end
+              
+      if true_file = resolve_path(cur_dir + up_to_root + url.sub(/\A\//,""))
+        url = true_file.relative_path_from(cur_dir).to_s
+        url += query if query
+        url += anchor if anchor
+        url
+      else
+        nil
+      end
+      
+    end
+    
+    def resolve_path(path)
+      path = Pathname.new(path) unless path.kind_of?(Pathname)
+      # Append index.html/index.htm/index.rhtml if it's a diretory
+      if path.directory?
+        search_files = %w{.html .htm}.map!{|p| path + "index#{p}" }
+      # If it ends with a slash or does not contain a . and it's not a directory
+      # try to add .html/.htm to see if that exists.
+      elsif (path.to_s =~ /\/$/) || (path.to_s =~ /^[^.]+$/)
+        search_files = [path.to_s + ".html", path.to_s + ".htm"].map!{|p| Pathname.new(p) }
+      else
+        search_files = [path]
+      end
+      search_files.find{|p| p.exist? }  
+    end   
+        
+  end
+end

data/lib/html_mockup/mockupfile.rb

@@ -0,0 +1,63 @@
+module HtmlMockup
+  # Loader for mockupfile
+  class Mockupfile
+    
+    # This is the context for the mockupfile evaluation. It should be empty except for the
+    # #mockup method.
+    class Context
+      
+      def initialize(mockupfile)
+        @_mockupfile = mockupfile
+      end
+      
+      def mockup
+        @_mockupfile
+      end
+      
+      def binding
+        ::Kernel.binding
+      end
+      
+    end
+    
+    # @attr :path [Pathname] The path of the Mockupfile for this project
+    attr_accessor :path, :project
+        
+    def initialize(project)
+      @project = project
+      @path = Pathname.new(project.path + "Mockupfile")
+    end
+
+    # Actually load the mockupfile
+    def load
+      if File.exist?(@path) && !self.loaded?
+        @source = File.read(@path)
+        context = Context.new(self)
+        eval @source, context.binding
+        @loaded = true
+      end      
+    end
+    
+    # Wether or not the Mockupfile has been loaded
+    def loaded?
+      @loaded
+    end
+    
+    def release
+      if block_given?
+        yield(self.project.release)
+      end
+      self.project.release      
+    end
+    
+    def serve
+      if block_given?
+        yield(self.project.server)
+      end
+      self.project.server      
+    end
+    
+    alias :server :serve
+    
+  end
+end

data/lib/html_mockup/project.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/release"
+require File.dirname(__FILE__) + "/server"
+require File.dirname(__FILE__) + "/mockupfile"
+
+module HtmlMockup
+  # Loader for mockupfile
+  class Project
+    
+    # @attr :path [Pathname] The project path
+    # @attr :html_path [Pathname] The path of the HTML mockup
+    # @attr :partial_path [Pathname] The path for the partials for this mockup
+    # @attr :mockupfile [Mockupfile] The Mockupfile for this project
+    attr_accessor :path, :html_path, :partial_path, :mockupfile
+    
+    def initialize(path, options={})
+      @path = Pathname.new(path)
+      
+      options = {
+        :html_path => @path + "html",
+        :partial_path => @path + "partials"
+      }.update(options)
+      
+      html_path, partial_path = mockup_paths(options[:html_path], options[:partial_path])
+      @mockupfile = Mockupfile.new(self)
+      @mockupfile.load
+    end
+    
+    def server
+      @server ||= Server.new(self.html_path, self.partial_path)
+    end
+    
+    def release
+      @release ||= Release.new(self)
+    end
+    
+    def html_path=(p)
+      @html_path = Pathname.new(p).realpath
+    end
+    
+    def partial_path=(p)
+      @partial_path = Pathname.new(p).realpath
+    end
+        
+    protected
+    
+    def mockup_paths(html_path, partial_path = nil)
+      html_path = Pathname.new(html_path)
+      partial_path = partial_path && Pathname.new(partial_path) || (html_path + "../partials/")
+      [html_path, partial_path]
+    end
+
+
+  end
+end

data/lib/html_mockup/rack/html_mockup.rb

@@ -14,16 +14,18 @@ module HtmlMockup
       def call(env)
         path = env["PATH_INFO"]
         
-        # Append index.html/index.htm/index.rhtml if it's a diretory
+        # TODO: Combine with Extractor#resolve_path
+        
+        # Append index.html/index.htm if it's a diretory
         if File.directory?(File.join(@docroot,path))
-          search_files = %w{.html .htm .rhtml}.map!{|p| File.join(@docroot,path,"index#{p}")}
-        # If it's already a .html/.htm/.rhtml file, render that file
-        elsif (path =~ /\.r?html?$/)
+          search_files = %w{.html .htm}.map!{|p| File.join(@docroot,path,"index#{p}")}
+        # If it's already a .html/.htm file, render that file
+        elsif (path =~ /\.html?$/)
           search_files = [File.join(@docroot,path)]
         # If it ends with a slash or does not contain a . and it's not a directory
-        # try to add .html/.htm/.rhtml to see if that exists.
+        # try to add .html/.htm to see if that exists.
         elsif (path =~ /\/$/) || (path =~ /^[^.]+$/)
-          search_files = [path + ".html", path + ".htm", path + ".rhtml"].map!{|p| File.join(@docroot,p) }
+          search_files = [path + ".html", path + ".htm"].map!{|p| File.join(@docroot,p) }
         # Otherwise don't render anything at all.
         else
           search_files = []

data/lib/html_mockup/rack/sleep.rb

@@ -0,0 +1,21 @@
+module HtmlMockup
+  module Rack
+    # Listens to the "sleep" parameter and sleeps the amount of seconds specified by the parameter. There is however a maximum of 5 seconds.
+    class Sleep
+  
+      def initialize(app)
+        @app = app
+      end
+  
+      def call(env)
+        r = Rack::Request.new(env)
+        if r.params["sleep"]
+          sleeptime = [r.params["sleep"].to_i, 5].min
+          sleep sleeptime
+        end
+        @app.call(env)
+      end
+  
+    end
+  end
+end

data/lib/html_mockup/release/finalizers/dir.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+# Finalizes the release into a directory in target_path
+# 
+# The directory name will have the format PREFIX-VERSION
+#
+module HtmlMockup::Release::Finalizers
+  class Dir < Base
+    
+    # @option options :prefix Prefix to put before the version (default = "html")
+    def call(release, options = {})
+      name = [(options[:prefix] || "html"), release.scm.version].join("-")
+      
+      release.log(self, "Finalizing release to #{release.target_path + name}")
+      
+      if File.exist?(release.target_path + name)
+        release.log(self, "Removing existing target #{release.target_path + name}")
+        FileUtils.rm_rf(release.target_path + name)
+      end
+      
+      FileUtils.cp_r release.build_path, release.target_path + name
+    end
+  end
+end

data/lib/html_mockup/release/finalizers/zip.rb

@@ -0,0 +1,4 @@
+module HtmlMockup::Release::Finalizers
+  class Zip < Base
+  end
+end

data/lib/html_mockup/release/finalizers.rb

@@ -0,0 +1,11 @@
+module HtmlMockup::Release::Finalizers
+  class Base    
+    def call(release, options = {})
+      raise ArgumentError, "Implement in subclass"
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/finalizers/zip"
+require File.dirname(__FILE__) + "/finalizers/dir"
+

data/lib/html_mockup/release/injector.rb

@@ -0,0 +1,98 @@
+require 'tilt'
+module HtmlMockup
+  
+  # Inject VERSION / DATE (i.e. in TOC)
+  # r.inject({"VERSION" => release.version, "DATE" => release.date}, :into => %w{_doc/toc.html})
+  
+  # Inject CHANGELOG
+  # r.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}}, :into => %w{_doc/changelog.html})  
+  
+  class Release::Injector
+    
+    # @example Simple variable injection (replaces [VARIABLE] into all .css files)
+    #     {"[VARIABLE]" => "replacement"}, :into => %w{**/*.css}
+    #
+    # @example Regex variable injection (replaces all matches into test.js files)
+    #     {/\/\*\s*\[BANNER\]\s*\*\// => "replacement"}, :into => %w{javacripts/test.js}    
+    #
+    # @example Simple variable injection with filtering (replaces [VARIABLE] with :content run through the markdown processor into all .html files)
+    #     {"[VARIABLE]" => {:content => "# header one", :processor => "md"}, :into => %w{**/*.html}
+    #    
+    # @example Full file injection (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG.md" into _doc/changelog.html)
+    #
+    #     {"CHANGELOG" => {:file => "CHANGELOG.md"}}, :into => %w{_doc/changelog.html}
+    #
+    # @example Full file injection with filtering (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG" which ran through Markdown compresser into _doc/changelog.html)
+    #
+    #     {"CHANGELOG" => {:file => "CHANGELOG", :processor => "md"}}, :into => %w{_doc/changelog.html}
+    #
+    # Processors are based on Tilt (https://github.com/rtomayko/tilt). 
+    # Currently supported/tested processors are:
+    #
+    # * 'md' for Markdown (bluecloth)
+    #
+    # Injection files are relative to the :source_path
+    # 
+    # @param [Hash] variables Variables to inject. See example for more info
+    # @option options [Array] :into An array of file globs relative to the build_path
+    def initialize(variables, options)      
+      @variables = variables
+      @into = options[:into]
+    end
+    
+    def call(release)
+      files = release.get_files(@into)
+      
+      files.each do |f|
+        c = File.read(f)
+        injected_vars = []
+        @variables.each do |variable, injection|
+          if c.gsub!(variable, get_content(injection, release))
+            injected_vars << variable
+          end
+        end
+        release.log(self, "Injected variables #{injected_vars.inspect} into #{f}") if injected_vars.size > 0
+        File.open(f,"w") { |fh| fh.write c }
+      end
+      
+    end
+    
+    def get_content(injection, release)
+      case injection
+      when String
+        injection
+      when Hash
+        get_complex_injection(injection, release)
+      else
+        if injection.respond_to?(:to_s)
+          injection.to_s
+        else
+          raise ArgumentError, "Woah, what's this? #{injection.inspect}"
+        end
+      end
+    end
+    
+    def get_complex_injection(injection, release)
+      
+      if injection[:file]
+        content = File.read(release.source_path + injection[:file])
+      else
+        content = injection[:content]
+      end
+      
+      raise ArgumentError, "No :content or :file specified" if !content
+
+      if injection[:processor]
+        if tmpl = Tilt[injection[:processor]]
+          (tmpl.new{ content }).render
+        else
+          raise ArgumentError, "Unknown processor #{injection[:processor]}"
+        end
+      else
+        content
+      end
+      
+    end
+    
+  end
+end

data/lib/html_mockup/release/processors/requirejs.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+module HtmlMockup::Release::Processors
+  class Requirejs < Base
+
+    # @option options [Hash] :build_files An a hash of files to build (as key) and the target directory in the release to put it as value, each one will be built in a separate directory. (default is {"javascripts/site.build.js" => "javascripts"})
+    # @option options [String] :node The system path for node (defaults to "node" in path)
+    # @option options [String] :rjs The system path to the requirejs optimizer (r.js) (defaults to "../vendor/requirejs/r.js" (relative to source_path))
+    def call(release, options={})
+      options = {
+        :build_files => {"javascripts/site.build.js" => "javascripts"},
+        :rjs => release.source_path + "../vendor/requirejs/r.js",
+        :node => "node"
+      }.update(options)
+      
+      begin
+        `#{options[:node]} -v`
+      rescue Errno::ENOENT
+        raise RuntimeError, "Could not find node in #{node.inspect}"
+      end
+      
+      if !File.exist?(options[:rjs])
+        raise RuntimeError, "Could not find r.js optimizer at #{options[:rjs].inspect}"
+      end
+      
+      options[:build_files].each do |build_file, target|
+        build_file = release.build_path + build_file
+        target = release.build_path + target
+        release.log(self, "Optimizing #{build_file}")
+                
+        # Hack to create tempfile in build
+        t = Tempfile.new("requirejs", release.build_path)
+        tmp_build_dir = t.path
+        t.close
+        t.unlink
+      
+        # Run r.js optimizer
+        output = `#{options[:node]} #{options[:rjs]} -o #{build_file} dir=#{tmp_build_dir}`
+        
+        # Check if r.js succeeded
+        unless $?.success?
+          raise RuntimeError, "Asset compilation with node failed.\nr.js output:\n #{output}"
+        end
+        
+        if File.exist?(target)
+          release.log(self, "Removing target #{target}")
+          FileUtils.rm_rf(target)
+        end        
+        
+        # Move the tmp_build_dir to target
+        FileUtils.mv(tmp_build_dir, target)
+      end
+    end
+  end
+end

data/lib/html_mockup/release/processors/sass.rb

@@ -0,0 +1,38 @@
+# Use the sass gem
+require 'sass'
+
+module HtmlMockup::Release::Processors
+  class Sass < Base
+    # @param [Hash] options Options as described below, all other options will be passed to Sass.compile_file.
+    #
+    # @option options [Array] :match An array of shell globs, defaults to ["stylesheets/**/*.scss"]
+    # @option options [Array] :skip An array of regexps which will be skipped, defaults to [/_.*\.scss\Z/], Attention! Skipped files will be deleted as well!
+    def call(release, options={})
+      options = {
+        :match => ["stylesheets/**/*.scss"],
+        :skip => [/_.*\.scss\Z/],
+        :style => :expanded
+      }.update(options)
+      
+      match = options.delete(:match)
+      skip = options.delete(:skip)
+      
+      # Sassify SCSS files
+      files = release.get_files(match)
+      files.each do |f|
+        if !skip.detect{|r| r.match(f) }
+          release.log(self, "Processing: #{f}")          
+          # Compile SCSS
+          ::Sass.compile_file(f, f.gsub(/\.scss$/, ".css"), options)
+        end        
+      end
+      
+      # Cleanup
+      files.each do |f|
+        # Remove source file
+        File.unlink(f)
+      end
+      
+    end
+  end
+end