wire-framework 0.1.0

data/lib/app/file.rb

@@ -0,0 +1,81 @@
+require 'awesome_print'
+require_relative '../wire'
+
+# Static is a Wire::App for serving read-only, static files
+# @author Bryan T. Meyers
+module Static
+	extend Wire::App
+	extend Wire::Resource
+
+	# Map a file folder to a sub-URI
+	# @param [String] resource the sub-URI
+	# @param [Class] path the file folder
+	# @return [void]
+	def self.local(resource, path)
+		$current_app[:resources][resource] = { local: path }
+	end
+
+	# Get a file listing for this folder
+	# @param [Hash] context the context for this request
+	# @return [Response] a listing, or status code
+	def self.do_read_all(context)
+		path = context.resource[:local]
+		if path
+			return 404 unless File.exists?(path)
+			if File.directory? path
+				Dir.entries(path).sort.to_s
+			else
+				401
+			end
+		else
+			404
+		end
+	end
+
+	# Get a file from this folder
+	# @param [Hash] context the context for this request
+	# @return [Response] a file, listing, or status code
+	def self.do_read(context)
+		path = context.resource[:local]
+		id   = context.uri[3..context.uri.length].join('/')
+		if path
+			ext_path = File.join(path, id)
+			return 404 unless File.exists?(ext_path)
+			if File.directory?(ext_path)
+				"#{ap Dir.entries(ext_path).sort}"
+			else
+				if ext_path.end_with?('.wiki') || ext_path.end_with?('.mediawiki')
+					mime = 'text/wiki'
+				else
+					mime = `mimetype --brief #{ext_path}`
+				end
+				headers                  = {}
+				headers['Content-Type']  = mime
+				headers['Cache-Control'] = 'public'
+				headers['Expires']       = "#{(Time.now + 30000000).utc}"
+				body                     = File.read(ext_path)
+				[200, headers, body]
+			end
+		else
+			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)
+		return 404 unless context.resource
+		case context.action
+			when :read
+				if context.uri[3]
+					do_read(context)
+				else
+					do_read_all(context)
+				end
+			else
+				403
+		end
+	end
+end

data/lib/app/history.rb

@@ -0,0 +1,59 @@
+require 'awesome_print'
+require 'tilt'
+require_relative '../wire'
+require_relative 'history/svn'
+
+# History is a Wire::App for accessing the history of versioned content
+# @author Bryan T. Meyers
+module History
+
+	# 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 histories
+	# @param [Symbol] path location of the Tilt compatible template
+	# @return [void]
+	def log(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
+
+	# Get the history of a single file or directory
+	# @param [Hash] context the context for this request
+	# @return [Response] the history, or status code
+	def do_read(actions, context)
+		resource = context.uri[2]
+		web      = context.app[:web]
+		id       = context.uri[3...context.uri.length].join('/')
+		list     = get_log(web, resource, id)
+		if list == 404
+			return 404
+		end
+		template = context.app[:template]
+		template.render(self, actions: actions, context: context, list: list)
+	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 :read
+				do_read(actions, context)
+			else
+				403
+		end
+	end
+end

data/lib/app/history/svn.rb

@@ -0,0 +1,34 @@
+require_relative '../repo'
+require 'cobravsmongoose'
+
+module History
+	# History::SVN is a connector for viewing log information in SVN
+	# @author Bryan T. Meyers
+	module SVN
+		extend Wire::App
+		extend Wire::Resource
+		extend History
+
+		# Get the log information for any part of a Repo
+		# @param [String] web the web path of the repo
+		# @param [String] repo the name of the repository to access
+		# @param [String] id the sub-URI of the item to access
+		# @return [Hash] the history entries
+		def self.get_log(web, repo, id = nil)
+			if id.nil?
+				log = `svn log -v --xml 'svn://localhost/#{repo}'`
+			else
+				if web.nil?
+					log = `svn log -v --xml 'svn://localhost/#{repo}/#{id}'`
+				else
+					log = `svn log -v --xml 'svn://localhost/#{repo}/#{web}/#{id}'`
+				end
+			end
+			unless $?.exitstatus == 0
+				return 404
+			end
+			log = CobraVsMongoose.xml_to_hash(log)
+			log['log']['logentry']
+		end
+	end
+end

data/lib/app/login.rb

@@ -0,0 +1,14 @@
+# Login is a Wire::App for forcing user logins
+# @author Bryan T. Meyers
+module Login
+
+	# 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 redirect message returning to the previous page
+	def self.invoke(actions, context)
+		referer = context.referer
+		[301, { 'Location' => referer }, ['Login Redirect']]
+	end
+
+end

data/lib/app/render.rb

@@ -0,0 +1,121 @@
+require 'nokogiri'
+require 'rest-client'
+require 'awesome_print'
+require 'docile'
+require 'tilt'
+require 'json'
+require_relative '../wire'
+require_relative 'render/document'
+require_relative 'render/editor'
+require_relative 'render/instant'
+require_relative 'render/page'
+require_relative 'render/partial'
+require_relative 'render/style'
+
+# Render is an Abstract Wire::App for transforming content
+# @author Bryan T. Meyers
+module Render
+	include Wire::Resource
+
+	# Setup the remote connection for content
+	# @param [String] hostname http hostname and port of remote
+	# @param [String] uri the base URI for content on the remote
+	# @return [void]
+	def remote(hostname, uri)
+		$current_app[:remote_host] = hostname
+		$current_app[:remote_uri]  = uri
+	end
+
+	# Setup the template for rendering
+	# @param [String] path location of the template
+	# @param [Proc] block block to execute for setting up template
+	# @return [void]
+	def template(path, &block)
+		$current_app[:template] = { path: path.nil? ? nil : Tilt.new(path, 1, { ugly: true }), sources: {} }
+		if block
+			Docile.dsl_eval(self, &block)
+		end
+	end
+
+	# Enable the use of an outer layout, for the current template
+	def use_layout
+		$current_app[:template][:use_layout] = true
+	end
+
+	# Setup the source for additional template information
+	# @param [Symbol] key the type of key for this source
+	# @param [String] uri the path for a remote source
+	# @param [Proc] block block to execute for setting up source
+	# @return [void]
+	def source(key, uri, &block)
+		$current_app[:template][:sources][key] = { uri: uri, key: nil }
+		$current_source                        = $current_app[:template][:sources][key]
+		if block
+			Docile.dsl_eval(self, &block)
+		end
+	end
+
+	# Setup the key for additional source information
+	# @param [Symbol] type the type of key for this source
+	# @return [void]
+	def key(type)
+		$current_source[:key] = type
+	end
+
+	# Setup the template for rendering single items
+	# @param [String] template the path to the template
+	# @return [void]
+	def single(template)
+		partial                    = Tilt.new(template, 1, { ugly: true })
+		$current_resource[:single] = partial
+	end
+
+	# Setup the template for rendering multiple items
+	# @param [String] template the path to the template
+	# @return [void]
+	def multiple(template)
+		partial                      = Tilt.new(template, 1, { ugly: true })
+		$current_resource[:multiple] = partial
+	end
+
+	# Setup the template for rendering one or more items
+	# @param [String] template the path to the template
+	# @return [void]
+	def all(template)
+		multiple(template)
+		single(template)
+	end
+
+	# Proxy method used when forwarding requests
+	# @param [Symbol] method the action to use when forwarding
+	# @param [Hash] context the context for this request
+	# @return [Response] a Rack Response triplet, or status code
+	def forward(method, context)
+		host     = context.app[:remote_host]
+		path     = context.app[:remote_uri]
+		resource = context.uri[2]
+		referer  = context.referer.join('/')
+
+		q  = '?' + context.query_string
+		id = context.uri[3...context.uri.length].join('/')
+		case (method)
+			when :create
+				puts "POST: Forward Request to https://#{host}/#{path}/#{resource}#{q}"
+				RestClient.post "http://#{host}/#{path}/#{resource}#{q}", context.body
+			when :update
+				puts "PUT: Forward Request to https://#{host}/#{path}/#{resource}/#{id}#{q}"
+				RestClient.put "http://#{host}/#{path}/#{resource}/#{id}#{q}", context.body
+			when :readAll
+				puts "GET: Forward Request to https://#{host}/#{path}/#{resource}#{q}"
+				RestClient.get "http://#{host}/#{path}/#{resource}#{q}", referer: referer
+			when :read
+				puts "GET: Forward Request to https://#{host}/#{path}/#{resource}/#{id}#{q}"
+				RestClient.get "http://#{host}/#{path}/#{resource}/#{id}#{q}", referer: referer
+			when :delete
+				puts "DELETE: Forward Request to https://#{host}/#{path}/#{resource}/#{id}#{q}"
+				RestClient.delete "http://#{host}/#{path}/#{resource}/#{id}#{q}"
+			else
+				401
+		end
+	end
+end

data/lib/app/render/document.rb

@@ -0,0 +1,51 @@
+require_relative '../render'
+
+module Render
+	# Document renders a file to an HTML representation
+	# @author Bryan T. Meyers
+	module Document
+		extend Render
+
+		# Renders a document or listing to HTML
+		# @param [Array] actions the actions allowed for this URI
+		# @param [Wire::Context] context the context for this request
+		# @param [Symbol] specific the type of read to perform
+		# @return [Response] a Rack Response triplet, or status code
+		def self.do_read(actions, context, specific)
+			begin
+				response = forward(specific, context)
+				mime     = response.headers[:content_type]
+				renderer = $renderers[mime]
+				if renderer
+					template = $templates[renderer]
+					template.render(self, { actions: actions, context: context, mime: mime, response: response.body })
+				else
+					response
+				end
+			rescue RestClient::ResourceNotFound
+				[404, {}, $apps[404][:template][:path].render(self, locals = { actions: actions, context: context })]
+			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, :read)
+					else
+						do_read(actions, context, :readAll)
+					end
+				when :update
+					forward(:update, context)
+				else
+					405
+			end
+		end
+	end
+end

data/lib/app/render/editor.rb

@@ -0,0 +1,55 @@
+require_relative '../render'
+
+module Render
+
+	# Editor allows a document to be displayed in an editing form
+	# @author Bryan T. Meyers
+	module Editor
+		extend Render
+
+		# Open an editor for a document
+		# @param [Array] actions the allowed actions for this URI
+		# @param [Hash] context the context for this request
+		# @return [Response] the Editor with containing document, or status code
+		def self.do_read(actions, context)
+			resource = context.uri[2]
+			query    = context.query
+			id       = context.uri[3...context.uri.length].join('/')
+			body     = ''
+			begin
+				response = forward(:read, context)
+				mime     = response.headers[:content_type]
+				body     = response.body
+			rescue RestClient::ResourceNotFound
+				if query[:type]
+					mime = query[:type]
+				else
+					return [404, {}, 'EDITOR: Document type not set for new document']
+				end
+			end
+			template = $editors[mime]
+			if template
+				template.render(self, { actions: actions, resource: resource, id: id, mime: mime, response: body })
+			else
+				body
+			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
+					do_read(actions, context)
+				when :update
+					forward(:update, context)
+				else
+					405
+			end
+		end
+	end
+end

data/lib/app/render/instant.rb

@@ -0,0 +1,65 @@
+require_relative '../render'
+
+module Render
+	# Instant allows for previews of edited documents
+	# @author Bryan T. Meyers
+	module Instant
+		extend Render
+
+		# Render a temporary document 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_update(actions, context)
+			body = context.body
+			if body
+				body = body.split('=')[1]
+				if body
+					body = URI.decode(body)
+				end
+			end
+			resource = context.uri[2]
+			id       = context.uri[3]
+			## Default to not found
+			message  = ''
+			status   = 404
+			if resource
+				if body
+					## Assume unsupported mime type
+					status   = 415
+					message  = 'INSTANT: Unsupported MIME Type'
+					renderer = $renderers["#{resource}/#{id}"]
+					if renderer
+						template = $templates[renderer]
+						result   = template.render(self,
+																			 { actions:  actions,
+																				 context:  context,
+																				 mime:     "#{resource}/#{id}",
+																				 response: body,
+																			 })
+						template = context.app[:template]
+						if template
+							message = template[:path].render(self, { actions: actions, context: context, content: result })
+						else
+							message = result
+						end
+						status = 200
+					end
+				end
+			end
+			[status, {}, 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)
+			if context.action.eql? :update
+				do_update(actions, context)
+			else
+				405
+			end
+		end
+	end
+end