masterview 0.1.5 → 0.2.0

data/lib/masterview/io.rb

@@ -0,0 +1,352 @@
+require 'ostruct'
+require 'pathname'
+require 'stringio'
+require File.join( File.dirname(__FILE__), 'pathname_extensions' )
+require File.join( File.dirname(__FILE__), 'mtime_tracking_hash' )
+require File.join( File.dirname(__FILE__), '../facets/core/string/starts_with' )
+require File.join( File.dirname(__FILE__), 'filter_helpers' )
+
+module MasterView
+  # IOManager which retrieves the proper MasterViewIOTree object for the type of object being requested
+  # set and access MasterViewIOTree by using accessors 
+  # IOMgr.template = FileMIOTree()
+  # ftree = IOMgr.template
+  # IOMgr.erb = FileMIOTree()
+  # etree = IOMgr.erb
+  # Once the mioTree is obtained it may be used for obtaining mio objects for reading and writing
+  class MIOTrees < OpenStruct
+  end
+
+#   MIOTreeInterface
+#   path(path)
+#   find(options, &block) options[:path] = 'foo' limits find to dir foo
+#   cleanup_path_get_relative_pathname(path)
+
+#   MIOInterface
+#   pathname()
+#   full_pathname() # for FileMIO returns full_pathname otherwise for all others identical to pathname
+#   read(options={}) options[:disable_cache]=true bypasses cache filter, options[:disable_logging] = true turns off log of this event
+#   write(content=nil, options={}, &block) options[:disable_logging]=true turns off log of this event options[:force] = true forces the write even if identical
+#   exist?(path)
+#   identical?(content)
+#   mtime()
+  
+
+  # mixin which encapsulates the apply filter to new MIO objects and 
+  # the default filter block
+  module MasterViewIOTreeMixin
+    DefaultExtensionInstances = {}
+
+    # apply filters to object, use block if provided otherwise use
+    # default_mio_filter_block which is customized by options hash
+    # options[:escape_erb] = true enables erb escaping
+    # options[:tidy] = true enables tidy processing to cleanup bad xhtml
+    # options[:caching] = true enables caching so that reads are cached
+    # options[:logging] = true enables logging of reads and writes 
+    def apply_filters(mio, options, block)
+      if block
+        block.call(mio)
+      else
+        default_mio_filter_block(options).call(mio)
+      end
+      mio
+    end
+
+    def default_mio_filter_block(options)
+      lambda do |mio|
+        mio.extend EscapeErbMIOFilter if options[:escape_erb]
+        mio.extend TidyMIOFilter if options[:tidy]
+        mio.extend CachingMIOFilter if options[:caching]
+        mio.extend ReadWriteLoggingMIOFilter if options[:logging]
+      end
+    end
+
+    def default_extension
+      DefaultExtensionInstances[object_id]
+    end
+
+    def default_extension=(default_extension)
+      DefaultExtensionInstances[object_id] = default_extension
+    end
+
+    # clean up ../.. check if path starts with root path and if so get relative, otherwise return path, root_path is only
+    # used in FileMIO, so all others just simply clean the path. FileMIO will override this with its own implementation.
+    def cleanup_path_get_relative_pathname(path)
+      pathname = Pathname.for_path(path)
+      pathname = Pathname.for_path(pathname.to_s+self.default_extension) if pathname.extname.empty? && self.default_extension && !self.default_extension.empty?
+      pathname
+    end
+  end
+
+  class FileMIOTree < Pathname
+    include MasterViewIOTreeMixin
+    def initialize(root_path=Pathname.getwd, default_extension=nil, options = {}, &block)
+      @options = options
+      self.default_extension = default_extension
+      super(Pathname.for_path(root_path).cleanpath)
+      @new_mio_block = block
+    end
+
+    def path(path)
+      raise InvalidPathError.new('Invalid path specified ('+path.to_s+'). Path is limited to directories under root_path ('+self.to_s+')') unless (self+path).expand_path.to_s.starts_with?(self.expand_path.to_s) #ensure sandbox
+      mio = FileMIO.new(path, self + path)
+      apply_filters(mio, @options, @new_mio_block)
+    end
+
+    # returns mio objects, if block_given then it yields passing the mio object to the block
+    def find(options = {}, &block)
+      path = options[:path] || '.'
+      found = []
+      working_path = Pathname.safe_concat(self, path)
+      working_path.find { |p| found << p unless p.directory? }
+      found = found.select { |f| f.basename.fnmatch?(options[:pattern]) } if options[:pattern]
+      found = found.collect{ |f| self.path(f.relative_path_from(self)) } # create mio objects
+      found = found.sort { |a,b| a.pathname.to_s <=> b.pathname.to_s }
+      found.each { |mio| yield mio } if block_given?
+      found
+    end
+
+    # clean up ../.. check if path starts with root path and if so get relative, otherwise return path
+    def cleanup_path_get_relative_pathname(path)
+      pathname = Pathname.for_path(path)
+      pathname = pathname.relative_path_from(self) if pathname.to_s.starts_with?(self.to_s)
+      pathname = Pathname.for_path(pathname.to_s+self.default_extension) if pathname.extname.empty? && self.default_extension && !self.default_extension.empty?
+      pathname
+    end
+  end
+
+  # MIO implemented as simple hash of path to string content
+  # This MIOTree does not keep track of mtimes and thus will always return new mtimes
+  class StringHashMIOTree
+    include MasterViewIOTreeMixin
+    attr_reader :string_hash
+    def initialize(string_hash = {}, default_extension=nil, options={}, &block)
+      @string_hash = string_hash
+      @options = options
+      self.default_extension = default_extension
+      @new_mio_block = block
+    end
+
+    def string_hash=(string_hash)
+      @string_hash = string_hash
+    end
+
+    def path(path)
+      clean_path = Pathname.for_path(path).cleanpath
+      mio = StringMIO.new(clean_path, @string_hash)
+      mio.pathname = clean_path
+      apply_filters(mio, @options, @new_mio_block)
+    end
+
+    def find(options = {})
+      path = options[:path] || '' 
+      path = '' if path == '.'
+      found = []
+      @string_hash.each { |p,v| found << p if p.starts_with?(path) }
+      found = found.select { |p| Pathname.for_path(p).basename.fnmatch?(options[:pattern]) } if options[:pattern]
+      found.sort!
+      found = found.collect{ |p| self.path(p) } # create mio objects
+      found.each { |mio| yield mio } if block_given?
+      found
+    end
+
+  end
+
+  class ActiveRecordMIOTree #todo
+    include MasterViewIOTreeMixin
+    def initialize
+      self.default_extension = default_extension
+    end
+    
+    def path(path)
+    end
+
+    def find(options, &block)
+    end
+  end
+
+  # MIOTree which works like StringHashMIO but uses MTimeTrackingHash to track mod times
+  class MTimeStringHashMIOTree < StringHashMIOTree
+
+    def initialize(default_extension=nil, options={}, &block)
+      super(MTimeTrackingHash.new, default_extension, options)
+    end
+
+    def path(path)
+      clean_path = Pathname.for_path(path).cleanpath
+      mio = MTimeStringMIO.new(clean_path, @string_hash)
+      mio.pathname = clean_path
+      apply_filters(mio, @options, @new_mio_block)
+    end
+
+    def string_hash=(mtime_tracking_hash)
+      raise "mtime_tracking_hash passed in does not respond_to mtime method call" unless mtime_tracking_hash.respond_to?(:mtime)
+      @string_hash = mtime_tracking_hash
+    end
+
+  end
+
+  # mio which allows skipping the intermediate erb file generation in rails.
+  # Current implementation inherits its functionality from MTimeStringHashMIOTree
+  class RailsErbCacheMIOTree < MTimeStringHashMIOTree
+  end
+
+
+  class MIOBase
+    attr_accessor :pathname
+
+    def initialize(path)
+      @pathname = Pathname.for_path(path)
+    end
+
+    # for mio objects other than FileMIO, full_pathname is same as pathname
+    def full_pathname
+      @pathname
+    end
+  end
+
+  module MasterViewIOIdenticalMixin
+    def identical?(compare_content)
+      self.exist? && compare_content == self.read(:disable_logging => true ) # eliminate the noise, simply checking if different
+    end
+  end
+
+
+  class FileMIO < Pathname
+    include MasterViewIOIdenticalMixin
+    attr_reader :pathname
+
+    def initialize(path, full_path)
+      super(full_path)
+      @pathname = Pathname.for_path(path)
+    end
+
+    def full_pathname
+      self
+    end
+
+    def read(options = {})
+      super()
+    end
+
+    def write(content = nil, options={}, &block)
+      written = false
+      if block_given?
+        sio = ::StringIO.new
+        yield sio
+        content = sio.string
+      end
+      if options[:force] || !identical?(content)
+        self.dirname.mkpath unless self.dirname.exist?
+        self.open('w') do |io|
+          io << content
+        end
+        written = true
+      end
+      written
+    end
+  end
+
+  class StringMIO < MIOBase
+    include MasterViewIOIdenticalMixin
+    attr_accessor :exist
+    attr_reader :mtime
+
+    def initialize(path, string_hash, mtime = Time.new)
+      super(path)
+      @string_hash = string_hash
+      @mtime = mtime
+    end
+
+    def read(options = {})
+      @string_hash[self.pathname.to_s]
+    end
+
+    def write(content = nil, options = {}, &block)
+      written = false
+      if block_given?
+        sio = ::StringIO.new
+        yield sio
+        content = sio.string
+      end
+
+      if options[:force] || !self.identical?(content)
+        @string_hash[self.pathname.to_s] = content
+        @mtime = Time.now
+        written = true
+      end
+      written
+    end
+
+    def exist?
+      @string_hash.has_key?(self.pathname.to_s)
+    end
+  end
+
+  # used by MTimeStringHashMIOTree to create MIO objects that check
+  # their mod time using the MTimeTrackingHash
+  class MTimeStringMIO < StringMIO
+    def initialize(path, mtime_tracking_hash)
+      super(path, mtime_tracking_hash, nil)
+    end
+
+    def mtime
+      @string_hash.mtime(self.pathname.to_s)
+    end
+  end
+
+
+  class ActiveRecordMIO < MIOBase
+    include MasterViewIOIdenticalMixin
+    def exist?; end
+    def mtime; end
+  end
+
+
+
+  module CachingMIOFilter #todo
+    def read(options={}) 
+      if options[:disable_cache]
+        super
+      else #caching on
+        super #todo obtain from cache
+      end
+    end
+  end
+
+  module TidyMIOFilter
+    def read(options={})
+      content = super
+      ::MasterView::TidyHelper.tidy(content)
+    end
+  end
+
+  module EscapeErbMIOFilter
+    def read(options={})
+      content = super
+      ::MasterView::EscapeErbHelper.escape_erb(content)
+    end
+  end
+
+  module ReadWriteLoggingMIOFilter #todo
+    def read(options={})
+      Log.debug { "reading file="+self.full_pathname } unless options[:disable_logging]
+      super
+    end
+
+    def write(content = nil, options = {}, &block)
+      Log.debug { "writing file="+self.full_pathname } unless options[:disable_logging]
+      super
+    end
+  end
+
+
+  # raised when an invalid path is given, or if the path is outside of the root_path
+  class InvalidPathError < RuntimeError
+  end
+
+  # raised when a  method is not called with the appropriate arguments 
+  class InvalidArgumentError < RuntimeError
+  end
+
+end

data/lib/masterview/keyword_expander.rb

@@ -0,0 +1,116 @@
+module MasterView
+  # Keyword expander is used to hold variables defined to be used in expansion of 
+  # attributes. 
+  class KeywordExpander
+
+    #--
+    # keywords related to path information about the template being processed
+    #++
+    # relative path of the template being processed within the template src dir
+    # (does *not* include the template flie extension)
+    KW_TEMPLATE_PATH = '{template_path}'
+    # relative path of the directory containing the template being processed 
+    # within the template src dir.
+    # ('' if template is directly contained in the templates src dir)
+    KW_TEMPLATE_DIR_PATH = '{template_dir_path}'
+    # base filename of the template being processed (no file extension)
+    KW_TEMPLATE_BASENAME = '{template_basename}'
+    # filename extension of the template being processed (ordinarily '.html')
+    KW_EXTENSION = '{extension}'
+    # the default extension for generated output (ordinarily '.rhthml')
+    KW_DEFAULT_EXTENSION = '{default_extension}'
+    # list of all supported keywords related to the template being processed
+    TEMPLATE_KEYWORDS = [ KW_TEMPLATE_PATH, KW_TEMPLATE_DIR_PATH, KW_TEMPLATE_BASENAME, KW_EXTENSION ]
+
+    def initialize(hash = {})
+      @hash = hash
+      build_key_value_array_sorted_by_desc_length
+    end
+
+    # Sets a variety of path related keywords:
+    #
+    # MasterView supports the following keyword expansions for 
+    # mv:generate, mv:gen_partial, mv:import, and mv:import_render
+    #
+    #--
+    # The default generated output extension is MasterView::GeneratedFileDefaultExtension,
+    # per the masterview config.output_filename_extension setting.
+    #++
+    #
+    # For template file <code>one/foo/bar.html</code> when default generated output extension '.rhtml':
+    #   {template_path} == use original masterview template path with default output extension (one/foo/bar.rhtml)
+    #   {template_path}.ext == use original masterview template path with the specified extension (one/foo/bar.ext)
+    #   {template_dir_path} == direct_parent_dirname (one/foo)
+    #   {template_basename} == basename (bar)
+    #   {extension} == extension (.html)
+    #
+    # For example:
+    # with MasterView template file <code>one/two/three.html</code> and default generated output extension '.rhtml'
+    #   mv:generate="{template_path}" expands to mv:generate="one/two/three.rhtml" (default generation output extension used)
+    #   mv:generate="{template_path}.rcss" expands to mv:generate="one/two/three.rcss" 
+    #   mv:generate="{template_dir_path}/{template_basename}" expands to mv:generate="one/two/three" (no extension)
+    #   mv:generate="{template_dir_path}/{template_basename}.rcss" expands to mv:generate="one/two/three.rcss" 
+    #   mv:generate="{template_dir_path}/{template_basename}-bar.rtxt" expands to mv:generate="one/two/three-bar.rtxt" 
+    #   mv:generate="somewhere/{template_basename}-bar{extension}" expands to mv:generate="somewhere/three-bar.html" 
+    #
+    # Note: All path values use forward slashes
+    # 
+    def set_template_pathname(template_pathname, default_erb_extension)
+      return if template_pathname.nil?
+      pn = Pathname.for_path(template_pathname)
+      default_erb_extension = '' if default_erb_extension.nil?
+      @hash[KW_TEMPLATE_PATH] = convert_pathname_to_s(pn.path_no_ext)  #defer decision: + default_erb_extension
+      @hash[KW_TEMPLATE_DIR_PATH] = convert_pathname_to_s(pn.dirname)
+      @hash[KW_TEMPLATE_BASENAME] = convert_pathname_to_s(pn.basename(pn.extname))
+      @hash[KW_EXTENSION] = pn.extname
+      @hash[KW_DEFAULT_EXTENSION] = default_erb_extension
+      build_key_value_array_sorted_by_desc_length
+    end
+
+    # set the value, regenerate a reverse sorted hash value array so that it will
+    # replace the longer replacement keys before the shorter ones, so FOO_BAR will be
+    # replaced before FOO
+    def set(key, value)
+      @hash[key] = value
+      build_key_value_array_sorted_by_desc_length
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    # expand all keywords, return value
+    def expand_keywords(str)
+      # maybe consider: add parm check_template_path=false that mv:generate processor would turn on 
+      # so that ext. defaulting cleverness only applies in that specific context.
+      # Might be overaggressive (or just unnecessary) to this this on *all* substitution mappings
+      # [DJL 18-Jun-2006]
+      return nil if str.nil?
+      append_default_ext = str.ends_with?(KW_TEMPLATE_PATH) and @hash.has_key?(KW_DEFAULT_EXTENSION)
+      val = str.clone
+      @hash_values_by_desc_key_length.each { |k,v| val.gsub!(k,v) } 
+      val << @hash[KW_DEFAULT_EXTENSION] if append_default_ext
+      val
+    end
+
+    # finds the attribute using the key deleting it from hash, expands value using current binding
+    # which allows KEYWORD substitutions before returning string, return nil if not found
+    def resolveAttrAndDelete(attributes, key)
+      attr_value = attributes.delete(key)
+      attr_value = expand_keywords(attr_value) unless attr_value.nil?
+      attr_value
+    end
+
+    private
+
+    # convert pathname to string, for '.' we want empty string
+    def convert_pathname_to_s(pathname)
+      (pathname.to_s == '.') ? '' : pathname.to_s
+    end
+
+    def build_key_value_array_sorted_by_desc_length
+      @hash_values_by_desc_key_length = @hash.sort { |a,b| b[0].length <=> a[0].length } # longest keys first
+    end
+  end
+end
+

data/lib/masterview/masterview_version.rb

@@ -1,8 +1,8 @@
 module MasterView
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 5
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/masterview/mtime_tracking_hash.rb

@@ -0,0 +1,44 @@
+module MasterView
+
+  # this hash is designed to track modified times of its values
+  # this behaviour is only supported through using []= and store 
+  # mechanisms and thus default semantics have been excluded
+  # other update methods such as merge! have been excluded from 
+  # this implementation and will raise errors
+  class MTimeTrackingHash < Hash
+
+    # MTimeTrackingHash does not support defaults and thus does
+    # not take default object or block
+    def initialize
+      super
+      @mtimes = {}
+    end
+    
+    def []=(key, value)
+      update_mtime(key)
+      super
+    end
+
+    def store(key, value)
+      update_mtime(key)
+      super
+    end
+
+    # returns the Time object for this key
+    def mtime(key)
+      @mtimes[key]
+    end
+
+    private
+
+    def update_mtime(key)
+      @mtimes[key] = Time.now
+    end
+
+    def default=(obj); raise "Not implemented"; end
+    def merge!(obj,&block); raise "Not implemented"; end
+    def reject!(obj,&block); raise "Not implemented"; end
+    def replace(obj); raise "Not implemented"; end
+
+  end
+end