html_mockup 0.7.4 → 0.8.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmJiYTQ3MGRhMDdjM2QxZTE2MDU0N2NjYjcxNjdhZTJiNDk2ZGI1YQ==
+  data.tar.gz: !binary |-
+    OTlkMjZkNmM4YmViYmIwOGRjNjBiOTdkZjM2M2YzMGNmMjEyMzkzMg==
+SHA512:
+  metadata.gz: !binary |-
+    ZTBjZDI1ZDFlOGVhZjU0ZjJjN2JjOWVhYjI0OWVlYjY3NTRhMmU5MDJmY2Zk
+    NTkxNzg5MzMxNjRiYTdlOWE3OTNiN2QwYmY3MzYxODc4ODExMWIyMGVjNWE0
+    YjBlZGM2Nzc2YzA1NDI1NzI0MzEzMTM0MTUxZjA5N2NjZGIxYjg=
+  data.tar.gz: !binary |-
+    ZjkxZTExOTdhNTZkM2RmNjljZGMwYmM4YWI1OWM5MDAxN2FhOGUwZjlhNGYw
+    NmEyNjE0NmFlNzExMmFjMDdmNGZkNDZiM2MzZmZhMWY4MTM3ZTVlZDFhZmQy
+    ZTA2Zjc3ZjA1OTdkNTBhM2VmMTE0MTc0OGQ5NmZhNzI3NmIzMzU=

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## Version 0.8.0
+* Set content type header in response when rendering templates
+* Add option to prompt user before performing rsync finalizer (defaults to true)
+* Fix zip finalizer to use options[:zip] in actuall executed command too
+* Logger now outputs color and has support for warning messages
+* Mockup templating is now fully handled with Tilt
+* Mockup extraction and URL relativization etc. for release are now done in their respective processors (will be added automatically if you haven't added them yourself.) This gives a fine-grained control over the point in time when these processors are ran.
+* Add a testproject to the repository
+* Add support for layouts
+* Add a `git_branch` finalizer that allows us to release to a branch on a repository (this makes it easy to release github pages)
+* Allow requirejs processor to work wih single files as well
+* Expose server options to mockup so you can configure a https server if you want
+* Minor fixes
+
 ## Version 0.7.4
 * Allow for underscores in .scss files when releasing
 

data/html_mockup.gemspec

@@ -2,9 +2,9 @@
 
 Gem::Specification.new do |s|
   s.name = "html_mockup"
-  s.version = "0.7.4"
+  s.version = "0.8.0"
   
-  s.authors = ["Flurin Egger", "Edwin van der Graaf"]
+  s.authors = ["Flurin Egger", "Edwin van der Graaf", "Joran Kapteijns"]
   s.email = ["info@digitpaint.nl", "flurin@digitpaint.nl"]  
   s.homepage = "http://github.com/digitpaint/html_mockup"
   s.summary = "HTML Mockup is a set of tools to create self-containing HTML mockups."
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency("thor", ["~> 0.16.0"])
   s.add_dependency("rack", [">= 1.0.0"])
-  s.add_dependency("tilt", [">= 0"])
-  s.add_dependency("hpricot", [">= 0.6.4"])  
+  s.add_dependency("tilt", ["~> 1.4.0"])
+  s.add_dependency("sass", [">= 0"])
+  s.add_dependency("hpricot", [">= 0.6.4"])
 end

data/lib/html_mockup/cli.rb

@@ -13,6 +13,13 @@ require File.dirname(__FILE__) + "/w3c_validator"
 
 module HtmlMockup
   class Cli < Thor
+    
+    class_option :verbose,
+      :desc =>  "Set's verbose output",
+      :aliases => ["-v"],
+      :default => false,
+      :type => :boolean
+    
     desc "serve [directory]","Serve directory as HTML, defaults to current directory"
     method_options :port => :string, # Defaults to 9000
                    :html_path => :string, # The document root, defaults to "[directory]/html"
@@ -96,7 +103,7 @@ module HtmlMockup
     
     def banner(project)
       puts "  Html: \"#{project.html_path}\""
-      puts "  Partials: \"#{project.partial_path}\" (#{HtmlMockup::Template.partial_files(project.partial_path).size} found)"      
+      puts "  Partials: \"#{project.partial_path}\""
     end
     
     # TODO: handle options
@@ -107,7 +114,7 @@ module HtmlMockup
         exit(1)
       end
       
-      Project.new(path, options)
+      Project.new(path, {:shell => self.shell}.update(options))
     end
 
     def w3cvalidate(file)
@@ -119,7 +126,6 @@ module HtmlMockup
       end
       validator.valid
     end
-    
  
   end
 end

data/lib/html_mockup/extractor.rb

@@ -2,6 +2,8 @@ require 'hpricot'
 require File.dirname(__FILE__) + '/resolver'
 
 module HtmlMockup
+  
+  # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor and release.use(:url_relativizer, options) processor
   class Extractor
     
     attr_reader :project, :target_path
@@ -59,7 +61,7 @@ module HtmlMockup
     
     # Runs the extractor on a single file and return processed source.
     def extract_source_from_file(file_path, env = {})
-      source = HtmlMockup::Template.open(file_path, :partial_path => self.project.partial_path).render(env)
+      source = HtmlMockup::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
 
       if @options[:url_relativize]
         source = relativize_urls(source, file_path)

data/lib/html_mockup/mockup_template.rb

@@ -0,0 +1,97 @@
+require 'tilt'
+require 'strscan'
+require 'cgi'
+require 'tilt/template'
+
+module HtmlMockup
+
+  class MockupTemplate < Tilt::Template
+    
+    
+    class MissingPartial < StandardError; end
+    
+    
+    self.default_mime_type = 'text/html'
+    
+    attr_reader :scanner
+    
+    def self.engine_initialized?
+      true
+    end
+    
+    def prepare
+      
+    end
+    
+    def evaluate(scope, locals, &block)
+      @scanner = StringScanner.new(data)      
+      out = ""
+      while (partial = self.parse_partial_tag!) do
+        name, params, scanned = partial
+        # add new skipped content to output file
+        out << scanned
+
+        # scan until end of tag
+        current_content = self.scanner.scan_until(/<!-- \[STOP:#{name}\] -->/)
+        out << (render_partial(name, params, scope) || current_content)
+      end
+      out << scanner.rest  
+
+      @output = out
+    end
+    
+    protected
+    
+    def parse_partial_tag!
+      params = {}
+      scanned = ""
+      begin_of_tag = self.scanner.scan_until(/<!-- \[START:/)
+      return nil unless begin_of_tag
+      scanned << begin_of_tag
+      scanned << tag = self.scanner.scan(/[a-z0-9_\/\-]+/)
+      if scanned_questionmark = self.scanner.scan(/\?/)
+        scanned << scanned_questionmark
+        scanned << raw_params = self.scanner.scan_until(/\] -->/)
+        raw_params.gsub!(/\] -->$/,"")
+      
+        params = CGI.parse(raw_params)
+        params.keys.each{|k| params[k] = params[k].first }
+      else
+        scanned << self.scanner.scan_until(/\] -->/)
+      end
+
+      [tag,params,scanned]
+    end    
+    
+    def render_partial(name, params, scope)
+      if partial_template_path = scope.template.find_template(name, :partials_path)
+        # New style templates
+        out = (scope.partial(name, :locals => params) || current_content)
+      elsif partial_template_path = scope.template.find_template(name.to_s + ".part", :partials_path)
+        # Old style templates
+        template = Tilt::ERBTemplate.new(partial_template_path.to_s)
+        context = TemplateContext.new(params)
+        out = template.render(context, :env => scope.env)
+      else
+        # Not found        
+        raise MissingPartial.new("Could not find partial '#{name}'")
+      end
+      
+      "\n" + out.rstrip + "\n<!-- [STOP:#{name}] -->"
+    end
+    
+    class TemplateContext
+      # Params will be set as instance variables
+      def initialize(params)
+        params.each do |k,v|
+          self.instance_variable_set("@#{k}",v)
+        end
+      end      
+    end
+    
+  end
+
+end
+
+Tilt.register HtmlMockup::MockupTemplate, "html"
+Tilt.prefer HtmlMockup::MockupTemplate

data/lib/html_mockup/project.rb

@@ -10,24 +10,37 @@ module HtmlMockup
     # @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
+    attr_accessor :path, :html_path, :partial_path, :layouts_path, :mockupfile
+    
+    attr_accessor :shell
+    
+    attr_accessor :options
     
     def initialize(path, options={})
       @path = Pathname.new(path)
       
       @options = {
         :html_path => @path + "html",
-        :partial_path => @path + "partials"
-      }.update(options)
+        :partial_path => @path + "partials",
+        :layouts_path => @path + "layouts"
+      }
       
-      paths = mockup_paths(@options[:html_path], @options[:partial_path])
-      self.html_path = paths[0]
-      self.partial_path = paths[1]
+      # Clumsy string to symbol key conversion
+      options.each{|k,v| @options[k.is_a?(String) ? k.to_sym : k] = v }
+      
+      self.html_path = @options[:html_path]
+      self.partial_path = @options[:partials_path] || @options[:partial_path] || self.html_path + "../partials/"
+      self.layouts_path = @options[:layouts_path]
+      self.shell = @options[:shell]
       
       @mockupfile = Mockupfile.new(self)
       @mockupfile.load
     end
     
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+    
     def server
       options = @options[:server] || {}
       @server ||= Server.new(self, options)
@@ -45,15 +58,12 @@ module HtmlMockup
     def partial_path=(p)
       @partial_path = Pathname.new(p).realpath
     end
-        
-    protected
+    alias :partials_path :partial_path
+    alias :partials_path= :partial_path=
     
-    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]
+    def layouts_path=(p)
+      @layouts_path = Pathname.new(p).realpath
     end
-
-
+    
   end
 end

data/lib/html_mockup/rack/html_mockup.rb

@@ -13,10 +13,9 @@ module HtmlMockup
       
       def initialize(project)
         @project = project
-        root,partial_path = project.html_path, project.partial_path
+        @docroot = project.html_path
         
-        @docroot = root
-        @partial_path = partial_path
+        @resolver = Resolver.new(@docroot)
         @file_server = ::Rack::File.new(@docroot)
       end
 
@@ -24,25 +23,25 @@ module HtmlMockup
         url = env["PATH_INFO"]
         env["MOCKUP_PROJECT"] = project
         
-        resolver = Resolver.new(@docroot)
-
-        if template_path = resolver.url_to_path(url)
+        if template_path = @resolver.url_to_path(url)
           env["rack.errors"].puts "Rendering template #{template_path.inspect} (#{url.inspect})"
-          begin
-            templ = ::HtmlMockup::Template.open(template_path, :partial_path => @partial_path)
+          # begin
+            templ = ::HtmlMockup::Template.open(template_path, :partials_path => @project.partials_path, :layouts_path => @project.layouts_path)
+            mime = ::Rack::Mime.mime_type(File.extname(template_path), 'text/html')
             resp = ::Rack::Response.new do |res|
+              res.headers["Content-Type"] = mime if mime
               res.status = 200
               res.write templ.render(env)
             end
             resp.finish
-          rescue StandardError => e
-            env["rack.errors"].puts "  #{e.message}"
-            resp = ::Rack::Response.new do |res|
-              res.status = 500
-              res.write "An error occurred"
-            end
-            resp.finish
-          end
+          # rescue StandardError => e
+          #   env["rack.errors"].puts "#{e.message}\n #{e.backtrace.join("\n")}\n\n"
+          #   resp = ::Rack::Response.new do |res|
+          #     res.status = 500
+          #     res.write "An error occurred"
+          #   end
+          #   resp.finish
+          # end
         else
           env["rack.errors"].puts "Invoking file handler for #{url.inspect}"
           @file_server.call(env)

data/lib/html_mockup/release.rb

@@ -192,8 +192,9 @@ module HtmlMockup
     #
     # @param Hash options Options hash passed to extractor
     #
-    # @see  HtmlMockup::Extractor for more information
+    # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor
     def extract(options = {})
+      self.warn(self, "Don't use the extractor anymore, use release.use(:mockup, options) and release.use(:url_relativizer, options) processors")
       @extractor_options = options
     end
     
@@ -202,8 +203,10 @@ module HtmlMockup
       # Validate paths
       validate_paths!
       
-      # Extract valid mockup
-      run_extractor!
+      # Extract mockup
+      copy_source_path_to_build_path!
+      
+      validate_stack!
       
       # Run stack
       run_stack!
@@ -216,10 +219,31 @@ module HtmlMockup
       
     end    
     
-    def log(part, msg)
-      puts part.class.to_s + " : " + msg.to_s
+    # Write out a log message
+    def log(part, msg, verbose = false, &block)
+      if !verbose || verbose && self.project.options[:verbose]
+        self.project.shell.say "\033[37m#{part.class.to_s}\033[0m" + " : " + msg.to_s, nil, true
+      end
+      if block_given?
+        begin
+          self.project.shell.padding = self.project.shell.padding + 1
+          yield
+        ensure
+          self.project.shell.padding = self.project.shell.padding - 1
+        end
+      end
+    end
+    
+    def debug(part, msg, &block)
+      self.log(part, msg, true, &block)
+    end
+    
+    # Write out a warning message
+    def warn(part, msg)
+      self.project.shell.say "\033[37m#{part.class.to_s}\033[0m" + " : " + "\033[31m#{msg.to_s}\033[0m", nil, true
     end
     
+    
     # @param [Array] globs an array of file path globs that will be globbed against the build_path
     # @param [Array] excludes an array of regexps that will be excluded from the result
     def get_files(globs, excludes = [])
@@ -237,6 +261,8 @@ module HtmlMockup
     # = The runway =
     # ==============
     
+    # Checks if build path exists (and cleans it up)
+    # Checks if target path exists (if not, creates it)
     def validate_paths!
       if self.build_path.exist?
         log self, "Cleaning up previous build \"#{self.build_path}\""
@@ -249,9 +275,28 @@ module HtmlMockup
       end
     end
     
-    def run_extractor!
-      extractor = Extractor.new(self.project, self.build_path, @extractor_options)
-      extractor.run!
+    # Checks if deprecated extractor options have been set
+    # Checks if the mockup will be runned
+    def validate_stack!
+      
+      mockup_options = {}
+      relativizer_options = {}
+      run_relativizer = true
+      if @extractor_options
+        mockup_options = {:env => @extractor_options[:env]}
+        relativizer_options = {:url_attributes => @extractor_options[:url_attributes]}
+        run_relativizer = @extractor_options[:url_relativize]
+      end
+      
+      unless @stack.find{|(processor, options)| processor.class == HtmlMockup::Release::Processors::Mockup }
+        @stack.unshift([HtmlMockup::Release::Processors::UrlRelativizer.new, relativizer_options])        
+        @stack.unshift([HtmlMockup::Release::Processors::Mockup.new, mockup_options])
+      end
+    end
+    
+    def copy_source_path_to_build_path!
+      mkdir(self.build_path)
+      cp_r(self.source_path.children, self.build_path)
     end
     
     def run_stack!

data/lib/html_mockup/release/finalizers.rb

@@ -15,4 +15,5 @@ end
 require File.dirname(__FILE__) + "/finalizers/zip"
 require File.dirname(__FILE__) + "/finalizers/dir"
 require File.dirname(__FILE__) + "/finalizers/rsync"
+require File.dirname(__FILE__) + "/finalizers/git_branch"
 

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

@@ -0,0 +1,92 @@
+# Finalizes the release into a specific branch of a repository and pushes it
+#
+class GitBranch < HtmlMockup::Release::Finalizers::Base
+ 
+  # @param Hash options The options
+  #
+  # @option options String :remote The remote repository (default is the origin of the current repository)
+  # @option options String :branch The remote branch (default is "gh-pages")
+  # @option options Boolean :cleanup Cleanup temp dir afterwards (default is true)  
+  # @option options Boolean :push Push to remote (default is true)    
+  def initialize(options={})
+    @options = {
+      :remote => nil,
+      :branch => "gh-pages",
+      :cleanup => true,
+      :push => true
+    }
+  end
+  
+  
+  def call(release, options = {})
+    options = @options.dup.update(options)  
+    git_dir = find_git_dir(release.project.path)
+    
+    # 0. Get remote
+    unless remote = (options[:remote] || `git --git-dir=#{git_dir} config --get remote.origin.url`).strip
+      raise "No remote found for origin"
+    end
+    
+    e_remote = Shellwords.escape(remote)
+    e_branch = Shellwords.escape(options[:branch])
+
+    tmp_dir = Pathname.new(Dir.mktmpdir)
+    clone_dir = tmp_dir + "clone"
+    
+    # Check if remote already has branch
+    if `git ls-remote --heads #{e_remote} refs/heads/#{e_branch}` == ""
+      release.log(self, "Creating empty branch")
+      # Branch does not exist yet
+      FileUtils.mkdir(clone_dir)
+      Dir.chdir(clone_dir) do
+        `git init`
+        `git remote add origin #{e_remote}`
+        `git checkout -b #{e_branch}`
+      end
+    else
+      release.log(self, "Cloning existing repo")
+      # 1. Clone into different directory      
+      `git clone #{e_remote} --branch #{e_branch} --single-branch #{clone_dir}`
+    end
+    
+    release.log(self, "Working git magic in #{clone_dir}")
+    Dir.chdir(clone_dir) do
+      # 3. Copy changes
+      FileUtils.rm_rf("*")
+      FileUtils.cp_r release.build_path.to_s + "/.", clone_dir.to_s
+      
+      # 4. Add all files
+      `git add .`
+    
+      # 5. Commit
+      `git commit -a -m "Release #{release.scm.version}"`
+
+      # 6. Git push
+      if options[:push]
+        `git push origin #{e_branch}`
+      end
+    end
+    
+    if options[:cleanup]
+      FileUtils.rm_rf(tmp_dir)
+    end
+    
+  end
+  
+  protected
+  
+  # Find the git dir
+  # TODO this is just a copy from release/scm/git.rb 
+  def find_git_dir(path)
+    path = Pathname.new(path).realpath
+    while path.parent != path && !(path + ".git").directory?
+      path = path.parent
+    end
+    
+    path = path + ".git"
+    
+    raise "Could not find suitable .git dir in #{path}" if !path.directory?
+
+    path
+  end  
+end