shway 3.0

data/lib/shway/css/css_styles.rb

@@ -0,0 +1,368 @@
+module Shway
+
+  def self.define_styles(&block)
+    Shway::Css::CssStyles.class_eval &block
+  end
+  
+
+  module Css
+
+    #this has changed to no longer accept strings, you must use hashes. 
+    #I suppose I could parse strings.... I'll do that when I actually need it.
+    #you can supply the symbol for a previously defined hash or a new hash
+    class CssStyles
+      @@css_pseudo_classes = [:link,:visited,:active,:hover]
+
+      class << self
+  
+        def load_styles
+          path = File.join(RAILS_ROOT, 'app', 'stylesheets')
+          load_styles_from(path) if File.exist?(path)
+        end
+
+        def load_styles_from(dir)
+          return unless File.directory?(dir)
+          Dir.glob(File.join(dir, "*.css.rb")).sort.each do |file|
+            load file
+            # CssStyles.class_eval(File.read(file))
+          end
+        end
+
+        def reload_styles
+          clear_styles
+          load_styles
+        end
+    
+        def clear_styles
+          @@css_segments          = {}
+          @@css_hashes            = {}
+          @@css_caches            = {}
+          @@css_styles            = {}
+          @@css_styles[:main]     = {}
+          @@css_styles[:ie7]      = {}
+          @@css_styles[:ie6]      = {}
+          @@css_styles[:safari]   = {}
+          @@css_values            = {}
+          @@css_configs           = {}
+          @@css_finalized_configs = {}
+          @@included_styles       = []
+          #this is just a list of tag style names (with the preceding tag__) so we can find them among the other styles
+          @@css_tag_styles      = []
+        end
+    
+        def cache
+          @@css_caches
+        end
+  
+        #for now, for simplicity, we're just prefixing the tag name with tag__, storing the name in an array, and doing the rest as normal
+        #hopefully this makes things easier, but I plan on making this nicer at some point
+        def css_tag_style(tag_name, *css_hashes)
+          tag_name = "tag__#{tag_name.to_s}"
+          if @@css_tag_styles.include? tag_name
+            # puts "**WARNING: css_tag_style already defined for '#{tag_name}'" 
+          else
+            @@css_tag_styles << tag_name
+          end
+          css_style(tag_name, *css_hashes)
+        end
+        def selector(selector, *css_hashes)
+          css_tag_style(selector, *css_hashes)
+        end
+
+        #TODO name this better. These styles are the ones we DON'T want to raise an error if they aren't defined.
+        def include_style(*css_names)
+          css_names.each do |name|
+            @@included_styles << name unless @@included_styles.include? name
+          end
+        end
+        
+        #TODO this is mostly just for testing for now. Should I reload all the styles on each test somehow?
+        def remove_style(*css_names)
+          css_names.each do |name|
+            @@included_styles.delete name if @@included_styles.include? name
+          end
+        end
+
+        def style(name, *css_hashes)
+          include_style(name) #TODO just added this so that empty style hashes will still add the style
+          css_style(name, *css_hashes)
+        end
+        def css_style(name, *css_hashes)
+          raise "You must supply a name to 'css_style', not just a hash." if name.kind_of?(Hash)
+          name = name.to_s
+          #TODO make this logging optional. but turn it off for now.
+          # puts "**WARNING: css_style already defined for '#{name}'" if name.index('tag__') != 0 && @@css_hashes[name]
+          style_segments = []
+          style_hash = {}
+          #this is here so that the blank? checks won't fail on things that contain only links or pseudo styles, which both get extracted.
+          css_hashes << {:use_style => true}
+          #all actual hashes (not references/symbols) passed in are merged together to form a single "segment"
+          #this way any brower specific hash keys are merged into the segment, and the segments can be treated the same as typical style hashes.
+          references_and_merged_hashes = []
+          merged_hashes = {}
+          css_hashes.each do |symbol_or_hash|
+            if symbol_or_hash.kind_of? Symbol
+              references_and_merged_hashes << symbol_or_hash
+            else
+              raise "You can't merge in a nil hash to a css_style ('#{name}')" unless symbol_or_hash
+              raise "You must pass a Symbol or a hash to css_style. You passed a #{symbol_or_hash.class}" unless symbol_or_hash.kind_of? Hash
+              merge_style_hashes!(merged_hashes,symbol_or_hash)
+            end
+          end
+
+          references_and_merged_hashes << merged_hashes
+          #NOTE that this way of looping and merging means you don't need to clone incoming hashes that may be shared outside of here
+          references_and_merged_hashes.each do |hash|
+            style_segments << hash
+            if hash.kind_of? Symbol
+              style_reference = hash.to_s
+              hash = @@css_hashes[style_reference] 
+              raise "Shway has no style defined for the reference '#{style_reference.inspect}'." unless hash
+            end
+            merge_style_hashes!(style_hash,hash)
+          end
+          @@css_segments[name] = style_segments
+          @@css_hashes[name]   = style_hash
+          # style_is_psuedo_class = @@css_pseudo_classes.include? name.intern
+          #extract the various browser hashes and loop over them to build the styles
+          for_each_browser_hash style_hash do |browser,browser_hash|
+            next unless browser_hash
+            #define any pseudo_classes as separate styles in each browser. 
+            #pseudo classes are appended after a double underscore in the name. eg. text_style__hover = .text_style:hover
+            CssStyles.for_each_css_pseudo_class do |pseudo_class|
+              pseudo_style = browser_hash[pseudo_class]
+              pseudo_style[:use_style] = true if pseudo_style
+              @@css_styles[browser]["#{name}__#{pseudo_class}"] = Shway::Css::CssHelper.internal_css_for_hash(browser,pseudo_style) unless pseudo_style.blank?
+            end
+
+            #add styles in each browser, rejecting pseudo styles as they are handled above.
+            # do browser specific key/value substitutions here, so that we have access to the other styles:
+            if browser_hash.delete :alpha_filter
+              raise "alpha_filter can only be specified for an ie6 style. (#{name})" unless browser == :ie6
+              background = style_hash[:background]
+              raise "alpha_filter can only be specified for a style with a background supplied in its main style. (#{name})" unless background
+              browser_hash[:background_image] = :none
+              #"url(/images/shirt_mask_small.png) no-repeat" =~ /\((.*)\)/
+              match = /\((.*)\)/.match(background)
+              raise "alpha_filter can only be specified for a background of the form url(/path/image_name.png). (#{background})" unless match
+              background = match[1]
+              browser_hash[:filter]     = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='#{background}',sizingMethod='image');"
+            end
+            @@css_styles[browser][name] = Shway::Css::CssHelper.internal_css_for_hash(browser,reject_pseudo_class_styles(browser_hash))
+          end
+        end
+
+        #since the style hases nest other hashes (browser hashes and pseudo class hashes) the merge needs to account for those specially.
+        def merge_style_hashes!(hash_one, hash_two)
+          #allow for symbols as the second hash
+          hash_two = @@css_hashes[hash_two.to_s] if hash_two.kind_of? Symbol
+
+          #first we get all the hash_two styles separated into discreet browser style_hashes
+          hash_two_processed = {}
+          for_each_browser_hash hash_two do |key,browser_hash|
+            if browser_hash
+              #allow for symbols
+              browser_hash = @@css_hashes[browser_hash.to_s] if browser_hash.kind_of? Symbol
+              hash_two_processed[key] = browser_hash
+            end
+          end
+          #then we loop over hash_one and merge things in
+          for_each_browser_hash hash_one do |key,browser_hash|
+            next unless hash_two_processed[key]
+            if key == :main
+              #point to the main hash itself so that the merge! will work (reject returns a copy)
+              browser_hash = hash_one
+            else
+              #initialize the browser hash (except for main, since it always exists, and we don't want a :main => {} entry in our style)
+              browser_hash ||= {}
+              hash_one[key] ||= browser_hash
+            end
+            #TODO idea...  could I just loop and only merge things that aren't hashes?  and then merge the hashes with their counterpart? nested? seems messy.
+            #merge in everything but the pseudo classes, since they are hashes.
+            browser_hash.merge! reject_pseudo_class_styles(hash_two_processed[key])
+            #now merge the pseudo classes
+            CssStyles.for_each_css_pseudo_class do |pseudo_class|
+              next unless hash_two_processed[key][pseudo_class]
+              browser_hash[pseudo_class] ||= {}
+              pseudo_hash = hash_two_processed[key][pseudo_class]
+              #allow for symbols as the pseudo_hash
+              pseudo_hash = @@css_hashes[pseudo_hash.to_s] if pseudo_hash.kind_of? Symbol
+              browser_hash[pseudo_class].merge! pseudo_hash if pseudo_hash
+            end
+          end
+        end
+
+        # **CONVERT ALL OF THIS TO USE CssStyle class, and fix this weird bug while I'm at it'
+        def for_each_browser_hash(style_hash, &block)
+          #extract the various browser hashes and loop over them
+          { :ie7 =>     style_hash[:ie7],
+            :ie6 =>     style_hash[:ie6],
+            :safari =>  style_hash[:safari],
+            :main =>    style_hash.reject {|key, value| [:ie7,:ie6,:safari].include? key }
+          }.each do |key,browser_hash|
+            yield key,browser_hash
+          end
+        end
+
+        def reject_pseudo_class_styles(style_hash)
+          return nil unless style_hash
+          style_hash.reject {|key, value| @@css_pseudo_classes.include? key }
+        end
+
+        def for_each_css_pseudo_class(&block)
+          @@css_pseudo_classes.each do |pseudo_class|
+            yield pseudo_class
+          end
+        end
+
+        def value(args)
+          values(args)
+        end
+        def values(args)
+          args.each do |key,value|
+            # puts "**WARNING: css_value already defined for '#{key}'" if @@css_values[key.to_s]
+            @@css_values[key.to_s] = value
+          end
+        end
+
+        def css_config(name, config_hash)
+          name = name.to_s
+          merged_hash = @@css_configs[name] || {}
+          merged_hash = merged_hash.merge config_hash
+          @@css_configs[name] = merged_hash
+        end
+        
+        def finalize_css_config(name)
+          return unless @@css_configs[name]
+          config = @@css_configs[name].clone
+          config.each do |key,value|
+            config[key] = get_css_value_or_symbol(value) if value.kind_of? Symbol
+          end
+          @@css_finalized_configs[name] = config
+        end
+
+        def css_style_exists?(name,browser=nil)
+          name = name.to_s
+          pseudo_class = nil
+          for_each_css_pseudo_class do |pc|
+            if name =~ /__#{pc}$/
+              pseudo_class = pc 
+              name = name.chomp "__#{pc}"
+              break
+            end
+          end
+          if pseudo_class
+            style_hash = @@css_hashes[name][pseudo_class]
+          else
+            style_hash = @@css_hashes[name]
+          end
+          
+          return false if style_hash.blank?
+          case browser
+          when :ie7
+            style_hash = style_hash[:ie7]
+          when :ie6
+            style_hash = style_hash[:ie6]
+          when :safari
+            style_hash = style_hash[:safari]
+          end
+          #if it's the main hash, and anything is defined, then include it
+          !style_hash.blank?
+        end
+    
+        def get_css_style(name,browser=nil)
+          name = name.intern if name.respond_to? :intern
+          exists = css_style_exists?(name,browser)
+          raise "Shway has no style defined for: #{name.inspect}" unless css_style_exists?(name,browser) || @@included_styles.include?(name)
+          style = shared_get_css_style(name,browser)
+          style
+        end
+
+        #return the name (to_s) if the value isn't set. Useful for things like :bold, :right, :auto, etc.
+        def get_css_value(name)
+          name = name.to_s
+          value = @@css_values[name] ? @@css_values[name] : name.dasherize
+        end
+
+        #this method keeps the given name intact instead of converting it to a string
+        def get_css_value_or_symbol(name)
+          key = name.to_s
+          value = @@css_values[key] ? @@css_values[key] : name
+        end
+
+        def get_css_config(name)
+          name = name.to_s
+          finalize_css_config name unless @@css_finalized_configs[name]
+          raise "There is no css config for the name given. (#{name})" unless @@css_finalized_configs[name]
+          @@css_finalized_configs[name]
+        end
+        
+        def get_css_hash(name)
+          name = name.to_s
+          #TODO get rid of this :use_style hack eventually in a nice refactor.
+          if @@css_hashes[name]
+            hash = @@css_hashes[name]
+            hash.delete :use_style
+            hash
+          else
+            nil
+          end
+        end
+
+        def css_styles_from_namespace_stylesheet(stylesheet)
+          css_browser = browser_for_stylesheet(stylesheet)
+          #for now, we're ignoring the namespace and just returning ALL styles...  so there is currently only a global namespace
+          # namespace = stylesheet.gsub('stylesheets/','\'').chomp("-#{css_browser}")
+          #this is obviously a hack. I REALLY need to get rid of these hashes and use CssStyle objects.
+          styles = @@css_styles[css_browser].keys.delete_if do |style_name|
+            is_pseudo_class = false
+            %w{__link __visited __active __hover}.each do |pseudo_class| 
+              next unless style_name.chomp(pseudo_class) != style_name
+              is_pseudo_class = true
+              break;
+            end
+            is_pseudo_class
+          end
+    
+          return styles,css_browser
+        end
+  
+        def browser_for_stylesheet(stylesheet)
+          css_browser = nil
+          [:main,:safari,:ie6,:ie7].each do |browser|
+            browser_string = "-#{browser}"
+            if stylesheet.rindex(browser_string) == stylesheet.length-browser_string.length
+              css_browser = browser
+              stylesheet.chomp! browser_string
+              break;
+            end
+          end
+          css_browser || :main
+        end
+
+        private 
+    
+          def shared_get_css_style(name,browser=nil)
+            browser_styles = nil
+            case browser
+            when :ie7
+              browser_styles = @@css_styles[:ie7]
+            when :ie6
+              browser_styles = @@css_styles[:ie6]
+            when :safari
+              browser_styles = @@css_styles[:safari]
+            else
+              browser_styles = @@css_styles[:main]
+            end
+            browser_styles[name.to_s]
+          end
+    
+      end
+
+      clear_styles
+  
+    end #class CssStyles
+  
+  end
+
+end

data/lib/shway/extensions/routing_extensions.rb

@@ -0,0 +1,22 @@
+module Shway
+
+  module Extensions
+
+    module Routing
+
+      module MapperExtensions 
+        
+        def shway_css(options={})
+          with_options(:controller => "shway") do |shway_map| 
+            shway_map.css               '/stylesheets/:css.css',            :action => 'css'
+            # shway_map.css_style_reload  '/css_reload',                      :action => 'css_style_reload'
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/shway/helpers/html_helper.rb

@@ -0,0 +1,54 @@
+module Shway
+
+  module Helpers
+
+    #various html/css helpers. counters. default_head_contents, etc.
+    module HtmlHelper
+  
+      def css_namespace_stylesheet(namespace,browser=nil)
+        namespace = "#{namespace}-#{browser}" if browser
+        namespace
+      end
+
+      def html_attribute(name, value)
+        value ? %{#{name}="#{value}"} : ''
+      end
+
+      def default_head_contents(*args)
+        stylesheet,main_stylesheet,hash = ShwayHelper.arrange_args 3, *args
+        main_stylesheet = true if main_stylesheet.nil?
+        html = []
+        html << %{
+          <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+          <meta http-equiv="Pragma" content="no-cache" />
+          <meta http-equiv="Expires" content="-1" />
+          #{javascript_include_tag :defaults}
+        }
+        #eventually these will need to get the namespace and set it here. For now it's all global so it doesn't matter what it's called.
+        namespace = 'global'
+        html << %{
+          #{stylesheet_link_tag('shway/reset')}
+          #{stylesheet_link_tag(css_namespace_stylesheet(namespace, :main))}
+          <!--[if lt IE 7]> #{stylesheet_link_tag(css_namespace_stylesheet(namespace, :ie6))}<![endif]-->
+          <!--[if IE 7]>    #{stylesheet_link_tag(css_namespace_stylesheet(namespace, :ie7))}<![endif]-->
+        }
+        html << javascript_tag(%{
+            function isSafari(){
+              var app = navigator.userAgent;
+              if (app.indexOf('Safari') != -1) {
+                document.write(" #{stylesheet_link_tag(css_namespace_stylesheet(namespace, :safari)).gsub('"','\"')} ");
+              }
+            }
+            isSafari();
+        })
+        html << %{
+          <script type="text/javascript" src="/javascripts/shway/iepngfix_tilebg.js"></script>
+        }
+        html.join
+    	end
+
+    end
+
+  end
+  
+end

data/lib/shway/helpers/shway_controller_helper.rb

@@ -0,0 +1,51 @@
+module Shway
+
+  module Helpers
+
+    module ShwayControllerHelper #this is not named ShwayHelper since we want ShwayHelper to be used for other things throughout apps.
+
+      def css_page_for_filename(filename)
+        styles, browser = Shway::Css::CssHelper.css_styles_from_namespace_stylesheet(filename)
+        generate_css_page(styles, browser)
+      end
+
+      private
+
+        def generate_css_page(styles,browser)
+          #always add the pseudo classes since they aren't explicitly referenced with div(:hover), etc.
+          # styles.concat %w{__link __visited __active __hover}
+          css_styles = []
+          styles.each do |style_name|
+            next unless Shway::Css::CssStyles.css_style_exists?(style_name,browser)
+            style = Shway::Css::CssStyles.get_css_style(style_name,browser)
+            if (style_name.index('tag__') == 0)
+              name = style_name[5..style_name.size]
+              css_styles << "#{name} {#{style}}"# unless style.blank?
+              #for now we check for pseudo classes by looping. This could all be much better.
+              Shway::Css::CssStyles.for_each_css_pseudo_class do |pseudo_class|
+                css_pseudo_class_name = "#{style_name}__#{pseudo_class}"
+                if Shway::Css::CssStyles.css_style_exists?(css_pseudo_class_name,browser)
+                  pseudo_style = Shway::Css::CssStyles.get_css_style(css_pseudo_class_name,browser)
+                  css_styles << "#{name}:#{pseudo_class} {#{pseudo_style}}"
+                end
+              end
+            else
+              css_styles << ".#{style_name} {#{style}}"#         unless style.blank?
+              #for now we check for pseudo classes by looping. This could all be much better.
+              Shway::Css::CssStyles.for_each_css_pseudo_class do |pseudo_class|
+                css_pseudo_class_name = "#{style_name}__#{pseudo_class}"
+                if Shway::Css::CssStyles.css_style_exists?(css_pseudo_class_name,browser)
+                  pseudo_style = Shway::Css::CssStyles.get_css_style(css_pseudo_class_name,browser)
+                  css_styles << ".#{style_name} a:#{pseudo_class} {#{pseudo_style}}"
+                end
+              end
+            end
+          end
+          css_styles.join("\n")
+        end
+
+    end
+
+  end
+
+end

data/lib/shway/helpers/shway_helper.rb

@@ -0,0 +1,187 @@
+module Shway
+
+  module Helpers
+
+    module ShwayHelper
+
+
+      def presenter(options={}, &block)
+        #the current_shway_presenter is set up by a before filter and stored on the controller. So we need to get there depending on where this module was included.
+        current_shway_presenter = if @current_shway_presenter 
+          @current_shway_presenter
+        elsif self.kind_of? ActionView::Base
+          self.controller.instance_variable_get :@current_shway_presenter
+        elsif self.kind_of? ActionController::Base
+          self.instance_variable_get :@current_shway_presenter
+        elsif self.kind_of? ShwayPresenter
+          self.shared_instance_variable :@current_shway_presenter
+        else
+          raise "the current_shway_presenter could not be found. Be sure not to override the before_filter method 'setup_shway_presenter'."
+        end
+        current_shway_presenter.setup_options options
+        yield current_shway_presenter if block
+        current_shway_presenter
+      end
+
+
+      %w{div span body ul ol li h1 h2 h3 h4 h5 h6 b hr table tr th td a}.each do |tag| 
+        class_eval %{
+          def #{tag}(name=nil,options={}, &block)
+            render_tag '#{tag}', name, options, &block
+          end
+          def _#{tag}(options={})
+            comment = options.delete :comment
+            comment = "<!-- // \#{comment} -->" if comment
+            "</#{tag}>\#{comment}"
+          end
+        }
+      end
+
+      #NOTE this sort of goes with form_for_tag, which is in shway_control, but I think this is an ok place for it.
+      def _form
+        '</form>'
+      end
+
+      def _br
+        '<BR />'
+      end
+
+      def css_class_for(model)
+        model.class.name.underscore
+      end
+
+      #this will create an id that looks like model_name_12. 
+      #If a css_class is provided, it will be prepended like so: css_class_name_model_name_12. This allows you to have unique ids for different segments based on the same model.
+      def css_id_for(model, css_class=nil)
+        model_id = "#{css_class ? "#{css_class}_" : nil}#{css_class_for(model)}_#{model.id}"
+      end
+
+      #this allows us to render things in either a controller or helper consistently
+      def render_partial_to_string(options={})
+        if respond_to? :render_to_string
+          render_to_string :partial => options[:partial], :locals => options[:locals]
+        else
+          render :partial => options[:partial], :locals => options[:locals]
+        end
+      end
+
+      def render_tag(type, name=nil, options={}, &block)
+        raise "Shway no longer accepts blocks to the #{type} method." if block_given?
+        if (name.kind_of? Hash)
+          options = name
+          name = nil
+        end
+        options = options.clone
+
+        if options[:for]
+          model = options.delete(:for)
+          raise "render_tag :for expects an ActiveRecord::Base model object. (#{model.class.name} was given)" unless model.kind_of? ActiveRecord::Base
+          raise "render_tag :for cannot be used when an :id is specified. (:#{options[:id]} was specified)" if options[:id]
+          id          = css_id_for(model, name)
+          name        ||= css_class_for(model)
+        end
+
+        id                  ||= options.delete(:id)
+        class_name          ||= options.delete(:class)
+
+        onclick             = options.delete(:onclick)
+        onload              = options.delete(:onload)
+        text                = options.delete(:text)
+        raise "You can supply :text or :partial when rendering a tag with Shway, but not both." if text && options[:partial]
+        text                = render_partial_to_string(:partial => options.delete(:partial), :locals => options.delete(:locals)) if options[:partial]
+        close               = options.delete(:close)
+        style               = options.delete(:style) || ''
+        cellpadding         = options.delete(:cellpadding)
+        cellspacing         = options.delete(:cellspacing)
+        rowspan             = options.delete(:rowspan)
+        colspan             = options.delete(:colspan)
+        href                = options.delete(:href)
+        nowrap              = options.delete(:nowrap)
+        align               = options.delete(:align)
+        valign              = options.delete(:valign)
+        title               = options.delete(:title)
+        #merge :additional_classes and :additional_class into a single array of classes
+        options[:additional_classes] = [options[:additional_classes]] unless options[:additional_classes].is_a?(Array)
+        options[:additional_class] = [options[:additional_class]] unless options[:additional_class].is_a?(Array)
+        additional_classes  = options.delete(:additional_classes).compact.concat options.delete(:additional_class).compact
+        raise "You can't specify a name and a class for a tag: (:#{name}, :class => #{class_name})" if name && class_name
+        class_name ||= name
+        class_name = [class_name].concat(additional_classes).join ' '
+
+        html = []
+        html << %{<#{type.to_s}}
+        html << %{ id="#{id}"} unless id.blank?
+        html << %{ cellpadding="#{cellpadding}"} unless cellpadding.blank?
+        html << %{ cellspacing="#{cellspacing}"} unless cellspacing.blank?
+        html << %{ rowspan="#{rowspan}"} unless rowspan.blank?
+        html << %{ colspan="#{colspan}"} unless colspan.blank?
+        html << %{ align="#{align}"} unless align.blank?
+        html << %{ href="#{href == :void ? "javascript:void(0)" : href}"} unless href.blank?
+        html << %{ nowrap} if nowrap
+        html << %{ valign="#{valign}"} unless valign.blank?
+        html << %{ title="#{title}"} unless title.blank?
+        #we just call this to allow it to raise the exception if its needed. I know, I know..  add a beter method. I will later.
+        Shway::Css::CssStyles.get_css_style(name) unless name.blank?
+        html << %{ class="#{class_name}"} unless class_name.blank?
+        html << %{ style="#{style};#{css_for_hash(options)}"} unless options.blank? && style.blank?
+        html << %{ onclick="#{onclick}"} unless onclick.blank?
+        html << %{ onload="#{onload}"} unless onload.blank?
+        html << '>'
+        html << text unless text.blank?
+        # html << capture(&block) if block_given?
+        html << %{</#{type.to_s}>} if text || close
+        html.join
+      end
+
+      def get_css_value(name)
+        Shway::Css::CssStyles.get_css_value(name)
+      end
+
+      def get_css_style(name)
+        Shway::Css::CssStyles.get_css_style(name)
+      end
+
+      def get_css_config(name)
+        Shway::Css::CssStyles.get_css_config(name)
+      end
+
+      def get_css_hash(name)
+        Shway::Css::CssStyles.get_css_hash(name)
+      end
+
+      def arrange_args(count, *args)
+        ShwayHelper.arrange_args(count, *args)
+      end
+      ######################################
+      # ARGUMENT MANIPULATION
+      # these let you manipulate method arguments so you can create flexible method ignatures more easily
+      ######################################
+
+      #this method lets you define a bunch of nil arguments in a method signature, and then push the first Hash to the last argument.
+      #this allows you to have optional parameters that you can leave off, but still collect the end hash correctly.
+      #normally you have to do this with a series of "if nil" checks, or the somewhat non-trivial technique we have here.
+      #so the method ignatures can be more flexible, without a ton of parameter manipulating at the top
+      #EX: id,a,b,c,hash = arrange_args 5, *args
+      #The nuber is the TOTAL number of args, INCLUDING the hash.
+      def self.arrange_args(count, *args)
+        (count-args.size).times { args.push nil }
+        new_args = []
+        hash = nil
+        args.each do |arg|
+          if arg.kind_of? Hash || hash
+            hash ||= arg
+            new_args.push nil
+          else
+            new_args.push arg
+          end
+        end
+        new_args.pop
+        new_args.push(hash || {})
+        return *new_args
+      end
+
+    end
+
+  end
+
+end