razor 0.4.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Ferreira, Christopher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the Software), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/bin/razor

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+
+$:.unshift './lib'
+
+require 'razor/runner'
+
+Razor::Runner.new

data/lib/razor.rb

@@ -0,0 +1,58 @@
+require 'version'
+require 'rubygems'
+require 'fileutils'
+
+require 'razor/generable'
+require 'highline'
+
+module Razor
+	
+	class << self
+		attr :get
+	end
+
+	def self.create(name)
+		Dir.mkdir name
+	end
+	
+	def self.generate(src, dest)
+		site = Site.new(src, dest)
+		FileUtils.rm_r(dest) rescue nil
+		site.generate
+	end
+	
+	def self.server(port, src)
+		require 'rack'
+		port = (port and port.to_i or 9000)
+		on_request = lambda do |env|
+			page = Razor.http_request src, env['PATH_INFO']
+			p page.dest_name rescue nil
+			if page
+				[
+					200,
+					{ 'Content-Type' =>
+							Rack::Mime.mime_type(page.dest_ext) },
+					[ page.contents ]
+				]
+			else
+				[
+					404,
+					{ 'Content-Type' => 'text/html' },
+					[ 'Page Not Found' ]
+				]
+			end
+		end
+		Rack::Handler::WEBrick.run(on_request, :Port => port) { |server|
+			trap(:INT) { server.stop }
+			trap(:TERM) { server.stop }
+		}
+	end
+	
+	def self.http_request(src, url)
+		url = url[1..-1].sub(/\/+/, '/')
+		site = Site.new(src, '')
+		file = site.http(url)
+		file and file.request
+	end
+	
+end

data/lib/razor/generable.rb

@@ -0,0 +1,142 @@
+require 'fileutils'
+
+require 'razor/template'
+
+module Razor
+
+	class Generable
+		
+		attr_reader :parent, :src_name
+		
+		def initialize(parent, src_name)
+			@parent = parent
+			@src_name = src_name
+		end
+		
+		alias dest_name src_name
+		
+		def src
+			@src ||= File.join(parent.src, src_name)
+		end
+	
+		def dest
+			@dest ||= File.join(parent.dest, dest_name)
+		end
+		
+		def url
+			@url ||= File.join(parent.url, dest_name)
+		end
+		
+		def http(url)
+			url.empty? and return self
+			return nil
+		end
+		
+	end
+	
+	class GenerableFile < Generable
+
+		def contents
+			File.read(src, :mode=>'rb')
+		end
+
+		def generate
+			File.open(dest, 'wb') { |f| f << contents }
+		end
+		
+		def request
+			self
+		end
+		
+		def dest_ext
+			File.extname(dest_name)
+		end
+	end
+	
+	class Directory < Generable
+		
+		attr_reader :files
+		
+		def initialize(parent, src_name)
+			super(parent, src_name)
+			@files = Dir.entries(src).reject { |filename|
+				filename =~ /^[\._].*/ or filename=='Rakefile'
+			}.map { |filename|
+				if File.directory? File.join(src,filename)
+					Directory.new(self, filename)
+				elsif filename =~ /^[^~].*\.rb$/
+					TemplateFile.new(self, filename)
+				else
+					RegularFile.new(self, filename)
+				end
+			}
+		end
+	
+		def generate
+			Dir.mkdir(dest)
+			@files.each(&:generate)
+		end
+		
+		def http(url)
+			s = super(url)
+			s and return s
+			name, *rest = url.split('/')
+			file = @files.find { |f| f.dest_name == name }
+			file or return nil
+			file.http(rest*'/')
+		end
+		
+		def request
+			@files.find { |f| f.dest_name == 'index.html' }
+		end
+	end
+
+	class Site < Directory
+
+		attr_reader :src, :dest
+		def initialize(src, dest)
+			Template.reset_instances!
+			@src, @dest = src, dest
+			layouts = File.join(src, '_layout/')
+			Template.path = layouts
+			Dir.chdir(layouts) { load './layouts.rb' }
+			super(nil, nil)
+		end
+		
+		def url
+			'/'
+		end
+	end
+
+	class RegularFile < GenerableFile
+		
+		def dest_name
+			# delete first '~' if needed.
+			super =~ /([^~].+)/
+			return $1
+		end
+		
+		def generate
+			FileUtils.cp(src, dest)
+		end
+	end
+	
+	class TemplateFile < GenerableFile
+		
+		def initialize(parent, src_name)
+			super(parent, src_name)
+			@template = Template.eval(self)
+		end
+		
+		def dest_name
+			ext = @template.class.get_extension
+			src_name.sub(/rb$/, ext)
+		end
+		
+		def contents
+			@template.render
+		end
+			
+	end
+
+end

data/lib/razor/renderer.rb

@@ -0,0 +1,120 @@
+require 'bluecloth'
+require 'sass'
+
+module Razor
+	
+	class Renderer
+
+		class Getter
+			
+			class << self
+				
+				attr_reader :renderers, :extensions
+				
+				def define_renderer(name, renderer)
+					@renderers[name] = renderer
+					class_eval(<<-END)
+						def #{name}(string)
+							self.class.renderers[#{name.inspect}].new(string)
+						end
+					END
+				end
+			
+				def define_extension(name, renderer)
+					@extensions[".#{name}"] = renderer
+				end
+				
+			end
+				
+			@renderers = {}
+			@extensions = {}
+			
+			attr :renderer
+			
+			def initialize(path, proc)
+				@path = path
+				if proc
+					@renderer = instance_exec &proc
+				else
+					@renderer = instance_exec { nil }
+				end
+				if @renderer.is_a? String or @renderer.is_a? NilClass
+					@renderer = Renderer.new(@renderer)
+				end
+				return @renderer
+			end
+			
+			def from_file(filename)
+				filepath = File.join(@path, filename)
+				str = (File.read(filepath, :mode=>'rb') rescue nil)
+				ext = File.extname filename
+				renderer = self.class.extensions[ext]
+				renderer ||= Renderer
+				return renderer.new(str)
+			end
+			
+		end
+		
+		class << self
+		
+			def get(path, proc)
+				Getter.new(path, proc).renderer
+			end
+			
+			def name_ext(n)
+				name(n)
+				extension(n)
+			end
+			
+			def name(n)
+				Getter.define_renderer(n, self)
+			end
+			
+			def extension(ext)
+				Getter.define_extension(ext, self)
+			end
+		end
+		
+		attr :string
+		
+		def initialize(string)
+			@string = string
+		end
+		
+		def layout_render(context)
+			@string.nil? and return context['yield']
+			render(context)
+		end
+		
+		def valid?
+			!!@string
+		end
+		
+		def render(context)
+			@string.nil? and return ''
+			Mustache.render(@string, context)
+		end
+		
+	end
+	
+	class BlueRenderer < Renderer
+				
+		name_ext 'markdown'
+		
+		def render(context)
+			BlueCloth.new(super(context)).to_html
+		end
+		
+	end
+	
+	class ScssRenderer < Renderer
+		
+		name_ext 'scss'
+		
+		def render(context)
+			Sass::Engine.new(super(context), :syntax=>:scss ).render
+		end
+		
+	end
+	
+end

data/lib/razor/runner.rb

@@ -0,0 +1,82 @@
+require 'optparse'
+require 'highline'
+
+require 'razor'
+
+module Razor
+
+	HL = HighLine.new
+
+	class Runner
+
+		def initialize
+			@options = {}
+	
+			@options_parser = OptionParser.new { |opt|
+	
+				opt.banner = "Usage: razor COMMAND"
+	
+				opt.separator ""
+				opt.separator "Commands :"
+				opt.separator "  generate [OPTIONS] [SOURCE DESTINATION]  : Generates the web directory from source."
+				opt.separator "  server [OPTIONS] [SOURCE] : Runs a webrick server which renders page on the fly."
+				opt.separator ""
+				opt.separator "Options : "
+	
+				opt.on("-p PORT", "--port PORT", "Set the local server port") do |port|
+					@options[:port] = port
+				end
+	
+				opt.on_tail("-v", "--version", "Show Version") do
+					@options[:version] = true
+				end
+	
+				opt.on_tail("-h", "--help", "Show this message") do
+					@options[:help] = true
+				end
+	
+				opt.separator ""
+	
+			}
+			@options_parser.parse!
+
+			unless ARGV.empty?
+				args = ARGV.clone
+				ARGV.replace []
+				if respond_to? args[0]
+					send *args
+				else
+					HL.say "Unknown Command #{args[0]}"
+					HL.say @options_parser.to_s
+				end
+			else
+	  			if @options[:version]
+		  			HL.say Razor::Version
+		  		else
+	  				HL.say @options_parser.to_s
+		  		end
+			end
+		end
+	
+		def _check_arguments(bool)
+			return if bool
+			HL.say 'Arguments Error'
+			HL.say @options_parser.to_s
+			exit
+		end
+
+		def generate(*args)
+			_check_arguments args.size < 3
+			args = ['.', '_site'] if args.empty?
+			args << File.join(args[0], '_site') if args.size==1
+			Razor.generate *args
+		end
+	
+		def server(url=nil)
+			url = '.' if url.nil?
+			Razor.server(@options[:port], url)
+		end
+	
+	end
+
+end

data/lib/razor/template.rb

@@ -0,0 +1,192 @@
+require 'mustache'
+require 'razor/renderer'
+
+module Razor
+
+	class Template
+		
+		class << self
+			
+			attr_reader :definition, :playout, :instances
+			
+			def inherited(subclass)
+				@subclasses << subclass
+				subclass.class_initialize
+			end
+			
+			def class_initialize
+				@subclasses = []
+				@definition = Class.new(superclass.definition)
+				@playout = superclass.playout
+				@fields = {}
+				@instances = []
+			end
+			
+			def reset_instances!
+				@instances = []
+				@subclasses.each(&:reset_instances!)
+			end
+			
+			def eval(templatefile)
+				@@last_evaluated = nil
+				@@last_templatefile = templatefile
+				Kernel.eval(File.read(templatefile.src), TOPLEVEL_BINDING)
+				return @@last_evaluated
+			end
+			
+			def extension(ext)
+				@extension = ext
+			end
+			
+			def path=(path)
+				@@path = path
+			end
+		
+			def get_extension
+				if superclass.respond_to? :get_extension
+					@extension or superclass.get_extension
+				else
+					@extension
+				end
+			end
+			
+			def layout(str=nil, &block)
+				@playout = str ? lambda { str } : block
+			end
+			
+			def field(name, default=nil)
+				if name =~ /^(field|contents)$/
+					raise "Try to create a #{name.inspect} field"
+				end
+				attr_accessor name
+				@fields["@#{name}"] = default
+				@definition.field(name)
+			end
+			
+			def fields
+				if superclass.respond_to? :fields
+					superclass.fields.merge(@fields)
+				else
+					@fields
+				end
+			end
+			
+			def new(*args, &block)
+				instance = super(*args, &block)
+				@instances << instance
+				@@last_evaluated = instance
+				return instance
+			end
+			
+			def all
+				@subclasses.inject(@instances) { |ary, subclass|
+					ary + subclass.instances
+				}
+			end
+			
+			def layout_render(instance)
+				render(Mustache::Context.new(instance))
+			end
+			
+			def render(context)
+				renderer = Renderer.get(@@path, @playout)
+				if superclass.respond_to? :render
+					if renderer.valid?
+						context.push('yield' => renderer.layout_render(context))
+					end
+					superclass.render(context)
+				else
+					if renderer.valid?
+						renderer.layout_render(context)
+					else
+						context['yield']
+					end
+				end
+			end
+			
+		end
+			
+		@extension = ''
+		@playout = nil
+		@fields = {}
+		@instances = []
+		@subclasses = []
+		
+		attr_accessor :contents
+		
+		def initialize(*args, &block)
+			@templatefile = @@last_templatefile
+			@contents = lambda { '' }
+			self.class.fields.each { |iv|
+				instance_variable_set(*iv)
+			}
+			if block_given?
+				self.class.definition.new(self, &block)
+			end
+		end
+		
+		def url
+			@templatefile.url
+		end
+		
+		def field(name, value)
+			(class<<self; self; end).class_eval { attr name }
+			instance_variable_set("@#{name}", value)
+		end
+		
+		def yield
+			Renderer.get(@templatefile.parent.src, @contents).render(self)
+		end
+		
+		def render
+			self.class.layout_render(self)
+		end
+		
+		@definition = Class.new {
+			
+			def self.field(name)
+				class_eval(<<-END)
+					def #{name}(val)
+						@tpl.#{name} = val
+					end
+				END
+			end
+			
+			def initialize(tpl, &block)
+				@tpl = tpl
+				instance_exec &block
+			end
+			
+			def field(name, value)
+				@tpl.field(name, value)
+			end
+			
+			def contents(str=nil, &block)
+				@tpl.contents = str ? lambda { str } : block
+			end
+			
+			def template_eval(&block)
+				@tpl.instance_eval(&block)
+			end
+	
+		}
+		
+	end
+	
+	class Page < Template
+		
+		extension 'html'
+		
+		layout { from_file 'page.html' }
+		
+	end
+	
+	class StyleSheet < Template
+		
+		extension 'css'
+		
+		layout { from_file 'stylesheet.css' }
+		
+	end
+	
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Razor
+	Version = '0.4.0'
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: razor
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Ferreira Christopher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-03-09 00:00:00.000000000 +01:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: &18858180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *18858180
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: &18857660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *18857660
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &18857180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *18857180
+description: ! '''Razor is a static website generator. Describe layouts and pages
+  in ruby. Write them with html and Mustache.
+
+  The concept behind razor is simple : layouts are described by classes, nested layouts
+  by subclasses and pages by instances of these classes.''
+
+'
+email: aumgn@free.fr
+executables:
+- razor
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- LICENSE
+- lib/razor.rb
+- lib/razor/generable.rb
+- lib/razor/runner.rb
+- lib/razor/renderer.rb
+- lib/razor/template.rb
+- lib/version.rb
+- bin/razor
+has_rdoc: true
+homepage: https://github.com/aumgn/razor
+licenses:
+- MIT License. See LICENSE file.
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Razor is a static website generator. Describe layouts and pages in ruby.
+  Write them with html and Mustache.
+test_files: []