guilded 1.0.0

data/lib/guilded.rb

@@ -0,0 +1,79 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'guilded/browser_detector'
+require 'guilded/component_def'
+require 'guilded/guilder'
+require 'guilded/exceptions'
+require 'guilded/rails/helpers'
+require 'guilded/rails/view_helpers'
+require 'guilded/rails/active_record/human_attribute_hint'
+require 'guilded/rails/active_record/human_attribute_override'
+require 'guilded/rails/inactive_record/human_attribute_hint'
+
+# Guilded is a framework for creating reusable UI components for web applications.  Guilded provides the facilities to 
+# easily add components and all of their required assets to a page.
+# 
+# A Guilded component is a set of XHTML, CSS and JavaScript that combine to create a rich UI.  The Guilded component should be
+# authored using progressive enhancement to enable users without CSS or JavaScript enabled to utilize the essential functionality
+# of the component.  The easiest way to accomplish this requirement is to write your behavior code as a jQuery plugin.  Doing
+# so will naturally guide your behavior code to be applied through progrssive enhancement and also allow your behavior code 
+# to be used without Guilded.
+#
+# To create a Guilded component at least four things must occur: writing a view helper, writing a JavaScript initialization
+# function, writing a default stylesheet and writing either a rake task or generator to place these assets into a project's 
+# public directory.  It is also probable that a jQuery plugin with the behavior code will need to be authored.  If this is the 
+# case, then the JavaScript initialization function will most likely just call the jQuery plugin on the DOM element(s) that should 
+# have the behavior applied.
+#
+# The view helper should output the HTML necessary for the component.  It must also add the component to a collection so that
+# Guilded can collect its assets and add them to the page.  This is accomplished through a call to the Guilder.add() method.
+# The Guilder is a singleton, so you must access it like: Guilded::Guilder.instance.add( ... ).  The Guilder.add() method adds
+# element to a collection with it's options.  Guilded automatically looks for CSS assets that obey the naming convention 
+# {component_name}/default.css.  Guilded also automatically looks for a JavaScript asset named: guilded.{component_name}.js.  
+# This asset should at least include the initComponentName( options ).  The Guilded.add() method can also add additional CSS and 
+# JavaScript assets necessary for a component.  An example of an additional JavaScript asset is the jQuery plugin authored to 
+# contain the behavior of a component.  The view helper must be called with an :id option as it is used to differentiate different
+# instances of the same component on a single page from each other.  It will also be used as the DOM element's id.  A Guilded view 
+# helper should have a g_ appended to the beginning of it to help differentiate from normal view helepr sin a project.
+# 
+# The JavaScript initialization function should be named init{ComponentName}( options ).  The options hash from the view helper
+# will automatically be passed to this function.  The function should handle a before and after init callback to enable the user
+# to set up anything necessary for the component and perform additional tasks.  This function must also perform any other code 
+# necessary to set up the behavior for a compnent.  An example fo this would be adding behavior to events or simply calling
+# a jQuery plugin on element(s) of the component.  Remember that any JavaScript relating to Guilded should be placed in the 'g'
+# namespace that Guilded creates on every page.  An example init function for a g_load_alerter would be:
+#
+#   g.initLoadAlerter = function( options )
+#   {
+#     if( g.beforeInitLoadAlerter )
+#       g.beforeInitLoadAlerter( options );
+#
+#     // Initialization code here...
+#
+#     if( g.afterInitLoadAlerter )
+#       g.afterInitLoadAlerter( options );
+#   };
+#
+# For a user to implement these callback functions, they should create a JavaScript file with the functions and call it on
+# any page they need it on utilizing Guilded's JavaScript include helper g_javascript_include_tag.  This helper will add the
+# JavaScript files after the jQuery and Guilded framework files, but within the component files in the order they were added.  
+# This will make the 'g' namespace available for use.  Obviously this file must be included prior to calling the component's helper,
+# or the callback functions will not be defined for use. 
+#
+# The default stylesheet for a Guilded component should be the minimum amount of CSS for the component to function.  When no :skin
+# option is passed to the view helper when a component is added, Guilded will look for the default stylesheet.  The assets
+# used within the stylesheet (images) should be placed in a folder named default that is in the same directory as the default.css
+# file.  All asssets used in the stylesheet should use an absolute reference from the public directory: /stylesheets/guilded/{component_name}/default/{asset_name}.
+#
+# In order to create another skin for a component, simply create a {skin_name}.css file and a {skin_name} directory with the style 
+# assets in it.  Be sure to reference the style assets with absolute paths from teh public directory so that the skin will work in 
+# all cases.  Then call the component's view helper and use the :skin option:
+#
+#   <%= g_load_alerter :skin => 'blueish', :id => 'load_alerter' %>
+#
+module Guilded
+  VERSION = '0.3.0'
+end
+
+ActionView::Base.send( :include, Guilded::Rails::ViewHelpers ) if defined?( ActionView )

data/lib/guilded/browser_detector.rb

@@ -0,0 +1,217 @@
+module Guilded 
+  
+  # The BrowserDetector provides the ability to determine browser information from the user 
+  # agent string.
+  #
+  class BrowserDetector
+    
+    attr_reader :ua
+    
+    def initialize( user_agent )
+      @ua = user_agent.downcase
+      @version_regex = /(\d*)\.(\d*)\.*(\d*)\.*(\d*)/
+    end
+    
+    # Returns true if the browser matches the options ent in, otherwise returns false.
+    #
+    # === Request
+    # * +request+ - The request object.
+    #
+    # === Options
+    # * +:name+ - The name of the browser.  For example 'ie' or :ie.
+    # * +:version+ - The version of the browser.  For example '3.0.5'.
+    # * +:major_version+ - The major version of the browser.  For example '3' or 3.
+    # * +:minor_version+ - The minor version of the browser.  For example '0' or 0.
+    #
+    def browser_is?( options={} )
+      name = options[:name]
+      version = options[:version]
+      major_version = options[:major_version]
+      minor_version = options[:minor_version]
+      build_version = options[:build_version]
+      revision_version = options[:revision_version]
+      
+      name ||= self.browser_name
+      version ||= self.browser_version
+      major_version ||= self.browser_version_major
+      minor_version ||= self.browser_version_minor
+      build_version ||= self.browser_version_build
+      revision_version ||= self.browser_version_revision
+
+      name = name.to_s.strip
+      version = version.to_s.strip
+      major_version = major_version.to_s.strip
+      minor_version = minor_version.to_s.strip
+      build_version = build_version.to_s.strip
+      revision_version = revision_version.to_s.strip
+      
+      self.browser_name == name && self.browser_version == version && self.browser_version_major == major_version &&
+        self.browser_version_minor == minor_version #&& self.browser_version_build == build_version && 
+        #self.browser_version_revision == revision_version
+    end
+
+    # Returns the name of the browser that is making this request.  For example 'ie'.
+    #
+    # === Request
+    # * +request+ - The request object.
+    #
+    def browser_name
+      begin
+        @browser_name ||= begin
+          ua = @ua
+          if ua.nil?
+            'unknown'
+          else
+            if ua.index( 'msie' ) && !ua.index( 'opera' ) && !ua.index( 'webtv' )
+              if ua.index( 'windows ce' )
+                'ie' + '_ce' #+ ua[ua.index( 'msie' ) + 5].chr 
+              else
+                'ie' # + ua[ua.index( 'msie' ) + 5].chr
+              end
+            elsif ua.include?( 'opera' )
+              'opera'
+            elsif ua.include?( 'konqueror' ) 
+              'konqueror'
+            elsif ua.include?( 'applewebkit/' )
+              'safari'
+            elsif ua.include?( 'chrome' )
+              'chrome'
+            #elsif ua.include?( 'mozilla/' )
+            #  'firefox'
+            elsif ua.include?( 'firefox' )
+              'firefox'
+            #elsif ua.include?( 'gecko/' ) 
+            #  'firefox'
+            elsif ua.include?( 'netscape' )
+              'netscape'
+            else
+              'unknown'
+            end
+          end
+        end
+      rescue
+        'unknown'
+      end
+    end
+
+    # Returns the version of the browser that is making this request.  For example '7'.
+    #
+    # === Request
+    # * +request+ - The request object.
+    #
+    def browser_version
+      @browser_version ||= begin
+        self.send( "resolve_version_for_#{self.browser_name}".to_sym )
+      end
+    end
+
+    def browser_version_major
+      match = @version_regex.match( browser_version )
+      return match[1].to_i.to_s unless match.nil? || match.size < 2
+      '0'
+    end
+
+    def browser_version_minor
+      match = @version_regex.match( browser_version )
+      return match[2].to_i.to_s unless match.nil? || match.size < 3
+      '0'
+    end
+    
+    def browser_version_build
+      match = @version_regex.match( browser_version )
+      return match[3].to_i.to_s unless match.nil? || match.size < 4 || match[3].empty? || match[3].nil?
+      '0'
+    end
+    
+    def browser_version_revision
+      match = @version_regex.match( browser_version )
+      return match[4].to_i.to_s unless match.nil? || match.size < 5 || match[4].empty? || match[4].nil?
+      '0'
+    end
+    
+    # Returns the browser name concatenated with the browser version.  for example, 'ie7'.
+    #
+    # === Request
+    # * +request+ - The request object.
+    #
+    def browser_full_name
+      self.send( "browser_full_name_for_#{self.browser_name}".to_sym )
+    end
+    
+    # Returns the browser name concatenated with the browser version.  for example, 'ie7'.
+    #
+    # === Request
+    # * +request+ - The request object.
+    #
+    def browser_id
+      browser_name + browser_version.gsub( /\./, '' )
+    end
+    
+    # Returns true if the current browser type can handle PNGs.
+    #
+    def can_use_png?
+      return browser_version.to_i >= 7 if browser_name== 'ie'
+    	true
+  	end
+
+    # A list of all the browser types that Guilded recognizes.
+    #
+    def self.all_browsers
+      %w( chrome firefox ie55 ie60 ie70 ie80 konqueror netscape opera safari )
+    end
+
+    # A list of all the mobile browser types that Guilded recognizes.
+    #
+    def self.all_mobile_browsers
+      %w( ie_ce4 iphone )
+    end
+    
+    def self.user_agents
+      { 
+        :ie55 => 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.1)', 
+        :ie60 => 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)',
+        :ie70 => 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)',
+        :ie80 => 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
+        :firefox2 => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1.17) Gecko/20080829 Firefox/2.0.0.17',
+        :firefox3 => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.0.11) Gecko/2009060214 Firefox/3.0.11',
+        :firefox35 => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3',
+        :firefox35win => 'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)',
+        :opera10 => 'Opera/9.80 (Macintosh; Intel Mac OS X; U; en) Presto/2.2.15 Version/10.00'
+      }
+    end
+    
+    protected
+    
+    def resolve_version_for_ie
+      match = /.*msie (.*); windows nt 5.1/.match( @ua )
+      return match.nil? ? '0' : match[1]
+    end
+    
+    def resolve_version_for_firefox
+      match = /.*\((.*); u;.*firefox\/(.*) \(.net.*/.match( @ua )
+      if match.nil?
+        match = /.*\((.*); u;.*firefox\/(.*)/.match( @ua )
+        return match.nil? ? '0' : match[2]
+      end
+      return match.nil? ? '0' : match[2]
+    end
+    
+    def resolve_version_for_opera
+      match = /.*\((.*); intel.*version\/(.*)/.match( @ua )
+      return match.nil? ? '0' : match[2]
+    end
+    
+    def browser_full_name_for_ie
+      "Internet Explorer #{browser_version}"
+    end
+    
+    def browser_full_name_for_firefox
+      "Firefox #{browser_version}"
+    end
+    
+    def browser_full_name_for_opera
+      "Opera #{browser_version}"
+    end
+    
+  end
+end

data/lib/guilded/component_def.rb

@@ -0,0 +1,24 @@
+module Guilded
+  class ComponentDef
+    
+    attr_reader :kind, :options, :libs, :styles
+    attr_accessor :additional_js
+  
+    def initialize( kind, options={}, libs=[], styles=[], additional_js='' )
+      @kind = kind
+      @options = options
+      @libs = libs
+      @styles = styles
+      @additional_js = additional_js
+    end
+    
+    def exclude_css?
+      options.include?( :exclude_css ) && ( options[:exclude_css] == 'true' || options[:exclude_css] == true )
+    end
+    
+    def exclude_js?
+      options.include?( :exclude_js ) && ( options[:exclude_js] == 'true' || options[:exclude_js] == true )
+    end
+
+  end
+end

data/lib/guilded/exceptions.rb

@@ -0,0 +1,29 @@
+module Guilded
+  module Exceptions
+    
+    class GuildedException < RuntimeError
+      def initialize( msg="" )    #:nodoc:
+        @msg = msg
+      end
+    end
+    
+    class IdMissing < GuildedException
+      def initialize    #:nodoc:
+        @msg = ":id for element must be present in the options hash"
+      end
+    end
+    
+    class DuplicateElementId < GuildedException
+      def initialize( id='' )    #:nodoc:
+        @msg = ":id #{id} for element is already in use on current page"
+      end
+    end
+    
+    class MissingConfiguration < GuildedException
+      def initialize    #:nodoc:
+        @msg = "There is no GUILDED_CONFIG instance.  Please load Guilded configuration with your apps initialization."
+      end
+    end
+    
+  end
+end

data/lib/guilded/guilder.rb

@@ -0,0 +1,357 @@
+require 'digest'
+require 'singleton'
+require 'guilded/exceptions'
+
+module Guilded
+  
+  # Guilder is the worker for the entire Guilded framework.  It collects all of the necessary components for a page
+  # through its add() method.  When the g_apply_behavior() method is called at the end of a page, the Guilder writes
+  # HTML to include all of the necessary asset files (caching them in production).  It also writes s JavaScript initialization
+  # function and fires the initialization function on page load.  
+  #
+  # This initialization function calls the initialization function for each Guilded component that was added to the current 
+  # page.  For example, if a Guilded component named 'g_load_alerter' was added to a page, the Guilder would include this line 
+  # in the initialization function it writes: g.initLoadAlerter( /* passing options hash here */ );  The g before the function
+  # is a JavaScript namespace that Guilded automatically creates to facilitate avoiding name collisions with other JavaScript 
+  # libraries and code.
+  #
+  # Th options hash that is passed to the init functions for each Guilded component is simply the options hash from the 
+  # component's view helper.  The Guilder calls .to_json() on the options hash.  Thus, if there are pairs in the options hash
+  # that need not go to the JavaScript init method they should be removed within the view helper. 
+  #
+  class Guilder
+    include Singleton
+    
+    GUILDED_NS = "guilded."
+      
+    attr_reader :initialized_at, :jquery_js, :mootools_js
+    
+    def initialize #:nodoc:
+      if defined?( GUILDED_CONFIG )
+        @config = GUILDED_CONFIG
+      else
+        raise Guilded::Exceptions::MissingConfiguration
+      end
+      configure_guilded
+      @initialized_at = Time.now
+      @g_elements = Hash.new
+      @g_data_elements = Hash.new
+      @combined_js_srcs = Array.new
+      @combined_css_srcs = Array.new
+      @assets_combined = false
+      # Make sure that the css reset file is first so that other files can override the reset,
+      # unless the user specified no reset to be included.
+      init_sources
+    end
+  
+    # Adds an element with its options to the @g_elements hash to be used later.
+    #
+    def add( element, options={}, libs=[], styles=[] )
+      raise Guilded::Exceptions::IdMissing.new unless options.has_key?( :id )
+      raise Guilded::Exceptions::DuplicateElementId.new( options[:id] ) if @g_elements.has_key?( options[:id] )
+      @need_mootools = true if options[:mootools]
+      @g_elements[ options[:id].to_sym ] = Guilded::ComponentDef.new( element, options, libs, styles )
+    end
+    
+    # Adds a data structure to be passed to the Guilded JavaScript environment for use on the client 
+    # side.  The data is passed using the ruby to_json method on the data structure provided.
+    #
+    # === Parameters
+    # * +name+ - The desired name of the variable on the client side.
+    # * +data+ - The data to pass to the Guilded JavaScript environment. 
+    #
+    def add_data( name, data )
+      @g_data_elements.merge!( name.to_sym => data )
+    end
+    
+    # Adds JavaScript sources to the libs collection by resolving them to the normal or min version
+    # based on the current running environment, development, production, etc.
+    #
+    def add_js_sources( *sources )
+      resolve_js_libs( *sources )
+    end
+  
+    def count #:nodoc:
+      @g_elements.size
+    end
+    
+    # The number of Guilded components to be renderred.
+    #
+    def component_count
+      count
+    end
+    
+    # The current number of CSS assets necessary for the Guilded component set. 
+    #
+    def style_count
+      @combined_css_srcs.size
+    end
+    
+    # The current number of JavaScript assets necessary for the Guilded component set. 
+    #
+    def script_count
+      @combined_js_srcs.size
+    end
+    
+    # Returns true if the component type is included, otherwise false.
+    #
+    def include_component?( type )
+      @g_elements.has_key?( type.to_sym )
+    end
+    
+    # The collection of JavaScript assets for the current Guilded component set.
+    #
+    def combined_js_srcs
+      #generate_asset_lists unless @assets_combined
+      @combined_js_srcs
+    end
+    
+    # The collection of CSS assets for the current Guilded component set.
+    #
+    def combined_css_srcs
+      #generate_asset_lists unless @assets_combined
+      @combined_css_srcs
+    end
+    
+    # Clears out all but the reset CSS and the base JavaScripts
+    #
+    def reset!
+      @combined_css_srcs.clear
+      @combined_js_srcs.clear
+      @g_elements.clear
+      @assets_combined = false
+      init_sources
+      @default_css_count = @combined_css_srcs.size
+      @default_js_count = @combined_js_srcs.size
+    end
+
+    def inject_css( *sources )
+      @combined_css_srcs.insert( @default_css_count, *sources )
+    end
+    
+    def inject_js( *sources )
+      @combined_js_srcs.insert( @default_js_count, *sources )
+    end
+    
+    # Generates the markup required to include all the assets necessary for the Guilded compoents in 
+    # @g_elements collection.  Use this if you are not interested in caching asset files.
+    #
+    def apply #:nodoc:
+      to_init = ""
+      generate_asset_lists unless @assets_combined
+      @combined_css_srcs.each { |css| to_init << "<link href=\"/stylesheets/#{css}\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />" }
+      @combined_js_srcs.each { |js| to_init << "<script type=\"text/javascript\" src=\"/javascripts/#{js}\"></script>" }
+      to_init << generate_javascript_init
+      reset!
+    end
+    
+    # Writes an initialization method that calls each Guilded components initialization method.  This 
+    # method will exceute on document load finish.
+    #
+    def generate_javascript_init #:nodoc:
+      code = "<script type=\"text/javascript\">"
+      code << "var initGuildedElements = function(){"
+      @g_data_elements.each do |name, data|
+        code << "g.#{name} = #{data.to_json};" 
+      end
+      @g_elements.each_value do |guilded_def| 
+        code << "g.#{guilded_def.kind.to_s.camelize( :lower )}Init(#{guilded_def.options.to_json});" unless guilded_def.exclude_js?
+      end
+      code << "jQuery('body').trigger('guildedInitialized');};jQuery('document').ready(initGuildedElements);</script>"
+    end
+    
+    # Generates a name to use when caching the current set of Guilded component JavaScript assets.  Sorts and concatenates
+    # the name of each JavaScript asset in @combined_js_srcs.  Then hashes this string to generate a reproducible, unique 
+    # and shorter string.
+    #
+    def js_cache_name
+      generate_js_cache_name( @combined_js_srcs )
+    end
+    
+    # Generates a name to use when caching the current set of Guilded component CSS assets.  Sorts and concatenates
+    # the name of each JavaScript asset in @combined_js_srcs.  Then hashes this string to generate a reproducible, unique 
+    # and shorter string.
+    #
+    def css_cache_name
+      generate_css_cache_name( @combined_css_srcs )
+    end
+    
+    def generate_js_cache_name( sources ) #:nodoc: 
+      generate_asset_lists unless @assets_combined
+      #return"#{controller.class.to_s.underscore}_#{controller.action_name}" if development?
+      sorted_srcs = sources.sort
+      stripped_srcs = sorted_srcs.map { |src| src.gsub( /.js/, '' ).gsub( /\//, '_') }
+      joined = stripped_srcs.join( "+" )
+      "#{Digest::MD5.hexdigest( joined )}"
+    end
+    
+    def generate_css_cache_name( sources ) #:nodoc:
+      generate_asset_lists unless @assets_combined
+      #return "#{controller.class.to_s.underscore}_#{controller.action_name}" if development?
+      sorted_srcs = sources.sort
+      stripped_srcs = sorted_srcs.map { |src| src.gsub( /.css/, '' ).gsub( /\//, '_') }
+      joined = stripped_srcs.join( "+" )
+      "#{Digest::MD5.hexdigest( joined )}"
+    end
+    
+  protected
+    
+    def configure_guilded #:nodoc: 
+      @js_path = @config[:js_path]
+      @js_folder = @config[:js_folder]
+      @jquery_js = @config[:jquery_js]
+      @mootools_js = @config[:mootools_js]
+      @jquery_folder = @config[:jquery_folder] || 'jquery/'
+      @mootools_folder = @config[:mootools_folder] || 'mootools/'
+      @guilded_js = 'guilded.min.js'
+      @url_js = 'jquery-url.min.js'
+      @css_path = @config[:css_path]
+      @css_folder = @config[:css_folder]
+      @reset_css = @config[:reset_css]
+      #@do_reset_css = @config[:do_reset_css]
+      @env = @config[:environment]
+      @env ||= :production
+      @js_path.freeze
+      @css_path.freeze
+      @js_folder.freeze
+      @guilded_js.freeze
+      @url_js.freeze
+      @jquery_js.freeze
+      @jquery_folder.freeze
+      @mootols_js.freeze
+      @mootools_folder.freeze
+      @guilded_js.freeze
+      @css_folder.freeze
+      @reset_css.freeze
+      #@do_reset_css.freeze
+      @env.freeze
+    end
+    
+    # Adds the Guilded reset CSS file and the guilded.js and jQuery files to the respective sources
+    # collections.
+    #
+    def init_sources #:nodoc: 
+      @combined_css_srcs << "#{@reset_css}" unless @reset_css.nil? || @reset_css.empty?
+      resolve_js_libs( "#{@jquery_js}", "#{@jquery_folder}#{@url_js}", "#{@js_folder}#{@guilded_js}" )
+    end
+    
+    # Combines all JavaScript and CSS files into lists to include based on what Guilded components are on 
+    # the current page.
+    #
+    def generate_asset_lists #:nodoc: 
+      @assets_combined = true
+      @g_elements.each_value do |defi|
+        #TODO get stylesheet (skin) stuff using rails caching
+        combine_css_sources( defi.kind, defi.options[:skin], defi.styles ) unless defi.exclude_css?
+
+        # Combine all JavaScript sources so that the caching option can be used on
+        # the javascript_incldue_tag helper.
+        combine_js_sources( defi.kind, defi.libs ) unless defi.exclude_js?
+      end
+    end
+    
+    # Helper method that takes the libs and component specific js files and puts them
+    # into one array so that the javascript_include_tag can correctly cache them.  Automatically
+    # ignores files that have already been inlcuded.
+    #
+    # *parameters*
+    # combined_src (required) An array of the combined sorces for the page being renderred.
+    # component (required) The name of a guilded component.
+    # libs An array of JavaScript libraries that this component depends on.  More than likely 
+    #   a jQuery plugin, etc.
+    #
+    def combine_js_sources( component, libs=[] )  #:nodoc:
+      libs << @mootools_js if @need_mootools
+      resolve_js_libs( *libs )
+      
+      comp_src = add_guilded_js_path( component )
+      @combined_js_srcs.push( comp_src ) unless @combined_js_srcs.include?( comp_src )
+    end
+    
+    # Helper method that adds the aditional JavaScript library icludes to the include set.
+    # 
+    # If running development mode, it will try to remove any .pack, .min, or.compressed
+    # parts fo the name to try and get the debug version of the library.  If it cannot 
+    # find the debug version of the file, it will just remain what was initially provded.
+    #
+    def resolve_js_libs( *libs ) #:nodoc: 
+      if development?
+        # Try to use an unpacked or unminimized version
+        libs.each do |lib|
+          debug_lib = lib.gsub( /.pack/, '' ).gsub( /.min/, '' ).gsub( /.compressed/, '' )
+          path = "#{RAILS_ROOT}/public/javascripts/#{debug_lib}"
+          if File.exist?( path )
+            @combined_js_srcs.push( debug_lib ) unless @combined_js_srcs.include?( debug_lib )
+          else
+            @combined_js_srcs.push( lib ) unless @combined_js_srcs.include?( lib )
+          end
+        end
+      else
+        libs.each { |lib| @combined_js_srcs.push( lib ) unless @combined_js_srcs.include?( lib ) }
+      end
+    end
+    
+    # Helper method that takes an array of js sources and adds the correct guilded
+    # path to them.  Returns an array with the new path resolved sources.
+    #
+    def map_guilded_js_paths( *sources ) #:nodoc: 
+      sources.map { |source| add_guilded_js_path( source ) }
+    end
+    
+    # Adds the guilded JS path to the the source name passed in.  When not in development mode,
+    # it looks for a .pack.js, .min.jsm .compressed.js and chooses one of these over the 
+    # development version.
+    #
+    def add_guilded_js_path( source ) #:nodoc: 
+      part = "#{@js_folder}#{GUILDED_NS}#{source.to_s}"
+      ext = 'js'
+      
+      return "#{part}.#{ext}" unless production?
+ 
+      possibles = [ "#{@js_path}#{part}.min.#{ext}", "#{@js_path}#{part}.pack.#{ext}", "#{@js_path}#{part}.compressed.#{ext}",
+        "#{@js_path}#{part}.#{ext}" ]
+      parts = [ "#{part}.min.#{ext}", "{part}.pack.#{ext}", "#{part}.compressed.#{ext}", "#{part}.#{ext}" ]
+      
+      possibles.each_with_index do |full_path, i|
+        return parts[i] if File.exists?( full_path )  
+      end
+      
+      "" # Should never reach here
+    end
+    
+    def combine_css_sources( component, skin, styles=[] ) #:nodoc: 
+      # Get all of this components defined external styles
+      styles.each do |style|
+        @combined_css_srcs.push( style ) unless @combined_css_srcs.include?( style )
+      end
+      
+      #Get the default or guilded skin styles for this component
+      comp_src = add_guilded_css_path( component, skin )
+      @combined_css_srcs.push( comp_src ) unless @combined_css_srcs.include?( comp_src ) || comp_src.empty?
+      user_src = add_guilded_css_path( component, "user" )
+      @combined_css_srcs.push( user_src ) unless @combined_css_srcs.include?( user_src ) || user_src.empty?
+      skin_user_src = add_guilded_css_path( component, "#{skin || 'default'}_user" )
+      @combined_css_srcs.push( skin_user_src ) unless @combined_css_srcs.include?( skin_user_src ) || skin_user_src.empty?
+    end
+    
+    def add_guilded_css_path( source, skin ) #:nodoc: 
+      skin = 'default' if skin.nil? || skin.empty?
+      part = "#{@css_folder}#{source.to_s}/#{skin}.css"
+      path = "#{@css_path}#{part}"
+      File.exists?( path ) ? part : ''
+    end
+    
+    def development? #:nodoc: 
+      @env.to_sym == :development
+    end
+    
+    def production? #:nodoc: 
+      @env.to_sym == :production
+    end
+    
+    def test? #:nodoc: 
+      @env.to_sym == :test
+    end
+    
+  end
+end