regenerate 0.1.0

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require "bundler"
+  Bundler.setup
+rescue LoadError
+  $stderr.puts "You need to have Bundler installed to be able build this gem."
+end
+
+gemspec = eval(File.read("regenerate.gemspec"))
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc "Build gem locally"
+task :build => :gemspec do
+  system "gem build #{gemspec.name}.gemspec"
+  FileUtils.mkdir_p "pkg"
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", "pkg"
+end
+
+desc "Install gem locally"
+task :install => :build do
+  system "gem install pkg/#{gemspec.name}-#{gemspec.version}"
+end
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+end
+
+task :default => :build

data/bin/regenerate

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+ 
+require 'regenerate'
+
+if ARGV.length == 1
+  Regenerate.regenerate(ARGV[0])
+else
+  raise Exception, "regenerate expects exactly one argument: #{ARGV.inspect}"
+end

data/lib/regenerate.rb

@@ -0,0 +1,13 @@
+# A framework for static website generation which regenerates files in place.
+
+require 'regenerate/web-page.rb'
+require 'regenerate/site-regenerator.rb'
+
+STDOUT.sync = true
+STDERR.sync = true
+
+#puts "ARGV = #{ARGV.inspect}"
+
+if ARGV.length >= 1
+  Regenerate.regeneratePath(ARGV[0])
+end

data/lib/regenerate/regenerate-utils.rb

@@ -0,0 +1,31 @@
+module Regenerate
+  
+  module Utils
+    
+    def makeBackupFile(outFile)
+      backupFileName = outFile+"~"
+      if File.exists? backupFileName
+        puts "Deleting existing backup file #{backupFileName} ..."
+        File.delete (backupFileName)
+      end
+      if File.exists? outFile
+        puts "Renaming file #{outFile} to #{backupFileName} ..."
+        File.rename(outFile, backupFileName)
+      end
+    end
+    
+    def ensureDirectoryExists(directoryName)
+      if File.exist? directoryName
+        if not File.directory? directoryName
+          raise "Cannot create directory #{directoryName}, already exists as a non-directory file"
+        end
+      else
+        puts "Creating missing directory #{directoryName} ..."
+        FileUtils.makedirs(directoryName)
+      end
+    end
+    
+  end
+    
+end
+

data/lib/regenerate/site-regenerator.rb

@@ -0,0 +1,156 @@
+require 'pathname'
+require 'fileutils'
+require 'regenerate/regenerate-utils.rb'
+
+module Regenerate
+  
+  class PathAndParents
+    def initialize(path)
+      @path = path
+    end
+    
+    def each
+      currentPath = @path
+      topLevel = false
+      while !topLevel do
+        yield currentPath
+        parentPath = File.dirname(currentPath)
+        topLevel = parentPath == currentPath
+        currentPath = parentPath
+      end
+    end
+  end
+  
+  class SiteRegenerator
+    
+    include Regenerate::Utils
+    
+    def initialize(baseDir, sourceSubDir, outputSubDir)
+      @baseDir = File.expand_path(baseDir)
+      @sourceSubDir = sourceSubDir
+      @outputSubDir = outputSubDir
+      @sourceTypeSubDirs = {:source => @sourceSubDir, :output => @outputSubDir}
+      @sourceTypeDirs = {:source => File.join(@baseDir, @sourceSubDir), 
+        :output => File.join(@baseDir, @outputSubDir)}
+      @oppositeSourceType = {:source => :output, :output => :source}
+      puts "SiteRegenerator, @baseDir = #{@baseDir.inspect}"
+    end
+    
+    def checkNotSourceOnly(pathComponents)
+      for component in pathComponents do
+        if component.start_with?("_")
+          raise "Cannot regenerate source-only component #{pathComponents.join("/")}"
+        end
+      end
+    end
+    
+    REGENERATE_EXTENSIONS = [".htm", ".html", ".xml"]
+    
+    def copySrcToOutputFile(srcFile, outFile)
+      makeBackupFile(outFile)
+      FileUtils.cp(srcFile, outFile, :verbose => true)
+    end
+    
+    def regenerateFileFromSource(srcFile, pathComponents)
+      puts "regenerateFileFromSource, srcFile = #{srcFile}, pathComponents = #{pathComponents.inspect}"
+      subPath = pathComponents.join("/")
+      outFile = File.join(@sourceTypeDirs[:output], subPath)
+      puts "  outFile = #{outFile}"
+      ensureDirectoryExists(File.dirname(outFile))
+      extension = File.extname(srcFile).downcase
+      puts "  extension = #{extension}"
+      if REGENERATE_EXTENSIONS.include? extension
+        WebPage.new(srcFile).regenerateToOutputFile(outFile)
+      else
+        copySrcToOutputFile(srcFile, outFile)
+      end
+    end
+    
+    def regenerateSourceFromOutput(outFile, pathComponents)
+      puts "regenerateSourceFromOutput, outFile = #{outFile}, pathComponents = #{pathComponents.inspect}"
+      subPath = pathComponents.join("/")
+      srcFile = File.join(@sourceTypeDirs[:source], subPath)
+      puts "  srcFile = #{srcFile}"
+      ensureDirectoryExists(File.dirname(srcFile))
+      extension = File.extname(outFile).downcase
+      puts "  extension = #{extension}"
+      if REGENERATE_EXTENSIONS.include? extension
+        raise "Regeneration from output not yet implemented."
+      else
+        copySrcToOutputFile(outFile, srcFile)
+      end
+    end
+    
+    def regenerateFile(srcFile, pathComponents, sourceType)
+      puts "regenerateFile, srcFile = #{srcFile}, sourceType = #{sourceType.inspect}"
+      outFile = File.join(@sourceTypeDirs[@oppositeSourceType[sourceType]], File.join(pathComponents))
+      puts " outFile = #{outFile}"
+      outFileDir = File.dirname(outFile)
+      if !File.exists?(outFileDir)
+        if sourceType == :output
+          raise "Cannot create missing source directory #{outFileDir} - please do so manually if required"
+        end
+        ensureDirectoryExists(outFileDir)
+      end
+      if sourceType == :output
+        regenerateSourceFromOutput(srcFile, pathComponents)
+      elsif sourceType == :source
+        regenerateFileFromSource(srcFile, pathComponents)
+      end
+    end
+    
+    def regenerateSubPath(pathComponents, sourceType)
+      puts "regenerateSubPath, pathComponents = #{pathComponents.inspect}, sourceType = #{sourceType.inspect}"
+      srcPath = File.join(@sourceTypeDirs[sourceType], File.join(pathComponents))
+      puts " srcPath = #{srcPath}"
+      if File.directory? (srcPath)
+        for entry in Dir.entries(srcPath) do
+          if ![".", ".."].include? entry
+            if !entry.start_with?("_")
+              regenerateSubPath(pathComponents + [entry], sourceType)
+            end
+          end
+        end
+      elsif File.file? (srcPath)
+        regenerateFile(srcPath, pathComponents, sourceType)
+      end
+    end
+    
+    def regeneratePath(path)
+      path = File.expand_path(path)
+      puts "SiteRegenerator.regeneratePath, path = #{path}"
+      relativePath = Pathname.new(path).relative_path_from(Pathname.new(@baseDir))
+      puts " relativePath = #{relativePath}"
+      relativePathComponents = relativePath.to_s.split("/")
+      puts " relativePathComponents = #{relativePathComponents.inspect}"
+      subDir = relativePathComponents[0]
+      relativeSubDirPathComponents = relativePathComponents[1..-1]
+      checkNotSourceOnly(relativeSubDirPathComponents)
+      if subDir == @sourceSubDir
+        regenerateSubPath(relativeSubDirPathComponents, :source)
+      elsif subDir == @outputSubDir
+        regenerateSubPath(relativeSubDirPathComponents, :output)
+      else
+        raise "Path #{path} to regenerate is not contained in #{@sourceSubDir} (source) or #{@outputSubDir} (output) sub-directory of base dir #{@baseDir}"
+      end
+    end
+    
+  end
+  
+  def self.findRegenerateScript(path, fileName)
+    for dir in PathAndParents.new(path) do
+      scriptFileName = File.join(dir, fileName)
+      puts " looking for #{scriptFileName} ..."
+      if File.exists?(scriptFileName)
+        return scriptFileName
+      end
+    end
+    raise "File #{fileName} not found in #{path} or any or its parent directories"
+  end
+  
+  def self.regeneratePath(path)
+    regenerateScriptFileName = findRegenerateScript(path, ".regenerate.rb")
+    regenerateScript = File.read(regenerateScriptFileName)
+    eval(regenerateScript, binding, regenerateScriptFileName, 1)
+  end
+end

data/lib/regenerate/web-page.rb

@@ -0,0 +1,468 @@
+require 'set'
+require 'erb'
+require 'json'
+require 'regenerate/regenerate-utils.rb'
+
+module Regenerate
+  
+  # A component, which includes a sequence of lines which make up the text of that component
+  class PageComponent
+    attr_reader :text
+    attr_accessor :parentPage
+    
+    def initialize
+      @lines = []
+      @text = nil # if text is nil, component is not yet finished
+      @parentPage = nil
+    end
+    
+    def processStartComment(parsedCommentLine)
+      @startName = parsedCommentLine.name
+      initializeFromStartComment(parsedCommentLine)
+      if parsedCommentLine.sectionEnd # section end in start comment line, so already finished
+        finishText
+      end
+    end
+    
+    def processEndComment(parsedCommentLine)
+      finishText
+      if parsedCommentLine.name != @startName
+        raise ParseException.new("Name #{parsedCommentLine.name.inspect} in end comment doesn't match name #{@startName.inspect} in start comment.")
+      end
+    end
+    
+    def initializeFromStartComment(parsedCommentLine)
+      # default do nothing
+    end
+    
+    def finished
+      @text != nil
+    end
+    
+    def addLine(line)
+      @lines << line
+    end
+    
+    def addToParentPage
+      # default do nothing
+    end
+    
+    def finishText
+      @text = @lines.join("\n")
+      addToParentPage
+    end
+  end
+  
+  # A component of static text which is not assigned to any variable, and which does not change
+  class StaticHtml < PageComponent
+    def output(showSource = true)
+      text + "\n"
+    end
+    
+    def varName
+      nil
+    end
+  end
+  
+  class RubyCode<PageComponent
+    
+    attr_reader :lineNumber
+    
+    def initialize(lineNumber)
+      super()
+      @lineNumber = lineNumber
+    end
+    
+    def output(showSource = true)
+      if showSource
+        "<!-- [ruby\n#{text}\nruby] -->\n"
+      else
+        ""
+      end
+    end
+    
+    def addToParentPage
+      @parentPage.addRubyComponent(self)
+    end
+  end
+  
+  class SetPageObjectClass<PageComponent
+    attr_reader :className
+    def initialize(className)
+      super()
+      @className = className
+    end
+    
+    def output(showSource = true)
+      if showSource
+        "<!-- [class #{@className}] -->\n"
+      else
+        ""
+      end
+    end
+    
+    def addToParentPage
+      @parentPage.setPageObject(@className)
+    end
+  end
+  
+  # Base class for the text variable types
+  class TextVariable<PageComponent
+    attr_reader :varName
+    
+    def initializeFromStartComment(parsedCommentLine)
+      @varName = parsedCommentLine.instanceVarName
+    end
+    
+    def addToParentPage
+      #puts "TextVariable.addToParentPage #{@varName} = #{@text.inspect}"
+      @parentPage.setPageObjectInstanceVar(@varName, @text)
+    end
+    
+    def textVariableValue
+      @parentPage.getPageObjectInstanceVar(@varName)
+    end
+  end
+  
+  # HtmlVariable Can be both source and result
+  class HtmlVariable < TextVariable
+    
+    def processEndComment(parsedCommentLine)
+      super(parsedCommentLine)
+      if !parsedCommentLine.hasCommentStart
+        raise ParseException.new("End comment for HTML variable does not have a comment start")
+      end
+    end
+    
+    def output(showSource = true)
+      if showSource
+        textValue = textVariableValue
+        if textValue == nil || textValue == ""
+          "<!-- [#{@varName}] -->\n"
+        else
+          "<!-- [#{@varName} -->\n#{textValue}\n<!-- #{@varName}] -->\n"
+        end
+      else
+        text
+      end
+    end
+  end
+  
+  # CommentVariable Is an input only
+  class CommentVariable < TextVariable
+    def processEndComment(parsedCommentLine)
+      super(parsedCommentLine)
+      if parsedCommentLine.hasCommentStart
+        raise ParseException.new("End comment for comment variable has an unexpected comment start")
+      end
+    end
+    
+    def output(showSource = true)
+      if showSource
+        "<!-- [#{@varName}\n#{textVariableValue}\n#{@varName}] -->\n"
+      else
+        ""
+      end
+    end
+  end
+  
+  COMMENT_LINE_REGEX = /^\s*(<!--\s*|)(\[|)((@|)[_a-zA-Z][_a-zA-Z0-9]*)(|\s+([_a-zA-Z0-9]*))(\]|)(\s*-->|)?\s*$/
+  
+  class ParseException<Exception
+  end
+  
+  class ParsedRejennerCommentLine
+    
+    attr_reader :isInstanceVar, :hasCommentStart, :hasCommentEnd, :sectionStart, :sectionEnd
+    attr_reader :isEmptySection, :line, :name, :value
+    
+    def initialize(line, match)
+      @hasCommentStart = match[1] != ""
+      @sectionStart = match[2] != ""
+      @isInstanceVar = match[4] != ""
+      @name = match[3]
+      @value = match[6]
+      @sectionEnd = match[7] != ""
+      @hasCommentEnd = match[8] != ""
+      @line = line
+      @isEmptySection = @sectionStart && @sectionEnd
+    end
+    
+    def to_s
+      "#{@hasCommentStart ? "<!-- ":""}#{@sectionStart ? "[ ":""}#{@isInstanceVar ? "@ ":""}#{@name.inspect}#{@value ? " "+@value:""}#{@sectionEnd ? " ]":""}#{@hasCommentEnd ? " -->":""}"
+    end
+    
+    def isRejennerCommentLine
+      return (@hasCommentStart || @hasCommentEnd) && (@sectionStart || @sectionEnd)
+    end
+    
+    def isRuby
+      !@isInstanceVar && @name == "ruby"
+    end
+    
+    def instanceVarName
+      return @name
+    end
+    
+    def raiseParseException(message)
+      raise ParseException.new("Error parsing line #{@line.inspect}: #{message}")
+    end
+    
+    # only call this method if isRejennerCommentLine returns true
+    def checkIsValid
+      if !@isInstanceVar and !["ruby", "class"].include?(@name)
+        raiseParseException("Unknown section name #{@name.inspect}")
+      end
+      if @isEmptySection and (!@hasCommentStart && !@hasCommentEnd)
+        raiseParseException("Empty section, but is not a closed comment")
+      end
+      if !@sectionStart && !@hasCommentEnd
+        raiseParseException("End of section in comment start")
+      end
+      if !@sectionEnd && !@hasCommentStart
+        raiseParseException("Start of section in comment end")
+      end
+      if (@sectionStart && @sectionEnd) && isRuby
+        raiseParseException("Empty ruby section")
+      end
+    end
+    
+  end
+  
+  class WebPage
+    
+    include Regenerate::Utils
+    
+    attr_reader :fileName
+    
+    def initialize(fileName)
+      @fileName = fileName
+      @components = []
+      @currentComponent = nil
+      @componentInstanceVariables = {}
+      initializePageObject(PageObject.new)  # default, can be overridden by SetPageObjectClass
+      @rubyComponents = []
+      readFileLines
+    end
+    
+    def initializePageObject(pageObject)
+      @pageObject = pageObject
+      setPageObjectInstanceVar("@fileName", @fileName)
+      setPageObjectInstanceVar("@baseDir", File.dirname(@fileName))
+      setPageObjectInstanceVar("@baseFileName", File.basename(@fileName))
+      @initialInstanceVariables = Set.new(@pageObject.instance_variables)
+    end
+    
+    def getPageObjectInstanceVar(varName)
+      @pageObject.instance_variable_get(varName)
+    end
+    
+    def setPageObjectInstanceVar(varName, value)
+      puts " setPageObjectInstanceVar, #{varName} = #{value.inspect}"
+      @pageObject.instance_variable_set(varName, value)
+    end
+    
+    def addRubyComponent(rubyComponent)
+      @rubyComponents << rubyComponent
+    end
+    
+    def setInstanceVarValue(varName, value)
+      if @initialInstanceVariables.member? varName
+        raise Exception, "Instance variable #{varName} is a pre-existing instance variable"
+      end
+      if @componentInstanceVariables.member? varName
+        raise Exception, "Instance variable #{varName} is a already defined for a component"
+      end
+      instance_variable_set(varName, value)
+      componentInstanceVariables << varName
+    end
+    
+    def startNewComponent(component, startComment = nil)
+      
+      component.parentPage = self
+      @currentComponent = component
+      #puts "startNewComponent, @currentComponent = #{@currentComponent.inspect}"
+      @components << component
+      if startComment
+        component.processStartComment(startComment)
+      end
+    end
+    
+    def processTextLine(line, lineNumber)
+      #puts "text: #{line}"
+      if @currentComponent == nil
+        startNewComponent(StaticHtml.new)
+      end
+      @currentComponent.addLine(line)
+    end
+    
+    def classFromString(str)
+      str.split('::').inject(Object) do |mod, class_name|
+        mod.const_get(class_name)
+      end
+    end
+    
+    def setPageObject(className)
+      pageObjectClass = classFromString(className)
+      initializePageObject(pageObjectClass.new)
+    end
+    
+    def processCommandLine(parsedCommandLine, lineNumber)
+      #puts "command: #{parsedCommandLine}"
+      if @currentComponent && (@currentComponent.is_a? StaticHtml)
+        @currentComponent.finishText
+        @currentComponent = nil
+      end
+      if @currentComponent
+        if parsedCommandLine.sectionStart
+          raise ParseException.new("Unexpected section start #{parsedCommandLine} inside component")
+        end
+        @currentComponent.processEndComment(parsedCommandLine)
+        @currentComponent = nil
+      else
+        if !parsedCommandLine.sectionStart
+          raise ParseException.new("Unexpected section end #{parsedCommandLine}, outside of component")
+        end
+        if parsedCommandLine.isInstanceVar
+          if parsedCommandLine.hasCommentEnd
+            startNewComponent(HtmlVariable.new, parsedCommandLine)
+          else
+            startNewComponent(CommentVariable.new, parsedCommandLine)
+          end
+        else
+          if parsedCommandLine.name == "ruby"
+            startNewComponent(RubyCode.new(lineNumber+1), parsedCommandLine)
+          elsif parsedCommandLine.name == "class"
+            startNewComponent(SetPageObjectClass.new(parsedCommandLine.value), parsedCommandLine)
+          else
+            raise ParseException.new("Unknown section type #{parsedCommandLine.name.inspect}")
+          end
+        end
+        if @currentComponent.finished
+          @currentComponent = nil
+        end
+      end
+      
+    end
+    
+    def finish
+      if @currentComponent
+        if @currentComponent.is_a? StaticHtml
+          @currentComponent.finishText
+          @currentComponent = nil
+        else
+          raise ParseException.new("Unfinished last component at end of file")
+        end
+      end
+    end
+    
+    def writeRegeneratedFile(outFile)
+      makeBackupFile(outFile)
+      puts "Outputting regenerated page to #{outFile} ..."
+      File.open(outFile, "w") do |f|
+        for component in @components do
+          f.write(component.output)
+        end
+      end
+      puts "Finished writing #{outFile}"
+    end
+    
+    def readFileLines
+      puts "Opening #{@fileName} ..."
+      lineNumber = 0
+      File.open(@fileName).each_line do |line|
+        line.chomp!
+        lineNumber += 1
+        #puts "line #{lineNumber}: #{line}"
+        commentLineMatch = COMMENT_LINE_REGEX.match(line)
+        if commentLineMatch
+          parsedCommandLine = ParsedRejennerCommentLine.new(line, commentLineMatch)
+          #puts "parsedCommandLine = #{parsedCommandLine}"
+          if parsedCommandLine.isRejennerCommentLine
+            parsedCommandLine.checkIsValid
+            processCommandLine(parsedCommandLine, lineNumber)
+          else
+            processTextLine(line, lineNumber)
+          end
+        else
+          processTextLine(line, lineNumber)
+        end
+      end
+      finish
+      #puts "Finished reading #{@fileName}."
+    end
+    
+    def regenerate
+      executeRubyComponents
+      writeRegeneratedFile(@fileName)
+      #display
+    end
+    
+    def regenerateToOutputFile(outFile)
+      executeRubyComponents
+      writeRegeneratedFile(outFile)
+    end
+    
+    def executeRubyComponents
+      fileDir = File.dirname(@fileName)
+      puts "Executing ruby components in directory #{fileDir} ..."
+      Dir.chdir(fileDir) do
+        for rubyComponent in @rubyComponents
+          rubyCode = rubyComponent.text
+          puts ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
+          puts "Executing ruby (line #{rubyComponent.lineNumber}) #{rubyCode.inspect} ..."
+          @pageObject.instance_eval(rubyCode, @fileName, rubyComponent.lineNumber)
+          #puts "Finished executing ruby at line #{rubyComponent.lineNumber}"
+        end
+      end
+      #puts "Finished executing ruby components."
+    end
+    
+    def display
+      puts "=========================================================================="
+      puts "Output of #{@fileName}"
+      for component in @components do
+        puts "--------------------------------------"
+        puts(component.output)
+      end
+    end
+  end
+  
+  class PageObject
+    include Regenerate::Utils
+    
+    def erb(templateFileName)
+      @binding = binding
+      File.open(relative_path(templateFileName), "r") do |input|
+        templateText = input.read
+        template = ERB.new(templateText, nil, nil)
+        template.filename = templateFileName
+        result = template.result(@binding)
+      end
+    end
+    
+    def relative_path(path)
+      File.expand_path(File.join(@baseDir, path.to_str))
+    end
+
+    def require_relative(path)
+      require relative_path(path)
+    end
+    
+    def saveProperties
+      properties = {}
+      for property in propertiesToSave
+        value = instance_variable_get("@" + property.to_s)
+        properties[property] = value
+      end
+      propertiesFileName = relative_path(self.class.propertiesFileName(@baseFileName))
+      puts "Saving properties #{properties.inspect} to #{propertiesFileName}"
+      ensureDirectoryExists(File.dirname(propertiesFileName))
+      File.open(propertiesFileName,"w") do |f|
+        f.write(JSON.pretty_generate(properties))
+      end
+    end
+
+  end
+  
+end