erbside 0.1.0 → 0.2.0

data/work/defunct/inline.rb

@@ -0,0 +1,202 @@
+module Till
+
+  # = Inline Templating
+  #
+  class Inline
+
+    # R E Q U I R E M E N T S
+
+    require 'erb'
+    require 'tilt'
+    require 'till/context'
+
+
+    # C O N S T A N T S
+
+    # Supported templating systems.
+    STENCILS = %w{ .erb .liquid .mustache }
+
+
+    # A T T R I B U T E S
+
+    # The file to receive inline templating.
+    attr :file
+
+    # The extname of the file.
+    attr :extension
+
+    # Location of the file.
+    attr :location
+
+    # The rendered result.
+    attr :result
+
+    # Rendering context/scope.
+    attr :context
+
+    # Extension name of stenciling template system
+    # to use. This determines with templating system to use,
+    # such as .erb, .liquid, etc. This defaults to '.erb',
+    # but can be changed in the file with:
+    #
+    #   # :till.stencil: <ext>
+    #
+    attr :stencil
+
+
+    # I N I T I A L I Z E
+
+    #
+    def initialize(file)
+      @file      = file
+      @extension = File.extname(file)
+      @location  = File.dirname(File.expand_path(file))
+
+      self.stencil = '.erb'
+
+      @context = Context.new(@location)
+    end
+
+    #
+    def stencil=(ext)
+      ext = (ext[0,1] == '.' ? ext : ".#{ext}")
+      raise "unsupported stencil type -- #{ext}" unless STENCILS.include?(ext)
+      @stencil = ext
+    end
+
+    #
+    def root
+      context.metadata.root
+    end
+
+    #
+    def render
+      render_inline(file)
+    end
+
+    #
+    def render_inline(file)
+      #name  = file.sub(Dir.pwd+'/', '')
+      save = false
+      text = ''
+      lines = File.readlines(file)
+      i = 0
+      while i < lines.size
+        line = lines[i]
+        if md = /^\s*#\s*:till.stencil:(.*?)/.match(line)
+          self.type = md[1].strip
+          text << line
+        elsif md = /^(\s*)#(\s*):till\+(\d*):/.match(line)
+          temp = md.post_match
+          code = md.post_match
+          line = lines[i+=1]
+          while i < lines.size && line =~ /^\s*^#/
+            temp << line
+            code << line
+            line = lines[i+=1]
+          end
+          res = render_template(code.gsub(/^\s*#*/,'').strip)
+          text << md[1] + "#" + md[2] + ":till+#{res.split("\n").size}:"
+          text << temp
+          text << res
+          text << "\n"
+          save = true
+          i += md[3].to_i
+        elsif md = /^(\s*).*?(\s*#\s*:till:)/.match(line)
+          pm = md.post_match.strip
+          if pm[0,1] == '^'
+            pm = pm[1..-1].strip
+            fm = pm[0...(pm.index('<')||-1)]
+            ri = line.index(fm)
+            if ri
+              text << line[0...ri] + render_template(pm) + md[2] + md.post_match
+            else
+              puts "waning: skipped line #{i} no match for #{fm}"
+              text << line
+            end
+          else
+            text << md[1] + render_template(pm) + md[2] + md.post_match
+          end
+          save = true
+          i += 1
+        else
+          text << line
+          i += 1
+        end
+      end
+
+      @result = text
+    end
+
+    #
+
+    def render_template(text)
+      template = Tilt[stencil]
+      unless template
+        warn "unknown template type #{stencil}"
+        template = Tilt::ERBTemplate
+      end
+      render_tilt(template.new{ text })
+    end
+
+    #
+
+    def render_tilt(template)
+      Dir.chdir(location) do
+        template.render(@context)
+      end
+    end
+
+    #
+
+    def relative_output(dir=nil)
+      dir = dir || Dir.pwd
+      output.sub(dir+'/', '')
+    end
+
+    #
+
+    def exist?
+      File.exist?(output)
+    end
+
+    # Has the file changed?
+
+    def changed?
+      if exist?
+        File.read(output) != result
+      else
+        true
+      end
+    end
+
+    # Save result to file.
+
+    def save
+      File.open(output, 'w'){ |f| f << result }
+    end
+
+    # Output file (same as the input file).
+
+    def output
+      file
+    end
+
+    #
+
+    #def erb(text, file=nil)
+    #  if file
+    #    dir = File.dirname(file)
+    #    Dir.chdir(dir) do
+    #      context.erb(text)
+    #    end
+    #  else
+    #    context.erb(text)
+    #  end
+    #end
+
+  end
+
+end
+
+

data/work/defunct/plan.rb

@@ -0,0 +1,37 @@
+module Till
+
+  # = Tilling Plan
+  #
+  # A plan file is used to easily repeat a set of tills.
+  #
+  #   myfile.html:
+  #     source: templates/myfile.rdoc
+  #     filter: erb, rdoc
+  #
+  class Plan
+
+    include Enumerable
+
+    #
+
+    def initialize(root)
+      file = Dir[File.join(root, '{.config,config}/till/plan.{yml,yaml}')].first
+      @plan = file ? YAML.load(File.new(file) : {}
+    end
+
+    #
+
+    def [](file)
+      @plan[file]
+    end
+
+    #
+
+    def each(&block)
+      @plan.each(&block)
+    end
+
+  end
+
+end
+

data/work/defunct/tiller.rb

@@ -0,0 +1,200 @@
+require 'till/metadata'
+require 'facets/kernel/ask'
+require 'facets/string/tabto'
+require 'erb'
+
+module Till
+
+  # The Tiller class is used to generate files from
+  # embebbded ERB template files.
+  #
+  class Tiller
+
+    attr_accessor :files
+
+    attr_accessor :force
+
+    attr_accessor :skip
+
+    #attr_accessor :delete
+
+    #
+    def initialize(files, options)
+      files = files || Dir['**/*.til']
+      files = files.map do |file|
+        if File.directory?(file)
+          collect_usable_files(file)
+        else
+          file
+        end
+      end.flatten
+      @files = files
+      @force = options[:force]
+      @skip  = options[:skip]
+      #@delete = options[:delete]
+    end
+
+    def collect_usable_files(dir)
+      Dir[File.join(dir,'**/*.{till,til,rb}')]
+    end
+
+    def delete? ; @delete ; end
+    def force?  ; @force  ; end
+    def skip?   ; @skip   ; end
+
+    def debug?  ; $DEBUG  ; end
+    def trial?  ; $TRIAL  ; end
+
+    #
+    #def tillfiles
+    #  @tillfiles ||= Dir[File.join(@output, '**/*.till')].select{ |f| File.file?(f) }
+    #end
+
+    #
+    #def rubyfiles
+    #  @rubyfiles ||= Dir[File.join(@output, '**/*.rb')].select{ |f| File.file?(f) }
+    #end
+
+    def till
+      files.each{ |file|
+        raise "unsupport file type -- #{file}" unless File.extname =~ /^\.(rb|til|till)$/
+      end
+
+      files.each do |file|
+        case File.extname(file)
+        when '.till', '.til'
+          till_template(file)
+        when '.rb'
+          till_inline(file)
+        end
+      end
+    end
+
+    # Search for till templates (*.till) and render.
+    #
+    def till_template(file)
+      result = erb(File.read(file))
+      fname = file.chomp(File.extname(file))
+      write(fname, result)
+      #rm(file) if delete?  # TODO
+    end
+
+    # Search through Ruby files for inline till templates.
+    def till_inline(file)
+      name  = file.sub(Dir.pwd+'/', '')
+      save = false
+      text = ''
+      lines = File.readlines(file)
+      i = 0
+      while i < lines.size
+        line = lines[i]
+        if md = /^(\s*)#(\s*):till\+(\d*):/.match(line)
+          temp = md.post_match
+          code = md.post_match
+          line = lines[i+=1]
+          while i < lines.size && line =~ /^\s*^#/
+            temp << line
+            code << line
+            line = lines[i+=1]
+          end
+          res = erb(code.gsub(/^\s*#*/,'').strip, file)
+          text << md[1] + "#" + md[2] + ":till+#{res.split("\n").size}:"
+          text << temp
+          text << res
+          text << "\n"
+          save = true
+          i += md[3].to_i
+        elsif md = /^(\s*).*?(\s*#\s*:till:)/.match(line)
+          pm = md.post_match.strip
+          if pm[0,1] == '^'
+            pm = pm[1..-1].strip
+            fm = pm[0...(pm.index('<')||-1)]
+            ri = line.index(fm)
+            if ri
+              text << line[0...ri] + erb(pm, file) + md[2] + md.post_match
+            else
+              puts "waning: skipped line #{i} no match for #{fm}"
+              text << line
+            end
+          else
+            text << md[1] + erb(pm, file) + md[2] + md.post_match
+          end
+          save = true
+          i += 1
+        else
+          text << line
+          i += 1
+        end
+      end
+
+      if save
+        write(file, text)
+      end
+    end
+
+    #
+    def write(fname, text)
+      name  = fname.sub(Dir.pwd+'/', '')
+      if trial?
+        puts "  #{name}"
+      else
+        if File.exist?(fname)
+          if skip?  # TODO: skip before running erb ?
+            puts "    skipped #{name}"
+            return
+          elsif File.read(fname) == text
+            puts "  unchanged #{name}"
+            return
+          elsif !force?
+            case ask("  overwrite #{name}? ")
+            when 'y', 'yes'
+            else
+              return
+            end
+          end
+        end
+        File.open(fname, 'w'){ |f| f << text }
+        puts "    written #{name}"
+      end
+    end
+
+    #
+    def context
+      @conext ||= Erb.new() #TODO: @output ?
+    end
+
+    def erb(text, file=nil)
+      if file
+        dir = File.dirname(file)
+        Dir.chdir(dir) do
+          context.erb(text)
+        end
+      else
+        context.erb(text)
+      end
+    end
+
+    # Tiller's erb context
+    #
+    class Erb
+
+      def initialize(dir=nil)
+        @metadata = Metadata.new(dir)
+      end
+
+      def method_missing(s)
+        @metadata.send(s)
+      end
+
+      # Processes through erb.
+      def erb(text)
+        erb = ERB.new(text)
+        erb.result(binding)
+      end
+
+    end#class Context
+
+  end#class Tiller
+
+end
+

data/work/defunct/webme/options.yml

@@ -0,0 +1,4 @@
+---
+colors:
+  back: green
+

data/work/defunct/whole.rb

@@ -0,0 +1,221 @@
+module Till
+
+  # = Whole Template
+  #
+  class Whole
+
+    # R E Q U I R E M E N T S
+
+    # TODO: Load engines only if used?
+
+    begin ; require 'rubygems'  ; rescue LoadError ; end   # why?
+    begin ; require 'erb'       ; rescue LoadError ; end
+    begin ; require 'redcloth'  ; rescue LoadError ; end
+    begin ; require 'bluecloth' ; rescue LoadError ; end
+    begin ; require 'rdiscount' ; rescue LoadError ; end
+
+    begin
+      require 'liquid'
+      #Liquid::Template.register_filter(TemplateFilters)
+    rescue LoadError
+    end
+
+    begin
+      require 'haml'
+      #Haml::Template.options[:format] = :html5
+    rescue LoadError
+    end
+
+    begin
+      require 'rdoc/markup/simple_markup'
+      require 'rdoc/markup/simple_markup/to_html'
+    rescue LoadError
+    end
+
+    require 'tilt'
+
+    require 'till/context'
+
+
+    # A T T R I B U T E S
+
+    # File pathname of the template file.
+    attr :file
+
+    # Directory location of the template +file+.
+    attr :location
+
+    # Format of the template (in terms of extension names).
+    attr :format
+
+    # Where to save the rendered result (defaults to +file+ w/o it's extension).
+    # This is also often referred to as the *target*.
+    attr :output
+
+    # List of redering filters to processes file through (defaults to +extension+ plus +erb+).
+    attr :filters
+
+    # Stores the rendered result, after #render is called.
+    attr :result
+
+    # Body of file.
+    attr :content
+
+    # Context/scope of template rendering.
+    attr :context
+
+
+    # I N I T I A L I Z E
+
+    #
+    def initialize(file)
+      @file = file
+
+      case ext = File.extname(file)
+      when '.till', '.til'
+        fname = file.chomp(ext)
+      else
+        fname = file
+      end
+
+      #@format    = File.extname(fname)
+      @location  = File.dirname(File.expand_path(file))
+
+      text = File.read(file).rstrip
+
+      # front matter indicator
+      if text =~ /\A---/
+        text = text.sub(/---.*?\n/, '')
+        meta, body = *text.split(/^---/)
+      else
+        meta = nil
+        body = text
+      end
+
+      @content = body
+
+      fm = meta ? YAML.load(meta) : {}
+
+      self.filters = fm['filter'] || ['erb']
+
+      self.format = fm['format'] || File.extname(fname)
+
+      if fm['output']
+        self.output = fm['output']
+      else
+        self.output = fname  #.chomp(extension) #+ DEFAULT_CONVERSIONS[filters.last]
+      end
+
+
+
+      #@context = Context.new(@location)  # prime context/scope
+    end
+
+    #
+
+    def output=(path)
+      if path[0,1] == '/'
+        path = File.join(root, path[1..-1])
+      else
+        path = File.join(location, path)
+      end
+      @output = File.expand_path(path)
+    end
+
+    #
+
+    def format=(ext)
+      ext = ext.to_s
+      ext = (ext[0,1] == '.' ? ext : ".#{ext}")
+      case ext
+      when '.md'
+        ext = '.markdown'
+      when '.tt'
+        ext = '.textile'
+      end
+      @format = ext
+    end
+
+    #
+
+    def filters=(list)
+      @filters = [list].flatten.compact.map{ |f| f.sub(/^\./,'') }
+    end
+
+    #
+
+    def relative_output(dir=nil)
+      dir = dir || Dir.pwd
+      output.sub(dir+'/', '')
+    end
+
+    # Does the output file exist?
+
+    def exist?
+      File.exist?(output)
+    end
+
+    #
+
+    def context
+      @context ||= Context.new(location)
+    end
+
+    # TODO: maybe bring root discovery up a level or two ?
+
+    def root 
+      context.metadata.root
+    end
+
+    # Render a whole template.
+
+    def render
+      context = Context.new(location)  # prime context/scope
+      result  = content
+
+      filters.each do |filter|
+        if filter == 'html'  # TODO: +next+ if html format and html filter ?
+          engine = Tilt[format]
+        else
+          engine = Tilt[filter]
+        end
+        raise "unknown filter #{filter}" unless engine
+        result = Dir.chdir(location) do
+          engine.new{result}.render(context)
+        end
+      end
+      @result = result
+    end
+
+    # Is the current rendering different then the output file's content?
+    # This will call #render if it hasn't been called yet.
+
+    def changed?
+      render unless result
+      if exist?
+        File.read(output) != result
+      else
+        true
+      end
+    end
+
+    # Save the rendering to the output file.
+    # This will call #render if it hasn't been called yet.
+
+    def save
+      render unless result
+      if File.exist?(output)
+        mode = File.stat(output).mode
+        File.chmod(mode | 0000220, output)
+        File.open(output, 'w'){ |f| f << result }
+        File.chmod(mode, output)
+      else
+        File.open(output, 'w'){ |f| f << result }
+        File.chmod(0440, output)  # change to read-only mode
+      end
+    end
+
+  end
+
+end
+