storefront 0.2.0

data/lib/storefront/helpers/image_helper.rb

@@ -0,0 +1,54 @@
+module Storefront
+  module ImageHelper
+    def image_tag(source, options = {})
+      options.symbolize_keys!
+
+      src = options[:src] = path_to_image(source)
+
+      unless src =~ /^cid:/
+        options[:alt] = options.fetch(:alt) { File.basename(src, '.*').gsub(/-\d+$/, "").gsub("-", " ").humanize }
+      end
+
+      if size = options.delete(:size)
+        options[:width], options[:height] = size.split("x") if size =~ %{^\d+x\d+$}
+      end
+      
+      if mouseover = options.delete(:mouseover)
+        options[:onmouseover] = "this.src='#{path_to_image(mouseover)}'"
+        options[:onmouseout]  = "this.src='#{src}'"
+      end
+
+      tag("img", options)
+    end
+
+    def load_logo(parent, size = "small", link = nil, lightbox = true)
+      if parent && parent.logo_id.present?
+        path = parent.logo.url(size.to_s) rescue nil
+      end
+
+      if path.blank?
+        path  = "/images/vendors/no-logo.png"
+        alt   = "No logo"
+      else
+        alt   = "Logo for #{parent.is_a?(::Group) ? parent.name : parent.vendor_name}"
+      end
+
+      if parent && parent.logo
+        path << "?#{parent.logo.updated_at.to_i}"
+      end
+      if link
+        # , :width => 74, :height => 74
+        clazz = lightbox == true ? 'fancy-ajax logo' : 'logo'
+        link_to [content_tag(:span), image_tag(path, :class =>  "photo", :alt => alt, :title => alt)].join("").html_safe, link, :class => clazz, :"data-deal-id" => parent.id, :"data-ajax" => "false"
+      else
+        image_tag(path)
+      end
+    end
+
+    # http://snippets.dzone.com/posts/show/805
+    def read_image_size(path)
+      width, height = IO.read("#{Rails.root}/public/images/#{path}")[0x10..0x18].unpack('NN')
+      {:width => width, :height => height}
+    end
+  end
+end

data/lib/storefront/helpers/list_helper.rb

@@ -0,0 +1,47 @@
+module Storefront
+  module ListHelper
+    def nav(key, path = nil, attributes = {}, &block)
+      condition = extract_condition!(attributes)
+      return if condition == false
+      text      = widget_text(key, :nav)
+      if attributes.has_key?(:current)
+        current = attributes.delete(:current) == true
+      else
+        current = on_current_page?(path)
+      end
+      li_class  = "primary-navigation-item"
+      if current
+        li_class  << " active"
+        attributes[:class] = [attributes[:class], "active"].compact.uniq.join(" ")
+      end
+      as = attributes.delete(:as) || :span
+      li_class  << " #{attributes.delete(:li_class)}" if attributes[:li_class]
+      li_class  = li_class.present? ? {:class => li_class} : nil
+      separator = attributes.delete(:separator)
+      checkbox  = attributes.delete(:checkbox) == true
+      result    = capture_haml do
+        haml_tag :li, li_class do
+          if checkbox
+            haml_tag :label, text.strip
+            haml_tag :input, :type => "checkbox"
+          else
+            if block_given?
+              case block.arity
+              when 1
+                yield(text.strip)
+              else
+                yield
+              end
+            elsif current && as == :span
+              haml_tag :span, text.strip, attributes
+            else
+              haml_concat link_to(text.strip, path, attributes)
+            end
+          end
+          haml_tag :span, separator if separator
+        end
+      end
+      result
+    end
+  end
+end

data/lib/storefront/helpers/locale_helper.rb

@@ -0,0 +1,175 @@
+module Storefront
+  module LocaleHelper
+    # t!(:"what.summary", :scope => :"reports.titles", :model => deal)
+    def t?(key, options = {})
+      return key if key.is_a?(::String)
+      model_names = options[:model_names]
+      model_names ||= options[:model].present? ? options[:model].class.ancestor_classes.map { |i| i.name.underscore } : []
+      allow_blank = options.delete(:allow_blank) == true
+
+      keys        = [key.to_s]
+      if options[:try].present?
+        keys += Array(options[:default]).map do |extra_key|
+          "#{key}.#{extra_key}"
+        end
+      end
+
+      count       = options.delete(:count)
+      # none, one, many, other
+      count_key   = count != 1 ? :other : :one
+
+      if options.has_key?(:present) || options.has_key?(:past) || options.has_key?(:future)
+        if options[:future] == true
+          tense_key = :future
+        else
+          tense_key = (options.delete(:present) == true || options.delete(:past) == false) ? :present : :past
+        end
+      else
+        tense_key = nil
+      end
+
+      defaults    = []
+
+      keys.each do |key|
+        model_names.each do |model_name|
+          path      = '{{model}}.{{key}}'
+          path.gsub!('{{model}}', model_name)
+          path.gsub!('{{key}}', key)
+          path.gsub!('..', '.')
+          defaults << path
+        end
+
+        path        = '{{key}}'
+        path.gsub!('{{key}}', key)
+        path.gsub!('..', '.')
+        defaults << path
+      end
+
+      defaults.map!(&:to_sym)
+      defaults << ''
+
+      value       = I18n.t(defaults.shift, options.merge(:default => defaults))
+
+      if value.is_a?(::Hash)
+        if value.has_key?(count_key)
+          value = value[count_key]
+        elsif value.has_key?(tense_key)
+          value = value[tense_key]
+          if value.is_a?(::Hash) && value.has_key?(count_key)
+            value = value[count_key]
+          end
+        elsif value.has_key?(count_key)
+          value = value[count_key]
+        end
+      end
+
+      if value.is_a?(::Hash)
+        if value.has_key?(:one)
+          value = value[:one]
+        end
+      end
+
+      if value.is_a?(::Hash)
+        if value.has_key?(:present)
+          value = value[:present]
+        elsif value.has_key?(:past)
+          value = value[:past]
+        elsif value.has_key?(:future)
+          value = value[:future]
+        end
+      end
+
+      value.blank? && !allow_blank ? key.to_s.split(".").last.titleize : value
+    end
+
+    # interpolate_hash(report, :scope => "reports", :begins_at_level => 3, :keys => {:bookmark => :selected})
+    def interpolate_hash(hash, options = {})
+      result = {}
+      hash.each do |key, value|
+        result[key.to_sym] = _interpolate_hash(key, value, {}, options)
+      end
+      result
+    end
+
+    protected
+    # This:
+    #     {
+    #       :who => {
+    #         :title => "Who",
+    #         :subtitle => "again?",
+    #         :averages => {
+    #           :title => "Averages",
+    #           :first_time => {
+    #             :title => "First Time",
+    #             :value => 10
+    #           }
+    #         },
+    #         :best => {
+    #           :location => {
+    #             :key   => "work",
+    #             :value => 80.0
+    #           }
+    #         }
+    #       }
+    #     }
+    #
+    # becomes...
+    # 
+    #     {
+    #       :who => {
+    #         :title    => "Who",
+    #         :subtitle => "again?",
+    #         :averages => {
+    #           :title => "Averages",
+    #           :first_time => {
+    #             :title => "First Time",
+    #             :value => 10.0
+    #           }
+    #         },
+    #         :best => {
+    #           :title => "Most Popular"
+    #           :location => {
+    #             :title => "Location",
+    #             :value => "Work (80%)"
+    #           }
+    #         }
+    #       }
+    #     }
+    #
+    # who.summary.title.past
+    # who.summary.title
+    # who.summary.past
+    # who.summary
+    def _interpolate_hash(key, object, result, options = {})
+      return object unless object.is_a?(::Hash)
+      key               = key.to_s
+      title             = object[:title] || object[:label]
+      subtitle          = object[:subtitle]
+      
+      title             = t!(:"#{key}", options.merge(:try => :title))
+      title             = key.to_s.split(".").last.titleize if title.blank? || title.is_a?(::Hash)
+      subtitle          = t!(:"#{key}.subtitle", options.merge(:allow_blank => true))
+
+      # everything has to have a title
+      result[:title]    = title
+
+      # not everything has to have a subtitle
+      result[:subtitle] = subtitle if subtitle.present?
+
+      # it's a leaf if we're at this point!
+      if object.has_key?(:value)
+        result[:value]  = object[:value]
+      else
+        object.each do |child_key, child_value|
+          if child_value.is_a?(::Hash)
+            result[child_key.to_sym] = _interpolate_hash("#{key}.#{child_key}", child_value, {}, options)
+          else
+            result[child_key.to_sym] = child_value
+          end
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/storefront/helpers/open_graph_helper.rb

@@ -0,0 +1,5 @@
+module Storefront
+  module OpenGraphHelper
+    
+  end
+end

data/lib/storefront/helpers/page_helper.rb

@@ -0,0 +1,73 @@
+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)
+      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"
+        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
+    end
+
+    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
+      end
+      result
+    end
+  end
+end

data/lib/storefront/helpers/presenter_helper.rb

@@ -0,0 +1,5 @@
+module Storefront
+  module PresenterHelper
+    
+  end
+end

data/lib/storefront/helpers/request_helper.rb

@@ -0,0 +1,66 @@
+module Storefront
+  module RequestHelper
+    def requesting?(expression)
+      case expression
+      when ::Symbol
+        (request.path =~ /#{expression}\/?$/).present?
+      else
+        (request.path =~ expression).present?
+      end
+    end
+    
+    def self.clear_session
+      before_filter { |controller| controller.session.clear }
+    end
+    
+    # ensure_domain :production => "site.com", :staging => "site-development.heroku.com"
+    def self.ensure_domain(options = {})
+      @ensure_domain_options = options.symbolize_keys
+      true
+    end
+    
+    def ensure_domain
+      domain = self.class.ensure_domain_options[Rails.env.to_sym]
+      return true if domain.blank?
+      redirect_to(request.protocol + domain + request.request_uri) if request.env['HTTP_HOST'] != domain
+      true
+    end
+    
+    def self.ensure_domain_options
+      @ensure_domain_options
+    end
+    
+    def on_current_page?(options)
+      url_string = CGI.unescapeHTML(url_for(options))
+      request = controller.request
+      if url_string.index("?")
+        fullpath = request.fullpath
+      else
+        fullpath = request.fullpath.split('?').first
+      end
+      if url_string =~ /^\w+:\/\//
+        url_string == "#{request.protocol}#{request.host_with_port}#{fullpath}"
+      else
+        url_string == fullpath.gsub(/&sort_by=.*/, "").gsub(/&vendor_name=.*/, "")
+      end
+    end
+    
+    def with_subdomain(subdomain)  
+      subdomain = (subdomain || "")  
+      subdomain += "." unless subdomain.empty?  
+      [subdomain, request.domain(2), request.port_string].join  
+    end
+
+    def url_for(options = {})
+      if options.kind_of?(Hash) && options.has_key?(:subdomain)  
+        options[:host] = with_subdomain(options.delete(:subdomain))  
+      end
+
+      if options.is_a?(Symbol) && options == :up
+        request.path.split("/")[0..-2].join("/")
+      else
+        super(options)
+      end
+    end
+  end
+end

data/lib/storefront/helpers/semantic/location_helper.rb

@@ -0,0 +1,18 @@
+module Storefront
+  module Semantic
+    module LocationHelper
+      def semantic_geo_tag(lat, lng, options = {})
+        capture_haml do
+          haml_tag :span, :itemprop => "geo", :itemtype => "http://data-vocabulary.org/Geo" do
+            haml_tag :span, :itemprop => "latitude" do
+              haml_tag :span, lat, :class => "value-title"
+            end
+            haml_tag :span, :itemprop => "longitude" do
+              haml_tag :span, lng, :class => "value-title"
+            end
+          end
+        end
+      end
+    end
+  end
+end