facades 0.1.0 → 1.0.0

data/lib/facades/helpers/navigation.rb

@@ -1,136 +1,208 @@
 module Facades
   module Helpers
-    ##
-    # 
-    # Convenience helpers for building navigation lists, and defining 'on' states.
-    #
     module Navigation
       
       ##
+      # Constructs a navigation list containing 
+      # a variable number of list items and links.
       # 
-      # Creates a link wrapped in a list item, to be used within a list-based navigation.
-      # 
-      # @param [String] text The text used within the link
-      # @param [String] path The url used as the link's +href+ attribute
-      # @param [Hash] attrs Hash of attributes to be applied to the link. This format is the same as Rail's +link_to+ helper
-      # @option attrs [String] :active_class The class to use if this link is 'active'. Defaults to "on"
-      # @option attrs [Proc] :proc A callback which, when called, determines the active state of the link
-      # @option attrs [Regex] :matcher A regular expression to be matched against +path+
-      # @param [Symbol] wrapper The html tag to be used as the wrapper. Defaults to +:li+
-      # 
-      # @example Create a list item link to any page
-      #   nav_link('Home Page', '/home') #=> <li><a href="/home">Home Page</a>
-      # 
-      # @example 'Active state' functionality for the current page
-      #   nav_link('Current Page', '/current_url') #=> <li class="on"><a href="/current_url" class="on">Current Page</a></li>
-      # 
-      def nav_link(text, path, attrs = {}, wrapper = :li, &block)
-        
-        if block_given?
-          return sub_nav_link(text, path, attrs, wrapper, :ol, &block)
-        end
-        
-        link_attrs    = update_link_attrs(path, attrs)
-        wrapper_attrs = link_attrs.delete(:wrapper)      
-        child_link    = link_to(text, path, link_attrs)
-        built = (wrapper === false ? child_link : content_tag(wrapper, child_link, wrapper_attrs))
-        built = built.html_safe if built.respond_to?(:html_safe)
-        built
+      def nav(options = {}, &block)
+        Navigator.new(self, options).render(&block)
       end
-      alias :nav_link_to :nav_link
       
-      def sub_nav_link(text, path, attrs = {}, wrapper = :li, container = :ol, &block)
-        wrapper_attrs = attrs.delete(:wrapper)
-        link_attrs    = update_link_attrs(path, attrs.merge(:wrapper => (attrs.delete(:item) || {}) ))
-        parent_link   = nav_link_to(text, path, attrs, false)
-        child_links   = content_tag(container, capture(&block), wrapper_attrs)
-        content_tag(wrapper, (parent_link << child_links), wrapper_attrs)
-      end     
-      private :sub_nav_link
+      alias :navigation :nav
       
       ##
+      # Similar to link_to, but adds the class 'active' if the link's href is in an active state.
+      # If the options :proc, or :matcher is passed, they are used to determine active state. If not the current 
+      # request.path is used.
       # 
-      # Creates a navigational list format, including a parent list / wrapper. Useful for nested list navigation
-      # @param [String] text The text used within the link
-      # @param [String] path The url used as the link's +href+ attribute
-      # @param [Hash] attrs Hash of attributes to be applied to the link. This format is the same as Rail's +link_to+ helper
-      # @option attrs [String] :active_class The class to use if this link is 'active'. Defaults to "on"
-      # @option attrs [Proc] :proc A callback which, when called, determines the active state of the link
-      # @option attrs [Regex] :matcher A regular expression to be matched against +path+
-      # @param [Symbol] wrapper The html tag to be used as the wrapper. Defaults to +:li+
-      # @param [Symbol] container The element that will be used as a container for the nested list
-      # @param [Block] &block A block containing the content of the nested items
-      # 
-      # @example Create a nested list navigation
-      #   nav do
-      #     nav_link('About Page', '/about')
-      #   end
-      # @example
-      #   <ol>
-      #     <li><a href="/home">Home Page</a>
-      #       <ol>
-      #           <li><a href="/about">Sub Page</a></li>
-      #       </ol>
-      #     </li>
-      #   </ol>
-      # 
-      def nav(container = :ol, html_attrs = {}, heading = nil, &block)
-        
-        wrapper_attrs = html_attrs.delete(:wrapper) || {}
-        
-        built = if Facades.enable_html5
-          inner = content_tag(container, capture(&block), wrapper_attrs)
-          inner = (content_tag(:h3, heading) << inner) unless heading.nil?
-          content_tag(:nav, html_attrs) do
-            inner
-          end          
-        else
-          content_tag(container, capture(&block), html_attrs)
+      def nav_link(text, href, options = {})
+        options.merge!(:path => request.path)
+        wrapper = options.delete(:wrapper)
+        link    = NavigationLink.new(text, href, options)
+        current = link.active?
+        link.options = Navigator.merge_html_classes('active', link.options) if current
+
+        if wrapper
+          if wrapper.is_a?(Hash)
+            wrap_attrs = wrapper
+            wrapper    = wrap_attrs.delete(:tag) || :li
+          else
+            wrap_attrs = {}
+          end
+          wrap_attrs = Navigator.merge_html_classes('active', wrap_attrs) if current
+          return content_tag(wrapper, link_to(link.text, link.href, link.options), wrap_attrs)
         end
-        built = built.html_safe if built.respond_to?(:html_safe)
-        built
         
+        link_to(link.text, link.href, link.options)
       end
       
-      private
-      
-      # @private
-      def update_link_attrs(path, attrs)
+      class Navigator
+        attr_reader :view, :path
+        attr_accessor :options, :nested, :links
         
-        proc          = attrs.delete(:proc) || false
-        regex         = attrs.delete(:matcher) || false
-        klasses       = attrs.delete(:class).try(:split, ' ')
-        on_class      = attrs.delete(:active_class) || "on"
-        wrapper_attrs = attrs.delete(:wrapper) || {}
-        wklasses      = wrapper_attrs[:class].try(:split, ' ')
+        def initialize(tpl, options = {}, nested = false)
+          @view, @options, @nested, @links = tpl, options, nested, []
+          @path = view.request.path
+        end
         
-        klasses  ||= []
-        wklasses ||= []
+        delegate :content_tag, :concat, :link_to, :to => :view
         
-        matcher = (proc || regex || request.path.to_s)
-        cpath   = request.path.to_s.sub("/","")
-        lpath   = path.to_s.sub("/","")
+        ##
+        # Renders the resulting html list, wrapped in a <nav> tag.
+        # 
+        def render(&block)
+          wrap_attrs = options.delete(:wrapper) || :ul
+          heading    = options.delete(:heading)
+          
+          unless wrap_attrs.is_a?(Hash)
+            wrapper    = wrap_attrs
+            wrap_attrs = {}
+          else
+            wrapper = wrap_attrs.delete(:tag) || :ul
+          end
+          
+          @wrapper_attrs = wrap_attrs
+          @wrapper       = wrapper
+          
+          output = content_tag(wrapper, view.capture(self, &block), options)
+          return output if nested?
+          
+          if heading
+            heading = generate_heading(heading)
+            output  = heading << output
+          end
+          content_tag(:nav, output, wrap_attrs)
+          
+        end
         
-        active = case matcher
-          when Proc then proc.call(path)
-          when Regexp then request.path.match(regex)
-          when String then (cpath == lpath || cpath.match(/#{lpath}\/\w/i))
-          else raise 'Proc, Regexp or String required... passed #{matcher.class}.'
+        ##
+        # Constructs a link wrapped in a list item for use 
+        # within a navigation list.
+        # 
+        def link(text, href, link_opts = {}, &block)          
+          
+          wrap_attrs = link_opts.delete(:wrapper) || {}
+          link_opts.merge!(:path => path)
+          link = NavigationLink.new(text, href, link_opts)
+          links << link
+          
+          if link.active?
+            wrap_attrs   = merge_html_classes("active", wrap_attrs)
+            link.options = merge_html_classes("active", link.options)
+          end
+          
+          if block_given?
+            subnav = Navigator.new(view, wrap_attrs, true)
+            inner  = subnav.render(&block)
+            unless subnav.links.empty?
+              output = link_to(link.text, link.href, link.options) << inner
+              content_tag(:li, output, wrap_attrs)
+            else
+              content_tag(:li, link_to(link.text, link.href, link.options), wrap_attrs)
+            end
+          else
+            content_tag(:li, link_to(link.text, link.href, link.options), wrap_attrs)
+          end        
         end
         
-        if active === true
-          klasses  << on_class
-          wklasses << on_class
+        class << self
+          
+          ##
+          # Takes an options array and adds any additional 
+          # classes passed to args. If a :class key exists, it 
+          # is updated. If not, it is added unless the result is
+          # an empty string. 
+          # 
+          def merge_html_classes(*args)
+            opts    = args.extract_options!
+            klasses = (opts.delete(:class) || "").split(" ")
+            klasses = [klasses, args].flatten.compact.reject{ |c| c.to_s.blank? }.join(" ")
+            (klasses.blank? ? opts : opts.merge(:class => klasses))
+          end
+          
         end
+        
+        private
 
-        attrs.merge!(:class => klasses.join(" ")) unless klasses.compact.empty?
-        wrapper_attrs.merge!(:class => wklasses.join(" ")) unless wklasses.compact.empty?
+        ##
+        # To be valid, a <nav> should have a heading of some sort.
+        # When passed via options, this generates the proper tag
+        # 
+        def generate_heading(opts)
+          if opts.is_a?(Hash)
+            heading_tag  = opts.delete(:tag)
+            heading_text = opts.delete(:text)
+          else 
+            heading_text = opts
+          end
+          heading_tag ||= :h3
+          content_tag(heading_tag, heading_text)
+        end
+        
+        def merge_html_classes(*args) #:nodoc:
+          Navigator.merge_html_classes(*args)
+        end
+        
+        ##
+        # Determines if the current navigation set 
+        # is nested within another.
+        # 
+        def nested?
+          @nested == true
+        end
 
-        attrs.merge!(:wrapper => wrapper_attrs)
-        attrs
       end
-            
-    end
+      
+      class NavigationLink
+        attr_accessor :href, :text, :options
+        attr_reader :matcher
+        
+        def initialize(text, href, options)
+          @href, @text, @options = href, text, options
+          @matcher  = (options.delete(:proc) || options.delete(:matcher))
+          curr_path = options.delete(:path)
+          @matcher ||= curr_path
+        end
+        
+        ##
+        # Checks the link's href against either a proc,
+        # regexp, or current request.path depending on 
+        # the options provided. Returns true if there is 
+        # a match, false if not.
+        # 
+        def active?
+          return matcher.call(href) if matcher.is_a?(Proc)
+          return ( (href =~ matcher).to_i >= 1 ) if matcher.is_a?(Regexp)
+          
+          match_path = normalize_path(matcher)
+          href_path  = normalize_path(href)
+          
+          return false if href_path.blank? && !match_path.blank?
+          
+          if key = options.delete(:match)
+            path_matcher = case key.to_s
+            when 'exact'  then match_path.match(%r{^/?#{href_path}/?$}i)
+            when 'after'  then match_path.match(%r{/?#{href_path}/?(.*)$}i)
+            when 'before' then match_path.match(%r{#{href_path}/?$}i)
+            end
+          else
+            path_matcher = match_path.match(/#{href_path}\/.*/i)
+          end
+          !!(match_path == href_path || path_matcher)
+        end
+        
+        private
+        
+        def normalize_path(path)
+          path.split("/").reject{ |part| part.blank? }.compact.join("/")
+        end
+        
+      end
+      
+    end # Navigation
     
-  end
-end
+  end # Helpers
+  
+end # Facades

data/lib/facades/helpers/{elements.rb → notifications.rb}

@@ -1,34 +1,6 @@
 module Facades
   module Helpers
-    ##
-    # 
-    # Generates misc html elements that aren't included in Rails core, or are custom.
-    #
-    module Elements
-      
-      ##
-      # Generates a "button" link tag. Simply a convenience method to skip adding 'class="button"' and also adds an +icon+ option
-      # @see Motr::Forms::Builder#button For form related buttons
-      # 
-      # @param [String] txt The link text
-      # @param [String] path The link href
-      # @param [Types] Name Description
-      # 
-      # @example Create a plain link.button 
-      #   button_link('Blog', '/blog') #=> <a href="/blog" class="button">Blog</a>
-      # @example Create a link.button with icon
-      #   button_link('Blog', '/blog', :icon => 'blog_image.png') #=> <a href="/blog" class="button"><img src="/images/blog_image.png" alt="Blog" /> Blog</a>
-
-      def button_link(txt, path, attrs = {}, incl_span = false)
-        image   = attrs.delete(:icon)
-        klasses = (attrs.delete(:class) || "").split(" ")
-        klasses << 'button'
-        klasses  = klasses.uniq.compact        
-        content  = ""
-        content <<  image_tag(image) unless image.nil?
-        content << (incl_span ? "<span>#{txt}</span>" : txt)
-        link_to content.html_safe, path, attrs.merge(:class => klasses.join(" "))
-      end
+    module Notifications
       
       ##
       # 
@@ -50,29 +22,30 @@ module Facades
       #
       #
       def flash_messages(attrs = {})
-        
+
         return if flash.nil? or flash.empty?
-        
+
         wrapper = attrs.delete(:wrapper) || :div
         closer  = attrs.delete(:closer)
         unless closer === false
-          closer ||= "<span>X</span>"
+          closer ||= "<span class='close'>x</span>"
         end
         klasses = (attrs.delete(:class) || "").split(" ")
         klasses << "flash-message"  
         content = ""    
-        
+
         flash.each do |key, value|
+          next if value === true or value.to_s == 'true' # fix awkward devise message
+          klasses << "notification"
           klasses << "flash-message-#{key.to_s.underscore}"
           msg_attrs = attrs.merge(:class => [key.to_s, klasses].flatten.join(' '))
           content.concat content_tag(wrapper, "#{value} #{closer}".html_safe, msg_attrs).html_safe
         end    
-        
+
         content.html_safe    
-        
+
       end
       
     end
-    
   end
 end

data/lib/facades/helpers.rb

@@ -1,23 +1,12 @@
+require 'action_view'
 require 'facades/helpers/layout'
 require 'facades/helpers/navigation'
-require 'facades/helpers/elements'
-require 'facades/helpers/pagination'
-require 'facades/helpers/utility'
-require 'facades/helpers/builders'
-require 'facades/helpers/mobile'
+require 'facades/helpers/notifications'
 
 module Facades
-  module Helpers
-    extend ActiveSupport::Concern
-    
-    included do
-      include Facades::Helpers::Layout
-      include Facades::Helpers::Navigation
-      include Facades::Helpers::Elements
-      include Facades::Helpers::Utility
-      include Facades::Helpers::Builders
-      include Facades::Helpers::Mobile
-    end
-    
+  module Helpers  
+    include Facades::Helpers::Layout
+    include Facades::Helpers::Navigation
+    include Facades::Helpers::Notifications
   end
 end

data/lib/facades/patterns/tabs.rb

@@ -0,0 +1,75 @@
+module Facades
+  module Patterns
+    ##
+    # Generates a tabbed container including 
+    # a navigation as well as the tab's "panes"
+    # 
+    module Tabs
+      
+      def tabbed(options = {}, &block)
+        TabBuilder.new(self, options).render(&block)
+      end
+      
+      class TabBuilder
+        attr_reader :view
+        attr_accessor :options, :tabs
+        
+        def initialize(tpl, options = {})
+          @view, @options, @tabs = tpl, options, []
+        end
+        
+        delegate :content_tag, :concat, :link_to, :capture, :to => :view
+        
+        ##
+        # Renders the resulting tab area 
+        # including a list navigation.
+        # 
+        def render(&block)
+          klasses = options.delete(:class) || ""
+          options.merge!(:class => klasses.split(" ").push("tabbed").join(" "))          
+          rendered = view.capture(self, &block)
+          output   = content_tag(:ul, { :class =>'tab-navigation' }) do
+            tabs.each_with_index do |tab, ind|
+              link_opts = ( ind == 0 ? { :class => 'active' } : {} )
+              concat content_tag(:li, link_to(tab.title, "##{tab.tab_id}"), link_opts)
+            end
+          end
+          output << rendered
+          concat content_tag(:div, output, options)
+        end
+        
+        ##
+        # Adds a new panel to the tabbed area.
+        # @param [String] title The text to be used in the navigation link.
+        # @param [Hash] options A hash of html attributes to be added to the tab panel.
+        # 
+        def panel(title, options = {}, &block)
+          panel = TabPanel.new(title, options)
+          tabs << panel
+          concat content_tag(:section, capture(&block), panel.options)
+        end
+        
+      end
+      
+      class TabPanel
+        attr_accessor :options, :title
+        
+        def initialize(title, options = {})
+          @title, @options = title, options
+          @options.merge!(:id => tab_id)
+          klasses = @options.delete(:class) || ""
+          @options.merge!(:class => klasses.split(" ").push("tab").join(" "))
+        end
+        
+        def tab_id
+          return options[:id] if options[:id]
+          value = title.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n, '').to_s
+          value.gsub(/[']+/, '').gsub(/\W+/, ' ').strip.downcase.gsub(" ", "_")
+        end
+        
+      end
+      
+      
+    end # Tabs
+  end # Patterns
+end # Facades

data/lib/facades/patterns.rb

@@ -0,0 +1,7 @@
+require 'facades/patterns/tabs'
+
+module Facades
+  module Patterns
+    include Facades::Patterns::Tabs
+  end
+end

data/lib/facades/{sass_ext → sass_extensions}/color.rb

@@ -1,5 +1,5 @@
 module Facades
-  module SassExt
+  module SassExtensions
     module Color
       
       # Check the luminance of color. This differs from lightness as it returns the actual values as 'light' and 'dark'
@@ -8,7 +8,7 @@ module Facades
         result = ((color.red * 299) + (color.green * 587) + (color.blue * 114) / 1000)
         Sass::Script::String.new( result >= 160 ? 'light' : 'dark')
       end
-      
+
       # Tint a color by mixing it with white
       def tint(color, dilution = Sass::Script::Number.new(50))
         assert_type color, :Color
@@ -25,14 +25,6 @@ module Facades
         mix(color, black, Sass::Script::Number.new(100 - dilution.value))
       end
       
-      # Converts a rgba to hex string, via compass ie_hex_str
-      def rgba_to_hex(color)
-        assert_type color, :Color
-        alpha = (color.alpha * 255).round
-        alphastr = alpha.to_s(16).rjust(2, '0')
-        Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
-      end
-      
-    end
-  end
-end
+    end # Color
+  end # SassExtensions
+end # Facades

data/lib/facades/sass_extensions/conversions.rb

@@ -0,0 +1,27 @@
+##
+# Extensions to sass's unit conversion and manipulation 
+# functionality. 
+# 
+module Facades
+  module SassExtensions
+    module Conversions
+      
+      ##
+      # Removes any unit values (px/em/rem etc)
+      # from a number leaving just the numeric
+      # representation.
+      # 
+      # @example Use unitless line heights
+      #   line-height:numeric(1em)  #=> line-height:1
+      # 
+      def numeric(value)
+        assert_type value, :Number
+        return value if value.unitless?
+        value = value.to_s.gsub(value.unit_str, '')
+        value = value.to_f.denominator > 1 ? value.to_f : value.to_i
+        Sass::Script::Number.new(value)
+      end
+      
+    end
+  end
+end

data/lib/facades/sass_extensions/functions.rb

@@ -0,0 +1,84 @@
+##
+# Misc functions to assist development.
+# 
+module Facades
+  module SassExtensions
+    module Functions
+      
+      ##
+      # Compact via compass
+      # Compacts a sass list removing any nil or empty items.
+      # @see http://compass-style.org
+      # 
+      def compact(*args)
+        sep = :comma
+        if args.size == 1 && args.first.is_a?(Sass::Script::List)
+          list = args.first
+          args = list.value
+          sep  = list.separator
+        end
+        Sass::Script::List.new(args.reject{|a| !a.to_bool}, sep)
+      end
+      
+      
+      ##
+      # Creates a selector including all 
+      # fields of a particular type. Helpful to 
+      # target text-like inputs etc.
+      # 
+      def input_types(*args)
+        Sass::Script::String.new(args.collect do |type|
+          send(:"#{type}_input_types")
+        end.flatten.compact.join(", "))
+      end
+      
+      ##
+      # Takes a value or values and prepends them to an existing list.
+      # 
+      def prepend(*args)
+        existing = args.first
+        unless args.first.is_a?(Sass::Script::List)
+          raise Sass::SyntaxError, "The first argument to 'unshift' must be a list"
+        end
+        existing = existing.value
+        args.each{ |arg| existing.unshift(arg) }
+        Sass::Script::List.new(args, :comma)
+      end
+            
+      
+      private
+      
+      ##
+      # Returns all input types
+      # 
+      def all_input_types
+        [boolean_input_types, button_input_types, text_input_types].flatten
+      end
+      
+      ##
+      # Returns an array of boolean input types (radio/checkbox)
+      # 
+      def boolean_input_types
+        ["input[type=radio]", "input[type=checkbox]"]
+      end
+      
+      ##
+      # Returns an array of button style input types
+      # 
+      def button_input_types
+        ["button", "input[type=button]", "input[type=submit]", "input[type=reset]"]
+      end
+      
+      ##
+      # Returns an array of text style input types
+      # 
+      def text_input_types
+        %w{email password text number search tel time url datetime date datetime-local week month}.collect do |type| 
+          "input[type=#{type}]"
+        end
+      end
+      
+    end
+    
+  end
+end