wire-framework 0.1.0

data/lib/app/render/page.rb

@@ -0,0 +1,91 @@
+require_relative '../render'
+
+module Render
+	# Page builds the a page that is presented directly to a user
+	# @author Bryan T. Meyers
+	module Page
+		include Render
+		extend self
+
+		# Render a full template, handling the gathering of additional Sources
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @param [Tilt::Template] template a pre-loaded Tilt template to render
+		# @param [String] content the content to render into the page
+		# @return [Response] a Rack Response triplet, or status code
+		def render_template(actions, context, template, content)
+			if template[:path]
+				hash = { actions: actions, context: context, content: content }
+				template[:sources].each do |k, s|
+					uri = "http://#{context.app[:remote_host]}/#{s[:uri]}"
+					case s[:key]
+						when :user
+							uri += "/#{context.user}"
+						when :resource
+							uri += "/#{context.uri[2]}"
+					end
+					begin
+						temp = RestClient.get uri
+					rescue RestClient::ResourceNotFound
+						temp = nil
+					end
+					hash[k] = temp
+				end
+				message = template[:path].render(self, hash)
+				if template[:use_layout]
+					message = render_template(actions, context, $apps[:global][:template], message)
+				end
+			else
+				message = 'Invalid Template'
+			end
+			message
+		end
+
+		# Render a page to its final form
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @param [Symbol] specific the kind of read to perform
+		# @return [Response] a Rack Response triplet, or status code
+		def do_read(actions, context, specific)
+			template = context.app[:template]
+			resource = context.uri[2]
+			message  = 'Resource not specified'
+			headers  = {}
+			if resource
+				begin
+					result = forward(specific, context)
+					if template
+						message = render_template(actions, context, template, result)
+					else
+						headers['Content-Type'] = result.headers[:content_type]
+						message                 = [200, headers, [result.to_str]]
+					end
+				rescue RestClient::ResourceNotFound
+					message = 404
+				end
+			end
+			message
+		end
+
+		# Proxy method used when routing
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.invoke(actions, context)
+			case context.action
+				when :create
+					forward(:create, context)
+				when :read
+					if context.uri[3]
+						do_read(actions, context, :read)
+					else
+						do_read(actions, context, :readAll)
+					end
+				when :update
+					forward(:update, context)
+				else
+					405
+			end
+		end
+	end
+end

data/lib/app/render/partial.rb

@@ -0,0 +1,110 @@
+require_relative '../render'
+
+module Render
+	# Partials are URI mapped renderers which generate only a piece of a document
+	# @author Bryan T.Meyers
+	module Partial
+		extend Render
+
+		# DSL method to enable forwarding to remote
+		# @return [void]
+		def self.use_forward
+			$current_resource[:forward] = true
+		end
+
+		# DSL method to pull in Source like objects
+		# @param [Symbol] name the key for this item
+		# @param [Hash] path the remote sub-URI for this item
+		# @return [void]
+		def self.extra(name, path)
+			unless $current_resource[:sources]
+				$current_resource[:sources] = {}
+			end
+			$current_resource[:sources][name] = path
+		end
+
+		# Read a listing and render to HTML
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.do_read_all(actions, context)
+			resource = context.uri[2]
+			begin
+				mime = ''
+				body = ''
+				if context.resource[:forward]
+					response = forward(:readAll, context)
+					mime     = response.headers[:content_type]
+					body     = response.body
+				else
+					body = 401
+				end
+
+				template = context.resource[:multiple]
+				hash     = { actions: actions, resource: resource, mime: mime, response: body }
+				if context.resource[:sources]
+					context.resource[:sources].each do |k, v|
+						hash[k] = RestClient.get("http://#{context.app[:remote_host]}/#{v}")
+					end
+				end
+				mime = 'text/html'
+				if template
+					[200, { 'Content-Type' => mime }, [template.render(self, hash)]]
+				else
+					[200, { 'Content-Type' => mime }, [body]]
+				end
+			rescue RestClient::ResourceNotFound
+				404
+			end
+		end
+
+		# Read a Partial and render it to HTML
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.do_read(actions, context)
+			app      = context.app[:uri]
+			resource = context.uri[2]
+			begin
+				response = forward(:read, context)
+				mime     = response.headers[:content_type]
+				template = context.resource[:single]
+				id       = context.uri[3...context.uri.length].join('/')
+				hash     = { actions: actions, app: app, id: id, resource: resource, mime: mime, response: response.body }
+				if context.resource[:sources]
+					context.resource[:sources].each do |k, v|
+						hash[k] = RestClient.get("http://#{context.app[:remote_host]}/#{v}")
+					end
+				end
+				if template
+					[200, { 'Content-Type' => 'text/html' }, [template.render(self, hash)]]
+				else
+					[200, { 'Content-Type' => 'text/plain' }, [response.body]]
+				end
+			rescue RestClient::ResourceNotFound
+				404
+			end
+		end
+
+		# Proxy method used when routing
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.invoke(actions, context)
+			case context.action
+				when :create
+					forward(:create, context)
+				when :read
+					if context.uri[3]
+						do_read(actions, context)
+					else
+						do_read_all(actions, context)
+					end
+				when :update
+					forward(:update, context)
+				else
+					403
+			end
+		end
+	end
+end

data/lib/app/render/style.rb

@@ -0,0 +1,52 @@
+require_relative '../render'
+
+module Render
+	# Style uses Tilt to render and serve stylesheets
+	# @author Bryan T. Meyers
+	module Style
+		extend Render
+
+		# DSL method to create a style
+		# @param [String] resource the sub-URI for this style
+		# @param [Hash] path the file location of the stylesheet
+		# @return [void]
+		def self.style(resource, path)
+			unless $current_app[:styles]
+				$current_app[:styles] = {}
+			end
+			$current_app[:styles][resource] = path.nil? ? nil : Tilt.new(path, 1, { ugly: true }).render
+		end
+
+		# Render a stylesheet to CSS
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.do_read_all(context)
+			begin
+				resource = context.uri[2]
+				template = context.app[:styles][resource]
+				headers  = {}
+				if template
+					headers['Content-Type'] = 'text/css'
+					[200, headers, [template]]
+				else
+					500
+				end
+			rescue RestClient::ResourceNotFound
+				404
+			end
+		end
+
+		# Proxy method used when routing
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] a Rack Response triplet, or status code
+		def self.invoke(actions, context)
+			case context.action
+				when :read
+					do_read_all(context)
+				else
+					403
+			end
+		end
+	end
+end

data/lib/app/repo.rb

@@ -0,0 +1,148 @@
+require 'awesome_print'
+require 'base64'
+require_relative '../wire'
+require_relative 'repo/svn'
+
+# Repo is a Wire::App for accessing versioned content
+# @author Bryan T. Meyers
+module Repo
+
+	# Select the location of the repositories
+	# @param [Symbol] path location of the repositories
+	# @return [void]
+	def repos(path)
+		$current_app[:repos_path] = path
+	end
+
+	# Select the render template for file listings
+	# @param [Symbol] path location of the Tilt compatible template
+	# @return [void]
+	def listing(path)
+		$current_app[:template] = Tilt.new(path, 1, { ugly: true })
+	end
+
+	# Select the sub-directory for web-serveable content
+	# @param [Symbol] path the sub-directory path
+	# @return [void]
+	def web_folder(path)
+		$current_app[:web] = path
+	end
+
+	# Create a new Repo
+	# @param [Hash] context the context for this request
+	# @return [Response] status code
+	def do_create(context)
+		path     = context.app[:repos_path]
+		resource = context.uri[2]
+		if path
+			if Dir.exist?("#{path}/#{resource}")
+				401
+			else
+				do_create_file(path, resource)
+			end
+		else
+			400
+		end
+	end
+
+	# Get the a root directory listing
+	# @param [Hash] context the context for this request
+	# @return [Response] the listing, or status code
+	def do_read_all(context)
+		resource = context.uri[2]
+		referrer = context.referer
+		repos    = context.app[:repos_path]
+		web      = context.app[:web]
+		mime     = 'text/html'
+		list     = do_read_listing(web, repos, resource)
+		if list == 404
+			return 404
+		end
+		template                 = context.app[:template]
+		list                     = template.render(self, list: list, resource: resource, id: '', referrer: referrer)
+		headers                  = {}
+		headers['Content-Type']  = mime
+		headers['Cache-Control'] = 'public'
+		headers['Expires']       = "#{(Time.now + 1000).utc}"
+		[200, headers, [list]]
+	end
+
+	# Get the a single file or directory listing
+	# @param [Hash] context the context for this request
+	# @return [Response] the file, listing, or status code
+	def do_read(context)
+		path     = context.uri[2]
+		referrer = context.referer
+		repos    = context.app[:repos_path]
+		web      = context.app[:web]
+		rev      = context.query[:rev]
+		id       = context.uri[3...context.uri.length].join('/')
+		info     = do_read_info(rev, web, repos, path, id)
+		if info == 404
+			return 404
+		end
+		type = info[:@kind]
+		if type.eql? 'dir'
+			mime     = 'text/html'
+			list     = do_read_listing(web, repos, path, id)
+			template = context.app[:template]
+			body     = template.render(self, list: list, resource: path, id: id, referrer: referrer)
+		else
+			body = do_read_file(rev, web, repos, path, id)
+			if body == 500
+				return body
+			end
+			mime = do_read_mime(rev, web, repos, path, id)
+		end
+		headers                  = {}
+		headers['Content-Type']  = mime
+		headers['Cache-Control'] = 'public'
+		headers['Expires']       = "#{(Time.now + 1000).utc}"
+		[200, headers, [body]]
+	end
+
+	# Update the a single file
+	# @param [Hash] context the context for this request
+	# @return [Response] status code
+	def do_update(context)
+		path    = context.uri[2]
+		repos   = context.app[:repos_path]
+		web     = context.app[:web]
+		content = context.json
+		id      = context.uri[3...context.uri.length].join('/')
+		if content[:file]
+			file = content[:file][:content].match(/base64,(.*)/)[1]
+			file = Base64.decode64(file)
+			if context.query[:type]
+				mime = context.query[:type]
+			else
+				mime = content[:file][:mime]
+			end
+			do_update_file(web, repos, path, id, file, content[:message], mime, context.user)
+		else
+			do_update_file(web, repos, path, id, URI.unescape(content[:updated]), content[:message], context.query[:type], context.user)
+		end
+	end
+
+	# Proxy method used when routing
+	# @param [Array] actions the allowed actions for this URI
+	# @param [Hash] context the context for this request
+	# @return [Response] a Rack Response triplet, or status code
+	def invoke(actions, context)
+		return 404 unless context.uri[2]
+		case context.action
+			when :create
+				do_create(context)
+			when :read
+				if context.uri[3]
+					do_read(context)
+				else
+					do_read_all(context)
+				end
+			when :update
+				do_update(context)
+			else
+				403
+		end
+	end
+end

data/lib/app/repo/svn.rb

@@ -0,0 +1,177 @@
+require_relative '../repo'
+require 'nori'
+
+# Force Nori to convert tag names to Symbols
+$nori = Nori.new :convert_tags_to => lambda { |tag| tag.snakecase.to_sym }
+
+module Repo
+	# Repo::SVN is a connector for svnserve
+	# @author Bryan T. Meyers
+	module SVN
+		extend Wire::App
+		extend Wire::Resource
+		extend Repo
+
+		# Make a new SVN repo
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @return [Integer] status code
+		def self.do_create_file(path, repo)
+			result = 200
+			`svnadmin create #{path}/#{repo}`
+			if $?.exitstatus != 0
+				return 500
+			end
+
+			if $?.exitstatus != 0
+				500
+			else
+				result
+			end
+		end
+
+		# Read a single file
+		# @param [String] rev the revision number to access
+		# @param [String] web the subdirectory for web content
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @param [String] id the relative path to the file
+		# @return [String] the file
+		def self.do_read_file(rev, web, path, repo, id)
+			@options = "--username=#{$environment[:repos_user]} --password=#{$environment[:repos_password]}"
+			if rev.nil?
+				rev = 'HEAD'
+			end
+			if web.nil?
+				body = `svn cat #{@options} -r #{rev} 'svn://localhost/#{repo}/#{id}'`
+			else
+				body = `svn cat #{@options} -r #{rev} 'svn://localhost/#{repo}/#{web}/#{id}'`
+			end
+
+			if $?.success?
+				body
+			else
+				500
+			end
+		end
+
+		# Read a directory listing
+		# @param [String] web the subdirectory for web content
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @param [String] id the relative path to the file
+		# @return [Array] the directory listing
+		def self.do_read_listing(web, path, repo, id = nil)
+			@options = "--username=#{$environment[:repos_user]} --password=#{$environment[:repos_password]}"
+			if web.nil?
+				if id.nil?
+					list = `svn list #{@options} --xml 'svn://localhost/#{repo}'`
+				else
+					list = `svn list #{@options} --xml 'svn://localhost/#{repo}/#{id}'`
+				end
+			else
+				if id.nil?
+					list = `svn list #{@options} --xml 'svn://localhost/#{repo}/#{web}'`
+				else
+					list = `svn list #{@options} --xml 'svn://localhost/#{repo}/#{web}/#{id}'`
+				end
+			end
+			unless $?.exitstatus == 0
+				return 404
+			end
+			list = $nori.parse(list)
+			list[:lists][:list][:entry]
+		end
+
+		# Read Metadata for a single file
+		# @param [String] rev the revision number to access
+		# @param [String] web the subdirectory for web content
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @param [String] id the relative path to the file
+		# @return [Hash] the metadata
+		def self.do_read_info(rev, web, path, repo, id)
+			@options = "--username=#{$environment[:repos_user]} --password=#{$environment[:repos_password]}"
+			if rev.nil?
+				rev = 'HEAD'
+			end
+			if web.nil?
+				info = `svn info #{@options} -r #{rev} --xml 'svn://localhost/#{repo}/#{id}'`
+			else
+				info = `svn info #{@options} -r #{rev} --xml 'svn://localhost/#{repo}/#{web}/#{id}'`
+			end
+
+			unless $?.exitstatus == 0
+				return 404
+			end
+			info = $nori.parse(info)
+			info[:info][:entry]
+		end
+
+		# Get a file's MIME type
+		# @param [String] rev the revision number to access
+		# @param [String] web the subdirectory for web content
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @param [String] id the relative path to the file
+		# @return [String] the MIME type
+		def self.do_read_mime(rev, web, path, repo, id)
+			@options = "--username=#{$environment[:repos_user]} --password=#{$environment[:repos_password]}"
+			if rev.nil?
+				rev = 'HEAD'
+			end
+			if web.nil?
+				mime = `svn propget #{@options} -r #{rev} --xml svn:mime-type 'svn://localhost/#{repo}/#{id}'`
+			else
+				mime = `svn propget #{@options} -r #{rev} --xml svn:mime-type 'svn://localhost/#{repo}/#{web}/#{id}'`
+			end
+
+			unless $?.success?
+				return 500
+			end
+			mime = $nori.parse(mime)
+			if mime[:properties].nil?
+				'application/octet-stream'
+			else
+				mime[:properties][:target][:property]
+			end
+		end
+
+		# Update a single file
+		# @param [String] web the subdirectory for web content
+		# @param [String] path the path to the repositories
+		# @param [String] repo the new repo name
+		# @param [String] id the relative path to the file
+		# @param [String] content the updated file
+		# @param [String] message the commit message
+		# @param [String] mime the mime-type to set
+		# @param [String] user the Author of this change
+		# @return [Integer] status code
+		def self.do_update_file(web, path, repo, id, content, message, mime, user)
+			@options = "--username=#{$environment[:repos_user]} --password=#{$environment[:repos_password]}"
+			status   = 500
+			`svn checkout #{@options} svn://localhost/#{repo} /tmp/svn/#{repo}`
+			if $?.exitstatus == 0
+				if web.nil?
+					file_path = "/tmp/svn/#{repo}/#{id}"
+				else
+					file_path = "/tmp/svn/#{repo}/#{web}/#{id}"
+				end
+				file = File.open(file_path, 'w+')
+				file.syswrite(content)
+				file.close
+				`svn add #{file_path}`
+				`svn propset svn:mime-type #{mime} #{file_path}`
+				`svn commit #{@options} -m "#{message}" /tmp/svn/#{repo}`
+				if $?.exitstatus == 0
+					status = 200
+				end
+				info = `svn info /tmp/svn/#{repo}`
+				rev  = info.match(/Last Changed Rev: (\d+)/)[1]
+				`svn propset --revprop -r #{rev} svn:author '#{user}' /tmp/svn/#{repo}`
+			end
+			`rm -R /tmp/svn/#{repo}`
+			status
+		end
+	end
+end