radiant-fabulator-extension 0.0.1

data/COPYING.markdown

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2010 Texas A&M University
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,21 @@
+== Fabulator
+
+Fabulator is an extension to the Radiant CMS for creating web applications
+The applications are written in an XML language that describes the set 
+of application views and the data that triggers a move from one view 
+to the next, along with initial conditions for the application and data 
+transformations.
+
+== Installation
+
+Installation is done in the usual manner for Radiant extensions.
+
+This extension requires Radiant 0.9 or higher as well as the following
+gems:
+
+* fabulator
+
+You may also want to add some fabulator extensions.
+See http://github.com/jgsmith/
+
+[Radiant CMS]: http://www.radiantcms.org/

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/app/models/fabulator_context.rb

@@ -0,0 +1,36 @@
+class FabulatorContext < ActiveRecord::Base
+  #serialize :context
+  belongs_to :page
+  belongs_to :user
+
+  def self.find_by_page(p)
+    if p.request.session[:user_id].blank?
+      c = self.first(:conditions => [
+        'page_id = ? AND session = ? AND (user_id IS NULL OR user_id=0)',
+        p.id, p.request.session[:session_id]
+      ] )
+    else
+      c = self.first(:conditions => [
+        'page_id = ? AND session = ? AND user_id = ?',
+        p.id, p.request.session[:session_id], p.request.session[:user_id]
+      ] )
+    end
+    if c.nil? && !p.request.session[:user_id].blank?
+      c = self.first(:conditions => [
+        'page_id = ? AND session = ?',
+        p.id, p.request.session[:session_id]
+      ] )
+      if !c.nil? && c.user.nil?
+        c.update_attribute(:user_id, p.request.session[:user_id])
+      end
+    end
+    p.fabulator_context = c.context unless c.nil?
+    return c unless c.nil?
+    self.new(
+      :context => YAML::dump(p.fabulator_context),
+      :page_id => p.id,
+      :user_id => p.request.session[:user_id],
+      :session => p.request.session[:session_id]
+    )
+  end
+end

data/app/models/fabulator_page.rb

@@ -0,0 +1,459 @@
+class FabulatorPage < Page
+  # precompile xslt so we don't do this for *every* request
+
+  @@fabulator_xslt_file = RAILS_ROOT + '/vendor/extensions/fabulator/xslt/form.xsl'
+  @@fabulator_xslt = REXML::Document.new File.open(@@fabulator_xslt_file)
+
+  attr_accessor :inner_content
+
+  description %{
+    A Fabulator page allows you to create a simple, interactive
+    web application that manages data in RDF models defined in the
+    Fabulator > RDF Models tab of the administrative area.
+  }
+  # need a reasonable name for the XML part
+  XML_PART_NAME = 'extended'
+
+  after_save :set_defaults
+  attr_accessor :resource_ln, :c_state_machine
+
+  # create tags to access filtered data in page display
+  # might also create tags for form fields, etc., so it's easy to
+  # create a form and fill in data
+
+  def cache?
+    false
+  end
+
+  def find_by_url(url, live = true, clean = false)
+    #Rails.logger.info("find_by_url(#{url}, #{live}, #{clean})")
+    #Rails.logger.info("invoking super")
+    p = super
+    #Rails.logger.info("returning from super")
+    #Rails.logger.info("Found #{p}")
+    return p if !p.nil? && !p.is_a?(FileNotFoundPage)
+    #Rails.logger.info("Seeing if we have a resource")
+
+    url = clean_url(url) if clean
+    #Rails.logger.info("Our url: #{self.url}")
+    #Rails.logger.info("Target url: #{url}")
+    if url =~ %r{^#{ self.url }([-_0-9a-zA-Z]+)/?$}
+      #Rails.logger.info("resource: #{$1}")
+      self.resource_ln = $1
+      return self
+    else
+      return p
+    end
+  end
+
+  def url
+    #Rails.logger.info("Getting url")
+    u = super
+    if !self.resource_ln.nil?
+      u = u + '/' + self.resource_ln
+    end
+    #Rails.logger.info("Returning '#{u}' as url")
+    u
+  end
+
+  def state_machine
+    if self.compiled_xml.nil? || self.compiled_xml == ''
+      self.c_state_machine = nil
+    else
+      self.c_state_machine = (YAML::load(self.compiled_xml) rescue nil) unless self.c_state_machine
+    end
+    self.c_state_machine
+  end
+
+  def fabulator_context
+    if @roots.nil?
+      @roots = { }
+    end
+
+    if @roots['data'].nil?
+      @roots['data'] = Fabulator::Expr::Node.new('data', @roots, nil, [])
+      ctx = Fabulator::Expr::Context.new
+      ctx.root = @roots['data']
+      ctx.traverse_path(['resource'], true).first.value = self.resource_ln if self.resource_ln
+      self.state_machine.init_context(ctx)
+    end
+    @roots['data']
+  end
+
+  def fabulator_context=(c)
+    fc = self.fabulator_context
+    @roots = { } if @roots.nil?
+    @roots['data'] = c
+  end
+
+  def headers
+    if @resetting_context
+      {
+        :location => self.url,
+      }
+    elsif @redirecting
+      {
+        :location => @redirecting,
+      }
+    else
+      { }
+    end
+  end
+
+  def response_code
+    @resetting_context ? 302 : ( @redirecting ? 304 : 200 )
+  end
+
+  def render_snippet(p)
+    if p.name != XML_PART_NAME
+      super
+    else
+      # check if page part was updated since page -- might need to recompile
+      
+      sm = self.state_machine
+      return '' if sm.nil?
+
+      # run state machine if POST
+      context = FabulatorContext.find_by_page(self)
+      @resetting_context = false
+
+      if request.method == :get && 
+         params[:reset_context]
+        if !context.new_record?
+          context.destroy
+        end
+        # redirect without the reset_context param?
+        @response.redirect(url,302)
+        @resetting_context = true
+        return
+      end
+
+      begin
+        sm.context = YAML::load(context.context)
+        if sm.context.empty?
+          sm.init_context(self.fabulator_context)
+        end
+        #sm.context.merge!(self.resource_ln, ['resource'] ) if self.resource_ln
+        if request.method == :post
+          sm.run(params)
+          # save context
+          @sm_missing_args = sm.missing_params
+          @sm_errors       = sm.errors
+          context.context = YAML::dump(sm.context)
+          context.save
+        end
+        # save statemachine state
+        # display resulting view
+      rescue Fabulator::FabulatorRequireAuth => e
+        @redirecting = e.to_s
+      rescue => e
+        return "<p>#{e.to_s}</p><pre>" + e.backtrace.join("\n") + "</pre>"
+      end
+      return '' if @redirecting
+      if sm.state != XML_PART_NAME
+        return self.render_part(sm.state)
+      else
+        return 'Error: Fabulator application is not in a displayable state.'
+      end
+    end
+  end
+
+  def missing_args
+    @sm_missing_args
+  end
+
+  tag 'fabulator' do |tag|
+    tag.locals.fabulator_context = tag.locals.page.fabulator_context
+    tag.expand
+  end
+
+  desc %{
+    Formats the enclosed logical form markup, adds default values,
+    existing values, and marks errors or warnings and required fields.
+  }
+  tag 'form' do |tag|
+    # get xml markup of form and transform it via xslt while adding
+    # default values and such
+    # wrap the whole thing in a form tag to post back to this page
+    xml = tag.expand
+    return '' if xml.blank?
+
+    text_parser = Fabulator::Template::Parser.new
+
+    c = get_fabulator_context(tag)
+    root = nil
+
+    missing_args = tag.locals.page.missing_args
+
+    form_base = tag.attr['base']
+    if form_base.nil? || form_base == ''
+      root = c
+      form_base = c.root.path.gsub(/^.*::/, '').gsub('/', '.').gsub(/^\.+/, '')
+    else
+      root = c.nil? ? nil : c.with_root(c.eval_expression('/' + form_base.gsub('.', '/')).first)
+      root = c if !c.nil? && root.root.nil?
+    end
+    root = c
+
+    xml = %{<view><form>} + xml + %{</form></view>}
+    doc = text_parser.parse(c, xml)
+
+    # add default values
+    doc.add_default_values(root)
+
+    doc.to_html
+  end
+
+  # borrowed heavily from http://cpansearch.perl.org/src/JSMITH/Gestinanna-0.02/lib/Gestinanna/ContentProvider/XSM.pm
+  def add_default_values(doc, ctx)
+    REXML::XPath.each(doc.root, %{
+      //text
+      | //textline
+      | //textbox
+      | //editbox
+      | //file
+      | //password
+      | //selection
+      | //grid
+    }) do |el|
+      own_id = el.attribute('id')
+      next if own_id.nil? || own_id.to_s == ''
+
+      default = 0
+      is_grid = false
+      if el.local_name == 'grid'
+        default = REXML::XPath.match(el, './default | ./row/default | ./column/default')
+        is_grid = true
+      else
+        default = REXML::XPath.match(el, './default')
+      end
+
+      #missing = el.attribute('missing')
+
+      ancestors = REXML::XPath.match(el, %{
+        ancestor::option[@id != '']
+        | ancestor::group[@id != '']
+        | ancestor::form[@id != '']
+        | ancestor::container[@id != '']
+      })
+      ids = ancestors.collect{|a| a.attribute('id')}.select{|a| !a.nil? }
+      ids << own_id
+      id = ids.collect{|i| i.to_s}.join('.')
+      ids = id.split('.')
+      if !ctx.nil? && (default.is_a?(Array) && default.empty? || !default)
+        # create a new node 'default'
+        l = ctx.traverse_path(ids)
+        if !l.nil? && !l.empty?
+          if is_grid
+            count = (el.attribute('count').to_s rescue '')
+            how_many = 'multiple'
+            direction = 'both'
+            if count =~ %r{^(multiple|single)(-by-(row|column))?$}
+              how_many = $1
+              direction = $3 || 'both'
+            end
+            if direction == 'both'
+              l.collect{|ll| ll.value }.each do |v|
+                default = el.add_element('default')
+                default.add_text(v)
+              end
+            elsif direction == 'row' || direction == 'column'
+              REXML::XPath.each(el, "./#{direction}").each do |div|
+                id = (div.attribute('id').to_s rescue '')
+                next if id == ''
+                l.collect{|c| c.traverse_path(id)}.flatten.collect{|c| c.value }. each do |v|
+                  default = div.add_element('default')
+                  default.add_text(v)
+                end
+              end
+            end
+          else
+            l.collect{|ll| ll.value }.each do |v|
+              default = el.add_element('default')
+              default.add_text(v)
+            end
+          end
+        end
+      end
+      # now handle missing info for el
+
+      if !missing_args.nil? && missing_args.include?(id)
+        el.add_attribute('missing', '1')
+      end
+    end
+
+  end
+
+  desc %{
+    Defines XML namespace prefix to URI mappings.
+  }
+  tag 'xmlns' do |tag|
+    tag.expand
+  end
+
+  desc %{
+    Iterates through a set of data nodes.
+
+    *Usage:*
+
+    <pre><code><r:for-each select="./foo">...</r:for-each></code></pre>
+  }
+  tag 'for-each' do |tag|
+    selection = tag.attr['select']
+    c = get_fabulator_context(tag)
+    #Rails.logger.info("context: #{YAML::dump(c)}")
+    #Rails.logger.info("for-each: #{selection} from #{c}")
+    ns = get_fabulator_ns(tag)
+    items = c.nil? ? [] : c.eval_expression(selection)
+    sort_by = tag.attr['sort']
+    sort_dir = tag.attr['order'] || 'asc'
+
+    if !sort_by.nil? && sort_by != ''
+      parser = Fabulator::Expr::Parser.new
+      sort_by_f = parser.parse(sort_by, c)
+      items = items.sort_by { |i| c.with_root(i).eval_expression(sort_by_f).first.value }
+      if sort_dir == 'desc'
+        items.reverse!
+      end
+    end
+    res = ''
+    #Rails.logger.info("Found #{items.size} items for for-each")
+    items.each do |i|
+      next if i.empty?
+      tag.locals.fabulator_context = c.with_root(i)
+      res = res + tag.expand
+    end
+    res
+  end
+
+  desc %{
+    Selects the value and returns it in HTML.
+    TODO: allow escaping of HTML special characters
+
+    *Usage:*
+
+    <pre><code><r:value select="./foo" /></code></pre>
+  }
+  tag 'value' do |tag|
+    selection = tag.attr['select']
+    c = get_fabulator_context(tag)
+    items = c.nil? ? [] : c.eval_expression(selection)
+    items.collect{|i| i.to([Fabulator::FAB_NS, 'html']).value }.join('')
+  end
+
+  desc %{
+    Chooses the first test which returns content.  Otherwise,
+    uses the 'otherwise' tag.
+  }
+  tag 'choose' do |tag|
+    @chosen ||= [ ]
+    @chosen.unshift false
+    ret = tag.expand
+    @chosen.shift
+    ret
+  end
+
+  desc %{
+    Renders the enclosed content if the test passes.
+  }
+  tag 'choose:when' do |tag|
+    return '' if @chosen.first
+    selection = tag.attr['test']
+    c = get_fabulator_context(tag)
+    items = c.nil? ? [] : c.eval_expression(selection)
+    if items.is_a?(Array)
+      if items.empty?
+        return ''
+      else
+        @chosen[0] = true
+        return tag.expand
+      end
+    elsif items
+      @chosen[0] = true
+      return tag.expand
+    end
+    return ''
+  end
+
+  desc %{
+    Renders the enclosed content.
+  }
+  tag 'choose:otherwise' do |tag|
+    return '' if @chosen.first
+    tag.expand
+  end
+
+  desc %{
+    Renders the inherited view.
+  }
+  tag 'inner' do |tag|
+    @inner_content.nil? ? '' : @inner_content
+  end
+
+  desc %{
+    Renders the parent view providing the child view as an augmentation.
+  }
+  tag 'augment' do |tag|
+    parent_page = self.state_machine.isa
+    inner = tag.expand
+    return inner if parent_page.nil?
+    parent_page.inner_content = inner
+    parent_page.render_part(self.state_machine.state)
+  end
+
+private
+
+  def get_fabulator_ns(tag)
+    c = tag.locals.page
+    if c.nil?
+      c = tag.globals.page
+    end
+    #Rails.logger.info("page: #{c}")
+    #Rails.logger.info("state machine: #{c.state_machine}")
+    #Rails.logger.info("namespaces: #{c.state_machine.namespaces}")
+    ret = (c.state_machine.namespaces rescue { })
+    #Rails.logger.info("get_fabulator_ns: [#{ret}]")
+    ret
+  end
+
+  def get_fabulator_context(tag)
+    c = tag.locals.fabulator_context
+    if c.nil? 
+      c = tag.locals.page.state_machine.fabulator_context
+      if c.nil?
+        c = tag.globals.page.state_machine.fabulator_context
+      end
+    end
+    # TODO: move serialization back into the model
+    if c.is_a?(String)
+      c = YAML::load(c)
+    end
+    if c.is_a?(Hash)
+      c = c[:data]
+    end
+    return c
+  end
+
+
+  def set_defaults
+    # create a part for each state in the document
+    # 'body' is a description/special
+    # 'sidebar' is reserved
+
+    # compile statemachine into a set of Ruby objects and save
+    # not the most efficient, but we don't usually have hundreds of states
+    self[:compiled_xml] = nil
+    @compiled_xml = nil
+    sm = self.state_machine
+    Rails.logger.info("SM: #{YAML::dump(sm)}")
+    return if sm.nil?
+    #Rails.logger.info("Ensuring the right parts are present")
+
+    sm.state_names.sort.each do |part_name|
+      parts.create(:name => part_name, :content => %{
+        <h1>View for State #{part_name}</h1>
+      }) unless parts.any?{ |p| p.name == part_name }
+    end
+  end
+
+end

data/db/migrate/001_add_fabulator_fields.rb

@@ -0,0 +1,9 @@
+class AddFabulatorFields < ActiveRecord::Migration
+  def self.up
+    add_column :pages, :compiled_xml, :text
+  end
+
+  def self.down
+    remove_column :pages, :compiled_xml
+  end
+end

data/db/migrate/002_create_fabulator_contexts_table.rb

@@ -0,0 +1,17 @@
+class CreateFabulatorContextsTable < ActiveRecord::Migration
+  def self.up
+    create_table :fabulator_contexts do |t|
+      t.string     :session, :null => false
+      t.references :page, :null => false
+      t.references :user
+      t.text       :context
+      t.integer :lock_version, :default => 0
+    end
+
+    add_index :fabulator_contexts, [ :session, :page_id, :user_id ], :unique => true
+  end
+
+  def self.down
+    drop_table :fabulator_contexts
+  end
+end

data/fabulator_extension.rb

@@ -0,0 +1,61 @@
+$: << File.expand_path(File.dirname(__FILE__))+'/lib'
+
+require 'fabulator/radiant'
+
+require_dependency "#{File.expand_path(File.dirname(__FILE__))}/app/models/fabulator_page"
+
+class FabulatorExtension < Radiant::Extension
+  version "1.0"
+  description "Applications as documents"
+  url "http://github.com/jgsmith/radiant-fabulator"
+
+  XML_PART_NAME = 'extended'
+
+  extension_config do |config|
+    config.gem 'fabulator'
+    config.after_initialize do
+      #run_something
+    end
+  end
+
+
+  def activate
+    FabulatorPage
+
+    tab 'Fabulator' do
+    end
+
+    PagePart.class_eval do
+      before_save :compile_xml
+
+      def compile_xml
+        if self.page.class_name == 'FabulatorPage' &&
+           self.name == FabulatorExtension::XML_PART_NAME
+          old_compiled_xml = self.page.compiled_xml
+          if self.content.nil? || self.content == ''
+            self.page.compiled_xml = nil
+          else
+            # compile
+            #isa = Fabulator::ActionLib.get_local_attr(doc.root, Fabulator::FAB_NS, 'is-a')
+            isa = nil
+            sm = nil
+            if isa.nil?
+              sm = Fabulator::Core::StateMachine.new.compile_xml(self.content)
+            else
+              supersm_page = self.page.find_by_url(isa)
+              if supersm_page.nil? || supersm_page.is_a?(FileNotFoundPage) || !supersm_page.is_a?(FabulatorPage) || supersm_page.state_machine.nil?
+                raise "File Not Found: unable to find #{isa}"
+              end
+              sm = supersm_page.state_machine.clone
+              sm.compile_xml(self.content)
+            end
+            self.page.compiled_xml = YAML::dump(sm)
+          end
+          if old_compiled_xml != self.page.compiled_xml
+            self.page.save
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/radiant.rb

@@ -0,0 +1 @@
+require 'fabulator/radiant/actions'

data/lib/fabulator/radiant/actions.rb

@@ -0,0 +1,89 @@
+require 'fabulator/action_lib'
+require 'fabulator/radiant/actions/require_auth'
+
+module Fabulator
+  RADIANT_NS="http://dh.tamu.edu/ns/fabulator/radiant/1.0#"
+  class FabulatorRequireAuth < StandardError
+    def initialize(message = "") super; end
+  end
+
+  module Radiant
+    module Actions
+      class Lib
+        include Fabulator::ActionLib
+
+        register_namespace RADIANT_NS
+
+        #action 'require-auth', Fabulator::Radiant::Actions::RequireAuth
+
+        #register_type 'user', {
+        #}
+
+        register_type 'page', {
+          :ops => {
+            :children => Proc.new { |p| p.value.children.collect { |c| Lib.page_to_node(c, p) } },
+          },
+        }
+
+        # page parts are attributes of a page
+        # as are @name, @breadcrumb, @description, @keywords
+        #        @layout, @page-type, @status
+        # slug is the node name
+        # page parts have attributes @filter
+        register_type 'page-part', {
+          :to => [
+            { :type => [ FAB_NS, 'string' ],
+              :weight => 1.0,
+              :convert => Proc.new { |p| p.anon_node(p.value, [ FAB_NS, 'string' ]) }
+            }
+          ],
+        }
+
+        # 'radiant' axis
+        axis 'radiant' do |ctx|
+          # returns the root 'Home' page for the site
+          # children are addressable by their slug
+          Lib.page_to_node(Page.find_by_parent_id(nil), ctx)
+        end
+
+        function 'find', [ RADIANT_NS, 'page' ] do |ctx, args|
+          args[0].collect { |a|
+            Lib.page_to_node(Page.find_by_parent_id(nil).find_by_url(a.to_s), ctx)
+          }
+        end
+
+        function 'current-user' do |ctx, args|
+          u = UserActionObserver.current_user
+          if !u.nil?
+            n = ctx.root.anon_node(u.id) #, [ RADIANT_NS, 'user' ])
+            n.set_attribute('admin', u.admin?)
+Rails.logger.info("Returning: #{YAML::dump(n)}")
+            return [ n ]
+          else
+            return [ ]
+          end
+        end
+
+        def self.page_to_node(p, ctx)
+          return nil if p.nil?
+          p_node = ctx.root.anon_node(p, [ RADIANT_NS, 'page' ])
+          p_node.name = p.slug
+          p.parts.each do |pp|
+            pp_node = ctx.root.anon_node(pp.content, [ RADIANT_NS, 'page-part' ])
+            pp_node.name = pp.name
+            #pp_node.set_attribute('filter', pp.filter)
+            p_node.set_attribute(pp.name, pp_node)
+          end
+          p_node.set_attribute('title', p.title)
+          p_node.set_attribute('breadcrumb', p.breadcrumb)
+          p_node.set_attribute('description', p.description)
+          p_node.set_attribute('keywords', p.keywords)
+          #p_node.set_attribute('layout', p.layout)
+          #p_node.set_attribute('page-type', p.page_type)
+          #p_node.set_attribute('status', p.status)
+          p_node
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: radiant-fabulator-extension
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-10 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fabulator
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :runtime
+  version_requirements: *id001
+description: Creates a Fabulator page type allowing applications to be built using the fabulator engine.
+email: jgsmith@tamu.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- COPYING.markdown
+- README.rdoc
+- VERSION
+- app/models/fabulator_context.rb
+- app/models/fabulator_page.rb
+- db/migrate/001_add_fabulator_fields.rb
+- db/migrate/002_create_fabulator_contexts_table.rb
+- fabulator_extension.rb
+- lib/fabulator/radiant.rb
+- lib/fabulator/radiant/actions.rb
+has_rdoc: true
+homepage: http://github.com/jgsmith/radiant-fabulator
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Fabulator Extension for Radiant CMS
+test_files: []
+