wire-framework 0.1.4.26 → 0.1.5

data/lib/app/render/partial.rb

@@ -1,106 +1,127 @@
-require_relative '../render'
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
 
-module Render
-	# Partials are URI mapped renderers which generate only a piece of a document
-	# @author Bryan T.Meyers
-	module Partial
-		extend Render
+require 'rest-less'
+require 'tilt'
 
-		# DSL method to enable forwarding to remote
-		# @return [void]
-		def self.use_forward
-			$current_resource[:forward] = true
-		end
+module Render
+  # Partials are URI mapped renderers which generate only a piece of a document
+  # @author Bryan T.Meyers
+  module Partial
 
-		# 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
+    # Configure repo with listing template
+    # @param [Hash] conf the raw configuration
+    # @return [Hash] post-processed configuration
+    def self.configure(conf)
+      conf['resources'].each do |k, v|
+        if v.is_a? Hash
+          conf['resources'][k]['multiple'] = Tilt.new(v['multiple'], 1, { ugly: true })
+          conf['resources'][k]['single']   = Tilt.new(v['single'], 1, { ugly: true })
+        elsif v.is_a? String
+          #TODO: fix needless duplication
+          conf['resources'][k]['multiple'] = Tilt.new(v, 1, { ugly: true })
+          conf['resources'][k]['single']   = Tilt.new(v, 1, { ugly: true })
+        end
+      end
+      conf
+    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]
-			body = ''
-			mime = ''
-			if context.resource[:forward]
-				response = forward(:readAll, context)
-				return response if response[0] != 200
-				mime     = response[1][:content_type]
-				body     = response[2]
-			end
-			template = context.resource[:multiple]
-			if template
-				hash     = { actions: actions, resource: resource, mime: mime, response: body }
-				if context.resource[:sources]
-					context.resource[:sources].each do |k, v|
-						hash[k] = RL.request(:get,
-																 "http://#{context.app[:remote_host]}/#{v}",
-																 {remote_user: context.user}
-						)[2]
-					end
-				end
-				mime = 'text/html'
-				body = template.render(self,hash)
-			end
-			[200,{'Content-Type' => mime },body]
-		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]
+      body     = ''
+      mime     = ''
+      if context.app['use_forward']
+        response = context.forward(:readAll)
+        return response if response[0] != 200
+        mime = response[1][:content_type]
+        body = response[2]
+      end
+      template = context.app['resources'][context.resource]['multiple']
+      if template
+        hash = { actions:  actions,
+                 resource: resource,
+                 mime:     mime,
+                 response: body }
+        if ccontext.app['resources'][context.resource]['extras']
+          context.app['resources'][context.resource]['extras'].each do |k, v|
+            hash[k] = RL.request(:get,
+                                 "http://#{context.app['remote']}/#{v}",
+                                 { remote_user: context.user }
+            )[2]
+          end
+        end
+        mime = 'text/html'
+        body = template.render(self, hash)
+      end
+      [200, { 'Content-Type': mime }, body]
+    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.uri[1]
-			resource = context.uri[2]
-			id       = context.uri[3...context.uri.length].join('/')
-			body = ''
-			mime = ''
-			if context.resource[:forward]
-				response = forward(:read, context)
-				return response if response[0] != 200
-				mime     = response[1][:content_type]
-				body     = response[2]
-			end
-			template = context.resource[:single]
-			if template
-				hash     = { actions: actions, app: app, resource: resource, id: id, mime: mime, response: body }
-				if context.resource[:sources]
-					context.resource[:sources].each do |k, v|
-						hash[k] = RL.request(:get, "http://#{context.app[:remote_host]}/#{v}")[2]
-					end
-				end
-				mime = 'text/html'
-				body = template.render(self,hash)
-			end
-			[200,{'Content-Type' => mime },body]
-		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)
+      body     = ''
+      mime     = ''
+      if context.app['resources'][context.resource]['use_forward']
+        response = context.forward(:read)
+        return response if response[0] != 200
+        mime = response[1][:content_type]
+        body = response[2]
+      end
+      template = context.app['resources'][context.resource]['single']
+      if template
+        hash = { actions:  actions,
+                 app:      context.app,
+                 resource: context.resource,
+                 id:       context.id,
+                 mime:     mime,
+                 response: body }
+        if context.app['resources'][context.resource]['extras']
+          context.app['resources'][context.resource]['extras'].each do |k, v|
+            hash[k] = RL.request(:get, "http://#{context.app[:remote_host]}/#{v}")[2]
+          end
+        end
+        mime = 'text/html'
+        body = template.render(self, hash)
+      end
+      [200, { 'Content-Type': mime }, body]
+    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,:update,:delete
-					forward(context.action, context)
-				when :read
-					if context.uri[3]
-						do_read(actions, context)
-					else
-						do_read_all(actions, context)
-					end
-				else
-					403
-			end
-		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, :update, :delete
+          context.forward(context.action)
+        when :read
+          if context.id
+            do_read(actions, context)
+          else
+            do_read_all(actions, context)
+          end
+        else
+          403
+      end
+    end
+  end
 end

data/lib/app/render/style.rb

@@ -1,48 +1,62 @@
-require_relative '../render'
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
+
+require 'tilt'
 
 module Render
-	# Style uses Tilt to render and serve stylesheets
-	# @author Bryan T. Meyers
-	module Style
-		extend Render
+  # Style uses Tilt to render and serve stylesheets
+  # @author Bryan T. Meyers
+  module Style
 
-		# 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
+    # Configure styles
+    # @param [Hash] conf the raw configuration
+    # @return [Hash] post-processed configuration
+    def self.configure(conf)
+      conf['styles'].each do |k, v|
+        conf['styles'][k] = Tilt.new(v, 1, {ugly: true}).render
+      end
+      conf
+    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)
-			resource = context.uri[2]
-			template = context.app[:styles][resource]
-			headers  = {'Cache-Control' => 'public,max-age=3600'}
-			if template
-				headers['Content-Type'] = 'text/css'
-				[200, headers, [template]]
-			else
-				404
-			end
-		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)
+      resource = context.uri[2]
+      template = context.app['styles'][resource]
+      headers  = {'Cache-Control': 'public,max-age=3600'}
+      if template
+        headers['Content-Type'] = 'text/css'
+        [200, headers, [template]]
+      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)
-			case context.action
-				when :read
-					do_read_all(context)
-				else
-					403
-			end
-		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

@@ -1,148 +1,154 @@
-require 'awesome_print'
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
+
 require 'base64'
-require_relative '../wire'
+require 'tilt'
 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
+  # Configure repo with listing template
+  # @param [Hash] conf the raw configuration
+  # @return [Hash] post-processed configuration
+  def self.configure(conf)
+    conf['listing'] = Tilt.new(conf['listing'], 1, { ugly: true })
+    conf
+  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
+  # Create a new Repo
+  # @param [Hash] context the context for this request
+  # @return [Response] status code
+  def do_create(context)
+    path     = context.config['repos']
+    resource = context.resource
+    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 root directory listing
+  # @param [Hash] context the context for this request
+  # @return [Response] the listing, or status code
+  def do_read_all(context)
+    mime     = 'text/html'
+    list     = do_read_listing(context.config['web'],
+                               context.config['repos'],
+                               context.resource)
+    if list == 404
+      return 404
+    end
+    template = context.config['listing']
+    list     = template.render(self,
+                               list:     list,
+                               resource: context.resource,
+                               id:       '',
+                               referrer: context.referer)
+    headers  = { 'Content-Type':  mime,
+                 'Cache-Control': 'public',
+                 '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
+  # 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.resource
+    referrer = context.referer
+    repos    = context.config['repos']
+    web      = context.config['web']
+    rev      = context.query[:rev]
+    id       = context.id
+    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.config['listing']
+      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 = { 'Content-Type':  mime,
+                'Cache-Control': 'public',
+                '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
+  # Update the a single file
+  # @param [Hash] context the context for this request
+  # @return [Response] status code
+  def do_update(context)
+    path    = context.resource
+    repos   = context.config['repos']
+    web     = context.config['web']
+    content = context.json
+    id      = context.id
+    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
+  # 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.resource
+    case context.action
+      when :create
+        do_create(context)
+      when :read
+        if context.id
+          do_read(context)
+        else
+          do_read_all(context)
+        end
+      when :update
+        do_update(context)
+      else
+        403
+    end
+  end
 end