wire-framework 0.1.4.26 → 0.1.5

data/lib/app/render/document.rb

@@ -1,45 +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.
+##
 
 module Render
-	# Document renders a file to an HTML representation
-	# @author Bryan T. Meyers
-	module Document
-		extend Render
+  # Document renders a file to an HTML representation
+  # @author Bryan T. Meyers
+  module Document
 
-		# 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)
-			response = forward(specific, context)
-			mime     = response[1]['content-type']
-			renderer = $renderers[mime]
-			if renderer
-				template = $templates[renderer]
-				template.render(self, { actions: actions, context: context, mime: mime, response: response[2] })
-			else
-				response
-			end
-		end
+    # 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)
+      response = context.forward(specific)
+      mime     = response[1]['content-type']
+      #TODO: Fix lookup
+      renderer = $wire_renderers[mime]
+      if renderer
+        template = renderer['partial']
+        template.render(self, { actions:  actions,
+                                context:  context,
+                                mime:     mime,
+                                response: response[2] })
+      else
+        response
+      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
-					forward(context.action, context)
-				when :read
-					if context.uri[3]
-						do_read(actions, context, :read)
-					else
-						do_read(actions, context, :readAll)
-					end
-				else
-					405
-			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, :read)
+          else
+            do_read(actions, context, :readAll)
+          end
+        else
+          405
+      end
+    end
+  end
 end

data/lib/app/render/editor.rb

@@ -1,50 +1,65 @@
-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
 
-	# Editor allows a document to be displayed in an editing form
-	# @author Bryan T. Meyers
-	module Editor
-		extend Render
+  # Editor allows a document to be displayed in an editing form
+  # @author Bryan T. Meyers
+  module Editor
 
-		# 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('/')
-			response = forward(:read, context)
-			body     = (response[0] == 200 ) ? response[2] : ''
-			if query[:type]
-				mime = query[:type]
-			elsif response[1]['content-type']
-				mime = response[1]['content-type']
-			else
-				return [404, {}, 'EDITOR: Document type not set for new document']
-			end
-			template = $editors[mime]
-			if template
-				template.render(self, { actions: actions, resource: resource, id: id, mime: mime, response: body })
-			else
-				body
-			end
-		end
+    # 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)
+      response = context.forward(:read)
+      body     = (response[0] == 200) ? response[2] : ''
+      if context.query[:type]
+        mime = context.query[:type]
+      elsif response[1]['content-type']
+        mime = response[1]['content-type']
+      else
+        return [404, {}, 'EDITOR: Document type not set for new document']
+      end
+      #TODO: Fix lookup
+      template = $wire_editors[mime]
+      if template
+        template.render(self, { actions:  actions,
+                                resource: context.resource,
+                                id:       context.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,:update
-					forward(context.action, context)
-				when :read
-					do_read(actions, context)
-				else
-					405
-			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
+          context.forward(context.action)
+        when :read
+          do_read(actions, context)
+        else
+          405
+      end
+    end
+  end
 end

data/lib/app/render/error.rb

@@ -1,41 +1,61 @@
-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
-	module Error
-		extend Render
+  module Error
 
-		def self.error(match, path)
-			unless $current_app[:errors]
-				$current_app[:errors] = {}
-			end
-			$current_app[:errors][match] = Tilt.new(path, 1, { ugly: true })
-		end
+    # Configure error templates
+    # @param [Hash] conf the raw configuration
+    # @return [Hash] post-processed configuration
+    def self.configure(conf)
+      conf['errors'].each do |k, v|
+        conf['errors'][k] = Tilt.new(v, 1, { ugly: true })
+      end
+      conf
+    end
 
-		def self.error_check(actions, context, result)
-			errors = context.app[:errors]
-			if errors
-				template = errors[result[0]]
-				if template
-					result[2] = template.render(self, {actions: actions, context: context, result: result})
-				end
-			end
-			result
-		end
+    def self.error_check(actions, context, result)
+      errors = context.app['errors']
+      if errors
+        template = errors[result[0]]
+        if template
+          result[2] = template.render(self, { actions: actions,
+                                              context: context,
+                                              result:  result })
+        end
+      end
+      result
+    end
 
-		def self.invoke(actions, context)
-			case context.action
-				when :create,:update
-					result = forward(context.action, context)
-				when :read
-					if context.uri[3]
-						result = forward(:read, context)
-					else
-						result = forward(:readAll, context)
-					end
-				else
-					result = 405
-			end
-			error_check(actions, context, result)
-		end
-	end
+    def self.invoke(actions, context)
+      case context.action
+        when :create, :update
+          result = context.forward(context.action)
+        when :read
+          if context.id
+            result = context.forward(:read)
+          else
+            result = context.forward(:readAll)
+          end
+        else
+          result = 405
+      end
+      error_check(actions, context, result)
+    end
+  end
 end

data/lib/app/render/instant.rb

@@ -1,65 +1,76 @@
-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
-	# Instant allows for previews of edited documents
-	# @author Bryan T. Meyers
-	module Instant
-		extend Render
+  # Instant allows for previews of edited documents
+  # @author Bryan T. Meyers
+  module Instant
 
-		# 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
+    # 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)
+      ## Default to not found
+      message  = ''
+      status   = 404
+      if context.resource
+        body = context.body
+        if body
+          #TODO: This looks off...
+          body = body.split('=')[1]
+          if body
+            body = URI.decode(body)
+          end
+          ## Assume unsupported mime type
+          status   = 415
+          message  = 'INSTANT: Unsupported MIME Type'
+          renderer = $wire_renderers["#{context.resource}/#{context.id}"]
+          if renderer
+            template = $wire_templates[renderer]
+            result   = template.render(self, { actions:  actions,
+                                               context:  context,
+                                               mime:     "#{context.resource}/#{context.id}",
+                                               response: body, })
+            #TODO: Fix template lookup
+            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
+    # 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

data/lib/app/render/page.rb

@@ -1,85 +1,110 @@
-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
-	# Page builds the a page that is presented directly to a user
-	# @author Bryan T. Meyers
-	module Page
-		include Render
-		extend self
+  # Page builds the a page that is presented directly to a user
+  # @author Bryan T. Meyers
+  module Page
 
-		# 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]}"
-					go_ahead = true
-					case s[:key]
-						when :user
-							go_ahead = (context.user and !context.user.empty?)
-							uri += "/#{context.user}"
-						when :resource
-							go_ahead = (context.uri[2] and !context.uri[2].empty?)
-							uri += "/#{context.uri[2]}"
-					end
-					temp = []
-					if go_ahead
-							temp = RL.request(:get, uri, {remote_user: context.user})
-					end
-					hash[k] = (temp[0] == 200) ? temp[2] : nil
-				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 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['file']
+        hash = { actions: actions, context: context, content: content }
+        template['sources'].each do |k, s|
+          uri      = "http://#{context.app[:remote_host]}"
+          go_ahead = true
+          if s.is_a? Hash
+            uri += "/#{hash['uri']}"
+            case s['key']
+              when 'user'
+                go_ahead = (context.user and !context.user.empty?)
+                uri      += "/#{context.user}"
+              when 'resource'
+                go_ahead = (context.uri[2] and !context.uri[2].empty?)
+                uri      += "/#{context.uri[2]}"
+              else
+                # do nothing
+            end
+          else
+            uri += s
+          end
+          temp = []
+          if go_ahead
+            temp = RL.request(:get, uri, { remote_user: context.user })
+          end
+          if temp[0] == 200
+            begin
+              hash[k] = JSON.parse_clean(temp[2])
+            rescue
+              hash[k] = temp[2]
+            end
+          end
+        end
+        message = template[:path].render(self, hash)
+        if template['use_layout']
+          message = render_template(actions, context, $wire_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)
-			resource = context.uri[2]
-			if resource
-				result = forward(specific, context)
-				template = context.app[:template]
-				if template
-					result[1]['Content-Type'] = 'text/html'
-					result[2] = render_template(actions, context, template, result[2])
-				end
-			else
-				result = [401,{},'Resource not specified']
-			end
-			result
-		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)
+      if context.resource
+        result   = context.forward(specific)
+        #TODO: fix lookup
+        template = context.app[:template]
+        if template
+          result[1]['Content-Type'] = 'text/html'
+          result[2]                 = render_template(actions, context, template, result[2])
+        end
+      else
+        result = [401, {}, 'Resource not specified']
+      end
+      result
+    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, :read)
-					else
-						do_read(actions, context, :readAll)
-					end
-				else
-					405
-			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.uri[3]
+            do_read(actions, context, :read)
+          else
+            do_read(actions, context, :readAll)
+          end
+        else
+          405
+      end
+    end
+  end
 end