webs 0.1.9 → 0.1.10

data/Rakefile

@@ -0,0 +1,15 @@
+# Rakefile
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('webs', '0.1.10') do |p|
+  p.description    = "Reusable webs stuff."
+  p.url            = "https://colczak@github.com/websdev/websgem.git"
+  p.author         = "Chuck Olczak"
+  p.email          = "chuck@webs.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/lib/cache/cache.rb

@@ -0,0 +1,42 @@
+module Webs
+  mattr_accessor :cache
+  module Cache
+    mattr_accessor :debug
+    
+    def cache_remove(key)
+      Rails.logger.debug "*********** cache_remove(#{key})" if debug
+      return if key.nil?
+      Webs.cache.delete(key.to_s)
+    rescue Exception => e
+      Rails.logger.error "------------------------------------------------\nmemcache_error: #{e.message}"
+      false
+    end
+    
+    def cache_block(key, options=nil, &block)
+      return if key.nil?
+      unless data = Webs.cache.read(key)
+        if self.respond_to?('capture')
+          data = capture(&block) # called from view
+        else
+          data = yield
+        end
+        s_data = Marshal.dump(data)
+        block_size = s_data.size
+        #TODO: Check to see if dalli cache & compressed then up the size to 3MB
+        # should get almost 10:1 compression ratio. This will be key for caching pages & fragments
+        if block_size < 1.megabyte
+          Rails.logger.debug "*********** cache_block[#{block_size}](#{key}, #{data} )" if debug
+          Webs.cache.write(key, data)
+        else
+          Rails.logger.debug "*********** block not cached since exceeds 3M @ #{block_size} )" if debug
+        end
+      else
+        Rails.logger.debug "****HIT**** cache_block(#{key}, #{data} )" if debug
+      end
+      data
+    rescue Exception => e
+      Rails.logger.error "------------------------------------------------\nmemcache_error: #{e.message}"
+      data
+    end
+  end
+end

data/lib/config/webs_constants.rb

@@ -0,0 +1,67 @@
+module Webs
+  module PermissionLevel
+    LEVEL = {
+      :anyone => { :name=>'Anyone', :value=>-255 },
+      :none => { :name=>'None', :value=>0 },
+      :requesting => { :name=>'Requesting Members', :value=>10 },
+      :limited => { :name=>'Limited Members', :value=>25 },
+      :member => { :name=>'Members', :value=>50 },
+      :moderator => { :name=>'Moderators', :value=>75 },
+      :admin => { :name=>'Administrators', :value=>100 },
+      :owner => { :name=>'Only Me (Site Owner)', :value=>125 },
+      :disabled => { :name=>'Disabled', :value=>255 }
+    }
+    
+    LEVELS=LEVEL.keys
+    VALUES=LEVEL.values.collect{ |v| v[:value] }.sort
+    
+    PERMISSION_LEVELS_BY_VALUE=LEVELS.inject({}) do |level_hash, level_key|
+      lvl = LEVEL[level_key]
+      level_hash[lvl[:value]] = lvl
+      level_hash
+    end
+    
+    def self.[](k)
+      value_for_level k
+    end
+    
+    def self.level_for_value v
+      PERMISSION_LEVELS_BY_VALUE[v]
+    end
+    
+    def self.value_for_level k
+      LEVEL[k][:value]
+    end
+    
+    def self.options_for_select options={}
+      levels = LEVELS
+      names = options.delete(:names)
+      names ||= {}
+      only = options.delete(:only)
+      levels = only if only
+      except = options.delete(:except)
+      levels = levels-except if except
+      levels.collect { |lvl_key| [ names[lvl_key] || LEVEL[lvl_key][:name], LEVEL[lvl_key][:value] ] }
+    end
+    
+    def self.compare(k1, k2)
+      value_for_level( k1 ) - value_for_level( k2 )
+    end
+    
+    # ex: Webs::PermissionLevel.is_at_least( 25, :limited ) => true
+    def self.is_at_least( v, k )
+      value_for_level( k ) >= v
+    end
+  end
+  
+  module CommentsOrder
+    ASC   = 0
+    DESC  = 1
+    VIEWS = [[ASC, "Oldest first (default)"], [DESC, "Newest first"]]
+    SELECT_OPTIONS = VIEWS.map { |val, disp| [disp, val] }
+    VAL_LIST  = VIEWS.map {|val, disp| val}
+    def self.val_to_str(val)
+      val.to_i == ASC ? "ASC": "DESC"
+    end
+  end
+end

data/lib/config/webs_initializer.rb

@@ -4,7 +4,9 @@ module Webs
   # additionally check the webs_config.yml which should support overriding for dev & test environments
   # by adding a 'development.webs_config.yml" file.
   def self.webs_config &block
-    config = YAML.load( ERB.new( File.read("#{Rails.root}/config/webs_config.yml") ).result )[Rails.env]
+#    load_constants
+    
+    config = YAML.load( ERB.new( File.read("#{Rails.root.to_s}/config/webs_config.yml") ).result )[Rails.env]
     
     # CREATE CONSTANTS FOR EACH KEY
     config.each_key { |k| self.const_set(k.to_s.upcase, config[k]) }

data/lib/controller/webs_controller.rb

@@ -1,4 +1,6 @@
 module Webs
+  mattr_accessor :app_name
+  
   module Controller
     module WebsController
       def self.included(base)
@@ -7,18 +9,21 @@ module Webs
   
       module ClassMethods
         def webs_helpers
+          helper Webs::Helper::Application
           helper Webs::Helper::Params
           helper Webs::Helper::Tags
+          helper Webs::Cache
           include Webs::Helper::Params
           include Webs::Helper::Tags
+          include Webs::Cache
+          helper_method :webs_site
           helper_method :webs_app_name
           helper_method :webs_appenv_name
         end
       end
       
       def webs_app_name
-        app_name = APP_NAME if defined?(APP_NAME)
-        app_name ||= Webs::APP_NAME if defined?(Webs::APP_NAME)
+        Webs::APP_NAME || APP_NAME
       end
 
       def webs_appenv_name
@@ -46,60 +51,42 @@ module Webs
         s = webs_auth_string
         Digest::MD5.hexdigest(webs_auth_string + secret)
       end
-    
-      # mappings to http://wiki.beta.freewebs.com/index.php/Fw:member-level-select
-      def webs_member_level_to_int member_level
-        {
-          'anyone'=>Webs::Permission::ANYONE,
-          'limited'=>Webs::Permission::LIMITED,
-          'member'=>Webs::Permission::MEMBERS,
-          'moderator'=>Webs::Permission::MODERATORS,
-          'admin'=>Webs::Permission::ADMIN
-        }[member_level.downcase]
-      end      
 
-      # mappings of the select value of fw:member-level-select to the old int vals
-      # TODO: convert data to new vals, don't have time right now
-      def webs_member_level_value_to_old_member_level webs_member_level
-        {
-          '-255'=>Webs::Permission::ANYONE,
-          '25'=>Webs::Permission::LIMITED,
-          '50'=>Webs::Permission::MEMBERS,
-          '75'=>Webs::Permission::MODERATORS,
-          '100'=>Webs::Permission::ADMIN,
-          '125'=>Webs::Permission::OWNER,
-          '255'=>Webs::Permission::DISABLED
-        }[webs_member_level]
+      # Examples:
+      # webs_redirect acontroller_path( @model_object )
+      # webs_redirect acontroller_path( @model_object ), :partials=>[partial1, partial2]
+      # webs_redirect :controller=>:acontroller, :flash=>'a message'
+      def webs_redirect(*args)
+        if args && args[0] && args[0].class.to_s =~ /String/
+          url = args[0]
+          options = args[1]
+        else
+          options = args[0]
+        end  
+    
+        if options.class.to_s =~ /Hash/
+          partials = options.delete(:partials)
+        end
+        
+        message = options.delete(:flash)
+        flash[:notice] = message if !message.blank?
+        
+        url = url_for( options.merge(:only_path=>true) ) if url.blank?
+    
+        render_text = %(<fw:redirect url="#{url}">#{partials.collect{ |p| render_to_string :partial=>p } if partials && partials.any?}Redirecting, please wait...</fw:redirect>)
+        Rails.logger.debug render_text
+        render :text => render_text
       end
 
-      def webs_int_to_member_level n
-        {
-          Webs::Permission::DISABLED=>'disabled',
-          Webs::Permission::ANYONE=>'anyone',
-          Webs::Permission::LIMITED=>'limited',
-          Webs::Permission::MEMBERS=>'member',
-          Webs::Permission::MODERATORS=>'moderator',
-          Webs::Permission::ADMIN=>'admin',
-          Webs::Permission::OWNER=>'admin'
-        }[n]
-      end      
-
-      # converts level which is an int for the select options of a fw:member-level-select
-      # first to an associated Webs::Permission then to a blog member level
-      # TODO: This should be cleaned up and blogs should use the fw:member-level-select values
-      # the mapping is useful if you need to change the result, generally sending returning admin if owner
-      # since most of the apps use owner not admin
-      # The generally needs to be done in params since some objects contain validations
-      # example: 
-      #  convert_webs_member_level( params[:entries], :view_level, {Webs::Permission::ADMIN=>Webs::Permission::OWNER} )
-      #  will take a webs member-level-select and convert it to a  Webs::Permission mapping ADMIN to OWNER
-      def convert_webs_member_level h, key, mapping={}
-        return if h.nil?
-        v = webs_member_level_value_to_old_member_level( h[key] )
-        h[key] = mapping[v] || v
+      def webs_info
+        render :partial=>'shared/webs_info'
       end
 
       # FILTERS
+      def set_page_title
+        @title = Webs::app_title
+      end
+      
       def validate_webs_session
         render :text => "Access Denied: Webs::SECRET not defined." and return(false) unless defined?( Webs::SECRET )
         render :text => "Access Denied" and return(false) unless fw_sig == webs_auth( Webs::SECRET )
@@ -113,6 +100,36 @@ module Webs
         render(:text => "You are not authorized.") unless webs_admin?
       end
       
+      def webs_site
+        @webs_site
+      end
+      
+      # options include primary_key_col
+      def load_site_model modelname, options={}
+        Rails.logger.debug "load_site_model #{modelname} #{options.inspect}"
+        model = modelname.constantize
+        pk = options.delete(:primary_key_col)
+        if pk
+          @webs_site = model.find( :first, :conditions=>{ pk=>webs_site_id } )
+        else
+          @webs_site = model.find( webs_site_id )
+        end
+          
+        rescue
+          Rails.logger.debug "!!!!!!!!!!!!!!!!!!! load_site_model Failed"
+          nil
+      end
+      
+      def log_fw_params
+        Rails.logger.debug "FW_PARAMS={"
+        Rails.logger.debug params.select{ |k,v| k.starts_with?("fw_sig_") }.sort.collect { |k,v| "  :#{k}=>'#{v}'" }.join(",\n")
+        Rails.logger.debug "}"
+      end
+      
+      # Usefull for debugging, set FW_PARAMS in development.rb and you can see the raw html in a browser
+      def set_fw_params
+        params.merge!( FW_PARAMS ) if defined?( FW_PARAMS )
+      end
     end
   end
 end

data/lib/helper/application.rb

@@ -0,0 +1,40 @@
+module Webs
+  module Helper
+    module Application
+      def cdata str="", &block
+        return "<![CDATA[#{str}]]>" unless block
+        
+        content = capture(&block)
+        begin
+          # Rails 3
+          output = ActiveSupport::SafeBuffer.new
+          output.safe_concat("<![CDATA[")
+          output << content
+          output.safe_concat("]]>")
+        rescue
+          concat("<![CDATA[", block.binding)
+          concat( content, block.binding)
+          concat("]]>", block.binding)
+        end
+      end
+
+      # shouldn't need this anymore for Rails 3, just use image_tag
+      # def webs_image_url img
+      #   "http://#{Webs::ASSET_HOST}/images/#{img}"
+      # end
+      
+      def webs_info
+        render :partial=>'shared/webs_info'
+      end
+      
+      # return an array of value, name select options for the given levels
+      # if names are present map the names by level key 
+      def webs_permission_level_select_options levels=Webs::PERMISSION_LEVELS, names={}
+        levels.collect do |lvl_key|
+          lvl = PERMISSION_LEVEL[lvl_key]
+          [ lvl[:value], names[lvl_key] || lvl[:name] ]
+        end
+      end
+    end
+  end
+end

data/lib/helper/params.rb

@@ -1,59 +1,53 @@
 module Webs
   module Helper
     module Params
-      [:fw_sig, :fw_sig_site, :fw_sig_is_admin, :fw_sig_permission_level, :fw_sig_session_key, :fw_sig_tier, :fw_sig_permissions, :fw_sig_time, :fw_sig_api_key, 
-       :fw_sig_url, :fw_sig, :fw_sig_user, :fw_sig_width, :fw_sig_social, :fw_sig_premium, :fb_sig_network].each do |fw_param|
+      FW_PARAMS = [:fw_sig, :fw_sig_site, :fw_sig_is_admin, :fw_sig_permission_level, :fw_sig_session_key, :fw_sig_tier, :fw_sig_permissions, :fw_sig_time, :fw_sig_api_key, 
+       :fw_sig_url, :fw_sig_user, :fw_sig_width, :fw_sig_social, :fw_sig_premium, :fb_sig_network]
+       
+      FW_PARAMS.each do |fw_param|
          module_eval( "def #{fw_param.to_s}() params[:#{fw_param.to_s}] end" )
       end
                
       # Some basic useful methods
-      def webs_admin_mode?
+      def webs_sitebuilder?
         fw_sig_is_admin == '1'
       end
       
-      def webs_permission
-        case fw_sig_permissions
-          when /admin/i
-            Permission::ADMIN
-          when /owner/i
-            Permission::OWNER
-          when /moderator/i
-            Permission::MODERATORS
-          when /contributor/i
-            Permission::MEMBERS
-          when /limited/i
-            Permission::LIMITED
-          else
-            Permission::ANYONE
-        end
+      def webs_anyone?
+        fw_sig_permission_level == Webs::PermissionLevel[:anyone].to_s
       end
       
-      # does fw_sig_permissions contain at least perm
-      def webs_permission?( perm=Permission::ANYONE )
-        webs_permission >= perm
-      end
-
-      def webs_admin?
-        webs_permission == Permission::ADMIN
+      #TODO: is this same as anyone and can we ditch the -255??
+      def webs_anonymous?
+        fw_sig_permission_level == Webs::PermissionLevel[:none].to_s
       end
       
-      def webs_owner?
-        webs_permission == Permission::OWNER
+      def webs_limited?
+        fw_sig_permission_level == Webs::PermissionLevel[:limited].to_s
       end
       
-      def webs_contributor?
-        webs_permission == Permission::MEMBERS
+      def webs_member?
+        fw_sig_permission_level == Webs::PermissionLevel[:member].to_s
       end
       
       def webs_moderator?
-        webs_permission == Permission::MODERATORS
+        fw_sig_permission_level == Webs::PermissionLevel[:moderator].to_s
       end
       
-      def webs_site_owner_or_admin?
-        webs_admin? || webs_owner?
+      def webs_admin?
+        fw_sig_permission_level == Webs::PermissionLevel[:admin].to_s
       end
       
-      def fw_sig_premium?
+      def webs_owner?
+        fw_sig_permission_level == Webs::PermissionLevel[:owner].to_s
+      end
+      
+      #TODO: Also need to check the java??
+      def webs_disabled?
+        fw_sig_permission_level == Webs::PermissionLevel[:disabled].to_s
+      end
+      
+      def webs_premium?
         fw_sig_premium == '1'
       end
       
@@ -61,6 +55,18 @@ module Webs
         fw_sig_social == '1'
       end
       
+      def webs_admin_owner_sitebuilder?
+        webs_admin? || webs_owner? || webs_sitebuilder?
+      end
+      
+      def webs_admin_owner?
+        webs_admin? || webs_owner?
+      end
+      
+      def webs_site_id
+        fw_sig_site.to_i if !fw_sig_site.blank?
+      end
+      
       def webs_params
         params.select{ |k,v| k.starts_with?("fw_sig_") }.sort
       end

data/lib/helper/tags.rb

@@ -2,28 +2,53 @@ module Webs
   module Helper
     module Tags
       def fwml tagname, options={}, &block
-        s_options = ' ' + options.each_key.collect{|k| "#{k.to_s}=\"#{options[k]}\"" }.join(' ')  if options.size > 0
-        
-        return "<fw:#{tagname}#{s_options}/>" unless block
-
-        content = capture(&block)
-        begin
-          # Rails 3
-          output = ActiveSupport::SafeBuffer.new
-          output.safe_concat("<fw:#{tagname}#{s_options}>")
-          output << content
-          output.safe_concat("</fw:#{tagname}>")
-        rescue
-          concat("<fw:#{tagname}#{s_options}>", block.binding)
-          concat( content, block.binding)
-          concat("</fw:#{tagname}>", block.binding)
-          
+#        Rails.logger.debug "****** fwml #{tagname} #{options.inspect}"
+        if ['sanitize', 'wizzywig'].include?(tagname.to_s)
+          self.send( "fw_#{tagname}", options, &block )
+        else
+          return inline_tag( tagname, options ) unless block
+          render_tag_with_block tagname, options, false, &block
         end
       end
       
-      def webs_image_url img
-        "http://#{Webs::ASSET_HOST}/images/#{img}"
+      private
+      def html_options options
+        ' ' + options.each_key.select{ |k| !options[k].blank? }.collect{|k| "#{k.to_s}=\"#{options[k]}\"" }.join(' ')  if options.any?
+      end
+      
+      def render_tag_with_block tagname, options, cdata_wrapper=false, &block
+#        Rails.logger.debug "****** render_tag_with_block #{tagname} #{options.inspect} cdata=#{cdata_wrapper}"
+        content = capture(&block)
+        output = ActiveSupport::SafeBuffer.new
+        output.safe_concat("<fw:#{tagname}#{html_options(options)}>")
+        output.safe_concat("<![CDATA[") if cdata_wrapper
+        output << content  
+        output.safe_concat("]]>") if cdata_wrapper
+        output.safe_concat("</fw:#{tagname}>")
+      end
+      
+      def inline_tag tagname, options
+        "<fw:#{tagname}#{html_options(options)}/>"
+      end
+      
+      def fw_sanitize options={}, &block
+        cdata_wrapper = options.delete(:cdata) 
+        cdata_wrapper = true if cdata_wrapper.nil?
+        render_tag_with_block 'sanitize', options, cdata_wrapper, &block
+      end
+      
+      # fw_wizzywig should never be called with a block the text is passed in via text
+      def fw_wizzywig options={}
+        wizzywig_text = options.delete( :wizzywig_text )
+        "<fw:wizzywig #{html_options(options)}><![CDATA[#{wizzywig_text}]]></fw:wizzywig>"
       end
     end
   end
-end
+end
+
+# No support for rails 2
+# concat("<fw:#{tagname}#{s_options}>", block.binding)
+# concat("<![CDATA[") if cdata_wrapper
+# concat( content, block.binding)
+# concat("]]>") if cdata_wrapper
+# concat("</fw:#{tagname}>", block.binding)

data/lib/views/layouts/webs_page.html.erb

@@ -0,0 +1,19 @@
+<%= fwml :page, :permapath=>@permapath, :title=>@title do %>
+  <fw:head>
+    <%= javascript_include_tag 'application' %>
+    <%= stylesheet_link_tag 'styles' %>
+    <%= yield :fw_head %>
+  </fw:head>
+
+  <fw:paragraph>
+    <fw:title>
+      <span style="float:left" class="pageTitle">
+        <%= raw( %(<fw:page-title path='/' />) ) %>
+        <%= yield :fw_title %>
+      </span>
+      <div class="clear"></div>
+    </fw:title>
+  
+    <%= yield %>  
+  </fw:paragraph>
+<% end %>

data/lib/views/layouts/webs_utility.html.erb

@@ -0,0 +1,8 @@
+<%= fwml :utility, :title=>@page_title do %>
+  <fw:head>
+    <%= javascript_include_tag 'application' %>
+    <%= stylesheet_link_tag 'styles' %>
+    <%= yield :fw_head %>
+  </fw:head>
+  <%= yield %>
+<% end %>

data/lib/views/shared/_webs_info.html.erb

@@ -0,0 +1,38 @@
+<h1>Webs Info</h1>
+<table >
+  <% Webs::Helper::Params::FW_PARAMS.collect{|p| p.to_s}.sort.each do |fw_param| %>
+    <tr>
+      <td><%= fw_param %></td>
+      <td><%= eval fw_param %></td>
+    </tr>
+  <% end %>
+  <tr>
+    <td>webs_app_url</td>
+    <td><a href="<%= webs_app_url %>" target="_blank"><%= webs_app_url %></a></td>
+  </tr>  
+  <% %w[webs_app_name 
+        webs_appenv_name
+        webs_site_id 
+        webs_sitebuilder? 
+        webs_admin_owner? 
+        webs_admin_owner_sitebuilder? 
+        webs_premium?
+        webs_social? 
+        webs_anyone?
+        webs_anonymous?
+        webs_limited?
+        webs_member?
+        webs_moderator?
+        webs_admin?
+        webs_owner?
+        webs_disabled? ].each do |p| %>
+    <tr>
+      <td><%= p %></td>
+      <td><%= eval p %></td>
+    </tr>
+  <% end %>
+  
+</table>
+
+<%#
+%>

data/lib/webs.rb

@@ -1,21 +1,50 @@
 dir = Pathname(__FILE__).dirname.expand_path
 
+require dir + 'config/webs_constants'
 require dir + 'controller/webs_controller'
+require dir + 'helper/application'
 require dir + 'helper/params'
 require dir + 'helper/tags'
 
 module Webs
-  VERSION = "0.1.9".freeze
+  VERSION = "0.1.10".freeze
 
-  module Permission
-    DISABLED = -1
-    ANYONE = 0
-    LIMITED = 1
-    MEMBERS = 2
-    MODERATORS = 3
-    OWNER = 4
-    ADMIN = 5
+#  def self.load_constants
+    # s = File.read("#{Pathname(__FILE__).dirname.expand_path}/config/webs_constants.yml")
+    # Rails.logger.debug ERB.new( File.read("#{Pathname(__FILE__).dirname.expand_path}/config/webs_constants.yml") ).result
+    # config = YAML.load( ERB.new( File.read("#{Pathname(__FILE__).dirname.expand_path}/config/webs_constants.yml") ).result )
+    # 
+    # # CREATE CONSTANTS FOR EACH KEY
+    # config.each_key do |k| 
+    #   v = config[k]
+    #   # convert strings to symbols
+    #   # TODO: might need to do children
+    #   if v.is_a?(Hash)
+    #     h = {}
+    #     v.each_key { |vk| vk.is_a?(String) ? h[vk.to_sym] = v[vk] : h[vk] = v[vk] }
+    #     v = h
+    #   end
+    #   self.const_set(k.to_s.upcase, v)
+    # end
+    # map_permission_levels
+#  end
+  
+  # def self.map_permission_levels
+  #   h = {}
+  #   PERMISSION_LEVEL.each_value{ |v| h[v['value']] = v }
+  #   self.const_set('PERMISSION_LEVELS_BY_VALUE', h)
+  #   self.const_set('PERMISSION_LEVELS', PERMISSION_LEVEL.keys)
+  # end
+  
+  def self.app_title
+    APP_NAME.titleize
   end
   
+  class Railtie < Rails::Railtie
+    initializer 'webs_view-path' do |app|
+      path = "#{Pathname(__FILE__).dirname.expand_path}/views"
+      app.paths.app.views.push path
+    end
+  end
 end
 

data/webs.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{webs}
+  s.version = "0.1.10"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chuck Olczak"]
+  s.date = %q{2010-11-04}
+  s.description = %q{Reusable webs stuff.}
+  s.email = %q{chuck@webs.com}
+  gemfiles = [
+      "README.rdoc", 
+      "lib/webs.rb",  
+      "lib/cache/cache.rb", 
+      "lib/config/webs_constants.rb", 
+      "lib/config/webs_initializer.rb", 
+      "lib/controller/webs_controller.rb", 
+      "lib/helper/application.rb", 
+      "lib/helper/params.rb", 
+      "lib/helper/tags.rb", 
+      "lib/views/layouts/webs_page.html.erb", 
+      "lib/views/layouts/webs_utility.html.erb", 
+      "lib/views/shared/_webs_info.html.erb" 
+  ]
+  s.extra_rdoc_files = gemfiles
+  s.files = gemfiles + [ "Rakefile", "webs.gemspec" ]
+  s.homepage = %q{http://github.com/websdotcom/websgem}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Webs", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{webs}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Reusable webs stuff.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: webs
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: false
   segments: 
   - 0
   - 1
-  - 9
-  version: 0.1.9
+  - 10
+  version: 0.1.10
 platform: ruby
 authors: 
 - Chuck Olczak
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-09 00:00:00 -05:00
+date: 2010-11-04 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -28,17 +28,31 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 - lib/webs.rb
+- lib/cache/cache.rb
+- lib/config/webs_constants.rb
 - lib/config/webs_initializer.rb
 - lib/controller/webs_controller.rb
+- lib/helper/application.rb
 - lib/helper/params.rb
 - lib/helper/tags.rb
+- lib/views/layouts/webs_page.html.erb
+- lib/views/layouts/webs_utility.html.erb
+- lib/views/shared/_webs_info.html.erb
 files: 
 - README.rdoc
 - lib/webs.rb
+- lib/cache/cache.rb
+- lib/config/webs_constants.rb
 - lib/config/webs_initializer.rb
 - lib/controller/webs_controller.rb
+- lib/helper/application.rb
 - lib/helper/params.rb
 - lib/helper/tags.rb
+- lib/views/layouts/webs_page.html.erb
+- lib/views/layouts/webs_utility.html.erb
+- lib/views/shared/_webs_info.html.erb
+- Rakefile
+- webs.gemspec
 has_rdoc: true
 homepage: http://github.com/websdotcom/websgem
 licenses: []