storefront 0.2.1 → 0.2.7

data/lib/storefront/helpers/page_helper.rb

@@ -1,73 +1,91 @@
 module Storefront
   module PageHelper
-    def page(options = {})
-      page_title(options)
-    end
-
-    # = page              #=> figures out name from resource (inherited_resources)
-    # = page :step => 1   #=> prepends "Step 1: " to the title
-    # options => [:browser_title, :title, :clazz]
-    def page_title(options = {})
-      if options.is_a?(String)
-        title = browser_title = options
-        title_class = ""
-      elsif options.is_a?(Symbol)
-        title = browser_title = t("page.titles.#{options}")
-      else
-        title_class = options.delete(:title_class)
-        title = options.delete(:title)
-        browser_title = options.delete(:browser_title)
-      end
-      if title
-        capture_page_title((browser_title || title), (title || browser_title), :class => title_class)
+    
+    # calls <tt>model.to_title</tt>    
+    def page(*args)
+      options = args.extract_options!
+      title   = args.shift
+      options[:action] ||= storefront_config.current_scope[:action]
+      
+      title = case title
+      when ::String
+        title
+      when ::Symbol
+        t?(title, :scope => :"pages.titles")
       else
-        return "" unless (defined?(:resource) || defined?(:collection))
-        cont    = params[:controller].split("/").last
-        key     = "#{cont}.#{params[:action]}"
-        default_key = "resource.#{params[:action]}"
-        parent_exists = parent rescue nil
-        parent_exists = !parent_exists.nil?
-        options[:name] = resource.name if resource rescue nil
-        options[:name] ||= parent.name if parent_exists
-        if parent_exists
-          key << ".nested" 
-          default_key << ".nested"
-        end
-        if options[:clazz].blank?
-          options[:clazz] = cont.singularize.titleize
-          options[:clazz] = options[:clazz].pluralize if params[:action] == "index"
+        if options[:title].present?
+          options[:title]
+        else
+          parent_name = !!options[:parent] ? resource_to_title(storefront_config.current_scope[:parent], options) : nil
+          resource_name = resource_to_title(storefront_config.current_scope[:resource], options)
+          [parent_name, resource_name].compact.join(storefront_config.breadcrumb)
         end
-        browser_title_options = options.merge(:default => t("#{default_key}.browser_title"))
-        page_title_options    = options.merge(:default => t("#{default_key}.page_title"))
-        capture_page_title(
-          t("#{key}.browser_title", browser_title_options).strip.squeeze(" "),
-          t(key, page_title_options).strip.squeeze(" "),
-          :class => title_class
-        )
       end
+      
+      self.title options[:browser] || title
+      
+      options                                    = header_widget_options(options.merge(:title => title))
+      
+      options[:header_html].reverse_merge!(:id   => storefront_config.page_header_id) if storefront_config.page_header_id.present?
+      options[:title_html].reverse_merge!(:id    => storefront_config.page_title_id) if storefront_config.page_title_id.present?
+      options[:subtitle_html].reverse_merge!(:id => storefront_config.page_subtitle_id) if storefront_config.page_subtitle_id.present?
+      options[:level]                            = 1
+      options[:skip_format]                      = true
+      
+      header_widget options.merge(:title => title)
     end
+    
+    def title_widget(*args, &block)
+      options = args.extract_options!
+      options[:header_html] ||= {}
+      merge_class! options[:header_html], *widget_classes("title-widget")
+      header_widget(options, &block)
+    end
+    
+    def title_widget_options
 
-    def resource_title(options = {})
-      return options[:default] if options[:default]
-      return "" unless (defined?(:resource) || defined?(:collection))
-      options[:action] ||= params[:action]
-      cont = params[:controller].split("/").last
-      key     = "#{cont}.#{options[:action]}"
-      options[:name] = resource.name if resource rescue nil
-      options[:clazz] = cont.singularize.camelize
-      options[:clazz] = options[:clazz].pluralize if options[:action] == "index"
-      page_title_options    = options.merge(:default => t("resource.#{options[:action]}.page_title"))
-      t(key, page_title_options).strip.squeeze(" ")
     end
 
-    def capture_page_title(browser_title, the_page_title, options = {})
-      result  = capture_haml do
-        title browser_title
-        haml_tag :header, options.reject{|k,v| v.blank?}.merge(:id => "page-title") do
-          haml_tag :h1, the_page_title
-        end
+    def resource_to_title(resource, options = {})
+      if resource.present?
+        
+        # handle subdomains as well
+        t?(options[:action].to_sym, 
+          :scope       => :"pages.titles",
+          :model       => Storefront::ModelProxy.model_names(resource), 
+          :namespaces  => storefront_config.current_scope[:namespace],
+          :allow_blank => true,
+          :action      => "",
+          :name        => resource.is_a?(::Class) ? resource.name.titleize.pluralize : resource.to_title,
+          :clazz       => resource.is_a?(::Class) ? resource.name.titleize : resource.class.name
+        )
+      end
+    end
+    
+    def configure_storefront
+      action    = params[:action].to_s
+      
+      begin
+        resource_object  = self.resource rescue nil
+        resource_object  = resource_instance_name.to_s.camelize.constantize rescue nil
+      rescue Exception => e
+        resource_object  = nil
+      end
+      begin
+        parent_object    = self.parent rescue nil
+      rescue Exception => e
+        parent_object    = nil
       end
-      result
+      
+      namespace = params[:controller].split("/")
+      namespace = namespace.length > 1 ? namespace[0..-2].join(".") : nil
+      
+      storefront_config.current_scope = {
+        :action    => action,
+        :resource  => resource_object,
+        :parent    => parent_object,
+        :namespace => namespace
+      }
     end
   end
 end

data/lib/storefront/helpers/request_helper.rb

@@ -1,5 +1,8 @@
 module Storefront
   module RequestHelper
+    # requesting?(:deals)
+    # requesting?("/admin/users/:id")
+    # requesting?("admin/users#show")
     def requesting?(expression)
       case expression
       when ::Symbol

data/lib/storefront/helpers/table_helper.rb

@@ -16,7 +16,7 @@ module Storefront
     def next_page_path(collection)
       with_params(request.path, :page => collection.next_page)
     end
-  
+    
     def prev_page_path(collection)
       with_params(request.path, :page => collection.prev_page)
     end

data/lib/storefront/helpers/template_helper.rb

@@ -0,0 +1,11 @@
+module Storefront
+  module TemplateHelper
+    def javascript_template(name, options = {}, &block)
+      options[:id] ||= name.to_s.strip.gsub(/[\s|_]+/, storefront_config.separator).squeeze(storefront_config.separator)
+      options[:type] ||= "text/html"
+      capture_haml do
+        haml_tag :script, options, &block
+      end
+    end
+  end
+end

data/lib/storefront/helpers/time_helper.rb

@@ -5,10 +5,10 @@ module Storefront
     def set_time_zone
       offset       = (cookies[:timezone] || 0).to_i * -60
       # User.time_zone = ActiveSupport::TimeZone[-min.minutes]
-      User.time_zone = ActiveSupport::TimeZone.us_zones.find { |z| z.utc_offset == offset.to_i }
+      ::User.time_zone = ActiveSupport::TimeZone.us_zones.find { |z| z.utc_offset == offset.to_i }
       true
     end
-
+    
     def record_post_time
       cookies[:last_post_at] = Time.zone.now.to_i
     end

data/lib/storefront/helpers/widget_helper.rb

@@ -1,10 +1,161 @@
 module Storefront
   module WidgetHelper
+    WIDGETS = {} unless defined?(WIDGETS)
+    
     def widget(*args, &block)
       options = args.extract_options!
-      options.reverse_merge(:locale => nil)
+      name    = args.shift
+      
+      if widget_partial?(name)
+        widget_partial(name, options, &block)
+      elsif self.respond_to?("#{name}_widget")
+        send("#{name}_widget", name, options, &block)
+      else
+        raise "Please either define a helper method '#{name}_widget' or create a partial such as 'shared/widgets/#{name}.haml'"
+      end
+    end
+    
+    def text_widget(*args, &block)
+      options = text_widget_options(*args)
+      
+      capture_haml do
+        haml_tag :article, options[:outer_html] do
+          header = header_widget(options)
+          haml_concat header if header.present?
+          content = options[:content]
+          content ||= capture(&block) if block_given?
+          haml_tag options[:tag], content, options[:content_html]
+        end
+      end
+    end
+    
+    def text_widget_options(*args)
+      options = widget_options(*args)
+      
+      options[:content_html] ||= {}
+      
+      merge_class! options, storefront_config.content_class
+      
+      options[:tag] ||= :p
+      
+      options
+    end
+    
+    def buttons_widget(*args, &block)
+      options = args.extract_options!
+      options = widget_options("buttons-widget", options.reverse_merge(:title => false))
+      
+      capture_haml do
+        haml_tag :nav, options[:outer_html], &block
+      end
+    end
+    
+    def footer_widget(*args, &block)
+      options = args.extract_options!
+      options = widget_options("footer-widget", options.reverse_merge(:title => false))
+      
+      capture_haml do
+        haml_tag :footer, options[:outer_html], &block
+      end
+    end
+    
+    def header_widget(options = {}, &block)
+      options = header_widget_options(options) unless options[:skip_format]
+      
+      return nil if options.blank?
+      
+      capture_haml do
+        if block_given?
+          haml_tag :header, options[:header_html], &block
+        else
+          level    = options[:level] || 3
+          title    = options[:title_html].delete(:value)
+          subtitle = options[:subtitle_html].delete(:value)
+          
+          haml_tag :header, options[:header_html] do
+            if subtitle.present?
+              haml_tag :hgroup do
+                haml_tag :"h#{level}", title, options[:title_html]
+                haml_tag :"h#{level + 1}", subtitle, options[:subtitle_html]
+              end
+            else
+              haml_tag :"h#{level}", title, options[:title_html]
+            end
+          end
+        end
+      end
+    end
+    
+    def header_widget_options(options = {})
+      return {} if options[:title] == false
+      
+      header_html                       = options[:header_html] || {}
+      header_html.reverse_merge!(:class => storefront_config.header_class)
+      
+      title_html                        = options[:title_html] || {}
+      title_html.reverse_merge!(:class  => storefront_config.title_class)
+      title_html[:value]                = options.delete(:title)
+      
+      title_html[:value] = t?(title_html[:value], :scope => :"widgets.headers") if title_html[:value].is_a?(::Symbol)
+      
+      subtitle_html = options[:subtitle_html] || {}
+      if subtitle_html.present? || options[:subtitle].present?
+        subtitle_html.reverse_merge!(:class  => storefront_config.subtitle_class)
+        subtitle_html[:value]           = options.delete(:subtitle)
+        subtitle_html[:value]           = t?(subtitle_html[:value], :scope => :"widgets.headers") if subtitle_html[:value].is_a?(::Symbol)
+      end
+      
+      options.merge! :header_html => header_html, :title_html => title_html, :subtitle_html => subtitle_html
+      
+      options
+    end
+    
+    protected
+    def widget_partial(name, options = {}, &block)
       options.merge!(:yielded_content => block_given? ? capture(&block) : nil)
-      render(:partial => "shared/widgets/#{name}", :locals => options)
+      dir = name.is_a?(::Symbol) ? ::File.join(storefront_config.widgets_path, name.to_s) : name.to_s
+      render(:partial => dir, :locals => options)
+    end
+    
+    def widget_partial?(name)
+      return WIDGETS[name] if WIDGETS.has_key?(name)
+      
+      dir = name.is_a?(::Symbol) ? ::File.join(storefront_config.widgets_path, name.to_s) : name.to_s
+      
+      path = "#{Rails.root}/app/views/#{dir}"
+      
+      template = "_#{File.basename(path, File.extname(path))}"
+      
+      WIDGETS[name] = Dir.entries(File.dirname(path))[2..-1].detect do |file|
+        template == File.basename(file, File.extname(file))
+      end.present?
+      
+      WIDGETS[name]
+    end
+    
+    def widget_options(type, *args)
+      options       = args.extract_options!
+      key           = args.shift
+      
+      options[:title] ||= false
+      options[:key] ||= key
+      options[:outer_html] ||= {}
+      
+      options[:body_html] ||= {}
+      options[:footer_html] ||= {}
+      
+      unless options[:widget_class] == false
+        merge_class! options[:outer_html], *widget_classes(type)
+      end
+      
+      options
+    end
+    
+    def widget_classes(type)
+      [
+        storefront_config.widget_class,
+        type.to_s.strip.gsub(/[\s|_]+/, storefront_config.separator).squeeze(storefront_config.separator)
+      ]
     end
   end
 end

data/lib/storefront/model_helper.rb

@@ -0,0 +1,17 @@
+module Storefront
+  module ModelHelper
+    def self.included(base)
+      base.class_eval do
+        def self.to_title
+          name
+        end unless self.respond_to?(:to_title)
+        
+        def to_title
+          return title if respond_to?(:title)
+          return name if respond_to?(:name)
+          to_s
+        end unless self.instance_methods.include?(:to_title)
+      end
+    end
+  end
+end

data/lib/storefront/proxies/attribute_proxy.rb

@@ -0,0 +1,150 @@
+module Storefront
+  class AttributeProxy
+    attr_reader :name, :model, :required, :disabled, :top_level
+    
+    def initialize(options = {})
+      @name     = options[:name]
+      @model    = options[:model]
+      @required = options[:required].nil? ? model.required?(name) : options[:required]
+      @disabled = options[:disabled]
+      @top_level = options[:top_level]
+    end
+    
+    def config
+      Storefront.configuration
+    end
+    
+    def required?
+      @required
+    end
+    
+    def disabled?
+      @disabled
+    end
+    
+    def humanize
+      model.humanized_attribute_name(name)
+    end
+    
+    def errors?
+      top_level ? false : model.errors_on?(name, {})
+    end
+    
+    def value(default = nil)
+      return default if default.present?
+      return nil if top_level
+      if model.object.respond_to?(name)
+        model.object.send(name)
+      else
+        nil
+      end
+    end
+    
+    def access_key
+      name.to_s[0, 1]
+    end
+    
+    def param_for(*parts)
+      parts = parts.flatten.compact
+      parts[0].to_s + parts[1..-1].map {|i| "[#{i}]"}.join("")
+    end
+    
+    def to_id(options = {})
+      parts = []
+      parts << model.keys unless top_level
+      parts << options[:parent_index].to_s if options[:parent_index].present?
+      parts << name
+      parts << options[:index].to_s if options[:index].present?
+      parts << (options[:type] || "input").to_s
+      
+      parts.join(config.separator).underscore.strip.gsub(/[_\s]+/, config.separator)
+    end
+    
+    def to_param(options = {})
+      parts = []
+      parts << model.keys unless top_level
+      parts << options[:parent_index].to_s if options[:parent_index].present?
+      parts << name
+      parts << options[:index].to_s if options[:index].present?
+      
+      param_for(parts)
+    end
+    
+    def input_type(options = {})
+      model.default_input_type(name, options)
+    end
+    
+    def to_label
+      humanize
+    end
+    
+    def validations
+      return {} if top_level
+      
+      unless @validations.present?
+        return {} unless model.validators?
+        
+        attr_name = humanize
+        
+        kinds = []
+        
+        @validations = model.validators_on(name).inject({}) do |hash, validator|
+          key = case validator.kind
+          when :presence
+            :blank
+          when :uniqueness
+            :taken
+          when :inclusion
+            :inclusion
+          when :length
+            [:min, :max]
+          when :format
+            :invalid
+          when :numericality
+            :numericality
+          else
+            next
+          end
+          
+          kinds << validator.kind
+        
+          value = case validator.kind
+          when :presence
+            true
+          when :uniqueness
+            true
+          when :inclusion
+            Array(validator.options[:in]).compact.join(", ")
+          when :length
+            {:min => validator.options[:minimum], :max => validator.options[:maximum]}
+          when :format
+            validator.options[:with].is_a?(::Regexp) ? validator.options[:with].source : validator.options[:with].to_s
+          when :numericality
+            true
+          end
+          
+          unless validator.kind == :length
+            message                                           = model.validation_message(name, key, :attribute => attr_name)
+            
+            hash[:"data-validates-#{validator.kind}"]         = value.to_s
+            hash[:"data-validates-#{validator.kind}-message"] = message
+          else
+            key.each do |length_key|
+              next unless value[length_key].present?
+              message                                         = model.validation_message(name, length_key == :min ? :too_short : :too_long, :attribute => attr_name, :count => value[length_key])
+              
+              hash[:"data-validates-#{length_key}"]           = value[length_key].to_s
+              hash[:"data-validates-#{length_key}-message"]   = message
+            end
+          end
+          
+          hash
+        end
+        
+        @validations[:"data-validate"] = kinds.uniq.join(",") if kinds.present? && @validations.present?
+      end
+      
+      @validations
+    end
+  end
+end