RubyGems - radiant_helper - Versions diffs - 1.0.3 - Mend

radiant_helper 1.0.3

Files changed (9) hide show

data/bin/radiant_helper +93 -0
data/init.rb +1 -0
data/lib/radiant_helper.rb +62 -0
data/lib/radiant_helper_errors.rb +25 -0
data/lib/radiant_helper_page.rb +52 -0
data/lib/radiant_helper_response.rb +45 -0
data/lib/radiant_helper_text_helper.rb +23 -0
data/lib/tasks/rubyforge_config.yml +5 -0
metadata +60 -0

data/bin/radiant_helper ADDED Viewed

@@ -0,0 +1,93 @@
+puts ""
+puts %{
+*** View Level Usage ***
+So you've got a Radiant CMS and you want to include it as part of your app, eh?
+Well, just follow along and I'll help you intergrate CMS backed sections to your dynamic pages!
+1.) Configuration
+First we need to do a little configuration. We need to know a few details about where your Radiant server lives.
+  If you are using the application_configuration gem (and why wouldn't you be?) simply the set the following parameter:
+  radiant_server_url: http://www.myawesomeradiantserver.com
+  If you are not using the application_configuration (loser), then you can configure this parameter by setting the constant 'RADIANT_SERVER_URL'.
+Now your Rails application has all it needs to start including dynamic sections of pages from your Radiant CMS.
+2.) Usage
+Ok, so now we know where to find Radiant we can start incorporating it into your Rails application.
+  Example: some_page.rhtml
+  <html>
+    <head>
+      <title>My Awesome Rails App!</title>
+    </head>
+    <body>
+      Welcome: <%= current_user.display_name %>!
+      <%= load_radiant_page("my-news-area") %>
+      You last logged in at: <%= current_user.last_login_time %>
+    </body>
+  </html>
+Did you see the tag '<%= load_radiant_page("my-news-area") %>'? If you did, good for you! That's the magic that drives this whole thing!
+The 'load_radiant_page' method takes one required parameter, and an optional second parameter. The first parameter is the slug name for the Radiant CMS page you are trying to access. It will join this with the 'radiant_server_url' parameter you set up earlier. Woah! That was easy!!
+The optional second parameter is a Hash. Any values you pass in on this Hash will be converted to query string parameters and passed on to the Radiant CMS page you are trying to access.
+*** Controller Level Usage ***
+Ok, so we've talked about how to use Radiant to drive small sections of your page, well, what about if you want to use Radiant to drive the main content, or even the entire page from Radiant? Well, we got you covered!
+Let's say you have a controller that's entirely dedicated to this task. The controller could look as simple as:
+class CmsController < ApplicationController
+  action_requires :slug
+  def index
+    render(Radiant::Helper::Page.render(params))
+  end
+end
+And your routes.rb would have the following entry:
+map.connect "cms/:slug", :controller => "cms", :action => "index"
+The Radiant::Helper::Page.render method takes a Hash, which will mostly like be your params Hash, although it does not have to. What it DOES need to contain though is a :slug parameter which tells the Radiant::Helper::Page.render method which slug in the Radiant CMS it is going to try and access. Any other entries in the params Hash, with the exception of :action, :controller, and :slug, will be passed on as query string parameters to the Radiant slug you are trying to access.
+When the Radiant::Helper::Page.render method gets back the results from Radiant if the result is not a success (200) it will raise a Radiant::Helper::InvalidResponseError. Assuming the response is a success the next thing the Radiant::Helper::Page.render method will do is to determine if it already has a layout, and if not, which layout it should have.
+Let's look at this a little more closely, shall we?
+If we get a response back from Radiant that contains a <html> and a </html> tag, the Radiant::Helper::Page.render method assumes that it is using a Radiant layout, and will NOT add a layout from you Rails app on top of that.
+If the response does NOT contain these tags then the Radiant::Helper::Page.render method will try and determine which layout it should wrap the response with. This is done using two different configuration variables.
+Example:
+cms_layouts:
+  about: my_test_layout
+  foo: another_layout
+default_cms_layout: application
+The previous example configuration was for the application_configuration gem, if you are using constants set these config parameters using 'CMS_LAYOUTS' and 'DEFAULT_CMS_LAYOUT'.
+The 'default_cms_layout' config parameter is the layout that will get used if no other layout is defined for a particular slug. This is pretty simple and straight forward.
+The 'cms_layouts' config parameter is a Hash that maps a slug to the Rails layout you wish to use for that slug.
+*** That's it! ***
+Enjoy.
+}.strip
+puts ""

data/init.rb ADDED Viewed

	@@ -0,0 +1 @@
1	+ #require 'radiant_helper'

data/lib/radiant_helper.rb ADDED Viewed

@@ -0,0 +1,62 @@
+require 'net/http'
+require 'uri'
+require 'radiant_helper_errors'
+require 'radiant_helper_page'
+require 'radiant_helper_response'
+require 'singleton'
+module Radiant
+  module Helper
+    def self.cms_layouts
+      get_config_param(:cms_layouts) || {}
+    end
+    def self.radiant_server_url
+      get_config_param(:radiant_server_url)
+    end
+    def self.default_cms_layout
+      get_config_param(:default_cms_layout)
+    end
+    def self.logger
+      if const_defined?("RAILS_DEFAULT_LOGGER")
+        return RAILS_DEFAULT_LOGGER
+      else
+        return Radiant::Helper::RLogger.instance.logger
+      end
+    end
+    private
+    def self.get_config_param(config_name)
+      config_name = config_name.to_s
+      if self.respond_to?(:app_config)
+        p = app_config.send(config_name)
+        if p.nil?
+          raise Radiant::Helper::InvalidConfigurationError.new(config_name)
+        end
+        return p
+      else
+        if const_defined?(config_name.upcase)
+          return eval(config_name.upcase)
+        else
+          raise Radiant::Helper::InvalidConfigurationError.new(config_name)
+        end
+      end
+    end
+    class RLogger
+      include Singleton
+      attr_accessor :logger
+      def initialize
+        self.logger = Logger.new(STDOUT)
+      end
+    end
+  end # Helper
+end # Radiant
+require 'radiant_helper_text_helper'

data/lib/radiant_helper_errors.rb ADDED Viewed

@@ -0,0 +1,25 @@
+module Radiant
+  module Helper
+    class InvalidResponseError < Exception
+    end # InvalidResponseError
+    class InvalidConfigurationError < Exception
+      def initialize(config_name)
+        super(%{
+Radiant::Helper was not initialized correctly!
+If you are using the application_configuration gem then set the config param '#{config_name.downcase}'
+equal to the host of your Radiant server.
+If you are not using this gem (why aren't you?) then you can configure this setting by
+setting a constant called: '#{config_name.upcase}'.
+          }.strip)
+      end
+    end # InvalidConfigurationError
+  end # Helper
+end # Radiant

data/lib/radiant_helper_page.rb ADDED Viewed

@@ -0,0 +1,52 @@
+module Radiant
+  module Helper
+    class Page
+      class << self
+        def retrieve(slug, options = {})
+          begin
+            url = File.join(Radiant::Helper.radiant_server_url, slug)
+            if options.is_a? Hash
+              opts = options.dup
+              unless opts.nil? && opts.empty?
+                opts.delete(:controller)
+                opts.delete(:action)
+                opts.delete(:slug)
+                url << "?"
+                url << opts.collect {|k,v| "#{URI.escape(k.to_s)}=#{URI.escape(v.to_s)}"}.join("&")
+              end
+            end
+            # pp url
+            response = Net::HTTP.get_response(URI.parse(url))
+            return Radiant::Helper::Response.new(url, response.code, response.body)
+          rescue Radiant::Helper::InvalidConfigurationError => e
+            raise e
+          rescue Exception => e
+            Radiant::Helper.logger.error(e)
+            return Radiant::Helper::Response.new(url, 404)
+          end
+        end
+        def render(params)
+          slug = params[:slug] || params["slug"]
+          raise RuntimeError.new("You MUST define a slug parameter!") if slug.blank?
+          res = Radiant::Helper::Page.retrieve(slug, params)
+          if res.success?
+            opts = {:text => res.body}
+            unless res.has_layout?
+              cms_layouts = Radiant::Helper.cms_layouts
+              opts[:layout] = cms_layouts[slug] || Radiant::Helper.default_cms_layout
+            end
+            return opts
+          end
+          raise res.exception
+        end
+      end
+    end # Page
+  end # Helper
+end # Radiant

data/lib/radiant_helper_response.rb ADDED Viewed

@@ -0,0 +1,45 @@
+module Radiant
+  module Helper
+    class Response
+      attr_accessor :status
+      attr_accessor :body
+      attr_accessor :url
+      def initialize(url, status, body = "")
+        self.url = url
+        self.status = status.to_i
+        self.body = body
+      end
+      def success?
+        self.status == 200
+      end
+      def to_s
+        self.success? ? self.body : ""
+      end
+      def to_str
+        self.to_s
+      end
+      def has_layout?
+        ivar_cache("has_layout") do
+          unless self.body.nil?
+            b = self.body.downcase
+            return ((b.match("<html>") ? true : false) && (b.match("</html>") ? true : false))
+          end
+          return false
+        end
+      end
+      def exception
+        Radiant::Helper::InvalidResponseError.new("URL: #{self.url} did not return a valid response! Status: #{self.status}") unless self.success?
+      end
+    end # Response
+  end # Helper
+end # Radiant

data/lib/radiant_helper_text_helper.rb ADDED Viewed

@@ -0,0 +1,23 @@
+module ActionView
+  module Helpers
+    module TextHelper
+      def load_radiant_page(slug, options = {})
+        text = "<!-- Loading cms slug: '#{slug}' -->\n"
+        begin
+          res = Radiant::Helper::Page.retrieve(slug, request)
+          if res.success?
+            text << res.body
+          else
+            raise res.exception
+          end
+        rescue Exception => e
+          text << "<!-- Error: #{e.message} -->"
+        end
+        text << "\n<!-- Loaded cms slug: '#{slug}' -->"
+        text
+      end
+    end
+  end
+end

data/lib/tasks/rubyforge_config.yml ADDED Viewed

@@ -0,0 +1,5 @@
+--- !ruby/object:RubyForgeConfig
+gem_name: radiant_helper
+package: radiant_helper
+project: magrathea
+version: 1.0.3

metadata ADDED Viewed

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+rubygems_version: 0.9.2
+specification_version: 1
+name: radiant_helper
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+date: 2007-10-16 00:00:00 -04:00
+summary: radiant_helper
+require_paths:
+- lib
+- lib
+- lib
+- lib/tasks
+email:
+homepage:
+rubyforge_project: magrathea
+description: "radiant_helper was developed by: markbates"
+autorequire:
+- radiant_helper_text_helper
+- radiant_helper_response
+- radiant_helper_page
+- radiant_helper_errors
+- radiant_helper
+default_executable:
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 0.0.0
+  version:
+platform: ruby
+signing_key:
+cert_chain:
+post_install_message:
+authors:
+- markbates
+files:
+- init.rb
+- lib/radiant_helper.rb
+- lib/radiant_helper_errors.rb
+- lib/radiant_helper_page.rb
+- lib/radiant_helper_response.rb
+- lib/radiant_helper_text_helper.rb
+- lib/tasks/rubyforge_config.yml
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables:
+- radiant_helper
+extensions: []
+requirements: []
+dependencies: []