lib/spontaneous/plugins/page/formats.rb in spontaneous-0.2.0.alpha2 vs lib/spontaneous/plugins/page/formats.rb in spontaneous-0.2.0.alpha3

@@ -5,88 +5,113 @@
 module Spontaneous::Plugins::Page
   module Formats
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def formats(*formats)
-        return format_list if formats.nil? or formats.empty?
-        set_formats(formats)
+      def outputs(*outputs)
+        return output_list if outputs.nil? or outputs.empty?
+        set_outputs(outputs)
       end
 
-      def format_list
-        @formats ||= supertype_formats
+      def output_map
+        @outputs ||= supertype_outputs
       end
 
-      def mime_types
-        @mime_types ||= supertype_mimetypes
+      def output_list
+        output_map.values
       end
 
-      def add_format(new_format)
-        format = define_format(new_format)
-        format_list.push(format)
+      def add_output(format, *args)
+        options = args.extract_options!
+        output = define_and_add_output(format, options)
       end
 
-      def set_formats(formats)
-        formats = formats.flatten
-        mime_types.clear
-        format_list.clear
-        formats.map do |format|
-          format_list.push define_format(format)
+      def set_outputs(outputs)
+        output_map.clear
+        outputs.each do |definition|
+          define_and_add_output(*definition)
         end
       end
 
-      def define_format(format)
-        mime_type = nil
-        if format.is_a?(Hash)
-          mime_type = format.values.first
-          format = format.keys.first
-          mime_types[format.to_sym] = mime_type
-        else
-          mime_type = ::Rack::Mime.mime_type(".#{format}", nil)
+      def define_and_add_output(format, options = {})
+        output = define_output(format, options)
+        output_map[output.name] = output
+      end
+
+      def define_output(format, options = {})
+        o = Spontaneous::Output.create(format, options).tap do |output|
+          silence_warnings { self.const_set("Output#{format.to_s.upcase}", output) }
         end
-        raise Spontaneous::UnknownFormatException.new(format) unless mime_type
-        format.to_sym
       end
 
-      def supertype_formats
-        supertype? && supertype.respond_to?(:formats) ? supertype.formats.dup : [:html]
+      def supertype_outputs
+        supertype? && supertype.respond_to?(:outputs) ? supertype.output_map.dup : { :html => standard_output }
       end
 
-      def supertype_mimetypes
-        supertype? && supertype.respond_to?(:mime_types) ? supertype.mime_types.dup : {}
+      def standard_output
+        define_output(:html)
       end
 
-      def default_format
-        formats.first
+      def default_output
+        output_list.first
       end
 
       def provides_format?(format)
-        format = (format || :html).to_sym
-        formats.include?(format)
+        return true if format.blank?
+        format = format.to_s
+        outputs.any? { |output| (output == format) or (output.name.to_s == format) }
       end
 
+      alias_method :provides_output?, :provides_format?
+
+      def output(name = nil)
+        output_without_validation(name) or raise Spontaneous::UnknownOutputException.new(self, name)
+      end
+
+      def output_without_validation(name = nil)
+        return name if name.is_a?(Spontaneous::Output::Format)
+        return default_output if name.blank?
+        output_map[name.to_sym]
+      end
+
       def mime_type(format)
-        if mime_types && mime_types.key?(format)
-          mime_types[format]
+        return format.mime_type if format.respond_to?(:mime_type)
+        if (match = output_without_validation(format))
+          match.mime_type
         else
           ::Rack::Mime.mime_type(".#{format}")
         end
       end
     end # ClassMethods
 
-    def formats
-      self.class.formats
+    def outputs
+      self.class.outputs.map { |output| output.new(self) }
     end
 
-    def default_format
-      self.class.default_format
+    def default_output
+      self.class.default_output.new(self)
     end
 
-    def provides_format?(format)
-      self.class.provides_format?(format)
+    def provides_output?(format)
+      self.class.provides_output?(format)
     end
 
+    def output(format, content = nil)
+      return format if format.is_a?(Spontaneous::Output::Format)
+      output_class = self.class.output(format)
+      output_class.new(self, content)
+    end
+
     def mime_type(format)
       self.class.mime_type(format)
+    end
+
+    def render(format=:html, params={}, *args)
+      if format.is_a?(Hash)
+        params = format
+        format = :html
+      end
+      output = output(format)
+      output.render(params, *args)
     end
   end # Formats
 end # Spontaneous::Plugins::Page