chisel 0.0.1 → 0.0.2

data/bin/chisel

@@ -1,45 +1,120 @@
 #! /usr/bin/env ruby
 
 require 'chisel/wrapper'
+require 'filesystemwatcher/filesystemwatcher'
 require 'optparse'
+require 'webrick'
 
-module Chisel
-	if ARGV.count == 0
-		w = Wrapper.new('.')
-		w.run
-	else
+include WEBrick
+include Chisel
+
+def start_webrick(config = {})
+	server = HTTPServer.new(config)
+
+	yield server if block_given?
+	['INT', 'TERM'].each do |signal|
+	  trap(signal) { server.shutdown }
+	end
+
+	puts "\n*** Press Ctrl-C to stop the server ***\n\n"
+
+	server.start
+end
 	
-		case ARGV[0].downcase
-		
-		when 'new'
-			# TODO: Add checking for existing site, with option to "force" creation
+# Set up default command-line options
+
+options = {}
+options[:verbose] = false
+options[:server] = false
+options[:watch] = false
+options[:port] = 4000
+
+# Parse out options
+
+OptionParser.new do |opts|
+	opts.banner = 'Usage: chisel [options] [new|resource] [command]'
+	
+	opts.on('-v', '--verbose', 'Run verbosely') do |v|
+		options[:verbose] = v
+	end
+	
+	opts.on('-s', '--server [port]', 'Run local WEBrick server (default port 4000)') do |port|
+		options[:server] = true
+		options[:port] = port.to_i if port
+	end
+	
+	opts.on('-w', '--watch', 'Watch filesystem for changes and update automatically') do |w|
+		options[:watch] = w
+	end
+	
+end.parse!
+
+# Run the appropriate command
+
+if ARGV.count == 0
+	
+	site_dir = SiteDirectory.new('.')
+	
+	w = Wrapper.new(site_dir)
+	w.run
+	
+	if options[:watch]
+		puts 'File system watcher not yet implemented. Sorry!'
+		# TODO: Implement file system watcher
 		
-			if ARGV.length == 1 then
-				puts 'Creating new Chisel site in the current directory...'
-				SiteDirectory.create('.')
-				puts 'Done. Run \'chisel\' to create your site.'
-			else
-				dir = ARGV[1]
-				puts "Creating new Chisel site in directory '#{dir}'..."
-				SiteDirectory.create(dir)
-				puts "Done. Go into \'#{dir}\' and run \'chisel\' to create your site."
-			end
+		# watcher = FileSystemWatcher.new
+		# watcher.addDirectory(site_dir.realdirpath.to_s, '*.*')
+		# 
+		# site_dir.entries.each do |entry|
+		# 	
+		# end
+		# 
+		# watcher.sleepTime = 1
+		# watcher.start do |status, file|
+		# 	w1 = Wrapper.new(site_dir)
+		# 	w1.run
+		# end
+		# watcher.join
+	end
+	
+	if options[:server]
+		output_dir = site_dir.output_dir.realdirpath.to_s
+		start_webrick(:DocumentRoot => output_dir, :Port => options[:port])
+	end
+	
+else
+
+	case ARGV[0].downcase
+	
+	when 'new'
+		# TODO: Add checking for existing site, with option to "force" creation
+	
+		if ARGV.length == 1 then
+			puts 'Creating new Chisel site in the current directory...'
+			SiteDirectory.create('.')
+			puts 'Done. Run \'chisel\' to create your site.'
+		else
+			dir = ARGV[1]
+			puts "Creating new Chisel site in directory '#{dir}'..."
+			SiteDirectory.create(dir)
+			puts "Done. Go into \'#{dir}\' and run \'chisel\' to create your site."
+		end
+	
+	when 'resource'
 		
-		when 'resource'
-			
-			if ARGV.length == 1 then
-				# TODO: Something
-			else
-				site_dir = SiteDirectory.new('.')
-				case ARGV[1].downcase
-				when 'new'
-					site_dir.create_resource(ARGV[2])
-				end
+		if ARGV.length == 1 then
+			# TODO: Something
+		else
+			site_dir = SiteDirectory.new('.')
+			case ARGV[1].downcase
+			when 'new'
+				# TODO: Check that ARGV[2] exists and show help otherwise
+				site_dir.create_resource(ARGV[2])
 			end
-		
-		when 'help'
-		
 		end
 	
+	when 'help'
+	
 	end
+
 end

data/lib/chisel/ruby/array.rb

@@ -1,5 +1,5 @@
 class Array
-	def sort_by(method_name, ascending=true)
+	def sort_by_method(method_name, ascending=true)
 		method_name = method_name.to_sym
 		self.sort do |left, right|
 			if left.respond_to?(method_name) and right.respond_to?(method_name)

data/lib/chisel/site_directory.rb

@@ -61,9 +61,9 @@ module Chisel
 			self.output_dir.join(*resource.id, view_with_extension(view))
 		end
 	
-		def page_output_path(page)
+		def page_output_path(page, view_output_dir)
 			page = view_with_extension(page)
-			self.output_dir.join(page)
+			self.site_relative_path(page, view_output_dir)
 		end
 
 		def layout_view_path(layout_name)
@@ -73,6 +73,14 @@ module Chisel
 		def view_path(view)
 			self.view_dir.join("#{view_with_extension(view)}.erb")
 		end
+		
+		def site_relative_path(relative_path, view_output_dir)
+			if relative_path[0] == '/'
+				self.output_dir.join(relative_path[1..-1])
+			else
+				view_output_dir.join(relative_path)
+			end
+		end
 	
 		def view_with_extension(view)
 			view = "#{view}index" if view[-1] == '/'

data/lib/chisel/view.rb

@@ -26,7 +26,7 @@ module Chisel
 		
 			@path = Pathname.new(options[:path]) if options[:path]
 			@site_dir = SiteDirectory.new(options[:site_dir]) if options[:site_dir]
-		
+			
 			if options[:resource]
 				@type = :resource
 				@resource = options[:resource]
@@ -96,6 +96,8 @@ module Chisel
 			
 			header_vars = {}
 			if options[:resource]
+				resource_key = options[:resource].resource_type.to_sym
+				header_vars[resource_key] = options[:resource]
 				header_vars[:resource] = options[:resource]
 			end
 			

data/lib/chisel/view_helper.rb

@@ -35,14 +35,14 @@ module Chisel
 		end
 	
 		def link_to_page(page, text, options = {})			
-			page_output_path = @site_dir.page_output_path(page)
+			page_output_path = @site_dir.page_output_path(page, @output_path.dirname)
 			href = page_output_path.relative_path_from(@output_path.dirname).to_s
 		
 			link_to(href, text, options)
 		end
 	
 		def path_to(site_relative_path)
-			@site_dir.output_dir.join(site_relative_path).relative_path_from(@output_path.dirname)
+			@site_dir.site_relative_path(site_relative_path, @output_path.dirname).relative_path_from(@output_path.dirname)
 		end
 
 		def link_to(href, text, options = {})
@@ -53,7 +53,7 @@ module Chisel
 				end
 			end
 		
-			href = href[0..-11] if href.end_with?('index.html')
+			href = href[0..-11] if href.end_with?('index.html') and href != 'index.html'
 		
 			"<a href=\"#{href}\"#{attribute_string}>#{text}</a>"
 		end

data/lib/filesystemwatcher/filesystemwatcher.rb

@@ -0,0 +1,330 @@
+require "digest/md5"
+require "thread"
+require "#{File.dirname(__FILE__)}/servicestate.rb"
+
+# This class will watch a directory or a set of directories and alert you of
+# new files, modified files, deleted files. You can optionally only be alerted
+# when a files md5 hash has been changed so you only are alerted to real changes.
+# this of course means slower performance and higher cpu/io usage.
+class FileSystemWatcher
+  include ServiceState
+
+  CREATED = 0
+  MODIFIED = 1
+  DELETED = 2
+
+  # the time to wait before checking the directories again
+  attr_accessor :sleepTime, :priority, :directories
+
+  # you can optionally use the file contents md5 to detect if a file has changed
+  attr_accessor :useMD5
+
+  def initialize(dir=nil, expression="**/*")
+    @sleepTime = 5
+    @useMD5 = false
+    @priority = 0
+    @stopWhen = nil
+
+    @directories = Array.new()
+    @files = Array.new()
+
+    @foundFiles = nil
+    @firstLoad = true
+    @watchThread = nil
+    
+    initializeState()
+
+    if dir then
+      addDirectory(dir, expression)
+    end
+  end
+
+  # add a directory to be watched
+  # @param dir the directory to watch
+  # @param expression the glob pattern to search under the watched directory
+  def addDirectory(dir, expression="**/*")
+    if FileTest.exists?(dir) && FileTest.readable?(dir) then
+      @directories << FSWatcher::Directory.new(dir, expression)
+    else
+      raise FSWatcher::InvalidDirectoryError, "Dir '#{dir}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeDirectory(dir)
+    @directories.delete(dir)
+  end
+
+  # add a specific file to the watch list
+  # @param file the file to watch
+  def addFile(file)
+    if FileTest.exists?(file) && FileTest.readable?(file) then
+      @files << file
+    else
+      raise FSWatcher::InvalidFileError, "File '#{file}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeFile(file)
+    @files.delete(file)
+  end
+
+  # start watching the specified files/directories
+  def start(&block)
+    if isStarted? then
+      raise RuntimeError, "already started"
+    end
+
+    setState(STARTED)
+
+    @firstLoad = true
+    @foundFiles = Hash.new()
+
+    # we watch in a new thread
+    @watchThread = Thread.new {
+      # we will be stopped if someone calls stop or if someone set a stopWhen that becomes true
+      while !isStopped? do
+	if (!@directories.empty?) or (!@files.empty?) then	
+	  # this will hold the list of the files we looked at this iteration
+	  # allows us to not look at the same file again and also to compare
+	  # with the foundFile list to see if something was deleted
+	  alreadyExamined = Hash.new()
+	  
+	  # check the files in each watched directory
+	  if not @directories.empty? then
+	    @directories.each { |dirObj|
+	      examineFileList(dirObj.getFiles(), alreadyExamined, &block)
+	    }
+	  end
+	  
+	  # now examine any files the user wants to specifically watch
+	  examineFileList(@files, alreadyExamined, &block) if not @files.empty?
+	  
+	  # see if we have to delete files from our found list
+	  if not @firstLoad then
+	    if not @foundFiles.empty? then
+	      # now diff the found files and the examined files to see if
+	      # something has been deleted
+	      allFoundFiles = @foundFiles.keys()
+	      allExaminedFiles = alreadyExamined.keys()
+	      intersection = allFoundFiles - allExaminedFiles
+	      intersection.each { |fileName|
+		# callback
+		block.call(DELETED, fileName)
+		# remove deleted file from the foundFiles list
+		@foundFiles.delete(fileName)
+	      }	  
+	    end
+	  else
+	    @firstLoad = false
+	  end
+	end
+	
+	# go to sleep
+	sleep(@sleepTime)
+      end
+    }
+    
+    # set the watch thread priority
+    @watchThread.priority = @priority
+
+  end
+
+  # kill the filewatcher thread
+  def stop()
+    setState(STOPPED)
+    @watchThread.wakeup()
+  end
+
+  # wait for the filewatcher to finish
+  def join()
+    @watchThread.join() if @watchThread
+  end
+
+
+  private
+
+  # loops over the file list check for new or modified files
+  def examineFileList(fileList, alreadyExamined, &block)
+    fileList.each { |fileName|
+      # expand the file name to the fully qual path
+      fullFileName = File.expand_path(fileName)
+
+      # dont examine the same file 2 times
+      if not alreadyExamined.has_key?(fullFileName) then
+	# we cant do much if the file isnt readable anyway
+	if File.readable?(fullFileName) then
+	  # set that we have seen this file
+	  alreadyExamined[fullFileName] = true
+	  
+	  # get the file info
+	  modTime, size = File.mtime(fullFileName), File.size(fullFileName)
+	  
+	  # on the first iteration just load all of the files into the foundList
+	  if @firstLoad then
+	    @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size, false, @useMD5)
+	  else
+	    # see if we have found this file already
+	    foundFile = @foundFiles[fullFileName]
+
+	    if foundFile then
+	      
+	      # if a file is marked as new, we still need to make sure it isnt still
+	      # being written to. we do this by checking the file sizes.
+	      if foundFile.isNew? then
+		
+		# if the file size is the same then it is probably done being written to
+		# unless the writer is really slow
+		if size == foundFile.size then		  
+
+		  # callback
+		  block.call(CREATED, fullFileName)
+		  
+		  # mark this file as a changed file now
+		  foundFile.updateModTime(modTime)
+		  
+		  # generate the md5 for the file since we know it is done
+		  # being written to
+		  foundFile.genMD5() if @useMD5
+		  
+		else
+		  
+		  # just update the size so we can check again at the next iteration
+		  foundFile.updateSize(size)
+		  
+		end
+		
+	      elsif modTime > foundFile.modTime then
+
+		# if the mod times are different on files we already have
+		# found this is an update		
+		willYield = true
+		
+		# if we are using md5's then compare them
+		if @useMD5 then
+		  filesMD5 = FSWatcher.genFileMD5(fullFileName)
+		  if filesMD5 && foundFile.md5 then
+		    if filesMD5.to_s == foundFile.md5.to_s then
+		      willYield = false
+		    end
+		  end
+		  
+		  # if we are yielding then the md5s are dif so
+		  # update the cached md5 value
+		  foundFile.setMD5(filesMD5) if willYield
+
+		end
+		
+		block.call(MODIFIED, fullFileName) if willYield		
+		foundFile.updateModTime(modTime)
+
+	      end
+
+	    else	      
+
+	      # this is a new file for our list. dont update the md5 here since
+	      # the file might not yet be done being written to
+	      @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size)
+	      
+	    end
+	  end
+	end
+      end
+    }
+  end
+end
+
+# Util classes for the FileSystemWatcher
+module FSWatcher
+  # The directory to watch
+  class Directory
+    attr_reader :dir, :expression
+
+    def initialize(dir, expression)
+      @dir, @expression = dir, expression
+      @dir.chop! if @dir =~ %r{/$}
+    end
+
+    def getFiles()
+      return Dir[@dir + "/" + @expression]
+    end
+  end
+
+  # A FoundFile entry for the FileSystemWatcher
+  class FoundFile
+    attr_reader :status, :fileName, :modTime, :size, :md5
+
+    def initialize(fileName, modTime, size, isNewFile=true, useMD5=false)
+      @fileName, @modTime, @size, @isNewFile  = fileName, modTime, size, isNewFile      
+      @md5 = nil
+      if useMD5 then
+	genMD5()
+      end
+    end
+
+    def updateModTime(modTime)
+      @modTime = modTime
+      @isNewFile = false
+    end
+
+    def updateSize(size)
+      @size = size
+    end
+
+    def isNew?
+      return @isNewFile
+    end
+
+    def setMD5(newMD5)
+      @md5 = newMD5
+    end
+
+    # generate my files md5 value
+    def genMD5()
+      @md5 = FSWatcher.genFileMD5(@fileName)
+    end
+  end
+
+  # utility function for generating md5s from a files contents
+  def FSWatcher.genFileMD5(fileName)
+    if FileTest.file?(fileName) then      
+      f = File.open(fileName)
+      contents = f.read()
+      f.close()
+      return MD5.new(contents) if contents
+    end
+    return nil
+  end
+
+  # if the directory you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidDirectoryError < StandardError; end
+
+  # if the file you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidFileError < StandardError; end
+end
+
+#--- main program ----
+if __FILE__ == $0
+  watcher = FileSystemWatcher.new()
+  watcher.addDirectory("/cygdrive/c/Inetpub/ftproot/", "*.xml")
+  watcher.sleepTime = 3
+  watcher.useMD5 = true
+
+  test = false
+  watcher.stopWhen {
+    test == true
+  }
+
+  watcher.start() { |status,file|
+    if status == FileSystemWatcher::CREATED then
+      puts "created: #{file}"
+    elsif status == FileSystemWatcher::MODIFIED then
+      puts "modified: #{file}"
+    elsif status == FileSystemWatcher::DELETED then
+      puts "deleted: #{file}"
+    end
+  }
+
+  sleep(10)
+  test = true
+  watcher.join()
+end

data/lib/filesystemwatcher/servicestate.rb

@@ -0,0 +1,75 @@
+require 'thread'
+
+# The Runnable module is a generic mixin for including state and
+# status information in a class
+module ServiceState
+  # state constants
+  NOT_STARTED = 0
+  STARTED = 1
+  STOPPED = 2
+  CONFIGURED = 3
+  
+  attr_reader :startTime, :endTime
+  
+  # Initialize the state information
+  def initializeState()
+    @configured = false
+    @startTime = 0
+    @stopTime = 0
+    
+    @stateMutex = Mutex.new()
+    @stopWhen = nil
+    setState(NOT_STARTED)
+  end
+  
+  # Set the callback for when someone calls setState. You
+  # will be passed the state CONSTANT being set
+  def onStateChange(&callbackBlock)
+    @stateCallback = callbackBlock
+  end
+  
+  # All methods, inside this class or not, should use this
+  # method to change the state of the JobRunner
+  # @param newState The new state value
+  def setState(newState)
+    @stateMutex.synchronize {
+      if newState == CONFIGURED then
+	@configured = true
+      else
+	@state = newState
+	if isStarted? then
+	  @startTime = Time.now()
+	elsif isStopped?
+	  @stopTime = Time.now()
+	end
+      end
+    }
+    
+    if defined?(@stateCallback) then
+      @stateCallback.call(newState)
+    end
+  end
+  
+  def isConfigured?
+    return @configured
+  end
+
+  def isStarted?
+    return @state == STARTED
+  end
+
+  def isStopped?
+    if @state == STOPPED then
+      return true
+    elsif @stopWhen && @stopWhen.call() then
+      setState(STOPPED)
+      return true
+    else
+      return false
+    end
+  end   
+
+  def stopWhen(&block)
+    @stopWhen = block
+  end
+end

metadata

@@ -1,27 +1,45 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: chisel
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.2
   prerelease: 
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - Rockwell Schrock
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-07 00:00:00 Z
-dependencies: []
-
+date: 2011-06-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: RedCloth
+  requirement: &2152864840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152864840
+- !ruby/object:Gem::Dependency
+  name: maruku
+  requirement: &2152864360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152864360
 description: Chisel is tool to generate simple, resource-based static Web sites.
 email: schrockwell@gmail.com
-executables: 
+executables:
 - chisel
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/chisel/new_site/_config.yml
 - lib/chisel/new_site/_views/_layout/main.html.erb
 - lib/chisel/new_site/index.html.erb
@@ -36,33 +54,31 @@ files:
 - lib/chisel/view.rb
 - lib/chisel/view_helper.rb
 - lib/chisel/wrapper.rb
+- lib/filesystemwatcher/filesystemwatcher.rb
+- lib/filesystemwatcher/servicestate.rb
 - bin/chisel
 homepage: https://github.com/schrockwell/chisel
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: A static Web site generator.
 test_files: []
-