html_mockup 0.8.4 → 0.9.0

data/lib/html_mockup/cli/command.rb

@@ -0,0 +1,23 @@
+module HtmlMockup
+
+  class Cli::Command < Thor::Group
+
+    class_option :verbose,
+      :desc =>  "Set's verbose output",
+      :aliases => ["-v"],
+      :default => false,
+      :type => :boolean
+
+    def initialize_project
+      @project = Cli::Base.project
+    end
+
+    protected
+
+    def project_banner(project)
+      puts "  Html: \"#{project.html_path}\""
+      puts "  Partials: \"#{project.partial_path}\""
+    end
+  end
+
+end

data/lib/html_mockup/cli/generate.rb

@@ -0,0 +1,5 @@
+module HtmlMockup
+  class Cli::Generate < Thor
+
+  end
+end

data/lib/html_mockup/cli/release.rb

@@ -0,0 +1,10 @@
+module HtmlMockup
+  class Cli::Release < Cli::Command
+
+    desc "Release the current project"
+
+    def release
+      @project.release.run!
+    end
+  end
+end

data/lib/html_mockup/cli/serve.rb

@@ -0,0 +1,29 @@
+module HtmlMockup
+  class Cli::Serve < Cli::Command
+
+
+    desc "Serve the current project"
+
+    class_options :port => :string, # Defaults to 9000
+                   :handler => :string, # The handler to use (defaults to mongrel)
+                   :validate => :boolean # Run validation?
+
+    def serve
+      
+      server_options = {} 
+      options.each{|k,v| server_options[k.to_sym] = v }
+      server_options[:server] = {}
+      [:port, :handler, :validate].each do |k|
+        server_options[:server][k] = server_options.delete(k) if server_options.has_key?(k)
+      end
+      
+      server = @project.server
+      server.set_options(server_options[:server])
+      
+      puts "Running HtmlMockup with #{server.handler.inspect} on port #{server.port}"
+      puts project_banner(@project) 
+      
+      server.run!
+    end
+  end
+end

data/lib/html_mockup/generators.rb

@@ -1,6 +1,23 @@
+require 'thor'
+require 'thor/group'
+
 module HtmlMockup
   module Generators
+
+    class Base < Cli::Command
+      def self.register(sub)
+        name = sub.to_s.sub(/Generator$/, "").sub(/^.*Generators::/,"").downcase
+        usage = "#{name} #{sub.arguments.map{ |arg| arg.banner }.join(" ")}"
+        long_desc =  sub.desc || "Run #{name} generator"
+        
+        Cli::Generate.register sub, name, usage, long_desc
+        Cli::Generate.tasks[name].options = sub.class_options if sub.class_options
+      end
+    end
+
   end
 end
 
-require File.dirname(__FILE__) + "/generators/new"
+# Default generators
+require File.dirname(__FILE__) + "/generators/new"
+require File.dirname(__FILE__) + "/generators/generator"

data/lib/html_mockup/generators/generator.rb

@@ -0,0 +1,23 @@
+class HtmlMockup::Generators::GeneratorGenerator < HtmlMockup::Generators::Base
+  
+  include Thor::Actions
+  
+  desc "Create your own generator for html_mockup"
+  argument :name, :type => :string, :required => true, :desc => "Name of the new generator"
+  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
+  # class_option :template, :type => :string, :aliases => ["-t"], :desc => "Template to use, can be a path or a git repository remote, uses built in minimal as default"
+  
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  def create_lib_file
+    destination = "#{path}/#{name}_generator.rb"
+    template('templates/generator.tt', destination)
+    say "Add `require #{destination}` to your mockup file and run mockup generate #{name}."
+  end
+
+  
+end
+
+HtmlMockup::Generators::Base.register HtmlMockup::Generators::GeneratorGenerator

data/lib/html_mockup/generators/new.rb

@@ -1,6 +1,6 @@
 require 'shellwords'
 
-class HtmlMockup::Generators::New < Thor::Group
+class HtmlMockup::Generators::NewGenerator < Thor::Group
   
   include Thor::Actions
   
@@ -62,5 +62,6 @@ class HtmlMockup::Generators::New < Thor::Group
     directory(".", ".")
   end
   
-  
-end
+end
+
+HtmlMockup::Generators::Base.register HtmlMockup::Generators::NewGenerator

data/lib/html_mockup/generators/templates/generator.tt

@@ -0,0 +1,13 @@
+class <%= name.capitalize %>Generator < HtmlMockup::Generators::Base
+  
+  include Thor::Actions
+  
+  desc "<%= name.capitalize %> generator helps you doing ... and ..."
+  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
+  
+  def create_stuff
+    # your stuff
+  end
+end
+
+HtmlMockup::Generators::Base.register <%= name.capitalize %>Generator

data/lib/html_mockup/project.rb

@@ -33,8 +33,6 @@ module HtmlMockup
       self.layouts_path = @options[:layouts_path]
       self.shell = @options[:shell]
       
-      
-      load_dependencies!
       load_mockup!
     end
     
@@ -57,27 +55,29 @@ module HtmlMockup
     end
     
     def partial_path=(p)
-      @partial_path = self.realpath_or_path(p)
+      @partial_path = self.single_or_multiple_paths(p)
     end
     alias :partials_path :partial_path
     alias :partials_path= :partial_path=
     
     def layouts_path=(p)
-      @layouts_path = self.realpath_or_path(p)
+      @layouts_path = self.single_or_multiple_paths(p)
     end
     
     protected
-    
-    def load_dependencies!
-      if Object.const_defined?(:Bundler)
-        Bundler.require(:default)
-      end
-    end
-    
+
     def load_mockup!
       @mockupfile = Mockupfile.new(self)
       @mockupfile.load      
     end
+
+    def single_or_multiple_paths(p)
+      if p.kind_of?(Array)
+        p.map{|tp| self.realpath_or_path(tp) }
+      else
+        self.realpath_or_path(p)
+      end
+    end
     
     def realpath_or_path(path)
       path = Pathname.new(path)

data/lib/html_mockup/release.rb

@@ -339,8 +339,8 @@ module HtmlMockup
       
       commenters = {
         :html => Proc.new{|s| "<!-- #{s} -->" },
-        :css => Proc.new{|s| "/* #{s} */" },
-        :js => Proc.new{|s| "/* #{s} */" }                
+        :css => Proc.new{|s| "/*! #{s} */" },
+        :js => Proc.new{|s| "/*! #{s} */" }                
       }
       
       commenter = commenters[options[:style]] || commenters[:js]
@@ -360,4 +360,4 @@ require File.dirname(__FILE__) + "/release/scm"
 require File.dirname(__FILE__) + "/release/injector"
 require File.dirname(__FILE__) + "/release/cleaner"
 require File.dirname(__FILE__) + "/release/finalizers"
-require File.dirname(__FILE__) + "/release/processors"
+require File.dirname(__FILE__) + "/release/processors"

data/lib/html_mockup/resolver.rb

@@ -1,36 +1,55 @@
 module HtmlMockup
   class Resolver
+
+    attr_reader :load_paths
     
-    def initialize(path)
-      raise ArgumentError, "Resolver base path can't be nil" if path.nil?
-      @base = Pathname.new(path)
+    def initialize(paths)
+      raise ArgumentError, "Resolver base path can't be nil" if paths.nil?
+
+      # Convert to paths
+      @load_paths = [paths].flatten.map{|p| Pathname.new(p) }
     end
     
     # @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)
-      
-      path = File.join(@base, path)
+    # @param [Hash] options Options
+    #
+    # @option options [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.
+    # @option options [String] :preferred_extension The part to chop off and re-add to search for more complex double-extensions. (Makes it possible to have context aware partials)
+    def find_template(url, options = {})
+      orig_path, qs, anch = strip_query_string_and_anchor(url.to_s)
+
+      options = {
+        :exact_match => false,
+        :preferred_extension => "html"  
+      }.update(options)
+
+      paths = self.load_paths.map{|base| File.join(base, orig_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
-      
-      extensions = Tilt.mappings.keys + Tilt.mappings.keys.map{|ext| "html.#{ext}"}
+      paths.find do |path|
+        if options[: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 preferred_extension, we strip of the extension
+        if path =~ /\.#{options[:preferred_extension]}\Z/
+          path.sub!(/\.#{options[:preferred_extension]}\Z/, "")
+        end
+        
+        extensions = Tilt.default_mapping.template_map.keys + Tilt.default_mapping.lazy_map.keys
 
-      if found_extension = extensions.find { |ext| File.exist?(path + "." + ext) }
-        Pathname.new(path + "." + found_extension)
+        # We have to re-add preferred_extension again as we have stripped it in in step 2!
+        extensions += extensions.map{|ext| "#{options[:preferred_extension]}.#{ext}"}
+
+        if found_extension = extensions.find { |ext| File.exist?(path + "." + ext) }
+          return Pathname.new(path + "." + found_extension)
+        end
+
+        false #Next iteration
       end
     end
     alias :url_to_path :find_template
@@ -39,11 +58,15 @@ module HtmlMockup
     # Convert a disk path on file to an url
     def path_to_url(path, relative_to = nil)
 
-      path = Pathname.new(path).relative_path_from(@base).cleanpath
+      # Find the parent path we're in
+      path = Pathname.new(path).realpath
+      base = self.load_paths.find{|lp| path.to_s =~ /\A#{Regexp.escape(lp.realpath.to_s)}/ }
+
+      path = path.relative_path_from(base).cleanpath
       
       if relative_to
         if relative_to.to_s =~ /\A\//
-          relative_to = Pathname.new(File.dirname(relative_to.to_s)).relative_path_from(@base).cleanpath
+          relative_to = Pathname.new(File.dirname(relative_to.to_s)).relative_path_from(base).cleanpath
         else
           relative_to = Pathname.new(File.dirname(relative_to.to_s))
         end
@@ -62,7 +85,7 @@ module HtmlMockup
       path, qs, anch = strip_query_string_and_anchor(url)
 
       # Get disk path
-      if true_path =  self.url_to_path(path, true)
+      if true_path =  self.url_to_path(path, :exact_match => true)
         path = self.path_to_url(true_path, relative_to_path)
         path += qs if qs
         path += anch if anch

data/lib/html_mockup/template.rb

@@ -1,9 +1,13 @@
 require 'tilt'
+require 'mime/types'
 require 'yaml'
 require 'ostruct'
 
 require File.dirname(__FILE__) + "/mockup_template"
 
+# We're enforcing Encoding to UTF-8
+Encoding.default_external = "UTF-8"
+
 module HtmlMockup
   
   class Template
@@ -44,28 +48,79 @@ module HtmlMockup
     
     def render(env = {})
       context = TemplateContext.new(self, env)
-      locals = {:document => OpenStruct.new(self.data)}
       
       if @layout_template
-        @layout_template.render(context, locals) do
-          self.template.render(context, locals)
+        content_for_layout = self.template.render(context, {}) # yields
+        
+        @layout_template.render(context, {}) do |content_for|
+          if content_for
+            context._content_for_blocks[content_for]
+          else
+            content_for_layout
+          end
         end
       else
-        self.template.render(context, locals)
+        self.template.render(context, {})
       end
     end
     
     def find_template(name, path_type)
       raise(ArgumentError, "path_type must be one of :partials_path or :layouts_path") unless [:partials_path, :layouts_path].include?(path_type)
 
+      return nil unless @options[path_type]
+
       @resolvers ||= {}        
       @resolvers[path_type] ||= Resolver.new(@options[path_type])
       
-      @resolvers[path_type].url_to_path(name)
-    end      
+      @resolvers[path_type].find_template(name, :preferred_extension => self.target_extension)
+    end
+
+    # Try to infer the final extension of the output file.
+    def target_extension
+      return @target_extension if @target_extension
+
+      if type = MIME::Types[self.target_mime_type].first
+        # Dirty little hack to enforce the use of .html instead of .htm
+        if type.sub_type == "html"
+          @target_extension = "html"
+        else
+          @target_extension = type.extensions.first
+        end
+      else
+        @target_extension = File.extname(self.source_path.to_s).sub(/^\./, "")
+      end
+    end
+
+    def source_extension
+      parts = File.basename(File.basename(self.source_path.to_s)).split(".")
+      if parts.size > 2
+        parts[-2..-1].join(".")
+      else
+        File.extname(self.source_path.to_s).sub(/^\./, "")
+      end
+    end
+
+    # Try to figure out the mime type based on the Tilt class and if that doesn't
+    # work we try to infer the type by looking at extensions (needed for .erb)
+    def target_mime_type
+      mime = self.template.class.default_mime_type
+      return mime if mime
+
+      path = File.basename(self.source_path.to_s)
+      mime = MIME::Types.type_for(path).first
+      return mime.to_s if mime
+
+      parts = File.basename(path).split(".")
+      if parts.size > 2
+        mime = MIME::Types.type_for(parts[0..-2].join(".")).first
+        return mime.to_s if mime
+      else
+        nil
+      end
+    end
     
     protected
-    
+
     # Get the front matter portion of the file and extract it.
     def extract_front_matter(source)
       fm_regex = /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
@@ -91,26 +146,55 @@ module HtmlMockup
   end
   
   class TemplateContext
-    
+    attr_accessor :_content_for_blocks
+
     def initialize(template, env={})
-      @_template, @_env = template, env
+      @_template, @_env = template, @_content_for_blocks = {}, env
     end
     
+    # The current HtmlMockup::Template in use
     def template
       @_template
     end
+
+    # Access to the front-matter of the document (if any)
+    def document
+      @_data ||= OpenStruct.new(self.template.data)
+    end
     
+    # The current environment variables.
     def env
       @_env
     end
+
+    # Capture content in blocks in the template for later use in the layout.
+    # Currently only works in ERB templates. Use like this in the template:
+    #
+    # ```
+    #   <% content_for :name %> bla bla <% end %>
+    # ```
+    #
+    # Place it like this in the layout:
+    #
+    # ```
+    #   <%= yield :name %>
+    # ```
+    def content_for(block_name, &capture)
+      raise ArgumentError, "content_for works only with ERB Templates" if !self.template.template.kind_of?(Tilt::ERBTemplate)
+      eval "@_erbout_tmp = _erbout", capture.binding
+      eval "_erbout = \"\"", capture.binding
+      t = Tilt::ERBTemplate.new(){ "<%= yield %>" }
+      @_content_for_blocks[block_name] = t.render(&capture)
+      return nil
+    ensure
+      eval "_erbout = @_erbout_tmp", capture.binding
+    end
         
     def partial(name, options = {})
       if template_path = self.template.find_template(name, :partials_path)
-        # puts "Rendering partial #{name}, with template #{template_path}"
         partial_template = Tilt.new(template_path.to_s)
         partial_template.render(self, options[:locals] || {})
       elsif template_path = self.template.find_template(name + ".part", :partials_path)
-        # puts "Rendering old-style partial #{name}, with template #{template_path}"
         template = Tilt::ERBTemplate.new(template_path.to_s)
         context = MockupTemplate::TemplateContext.new(options[:locals] || {})
         template.render(context, :env => self.env)