shway 3.0

data/lib/shway/css/css_helper.rb

@@ -0,0 +1,221 @@
+module Shway
+
+  module Css
+
+    module CssHelper
+
+      def self.included(mod)
+        # include Shway::Css
+        mod.send :include, Shway::Css
+      end
+
+      def self.css_styles_from_namespace_stylesheet(stylesheet)
+        CssStyles.css_styles_from_namespace_stylesheet(stylesheet)
+      end
+
+      #########################################
+
+      @@ALL_SIDES = %w{top right bottom left}
+
+      def link_styles(name, color=nil, styles=nil, hover_color=nil, hover_styles=nil, args={})
+        name = "#{name} a" unless name.strip == 'a'
+        normalize_params(args, :color => color, :styles => styles, :hover_color => hover_color, :hover_styles => hover_styles)
+        color        = args[:color]#       || 'black'
+        hover_color  = args[:hover_color] || color
+        styles       = args[:styles] 
+        hover_styles = args[:hover_styles] || styles
+        html = []
+        [ {:name => "#{name}:link   ", :color => color,       :styles => styles,       :decoration => 'none     '},
+          {:name => "#{name}:visited", :color => color,       :styles => styles,       :decoration => 'none     '},
+          {:name => "#{name}:active ", :color => hover_color, :styles => hover_styles, :decoration => 'underline'},
+          {:name => "#{name}:hover  ", :color => hover_color, :styles => hover_styles, :decoration => 'underline'},
+        ].each do |style|
+          color_style = color ? "color: #{style[:color]}" : ''
+          html << "#{style[:name]} {text-decoration: #{style[:decoration]};#{color_style};#{style[:styles]}}"
+        end
+        html = html.join
+        html
+      end
+
+      ####################
+      #These methods are used for css generated in helpers
+
+
+      #TODO I think I can get rid of this ie6 stuff now.
+      def hashes_to_style_tag(ie6=false, ids_and_hashes=nil)
+        ids_and_hashes, ie6 = ie6, false if ie6.class == Hash #this is an interesting idiom for moving the args into the right vars
+        
+        #convert all the keys to strings so we can sort by them. (apparently you cab't sort symbols)
+        new_ids_and_hashes = {}
+        ids_and_hashes.each do |key,value|
+          new_ids_and_hashes[key.to_s] = value
+        end
+        ids_and_hashes = new_ids_and_hashes
+        
+        styletag = []
+        if ie6
+          styletag << '<!--[if lt IE 7]>'
+        end
+        styletag << '<style>'
+        ids_and_hashes.keys.sort.each do |id|
+          styletag << "##{id}{#{css_for_hash ids_and_hashes[id]}}"
+        end
+        styletag << '</style>'
+        if ie6
+          styletag << '<![endif]-->'
+        end
+        styletag.join
+      end
+      
+      def id_att(css_id)
+        html_att 'id', css_id
+      end
+      
+      def class_att(css_class)
+        html_att 'class', css_class
+      end
+      
+      def html_att(att_name, att_value)
+        %{#{att_name}="#{att_value}"} if att_value
+      end
+      
+      # you can supply an array or a string with space or comma delimiters
+      # it gets transformed into a comma separated list, ala the css selector syntax
+      # you can put ? symbols in the selectors and have them replaced with whatever you supply as the replace param
+      # eg: css_selectors "#?_content .?_nw .?_sw .?id .?_se .?_ne", 'test'
+      #           yields "#test_content .test_nw .test_sw .testid .test_se .test_ne"
+      def self.css_selectors(selectors, replace=nil)
+        selectors = (selectors.collect{ |selector| selector.to_s}.join ',') if selectors.class == Array
+        selectors = selectors.split(' ').join(',')
+        selectors.gsub!('?', replace.to_s) if replace
+        selectors
+      end
+
+      def css_for_hash(selectors=[], replace=nil, hash={})
+        Shway::Css::CssHelper.css_for_hash(selectors, replace, hash)
+      end
+
+      def self.css_for_hash(selectors=[], replace=nil, hash={})
+        shared_css_for_hash(false,:main,selectors,replace,hash)
+      end
+
+      def self.internal_css_for_hash(browser,selectors=[], replace=nil, hash={})
+        shared_css_for_hash(true,browser,selectors,replace,hash)
+      end
+
+      #this should be private
+      def self.shared_css_for_hash(internal,browser,selectors=[], replace=nil, hash={})
+        #this will ignore any params that have nil values
+        if selectors.class == Hash 
+          hash = selectors
+          selectors = nil
+        end
+        
+        hash = hash.merge :use_style => nil
+
+        #disallow improper usage
+        unless internal
+          [:safari,:ie6,:ie7].each do |browser|
+            raise "Browser styles can only be defined using css_style, not with css_for_hash. (:#{browser})" unless hash[browser].blank?
+          end
+        end
+        raise "You can not set a value for :main in css hashes." if hash[:main]
+        raise "When generating css from a hash, :id and :class should NOT be set. (:id => #{hash[:id]}, :class => #{hash[:class]})" if hash[:id] || hash[:class]
+
+        raise "alpha_filter can only be specified fot css_style, not css_for_hash, since it is browser dependent. (#{name})" if hash[:alpha_filter]
+
+        #TODO: add a way to switch between versions. maybe development uses verbose/readable and the others use terse?
+        readable = RAILS_ENV == 'development' || RAILS_ENV == 'test'
+
+        css = []
+
+        #GOTCHA!! for styles like margin and padding, we need to sort everything alphabetically so you can set a margin, and then override just margin-top
+        hash.delete_if {|key, value| value.nil? }.sort{|a,b| a[0].to_s<=>b[0].to_s}.each do |key,values|
+          #process all values as arrays so that the ones that are arrays can be handled as well
+          values = [values] unless values.kind_of? Array
+          processed_values = []
+          values.each do |value|
+            #lookup the css_value if it's a symbol
+            #GOTCHA TODO should I just always just return this as a string
+            value = Shway::Css::CssStyles.get_css_value(value).to_s if value.kind_of? Symbol
+            #this is where we process things and add px, etc.
+            begin
+              #NOTE: need to set some styles, like z-index to NOT append 'px'
+              raise 'escape' if %w{z_index}.include? key.to_s 
+              Integer(value)
+              processed_values << "#{value.to_s}px"
+            rescue
+              processed_values << value
+            end 
+          end
+          css << "#{key.to_s.dasherize}:#{processed_values.join(' ')};"
+        end
+        styles = readable ? "  #{css.join("\n  ")}" : css.join
+        styles.strip!
+        styles = nil if styles.blank?
+        return styles unless selectors
+        
+        selectors = css_selectors(selectors, replace)
+        
+        if readable
+          ret = []
+          ret << "#{selectors} {"
+          ret << "#{styles}"
+          ret << "}"
+          ret << ""
+          ret.join "\n"
+        else
+          "#{selectors}{#{styles}}"
+        end
+
+      end
+
+      def style_tag_for_ie6_css(*args)
+        style_tag_for_css_shared true, *args
+      end
+
+      def style_tag_for_css(*args)
+        style_tag_for_css_shared false, *args
+      end
+
+      def style_tag_for_css_shared(ie6=false, *args)
+        args.collect! do |css|
+          css.class == Array ? css_for_hash(*css) : css
+        end
+        css = css_for_hashes *args
+        if ie6
+          "<!--[if lt IE 7]><style>#{css}</style><![endif]-->"
+        else
+          "<style>#{css}</style>"
+        end
+      end
+
+      def css_for_hashes(*args)
+        args.collect! do |css|
+          css.class == Array ? css_for_hash(*css) : css
+        end
+        args.join
+      end
+
+      def expand_css_array(array)
+        array = [array] unless array.kind_of? Array
+        array = case array.size
+        when 4
+          array
+        when 1
+          [array.first,array.first,array.first,array.first]
+        when 2
+          [array.first,array.last,array.first,array.last]
+        when 3
+          [array[0],array[1],array[2],array[1]]
+        else
+          [array[0],array[1],array[2],array[3]]
+        end
+        array   
+      end
+
+    end
+
+  end
+
+end

data/lib/shway/css/css_parser.rb

@@ -0,0 +1,155 @@
+module Shway
+
+  module Css
+
+    # rule :          P { font-size: 10pt }
+    class CssRule
+
+      attr_accessor :selectors, :declarations
+
+      CSS_RULES_REGEX = /([^{]*\{[^}]*\})/m #this gets a full rule, including the selectors and declaration, with braces
+      def self.parse_all(rules_string)
+        rules = []
+        rule_strings = rules_string.scan CSS_RULES_REGEX
+        rule_strings.collect(&:first).each do |rule_string|
+          rule = CssRule.parse(rule_string)
+          rules << rule if rule
+        end
+        rules
+      end
+
+      CSS_RULE_REGEX = /([^{]*)\{([^}]*)\}/m #this gets the selectors and the declarations from a single rule.
+      def self.parse(rule_string)
+        selectors_and_declarations_strings = rule_string.scan CSS_RULE_REGEX
+        raise "The rule_string supplied appears to have multiple rules in it, and it should only have one. (#{rule_string})" if selectors_and_declarations_strings.size > 1
+        raise "The rule_string does not appear to contain a rule. (#{rule_string})" if selectors_and_declarations_strings.first.size < 2
+
+        selectors_string, declarations_string = selectors_and_declarations_strings.first
+        selectors = CssSelector.parse_all(selectors_string)
+        declarations = CssDeclaration.parse_all(declarations_string)
+        CssRule.new selectors, declarations
+      end
+
+      def initialize(selectors=nil,declarations=nil)
+        raise "CssRule selectors cannot be empty." if selectors.blank?
+        raise "CssRule declarations cannot be empty." if declarations.blank?
+        @selectors = selectors if selectors
+        @declarations = declarations if declarations
+      end
+      
+      def to_s
+        "#{selectors.join(',')}{#{declarations.join(';')};}"
+      end
+      
+      
+    end #CssRule
+
+    # selector :      P
+    class CssSelector
+
+      attr_accessor :pattern
+
+      CSS_SELECTOR_REGEX = /[{};,]/
+      
+      def self.parse(selector_string)
+        CssSelector.new(selector_string)
+      end
+      
+      def self.parse_all(selectors_string)
+        selectors = []
+        selectors_string.split(',').each do |selector_string|
+          selector = CssSelector.parse selector_string
+          selectors << selector if selector
+        end
+        selectors
+      end
+
+      def initialize(pattern=nil)
+        raise "CssSelector patterns cannot be nil." if pattern.blank?
+        raise "CssSelector patterns cannot contain curly braces, semi-colons or commas (#{pattern})" unless (pattern =~ CSS_SELECTOR_REGEX).nil?
+        @pattern = pattern.strip if pattern
+      end
+      
+      def to_s
+        pattern || ''
+      end
+      
+    end #CssSelector
+
+    # declaration :   { font-size: 10pt }
+    class CssDeclaration
+      
+      attr_accessor :property, :value
+      
+      def self.parse(declaration_string)
+        property_string, value_string = declaration_string.strip.split(':').collect{|s|s.strip}
+        return nil if property_string.blank? && value_string.blank?
+        CssDeclaration.new(CssProperty.parse(property_string), CssValue.parse(value_string))
+      end
+      
+      def self.parse_all(declarations_string)
+        declarations = []
+        declarations_string.split(';').each do |declaration_string|
+          declaration = CssDeclaration.parse declaration_string
+          declarations << declaration if declaration
+        end
+        declarations
+      end
+      
+      def initialize(property=nil, value=nil)
+        @property = property if property
+        @value = value if value
+      end
+
+      def to_s
+        "#{property.name}:#{value.value}"
+      end
+      
+    end #CssDeclaration
+
+    # property :      font-size
+    class CssProperty
+
+      attr_accessor :name
+      
+      CSS_PROPERTY_REGEX = /[^-a-z]/
+      
+      def self.parse(property_string)
+        CssProperty.new(property_string)
+      end
+      
+      def initialize(name=nil)
+        raise "CssProperty names cannot be nil." if name.blank?
+        raise "CssProperty names must contain only lower case letters and hyphens (#{name})" unless (name =~ CSS_PROPERTY_REGEX).nil?
+        @name = name.strip if name
+      end
+      
+      def to_s
+        name || ''
+      end
+      
+    end #CssProperty
+
+    # value :         10pt
+    class CssValue
+      
+      attr_accessor :value
+      
+      def self.parse(value_string)
+        CssValue.new(value_string)
+      end
+      
+      def initialize(value=nil)
+        @value = value.strip if value
+      end
+
+      def to_s
+        value || ''
+      end
+
+    end #CssValue
+
+  end #Css
+
+end #Shway
+