ymdp 0.0.3

data/lib/application_view/processor/validator.rb

@@ -0,0 +1,125 @@
+require 'support/file'
+
+module ApplicationView
+  module Validator
+    class Base
+      extend ApplicationView::Config
+      extend ApplicationView::FileSupport
+    end
+    
+    class HTML < Base
+      def self.validate(path)
+        html_display_path = display_path(path)
+
+        doctype = CONFIG["doctype"] || "HTML 4.0 Transitional"
+
+        resp = post_file_to_w3c_validator(path, doctype)
+        html = resp.read_body
+        if html.include? "[Valid]"
+          $stdout.puts "   #{html_display_path}  validating . . . OK"
+        else 
+          log_path = "#{TMP_PATH}/#{File.basename(path)}_errors.html"
+          $stdout.puts "   #{html_display_path} is not valid HTML, writing to #{display_path(log_path)}"
+          $stdout.puts
+          $stdout.puts "     To view errors:"
+          $stdout.puts "     open #{display_path(log_path)}"
+          $stdout.puts
+          File.open(log_path,'w') { |f| f.puts html }
+          $stdout.puts "     Viewing errors..."
+  
+          g("HTML validation errors found")
+          system "open #{log_path}"
+          raise "Invalid HTML"
+        end
+      end
+    end
+    
+    class JavaScript < Base
+      def self.validate?
+        validate_embedded_js?
+      end
+      
+      def self.validate(filename)
+        if validate?
+          validate_javascript(filename)
+        end
+      end
+      
+      def self.use_jslint_settings?
+        !jslint_settings.blank?
+      end
+      
+      def self.jslint_settings
+<<-JSLINT
+/*jslint bitwise: true, browser: true, evil: true, eqeqeq: true, immed: true, newcap: true, onevar: false, plusplus: true, regexp: true, undef: true, sub: true */
+/*global YAHOO, openmail, OpenMailIntl, _gat, unescape, $, $$, $A, $H, $R, $w, $div, Event, Effect, Behavior, Try, PeriodicalExecuter, Element, identify, Sortable, window, I18n, Identity, Logger, OIB, Tags, ABTesting, Flash, Debug */
+JSLINT
+      end
+      
+      def self.jslint_settings_count
+        jslint_settings.to_s.split("\n").size
+      end
+      
+      def self.pre_process(content)
+        content
+      end
+    
+      def self.validate_javascript(path)
+        display = display_path(path)
+        $stdout.print "   #{display}  validating . . . "
+        output = ""
+      
+        File.open(path) do |f|
+          output = f.read
+        end
+        
+        output = pre_process(output)
+        
+        js_fragment_path = File.expand_path("#{TMP_PATH}/#{File.basename(path)}_fragment")
+        fragment_display_path = display_path(js_fragment_path)
+    
+        unless File.exists?(js_fragment_path)
+          File.open(js_fragment_path,'w') do |f|
+            f.puts jslint_settings if use_jslint_settings?
+            f.puts output
+          end
+
+          results = `java org.mozilla.javascript.tools.shell.Main ./script/jslint.js #{js_fragment_path}`
+
+          if results =~ /jslint: No problems found/
+            $stdout.puts "OK"
+          else
+            $stdout.puts "errors found!"
+            results.split("\n").each do |result|
+              if result =~ /line (\d+) character (\d+): (.*)/
+                line_number = $1.to_i
+                error = "Error at #{fragment_display_path} line #{line_number-jslint_settings_count} character #{$2}: #{$3}"
+                error += get_line_from_file(js_fragment_path, line_number)
+          
+                $stdout.puts error
+              end
+            end
+            message = "Javascript Errors embedded in #{display}"
+            g(message)
+            raise message
+          end
+        end
+      end
+    end
+    
+    class JSON < JavaScript
+      def self.validate?
+        validate_json_assets?
+      end
+      
+      def pre_process(output)
+        output = output.gsub("\\u003C", "HELLO")
+        output = output.gsub("\\u003E", "HELLO")
+        output
+      end
+      
+      def self.jslint_settings
+      end
+    end
+  end
+end

data/lib/application_view/support/file.rb

@@ -0,0 +1,54 @@
+module ApplicationView
+  module FileSupport
+    def confirm_overwrite(path)
+      if File.exists?(path)
+        puts "File exists: #{display_path(path)}"
+        print "  overwrite? (y/n)"
+        answer = $stdin.gets
+        
+        answer =~ /^y/i
+      else
+        true
+      end          
+    end
+    
+    # friendlier display of paths
+    def display_path(path)
+      path = File.expand_path(path)
+      path.gsub(BASE_PATH, "")
+    end
+    
+    # saves the output string to the filename given
+    #
+    def save_to_file(output, filename)
+      unless File.exists?(filename)      
+        File.open(filename, "w") do |w|
+          w.write(output)
+        end
+      end
+    end
+  
+    # given a path and line number, returns the line and two lines previous
+    #
+    def get_line_from_file(path, line_number)
+      line_number = line_number.to_i
+      output = ""
+      lines = []
+    
+      File.open(path) do |f|
+        lines = f.readlines
+      end
+  
+      output += "\n"
+  
+      3.times do |i|
+        line = lines[line_number-(3-i)]
+        output += line if line
+      end
+  
+      output += "\n"      
+    
+      output
+    end
+  end
+end

data/lib/application_view/support/form_post.rb

@@ -0,0 +1,58 @@
+# from http://devlicio.us/blogs/sergio_pereira/archive/2008/04/02/xhtml-validation-script-using-ruby.aspx
+
+require 'rubygems'
+require 'mime/types'
+require 'net/http'
+require 'CGI'
+ 
+class FormField
+  attr_accessor :name, :value
+  def initialize( name, value )
+    @name = name
+    @value = value
+  end
+ 
+  def to_form_data
+    field = CGI::escape(@name)
+    "Content-Disposition: form-data; name=\"#{field}\"" + 
+      "\r\n\r\n#{@value}\r\n"
+  end
+end
+ 
+class FileField
+  attr_accessor :name, :path, :content
+  def initialize( name, path, content )
+    @name = name
+    @path = "#{path}.html"
+    @content = content
+  end
+ 
+  def to_form_data
+    "Content-Disposition: form-data; " + 
+    "name=\"#{CGI::escape(@name)}\"; " + 
+    "filename=\"#{@path}\"\r\n" +
+    "Content-Transfer-Encoding: binary\r\n" +
+    "Content-Type: #{MIME::Types.type_for(@path)}" + 
+    "\r\n\r\n#{@content}\r\n"
+  end
+end
+
+class MultipartPost
+  SEPARATOR = 'willvalidate-aaaaaabbbb0000'
+  REQ_HEADER = {
+      "Content-type" => "multipart/form-data, boundary=#{SEPARATOR} "
+   }
+ 
+  def self.build_form_data ( form_fields )
+    fields = []
+    form_fields.each do |key, value|
+      if value.instance_of?(File)
+        fields << FileField.new(key.to_s, value.path, value.read)
+      else
+        fields << FormField.new(key.to_s, value)
+      end
+    end
+    fields.collect {|f| "--#{SEPARATOR}\r\n#{f.to_form_data}" }.join("") + 
+         "--#{SEPARATOR}--"
+  end
+end

data/lib/application_view/support/g.rb

@@ -0,0 +1,11 @@
+def g(s)
+  if CONFIG["growl"]
+    growl(s, :title => "YMDP")
+  end
+rescue StandardError => e
+  if e.message =~ /Connection refused/
+    puts s
+  else
+    raise e
+  end
+end

data/lib/application_view/support/growl.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'ruby-growl'
+require 'pp'
+
+$g_host ||= "localhost"
+$g_priority ||= 0
+$g_sticky ||= true
+
+module Kernel
+  def growl(*args)
+    options = {}
+    if args.last.class == Hash
+      options = args.pop
+    end
+    
+    title = options[:title] || 'g'
+    g = Growl.new $g_host, title, [$0]
+
+    messages =
+      if args.empty?
+        ['g!']
+      else
+        args.map { |i| i.pretty_inspect }
+      end
+
+    messages.each { |i| g.notify $0, title, i, $g_priority, $g_sticky }
+
+    if args.empty?
+      nil
+    elsif args.size == 1
+      args.first
+    else
+      args
+    end
+  end
+end

data/lib/application_view/support/timer.rb

@@ -0,0 +1,40 @@
+module ApplicationView
+  module Support
+    module Timer
+      def time(message="")
+        start_time = Time.now
+        yield
+        end_time = Time.now
+        put_elapsed_time(start_time, end_time, message)
+      end
+    
+      def put_elapsed_time(start_time, end_time, message="")
+        seconds = end_time - start_time
+        if seconds > 59
+          minutes = seconds / 60.0
+          seconds = (minutes - minutes.to_i) * 60
+    
+          m = minutes.to_i > 1 ? "minutes" : "minute"
+          elapsed_time = "#{minutes.to_i} #{m}"
+          if seconds > 0
+            s = seconds.to_i > 1 ? "seconds" : "minutes"
+            elapsed_time += ", #{seconds.to_i} #{s}"
+          end
+        else
+          s = seconds.to_i > 1 ? "seconds" : "minutes"
+          elapsed_time = "#{seconds.to_i} #{s}"
+        end
+  
+        puts
+        e = ""
+        unless message.blank?
+          message += ". "
+        end
+        e = message + e
+        e += "Elapsed time: #{elapsed_time}"
+        puts e
+        g(e)
+      end    
+    end
+  end
+end

data/lib/application_view/support/w3c.rb

@@ -0,0 +1,22 @@
+def post_file_to_w3c_validator(file_path, doc_type)
+  query = MultipartPost.build_form_data(
+        :uploaded_file  => File.new(file_path, 'r'),
+        :charset        => '(detect automatically)',
+        :doctype        => doc_type,   
+        :group          => '1'
+        )
+
+  Net::HTTP.start('validator.w3.org') do |http|
+    http.post2("/check", query, MultipartPost::REQ_HEADER)
+  end
+end
+
+def valid_response?(w3c_response)
+  html = w3c_response.read_body
+  html.include? "[Valid]"
+end
+
+def w3c_valid?(file_path)
+  resp = post_file_to_w3c_validator(file_path, 'HTML 4.01 Strict')
+  valid_response?(resp)
+end

data/lib/application_view/tag_helper.rb

@@ -0,0 +1,147 @@
+module ActionView
+  module Helpers #:nodoc:
+    # Provides methods to generate HTML tags programmatically when you can't use
+    # a Builder. By default, they output XHTML compliant tags.
+    module TagHelper
+      include ERB::Util
+
+      BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked).to_set
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|a| a.to_sym })
+
+      # Returns an empty HTML tag of type +name+ which by default is XHTML
+      # compliant. Set +open+ to true to create an open tag compatible
+      # with HTML 4.0 and below. Add HTML attributes by passing an attributes
+      # hash to +options+. Set +escape+ to false to disable attribute value
+      # escaping.
+      #
+      # ==== Options
+      # The +options+ hash is used with attributes with no value like (<tt>disabled</tt> and
+      # <tt>readonly</tt>), which you can give a value of true in the +options+ hash. You can use
+      # symbols or strings for the attribute names.
+      #
+      # ==== Examples
+      #   tag("br")
+      #   # => <br />
+      #
+      #   tag("br", nil, true)
+      #   # => <br>
+      #
+      #   tag("input", { :type => 'text', :disabled => true })
+      #   # => <input type="text" disabled="disabled" />
+      #
+      #   tag("img", { :src => "open & shut.png" })
+      #   # => <img src="open &amp; shut.png" />
+      #
+      #   tag("img", { :src => "open &amp; shut.png" }, false, false)
+      #   # => <img src="open &amp; shut.png" />
+      def tag(name, options = nil, open = false, escape = true)
+        "<#{name}#{tag_options(options, escape) if options}#{open ? ">" : " />"}"
+      end
+
+      # Returns an HTML block tag of type +name+ surrounding the +content+. Add
+      # HTML attributes by passing an attributes hash to +options+.
+      # Instead of passing the content as an argument, you can also use a block
+      # in which case, you pass your +options+ as the second parameter.
+      # Set escape to false to disable attribute value escaping.
+      #
+      # ==== Options
+      # The +options+ hash is used with attributes with no value like (<tt>disabled</tt> and
+      # <tt>readonly</tt>), which you can give a value of true in the +options+ hash. You can use
+      # symbols or strings for the attribute names.
+      #
+      # ==== Examples
+      #   content_tag(:p, "Hello world!")
+      #    # => <p>Hello world!</p>
+      #   content_tag(:div, content_tag(:p, "Hello world!"), :class => "strong")
+      #    # => <div class="strong"><p>Hello world!</p></div>
+      #   content_tag("select", options, :multiple => true)
+      #    # => <select multiple="multiple">...options...</select>
+      #
+      #   <% content_tag :div, :class => "strong" do -%>
+      #     Hello world!
+      #   <% end -%>
+      #    # => <div class="strong">Hello world!</div>
+      def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
+        # if block_given?
+        #   options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+        #   content_tag = content_tag_string(name, capture(&block), options, escape)
+        #       
+        #   if block_called_from_erb?(block)
+        #     concat(content_tag)
+        #   else
+        #     content_tag
+        #   end
+        # else
+          content_tag_string(name, content_or_options_with_block, options, escape)
+        # end
+      end
+
+      # Returns a CDATA section with the given +content+.  CDATA sections
+      # are used to escape blocks of text containing characters which would
+      # otherwise be recognized as markup. CDATA sections begin with the string
+      # <tt><![CDATA[</tt> and end with (and may not contain) the string <tt>]]></tt>.
+      #
+      # ==== Examples
+      #   cdata_section("<hello world>")
+      #   # => <![CDATA[<hello world>]]>
+      #
+      #   cdata_section(File.read("hello_world.txt"))
+      #   # => <![CDATA[<hello from a text file]]>
+      def cdata_section(content)
+        "<![CDATA[#{content}]]>"
+      end
+
+      # Returns an escaped version of +html+ without affecting existing escaped entities.
+      #
+      # ==== Examples
+      #   escape_once("1 > 2 &amp; 3")
+      #   # => "1 &lt; 2 &amp; 3"
+      #
+      #   escape_once("&lt;&lt; Accept & Checkout")
+      #   # => "&lt;&lt; Accept &amp; Checkout"
+      def escape_once(html)
+        html.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |special| ERB::Util::HTML_ESCAPE[special] }
+      end
+
+      private
+        BLOCK_CALLED_FROM_ERB = 'defined? __in_erb_template'
+
+        if RUBY_VERSION < '1.9.0'
+          # Check whether we're called from an erb template.
+          # We'd return a string in any other case, but erb <%= ... %>
+          # can't take an <% end %> later on, so we have to use <% ... %>
+          # and implicitly concat.
+          def block_called_from_erb?(block)
+            block && eval(BLOCK_CALLED_FROM_ERB, block)
+          end
+        else
+          def block_called_from_erb?(block)
+            block && eval(BLOCK_CALLED_FROM_ERB, block.binding)
+          end
+        end
+
+        def content_tag_string(name, content, options, escape = true)
+          tag_options = tag_options(options, escape) if options
+          "<#{name}#{tag_options}>#{content}</#{name}>"
+        end
+
+        def tag_options(options, escape = true)
+          unless options.blank?
+            attrs = []
+            if escape
+              options.each_pair do |key, value|
+                if BOOLEAN_ATTRIBUTES.include?(key)
+                  attrs << %(#{key}="#{key}") if value
+                else
+                  attrs << %(#{key}="#{escape_once(value)}") if !value.nil?
+                end
+              end
+            else
+              attrs = options.map { |key, value| %(#{key}="#{value}") }
+            end
+            " #{attrs.sort * ' '}" unless attrs.empty?
+          end
+        end
+    end
+  end
+end