html_mockup 0.7.4 → 0.8.0

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

@@ -14,12 +14,14 @@ module HtmlMockup::Release::Finalizers
     # @option options String :remote_path The remote path to upload to
     # @option options String :host The remote host to upload to
     # @option options String :username The remote username to upload to
+    # @option options Boolean :ask Prompt the user before uploading (default is true)
     def initialize(options = {})
       @options = {
         :rsync => "rsync",
         :remote_path => "",
         :host => "",
-        :username  => ""
+        :username  => "",
+        :ask => true
       }.update(options)
     end
   
@@ -28,36 +30,36 @@ module HtmlMockup::Release::Finalizers
     
       # Validate options
       validate_options!(release, options)
-    
-      begin
-        `#{@options[:rsync]} --version`
-      rescue Errno::ENOENT
-        raise RuntimeError, "Could not find rsync in #{@options[:rsync].inspect}"
-      end    
-    
-
-      local_path = release.build_path.to_s
-      remote_path = options[:remote_path]
-    
-      local_path += "/" unless local_path =~ /\/\Z/
-      remote_path += "/" unless remote_path =~ /\/\Z/    
-
-      release.log(self, "Starting upload of #{(release.build_path + "*")} to #{options[:host]}")
-    
-      command = "#{options[:rsync]} -az #{Shellwords.escape(local_path)} #{Shellwords.escape(options[:username])}@#{Shellwords.escape(options[:host])}:#{Shellwords.escape(remote_path)}"
-    
-      # Run r.js optimizer
-      output = `#{command}`
+      
+      if !options[:ask] || (prompt("Do you wish to upload to #{options[:host]}? Anything other than 'yes' will cancel: ")) == 'yes'
+        begin
+          `#{@options[:rsync]} --version`
+        rescue Errno::ENOENT
+          raise RuntimeError, "Could not find rsync in #{@options[:rsync].inspect}"
+        end
         
-      # Check if r.js succeeded
-      unless $?.success?
-        raise RuntimeError, "Rsync failed.\noutput:\n #{output}"
-      end
+        local_path = release.build_path.to_s
+        remote_path = options[:remote_path]
+        
+        local_path += "/" unless local_path =~ /\/\Z/
+        remote_path += "/" unless remote_path =~ /\/\Z/
         
+        release.log(self, "Starting upload of #{(release.build_path + "*")} to #{options[:host]}")
+      
+        command = "#{options[:rsync]} -az #{Shellwords.escape(local_path)} #{Shellwords.escape(options[:username])}@#{Shellwords.escape(options[:host])}:#{Shellwords.escape(remote_path)}"
+        
+        # Run r.js optimizer
+        output = `#{command}`
+        
+        # Check if r.js succeeded
+        unless $?.success?
+          raise RuntimeError, "Rsync failed.\noutput:\n #{output}"
+        end
+      end
     end
-  
+    
     protected
-  
+    
     def validate_options!(release, options)
       must_have_keys = [:remote_path, :host, :username]
       if (options.keys & must_have_keys).size != must_have_keys.size
@@ -65,6 +67,11 @@ module HtmlMockup::Release::Finalizers
         raise "Missing keys: #{(must_have_keys - options.keys).inspect}"
       end
     end
+    
+    def prompt(question = 'Do you wish to continue?')
+      print(question)
+      return $stdin.gets.strip
+    end
   
   end
 end

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

@@ -33,7 +33,7 @@ module HtmlMockup::Release::Finalizers
       end
 
       ::Dir.chdir(release.build_path) do
-        `zip -r -9 "#{release.target_path + name}" ./*`
+        `#{options[:zip]} -r -9 "#{release.target_path + name}" ./*`
       end
     end
     

data/lib/html_mockup/release/processors.rb

@@ -13,6 +13,8 @@ module HtmlMockup::Release::Processors
   end
 end
 
+require File.dirname(__FILE__) + "/processors/mockup"
+require File.dirname(__FILE__) + "/processors/url_relativizer"
 require File.dirname(__FILE__) + "/processors/requirejs"
 require File.dirname(__FILE__) + "/processors/sass"
 require File.dirname(__FILE__) + "/processors/yuicompressor"

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

@@ -0,0 +1,87 @@
+module HtmlMockup::Release::Processors
+  class Mockup < Base
+    
+    attr_accessor :project
+    
+    def initialize(options={})
+      @options = {
+        :env => {},
+        :match => ["**/*.{html,md,html.erb}"],
+        :skip => [/\Astylesheets/, /\Ajavascripts/]
+      }
+      
+      @options.update(options) if options            
+    end
+
+    def call(release, options={})
+      self.project = release.project
+      
+      options = {}.update(@options).update(options)
+      
+      options[:env].update("MOCKUP_PROJECT" => project)
+      
+      release.log(self, "Processing mockup files")
+      
+      release.get_files(options[:match], options[:skip]).each do |file_path|
+        self.run_on_file!(file_path, @options[:env])
+      end
+    end
+    
+    
+    def run_on_file!(file_path, env = {})
+      template = HtmlMockup::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path)
+      
+      # Clean up source file
+      FileUtils.rm(file_path)
+      
+      # Write out new file
+      File.open(self.target_path(file_path, template),"w"){|f| f.write(template.render(env.dup)) }
+    end
+    
+    # Runs the extractor on a single file and return processed source.
+    def extract_source_from_file(file_path, env = {})
+      HtmlMockup::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
+    end    
+    
+    protected
+    
+    def target_path(path, template)
+      # 1. If we have a double extension we rip of the template it's own extension and be done with it
+      parts = File.basename(path.to_s).split(".")
+      dir = Pathname.new(File.dirname(path.to_s))
+      
+      # 2. Try to figure out the extension based on the template's mime-type
+      mime_types = {
+        "text/html" => "html",
+        "text/css"  => "css",
+        "application/javascript" => "js",
+        "text/xml" => "xml",
+        "application/xml" => "xml",
+        "text/csv" => "csv",
+        "application/json" => "json"
+      }
+      extension = mime_types[template.template.class.default_mime_type]
+      
+      # Always return .html directly as it will cause too much trouble otherwise
+      if parts.last == "html"
+        return path
+      end
+      
+      if parts.size > 2
+        # Strip extension
+        dir + parts[0..-2].join(".")
+      else
+        return path if extension.nil?
+        
+        if parts.size > 1
+          # Strip extension and replace with extension
+          dir + (parts[0..-2] << extension).join(".")
+        else
+          # Let's just add the extension
+          dir + (parts << extension).join(".")
+        end
+      end
+    end    
+    
+  end
+end

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

@@ -4,14 +4,14 @@ module HtmlMockup::Release::Processors
     
     def initialize(options = {})
       @options = {
-        :build_files => {"javascripts/site.build.js" => "javascripts"},
+        :build_files => {"javascripts/site.build.js" => {:dir => "javascripts"}},
         :rjs => "r.js",
         :node => "node"
       }.update(options)
     end
     
 
-    # @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 [Hash] :build_files An a hash of files to build (as key) and the target as a hash with either {:dir => "STRING"} or {:file => "STRING"} in the release to put it as value, each one will be built in a separate directory. (default is {"javascripts/site.build.js" => {:dir => "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={})
@@ -27,7 +27,21 @@ module HtmlMockup::Release::Processors
       
       @options[:build_files].each do |build_file, target|
         build_file = release.build_path + build_file
-        target = release.build_path + target
+        
+        if target.kind_of?(Hash)
+          if target[:dir]
+            target = target[:dir]
+            target_type = :dir
+          elsif target[:file]
+            target = target[:file]
+            target_type = :file
+          end
+        else
+          # Old style
+          target_type = :dir
+        end
+        
+        target = release.build_path + target        
         release.log(self, "Optimizing #{build_file}")
                 
         # Hack to create tempfile in build
@@ -37,7 +51,13 @@ module HtmlMockup::Release::Processors
         t.unlink
       
         # Run r.js optimizer
-        output = `#{rjs_command} -o #{build_file} dir=#{tmp_build_dir}`
+        if target_type == :dir
+          output = `#{rjs_command} -o #{build_file} dir=#{tmp_build_dir}`
+        else
+          output = `#{rjs_command} -o #{build_file} out=#{tmp_build_dir}/out.js`
+        end
+        
+        release.debug(self, output)
         
         # Check if r.js succeeded
         unless $?.success?
@@ -50,7 +70,11 @@ module HtmlMockup::Release::Processors
         end        
         
         # Move the tmp_build_dir to target
-        FileUtils.mv(tmp_build_dir, target)
+        if target_type == :dir
+          FileUtils.mv(tmp_build_dir, target)
+        end
+          FileUtils.mv("#{tmp_build_dir}/out.js", target)
+          FileUtils.rm_rf(tmp_build_dir)
       end
     end
     

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

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '../../../resolver'
+
+module HtmlMockup::Release::Processors
+  class UrlRelativizer < Base
+    
+    def initialize(options={})
+      @options = {
+        :url_attributes => %w{src href action},
+        :match => ["**/*.html"]
+      }
+      
+      @options.update(options) if options            
+    end
+
+    def call(release, options={})
+      options = {}.update(@options).update(options)
+      
+      release.log(self, "Relativizing all URLS in #{options[:match].inspect} files in attributes #{options[:url_attributes].inspect}")
+      
+      @resolver = HtmlMockup::Resolver.new(release.build_path)
+      release.get_files(options[:match]).each do |file_path|
+        release.debug(self, "Relativizing URLS in #{file_path}") do
+          orig_source = File.read(file_path)
+          File.open(file_path,"w") do |f| 
+            doc = Hpricot(orig_source)
+            options[:url_attributes].each do |attribute|
+              (doc/"*[@#{attribute}]").each do |tag|
+                converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
+                release.debug(self, "Converting '#{tag[attribute]}' to '#{converted_url}'")
+                case converted_url
+                when String
+                  tag[attribute] = converted_url
+                when nil
+                  release.log(self, "Could not resolve link #{tag[attribute]} in #{file_path}")
+                end
+              end
+            end
+            f.write(doc.to_original_html) 
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -24,6 +24,8 @@ module HtmlMockup::Release::Processors
       css_compressor = YUI::CssCompressor.new(compressor_options) 
       js_compressor = YUI::JavaScriptCompressor.new(compressor_options)
       
+      release.log self,  "Minifying #{options[:match].inspect}"
+      
       # Add version numbers and minify the files
       release.get_files(options[:match], options[:skip]).each do |f|
         type = f[/\.([^.]+)\Z/,1]
@@ -36,14 +38,14 @@ module HtmlMockup::Release::Processors
           minified = [header]
     
           # Actual minification
-          release.log self,  "Minifying #{f}"
+          release.debug self,  "Minifying #{f}"
           case type
           when "css"
             minified << css_compressor.compress(data)
           when "js"
             minified << js_compressor.compress(data)
           else
-            release.log self, "Error minifying: encountered unknown type \"#{type}\""
+            release.warn self, "Error minifying: encountered unknown type \"#{type}\""
             minified << data
           end
 

data/lib/html_mockup/resolver.rb

@@ -2,37 +2,38 @@ module HtmlMockup
   class Resolver
     
     def initialize(path)
+      raise ArgumentError, "Resolver base path can't be nil" if path.nil?
       @base = Pathname.new(path)
     end
     
-    def url_to_path(url, exact_match = false)
+    # @param [String] url The url to resolve to a path
+    # @param [true,false] exact_match Wether or not to match exact paths, this is mainly used in the path_to_url method to match .js, .css, etc files.
+    def find_template(url, exact_match = false)
       path, qs, anch = strip_query_string_and_anchor(url.to_s)
       
-      extensions = %w{html htm}
-        
-      # Append index.extension if it's a diretory
-      if File.directory?(File.join(@base,path))
-        search_files = extensions.map{|p| File.join(@base,path,"index.#{p}")}
-      # If it's already a .extension file, return that file
-      elsif extensions.detect{|e| path =~ /\.#{e}\Z/ }
-        search_files = [File.join(@base,path)]
-      # If it ends with a slash or does not contain a . and it's not a directory
-      # try to add extenstions to see if that exists.
-      elsif (path =~ /\/$/) || (path =~ /^[^.]+$/)
-        search_files = extensions.map{|e| File.join(@base,"#{path}.#{e}") }
-      # Otherwise don't return anything at all.
-      else
-        if exact_match
-          search_files = [File.join(@base,path)]
-        else
-          search_files = []
-        end
+      path = File.join(@base, path)
+  
+      if exact_match && File.exist?(path)
+        return Pathname.new(path)
+      end
+      
+      # It's a directory, add "/index"
+      if File.directory?(path)
+        path = File.join(path, "index")
+      end
+      
+      # 2. If it's .html,we strip of the extension
+      if path =~ /\.html\Z/
+        path.sub!(/\.html\Z/, "")
       end
       
-      if file = search_files.find{|p| File.exist?(p) }
-        Pathname.new(file)
+      extensions = Tilt.mappings.keys + Tilt.mappings.keys.map{|ext| "html.#{ext}"}
+
+      if found_extension = extensions.find { |ext| File.exist?(path + "." + ext) }
+        Pathname.new(path + "." + found_extension)
       end
     end
+    alias :url_to_path :find_template
     
     
     # Convert a disk path on file to an url

data/lib/html_mockup/server.rb

@@ -4,10 +4,13 @@ require File.dirname(__FILE__) + "/w3c_validator"
 require File.dirname(__FILE__) + "/rack/html_mockup"
 require File.dirname(__FILE__) + "/rack/html_validator"      
 
+require 'webrick'
+require 'webrick/https'
+
 module HtmlMockup
   class Server
     
-    attr_reader :options
+    attr_reader :options, :server_options
     
     attr_reader :project
       
@@ -18,6 +21,8 @@ module HtmlMockup
             
       @project = project
       
+      @server_options = {}
+      
       set_options(options)
     end
     
@@ -28,7 +33,7 @@ module HtmlMockup
         :handler => nil, # Autodetect
         :port => 9000
       }.update(options)
-      
+            
       self.port = @options[:port]
       self.handler = @options[:handler]      
     end
@@ -57,6 +62,10 @@ module HtmlMockup
       end
     end
     alias :run :run!
+    
+    def port=(p)
+      self.server_options[:Port] = p
+    end
         
     protected
     
@@ -104,13 +113,5 @@ module HtmlMockup
       handler
     end
     
-    
-    # Generate server options for handler
-    def server_options
-      {
-        :Port => self.port
-      }
-    end
-
   end
 end