masterview 0.1.5 → 0.2.0

data/lib/masterview/parser.rb

@@ -178,37 +178,22 @@ module MasterView
     end
   end
 
-  class InvalidPathException < Exception
-    def initialize(msg)
-      super(msg)
+
+
+  class MIOSerializer
+    def initialize(options)
+      raise RequiredArgumentMissingError.new("Required argument is missing, specify the MasterViewIO object in options[:output_mio_tree]") unless options[:output_mio_tree]
+      @options = options
+      @mio_tree = options[:output_mio_tree]
     end
-  end
 
-  # Serializer which can serialize output to file system.
-  # It will create any directories that are necessary before writing the file.
-  # It will overwrite any existing file that existed.
-  class FileSerializer
     def serialize(render_mode, tag)
-      Log.debug { "outputting mode=#{render_mode.mode_type} to file=#{render_mode.output}".indent(2*(Renderer.last_renderer.render_levels.size - 1)) }
-      dir_name = File.dirname render_mode.output
-      FileUtils.makedirs(dir_name) unless File.exist?(dir_name) #ensure path exists
-
       data_to_write = tag.data.join
-      if File.exist? render_mode.output
-        existing_file_contents = File.readlines(render_mode.output).join
-        if data_to_write == existing_file_contents
-          Log.debug { "file identical, skipping output of #{render_mode.output}" }
-          return false
-        end
-      end
-
-      File.open(render_mode.output, 'w') do |io|
-        io << data_to_write
-      end
-      true
+      @mio_tree.path(render_mode.output).write(data_to_write, @options)
     end
   end
 
+=begin
   # Serializer which simply serializes output to the console
   class ConsoleSerializer
     def serialize(render_mode, tag)
@@ -234,11 +219,20 @@ module MasterView
       true
     end
   end
+=end
 
   class Renderer
     include DirectiveHelpers
-    attr_reader :restrict_output_to_directory, :directive_load_paths, :mv_ns
-    attr_accessor :render_levels, :directive_classes, :default_render_handler, :serializer, :template_path
+
+    # Set of element names that can be simplified. Used in simplify_empty_elements.
+    # Only simplify elements that are specified in the DTD as being empty, collapsing others can cause parsing
+    # or rendering problems in browsers. 
+    # http://www.w3.org/TR/xhtml1/dtds.html#a_dtd_XHTML-1.0-Strict
+    # base, meta, link, hr, br, param, img, area, input, col 
+    XHTMLEmptyElementNameSet = %w{ base meta link hr br param img area input col }.to_set
+
+    attr_reader :directive_load_paths, :mv_ns, :keyword_expander, :default_extension
+    attr_accessor :render_levels, :directive_classes, :default_render_handler, :serializer, :template_pathname, :template_full_pathname
 
     def self.last_renderer; @@last_renderer; end
 
@@ -250,11 +244,14 @@ module MasterView
       ]
 
       serializer = options[:serializer] || DefaultSerializer
-      self.serializer = serializer.is_a?(Class) ? serializer.new : serializer #one can pass in Serializer class or an instance
-      self.restrict_output_to_directory = options[:output_dir] || nil
+      self.serializer = serializer.is_a?(Class) ? serializer.new(options) : serializer #one can pass in Serializer class or an instance
       self.mv_ns = options[:namespace] || NamespacePrefix
+      self.template_pathname = options[:template_pathname] 
+      self.template_full_pathname = IOMgr.template.path(self.template_pathname).full_pathname if self.template_pathname
+      @default_extension = (options[:output_mio_tree]) ? options[:output_mio_tree].default_extension : IOMgr.erb.default_extension
+      @keyword_expander = KeywordExpander.new
+      @keyword_expander.set_template_pathname(self.template_pathname, @default_extension)
       self.directive_load_paths = ( DefaultDirectiveLoadPaths << options[:additional_directive_paths] ).flatten
-      self.template_path = options[:template_path] || ''
     end
 
     def mv_ns=(namespace_prefix)
@@ -262,11 +259,6 @@ module MasterView
       Log.debug { 'namespace_prefix set to '+namespace_prefix }
     end
 
-    def restrict_output_to_directory=(dir)
-      @restrict_output_to_directory = (!dir.nil?) ? File.expand_path(dir) : nil
-      Log.debug { 'restrict_output_to_directory set to '+@restrict_output_to_directory.to_s }
-    end
-
     # Sets directive_load_paths, re-requiring all the new load paths, however any directives that were
     # already required (and loaded) will still be in memory because these are not reset.
     def directive_load_paths=( directive_paths ) 
@@ -274,7 +266,7 @@ module MasterView
       @auto_directives = []
       directive_paths.each do |directive_path|
         next if directive_path.nil?
-        raise InvalidPathException.new('directive_path does not exist, path='+directive_path) unless File.exist? directive_path
+        raise InvalidPathError.new('directive_path does not exist, path='+directive_path) unless File.exist? directive_path
         Dir.open( directive_path ).each { |fn| require "#{directive_path}/#{fn}" if fn =~ /[.]rb$/ }
 
       end
@@ -305,23 +297,9 @@ module MasterView
       @render_levels.last.render_modes
     end
     def push_level(render_level)
-      render_level.render_modes.each do |mode|
-        enforce_sandbox!(mode.output)
-      end
       @render_levels.push render_level
     end
 
-    def enforce_sandbox!(path)
-      unless @restrict_output_to_directory.nil?
-        expanded_path = File.expand_path(path, @restrict_output_to_directory)
-        unless expanded_path.starts_with? @restrict_output_to_directory
-          raise InvalidPathException.new( "invalid path=#{path} resticted to path=#{@restrict_output_to_directory}")
-        end
-        path.replace expanded_path
-      end
-    end
-    
-
     def push_tag(tag_name, attributes)
       modes.each do |mode|
         attributes_copy = attributes.clone #these get changed in select_active_directives
@@ -373,19 +351,35 @@ module MasterView
       pop_level if need_to_pop_level
     end
 
+
+    # Simplify (collapse) empty elements so that <foo></foo> from rexml parsing ends up being <foo/> .
+    # Only simplify elements that are specified in the DTD as being empty, collapsing others can cause parsing
+    # or rendering problems in browsers. Uses constant XHTMLEmptyElementNameSet to find elements that should be
+    # collapsed. 
+    # http://www.w3.org/TR/xhtml1/dtds.html#a_dtd_XHTML-1.0-Strict
+    # xhtml-1.0-Strict empty elements are:
+    # base, meta, link, hr, br, param, img, area, input, col 
     def simplify_empty_elements(content) #relies on the fact that > and </ are individual strings and are back to back with nothing in between
       ret = []
+      current_element_name = nil
       next_to_last = nil
       last = nil
       content.flatten!
       content.each do |item|
-        if next_to_last == '>' && last == '</'
+        if next_to_last == '>' && last == '</' && XHTMLEmptyElementNameSet.include?(current_element_name) 
           ret.pop #remove '>'
           ret.pop #remove '</'
-          ret << '/>'
+          ret << ' />' # adding in a space to make xhtml more compatible with html editors and older browsers
         else
           ret << item
         end
+        unless item.nil?
+          if !item.starts_with?('</') && item.starts_with?('<')
+            current_element_name = /^<(\S*)/.match(item)[1] # depending on what is after < this might be empty string
+          elsif last && last.starts_with?('</')
+            current_element_name = nil
+          end
+        end
         next_to_last = last
         last = item
       end
@@ -474,20 +468,20 @@ module MasterView
       @renderer.append_raw ERB_EVAL+value+ERB_END
     end
 
-    # handle a mv:gen_render attribute, which calls generate and outputs a token
+    # handle a mv:gen_partial attribute, which calls generate and outputs a token
     # it takes an optional :dir => 'foo/bar' which is prepended to partial path,
     # otherwise it just uses what is in partial. 
     # This creates a generate attribute value which will be used later.
     # Parameters
-    # value = attribute value for gen_render
+    # value = attribute value for gen_partial
     # attributes = all remaining attributes hash
-    def handle_gen_render(attributes)
-      value = attributes.delete(@renderer.mv_ns+'gen_render')
+    def handle_gen_partial(attributes)
+      value = @renderer.keyword_expander.resolveAttrAndDelete(attributes, @renderer.mv_ns+'gen_partial')
       if value 
         prepend_dir = find_string_val_in_string_hash(value, :dir) #only used for masterview
         partial = find_string_val_in_string_hash(value, :partial) 
         return if partial.nil?
-        path = render_partial_name_to_file_name(partial)
+        path = render_partial_name_to_file_name(partial, @renderer.default_extension)
         path = File.join(prepend_dir, path) if prepend_dir
         generate_attribute = attributes[@renderer.mv_ns+'generate'] || '' # check if we need to add to existing generate
         generate_attribute = path + (generate_attribute.blank? ? '' : ', '+generate_attribute)
@@ -497,14 +491,15 @@ module MasterView
     end
 
     def push_levels(attributes)
-      handle_gen_render(attributes)
+      handle_gen_partial(attributes)
       
-      gen_replace = attributes.delete(@renderer.mv_ns+'gen_replace') #get and delete from map
+      gen_replace = @renderer.keyword_expander.resolveAttrAndDelete(attributes, @renderer.mv_ns+'gen_replace') #get and delete from map
       generate_replace( gen_replace ) unless gen_replace.nil?
 
-      gen = attributes.delete(@renderer.mv_ns+'generate') #get and delete from map
+      gen = @renderer.keyword_expander.resolveAttrAndDelete(attributes, @renderer.mv_ns+'generate') #get and delete from map
       if gen
-        attributes[@renderer.mv_ns+'insert_generated_comment'] =  @renderer.template_path unless OmitGeneratedComments #add the comment directive, so it will be written to each gen'd file
+        omit_comment = OmitGeneratedComments || File.extname(gen) != MasterView::IOMgr.erb.default_extension
+        attributes[@renderer.mv_ns+'insert_generated_comment'] =  @renderer.template_full_pathname.to_s unless omit_comment #add the comment directive, so it will be written to each gen'd file
         render_level = nil
         gen_values = parse_eval_into_hash(gen, :normal)
 
@@ -515,7 +510,7 @@ module MasterView
           arr_values = (value.is_a?(Enumerable)) ? value : [value] #if not enumerable add it to array
           value.each do |path|
             path.strip!
-            Log.debug { ('pushing mode='+mode_type.to_s+' path='+path).indent(2*@renderer.render_levels.size) } 
+            #Log.debug { ('pushing mode='+mode_type.to_s+' path='+path).indent(2*@renderer.render_levels.size) } 
             render_level ||= RenderLevel.new
             render_level.push RenderMode.new(path, mode_type)
           end
@@ -528,31 +523,26 @@ module MasterView
   end
 
   class Parser
-    # parse a MasterView template by first reading from file and render output. 
-    # template_file_path param is file path to template
-    # options are the optional parameters which control the output (:output_dir, :namespace)
-    def self.parse_file( template_file_path, output_dir, options = DefaultParserOptions.clone)
-      output_dir ||= '.'
-      Log.debug { "Parsing file=#{File.expand_path(template_file_path)} output_dir=#{File.expand_path(output_dir)}" }
-      options[:template_path]=File.expand_path(template_file_path)
-      options[:output_dir] = output_dir
-      template = File.new( template_file_path )
-      template = template.readlines.join if options[:tidy] || options[:escape_erb]
+    def self.parse_mio( template_mio, output_mio_tree, options = {})
+      options[:template_pathname]= template_mio.pathname
+      options[:output_mio_tree] = output_mio_tree
+      template = template_mio.read
       self.parse( template, options )
     end
 
+
     # parse a MasterView template and render output. 
     # template param is actual template source passed in as string or array.
-    # options are the optional parameters which control the output (:output_dir, :namespace, :serializer)
+    # options are the optional parameters which control the output (:output_mio_tree, :namespace, :serializer)
     def self.parse( template, options = DefaultParserOptions.clone)
       options[:listeners] ||= [MasterViewListener]
       options[:rescue_exceptions] = RescueExceptions unless options.include?(:rescue_exceptions)
 
       begin
       if options[:tidy]
-        template = self.tidy(template)
+        template = TidyHelper.tidy(template)
       elsif options[:escape_erb]
-        template = self.escape_erb(template)
+        template = EscapeErbHelper.escape_erb(template)
       end
       
       parser = REXML::Parsers::SAX2Parser.new( template )
@@ -574,24 +564,6 @@ module MasterView
       end
     end
 
-    def self.tidy(html)
-      Tidy.path = TidyPath unless Tidy.path
-      xml = Tidy.open do |tidy|
-        tidy.options.output_xml = true
-        tidy.options.indent = true
-        tidy.options.wrap = 0
-        xml = tidy.clean(html)
-      end
-      xml = self.escape_erb(xml)
-      Log.debug { 'tidy corrected xml='+xml }
-      xml
-    end
-
-    def self.escape_erb(html)
-      html = html.gsub(/<%/, InlineErbStart)
-      html.gsub!(/%>/, InlineErbEnd)
-      html
-    end
   end
 
 end

data/lib/masterview/pathname_extensions.rb

@@ -0,0 +1,33 @@
+require 'pathname'
+
+class Pathname
+  # create a new Pathname object for path, any backslashes are converted to /, 
+  # if Pathname object is passed in then returns this existing pathname object
+  def self.for_path(path)
+    return path if path.is_a? Pathname
+    Pathname.new(path.gsub('\\','/'))
+  end
+
+  # return the concatenated path, cleaning up any backslashes, ignores nulls or empty pathnames
+  def self.join(*args)
+    pathnames = args.collect { |a| Pathname.for_path(a) }
+    pathnames.inject { |fullpath, p| self.safe_concat(fullpath, p) }
+  end
+
+  # prepends a pathname to existing, ignores nulls or empty pathnames
+  def self.safe_concat(prepend_pn, pathname)
+    return nil if ((prepend_pn.nil? ||  prepend_pn.to_s.empty?) && (pathname.nil? || pathname.to_s.empty?)) #both are nil or empty
+    return prepend_pn if (pathname.nil? || pathname.to_s.empty?)
+    return pathname if (prepend_pn.nil? || prepend_pn.to_s.empty?)
+    prepend_pn+pathname
+  end
+
+  # return the path string without the extension
+  def path_no_ext
+    dirname = self.dirname
+    ext = self.extname
+    base = self.basename(ext)
+    presult = (dirname.to_s.empty?) ? base : dirname+base
+    presult.to_s
+  end
+end

data/lib/masterview/template_spec.rb

@@ -26,36 +26,35 @@ module MasterView
       File.basename @path
     end
 
+    # get path relative to working dir
+    def long_path
+      IOMgr.template.path(@path).full_pathname.to_s
+    end
+
     # scan the directory of templates, building template_specs and the content_hash
     def self.scan(options = {}, &block)
       content_hash = {}
       template_specs = {}
-      files = []
-      Find.find(File.join('app/views', TemplateSrcRelativePath)){ |f| files << f }
-      files.sort!
 
-      files.each do |path|
-        if !File.directory?(path) && File.fnmatch?(TemplateFilenamePattern, path)
-          template_specs[path] = scan_template_file(path, content_hash)
-        end
+      IOMgr.template.find(:pattern => TemplateFilenamePattern) do |mio|
+        template_specs[mio.pathname.to_s] = scan_template_mio(mio, content_hash)
       end
 
-      files.each do |path|
-        if !File.directory?(path) && File.fnmatch?(TemplateFilenamePattern, path)
-          if template_specs[path].status == Status::OK
-            invalid_parts = template_file_out_of_sync?(path, content_hash)
-            template_spec = template_specs[path]
-            template_spec.update_status_from_invalid_parts(invalid_parts)
-          end
-          yield template_specs[path], content_hash if block
+      IOMgr.template.find(:pattern => TemplateFilenamePattern) do |mio|
+        path = mio.pathname.to_s
+        if template_specs[path].status == Status::OK
+          invalid_parts = template_mio_out_of_sync?(path, content_hash)
+          template_spec = template_specs[path]
+          template_spec.update_status_from_invalid_parts(invalid_parts)
         end
+        yield template_specs[path], content_hash if block_given?
       end
-
       return template_specs, content_hash
     end
 
-    def self.scan_template_file(path, content_hash = {} )
-      template = File.new(path)
+    def self.scan_template_mio(mio, content_hash = {} )
+      template = mio.read(:disable_cache => true)
+      path = mio.pathname.to_s
       self.scan_template(template, path, content_hash)
     end
 
@@ -69,7 +68,7 @@ module MasterView
     # create a template_spec
     def self.scan_template(template, path, content_hash = {})
       template_spec = TemplateSpec.new(path)
-      listener = MasterView::Analyzer::Listener.new
+      listener = MasterView::Analyzer::Listener.new( :template_pathname => Pathname.for_path(path) )
       begin 
         MasterView::Parser.parse( template, :rescue_exceptions => false, :listeners => [listener])
         template_spec.build_list = listener.list
@@ -89,14 +88,16 @@ module MasterView
       template_spec
     end
 
-    def self.template_file_out_of_sync?(path, content_hash)
-      self.template_out_of_sync?(File.new(path), content_hash)
+    def self.template_mio_out_of_sync?(path, content_hash)
+      mio = IOMgr.template.path(path)
+      template = mio.read(:disable_cache => true)
+      self.template_out_of_sync?(template, path, content_hash)
     end
 
     # check if the template is out of sync with the source content (check imports), return array of invalid
-    def self.template_out_of_sync?(template, content_hash)
+    def self.template_out_of_sync?(template, path, content_hash)
       invalid = []
-      listener = MasterView::Analyzer::Listener.new(:content_hash => content_hash, :only_check_hash => true)
+      listener = MasterView::Analyzer::Listener.new(:content_hash => content_hash, :template_pathname => Pathname.for_path(path), :only_check_hash => true)
       Parser.parse( template, :rescue_exceptions => false, :listeners => [listener] )
       invalid_list_items = listener.list.find_all { |li| li.hash_invalid? }
       invalid_with_dups = invalid_list_items.collect { |li| li.name }
@@ -107,8 +108,8 @@ module MasterView
     # rebuild template updating all imports, returns the string contents, 
     # if options[:write_to_file] = true then it will write the contents to file if different and return true, if identical then returns false
     # otherwise this method returns the content of the template
-    # raise error for any other problems. options[:backup] = true to make backup before rebuilding, uses DirectoryForRebuildBackups to determine
-    # path for where to store backup files. If DirectoryForRebuildBackups is nil, then no backup is created.
+    # raise error for any other problems. options[:backup] = true to make backup before rebuilding, uses MasterView::IOMgr.backup to determine
+    # path for where to store backup files. If MasterView::IOMgr.backup is nil, then no backup is created.
     def rebuild_template(content_hash, options = {} )
       out = []
       builder = MasterView::Analyzer::Builder.new(content_hash)
@@ -117,20 +118,18 @@ module MasterView
         con = builder.data(li.name, li.index)
         if li.import
           con = con.gsub NamespacePrefix+'generate', NamespacePrefix+'import'
-          con.gsub! NamespacePrefix+'gen_render', NamespacePrefix+'import_render'
+          con.gsub! NamespacePrefix+'gen_partial', NamespacePrefix+'import_render'
         end
         out << con
       end
       template = out.join
       if options[:write_to_file]
-        backup = !options[:backup].nil? ? options[:backup] : DirectoryForRebuildBackups
-        orig = File.readlines(self.path).join
+        backup = !options[:backup].nil? ? options[:backup] : !IOMgr.backup.nil?
+        orig = IOMgr.template.path(self.path).read(:disable_cache => true)
         file_written = false
         unless template == orig
           self.backup_file if backup
-          File.open(self.path, 'w') do |io|
-            io << template
-          end
+          IOMgr.template.path(self.path).write(template, :force => true) #force write in case tidy had cleaned up
           file_written = true
         end
         return file_written
@@ -141,11 +140,11 @@ module MasterView
 
     # create backup file by appending secs since epoch to filename
     def backup_file(options={} )
-      return unless DirectoryForRebuildBackups
-      FileUtils.makedirs(DirectoryForRebuildBackups) unless File.exist?(DirectoryForRebuildBackups) #ensure path exists
-      dst = File.join(DirectoryForRebuildBackups, File.basename(self.path)+'.'+Time.new.to_i.to_s)
-      Log.debug { 'creating backup file '+dst }
-      FileUtils.cp self.path, dst
+      return unless IOMgr.backup
+      contents_to_backup = IOMgr.template.path(self.path).read
+      backup_path = self.path+'.'+Time.new.to_i.to_s
+      Log.debug { 'creating backup file '+backup_path }
+      IOMgr.backup.path(backup_path).write(contents_to_backup)
     end
 
     # create empty shell file consisting of layout and a comment for where to insert new content, return contents
@@ -179,6 +178,7 @@ module MasterView
       end
     end
 
+
     # create empty shell file consisting of layout and a comment for where to insert new content. Use action_to_create
     # to infer the destination name controller_action.html and to customize the inserted place holder. Pass the 
     # empty insert erb (rhtml) content in which will be rendered with appropriate controller and action values.
@@ -187,36 +187,29 @@ module MasterView
     #    :template_source => source_for_template (use this source instead of reading from file)
     #    :content_hash => use this content_hash, otherwise it will scan the masterview template directory to create content_hash
     def self.create_empty_shell_for_action(path_to_copy_shell_from, action_to_create, empty_insert_erb, options={} )
-      short_name = File.basename(path_to_copy_shell_from)
-      controller_name = nil
-      extension = nil
-      short_name.scan( /^([^_.]+)_?([^.]*)(\.?\w*)$/ ) do |c, a, e|
-        controller_name = c
-        extension = e
-      end
-      extension = '.html' if extension.empty?
-      short_name = File.basename(short_name, extension)+extension #ensure short_name has extension
-
+      path = IOMgr.template.cleanup_path_get_relative_pathname(path_to_copy_shell_from).to_s
+      controller_name = Pathname.for_path(path).dirname.to_s
+      extension = IOMgr.template.default_extension
       erb_values = CreateShellERBValues.new(controller_name, action_to_create)
       template = ERB.new(empty_insert_erb)
       content_to_insert = template.result(erb_values.get_binding).strip #clear off surrounding whitespace that makes it difficult to debug
 
-      src_file = File.join('app/views', MasterView::TemplateSrcRelativePath, short_name)
-      dst_file = File.join('app/views', MasterView::TemplateSrcRelativePath, erb_values.controller_file_name+'_'+erb_values.action_name+extension)
-      src = (tsrc = options[:template_source]) ? tsrc : File.readlines(src_file).join
+      basename_with_extension = erb_values.action_name
+      basename_with_extension += extension if extension
+      dst_path = (Pathname.for_path(path).dirname+(basename_with_extension)).to_s
+      src = (tsrc = options[:template_source]) ? tsrc : IOMgr.template.path(path).read
 
       template_specs = {}
       content_hash = options[:content_hash]
       template_specs, content_hash = TemplateSpec.scan unless content_hash
-      template_spec_to_copy = template_specs[src_file] || TemplateSpec.scan_template(src, src_file)
+      template_spec_to_copy = template_specs[path] || TemplateSpec.scan_template(src, path)
 
-      result = MasterView::TemplateSpec.create_empty_shell( template_spec_to_copy, content_hash, content_to_insert)
+      result = TemplateSpec.create_empty_shell( template_spec_to_copy, content_hash, content_to_insert)
       if options[:write_to_file]
-        raise 'File '+dst_file+' already exists, operation aborted.' if File.exist? dst_file
-        File.open(dst_file, 'w') do |io|
-          io << result
-        end
-        return dst_file
+        template_mio = IOMgr.template.path(dst_path)
+        raise 'Template '+dst_path+' already exists, operation aborted.' if template_mio.exist?
+        template_mio.write(result)
+        return dst_path
       end
       result
     end