storefront 0.3.2 → 0.5.0

data/lib/storefront/helpers/model_helper.rb

@@ -0,0 +1,21 @@
+module Storefront
+  module Helpers
+    module ModelHelper
+      extend ActiveSupport::Concern
+    
+      module ClassMethods
+        def to_title
+          name
+        end unless self.respond_to?(:to_title)
+      end
+    
+      module InstanceMethods
+        def to_title
+          return title if respond_to?(:title)
+          return name if respond_to?(:name)
+          to_s
+        end unless self.class.instance_methods.include?(:to_title)
+      end
+    end
+  end
+end

data/lib/storefront/helpers/request_helper.rb

@@ -1,69 +1,317 @@
 module Storefront
-  module RequestHelper
-    # requesting?(:deals)
-    # requesting?("/admin/users/:id")
-    # requesting?("admin/users#show")
-    def requesting?(expression)
-      case expression
-      when ::Symbol
-        (request.path =~ /#{expression}\/?$/).present?
-      else
-        (request.path =~ expression).present?
+  module Helpers
+    module RequestHelper
+      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
+      
+        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,
+          :context   => self
+        }
+      end
+      
+      def storefront_config
+        Storefront.configuration
+      end
+      
+      def render_not_found(exception)
+        Exceptional::Catcher.handle_with_controller(exception, self, request) if defined?(::Exceptional)
+        logger.error(exception)
+        puts exception.inspect
+        puts exception.backtrace.join("\n")
+        render :template => "/error/404.html", :status => 404, :layout => false
       end
-    end
     
-    def self.clear_session
-      before_filter { |controller| controller.session.clear }
-    end
+      # check the current browser (via user agent) for the following:
+      # :mozilla / :firefox
+      # :ie6
+      # :ie7
+      # :ie
+      # :iphone
+      # :safari
+      def browser_is? name
+        name = name.to_s.strip
+      
+        return true if browser_name == name
+        return true if (name == 'mozilla' or name == "firefox") && browser_name == 'gecko'
+        return true if name == 'ie6' && browser_name.index('ie6')
+        return true if name == 'ie7' && browser_name.index('ie7')
+        return true if name == 'ie' && browser_name.index('ie')
+        return true if name == 'iphone' && browser_name == 'iphone'
+        return true if name == 'webkit' && browser_name == 'safari'
+      
+        false
+      end
     
-    # ensure_domain :production => "site.com", :staging => "site-development.heroku.com"
-    def self.ensure_domain(options = {})
-      @ensure_domain_options = options.symbolize_keys
-      true
-    end
+      # find the current browser name
+      def browser_name
+        @browser_name ||= begin
+          ua = request.user_agent.to_s.downcase
+          if ua.index('msie') && !ua.index('opera') && !ua.index('webtv')
+            'ie'+ua[ua.index('msie')+5].chr
+          elsif ua.index('gecko/') 
+            'gecko'
+          elsif ua.index('opera')
+            'opera'
+          elsif ua.index('konqueror') 
+            'konqueror'
+          elsif ua.index('iphone')
+            'iphone'
+          elsif ua.index('applewebkit/')
+            'safari'
+          elsif ua.index('mozilla/')
+            'gecko'
+          else
+            ""
+          end
+        end
+      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 ip_address
+        request.env['REMOTE_ADDR']
+      end
     
-    def self.ensure_domain_options
-      @ensure_domain_options
-    end
+      def user_agent
+        @user_agent ||= UserAgent.parse(request.user_agent)
+      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
+      def windows?
+        # Can't match for just 'win' cause it will match darwin as well.
+        (/win32|mswin|mingw/).match(RUBY_PLATFORM) ? true : false
       end
-      if url_string =~ /^\w+:\/\//
-        url_string == "#{request.protocol}#{request.host_with_port}#{fullpath}"
-      else
-        url_string == fullpath.gsub(/&sort_by=.*/, "").gsub(/&vendor_name=.*/, "")
+
+      # Works on Debian and Ubuntu, don't have anything else to test on.
+      def linux?
+        (/linux/).match(RUBY_PLATFORM) ? true : false
+      end
+
+      # Works on my MacBook Pro, don't have anything else to test on,
+      def mac?
+        (/darwin/).match(RUBY_PLATFORM) ? true : false
       end
-    end
     
-    def with_subdomain(subdomain)  
-      subdomain = (subdomain || "")  
-      subdomain += "." unless subdomain.empty?  
-      # needs to be dynamic!
-      [subdomain, request.domain, request.port_string].join
-    end
+      # requesting?(:deals)
+      # requesting?("/admin/users/:id")
+      # requesting?("admin/users#show")
+      def requesting?(expression)
+        case expression
+        when ::Symbol
+          (request.path =~ /#{expression}\/?$/).present?
+        else
+          (request.path =~ expression).present?
+        end
+      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?  
+        # needs to be dynamic!
+        [subdomain, request.domain, 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))  
+      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
+    
+      def current_subdomain
+        subdomain = request.subdomain.to_s.split(".").first
+        subdomain = nil if subdomain == App.name
+        (subdomain.blank? || subdomain == "www") ? nil : subdomain
+      end
+    
+      def path_namespace?(*args)
+        args.present? ? args.any? { |is| path_namespace == is.to_s } : path_namespace.present?
+      end
+    
+      def path_namespace
+        if @path_namespace.nil?
+          if current_subdomain.present?
+            @path_namespace = current_subdomain
+          elsif params[:path_namespace]
+            @path_namespace = params[:path_namespace]
+          else
+            parts = params[:controller].split("/")
+            @path_namespace = parts.length > 1 ? parts.first : ""
+          end
+        end
+      
+        @path_namespace
+      end
+    
+      def with_current_params(path_method, *args)
+        send path_method, *(args << Rack::Utils.parse_query(request.query_string).merge(args.extract_options!))
+      end
+      
+      def link_to_sort(title, attribute)
+        sort_param = sort_value(attribute, opposite_sort_direction(attribute))
+        link_to title, with_params(request.path, :sort => sort_param)
+      end
+      
+      # gives you the other direction from the current, if exists
+      def opposite_sort_direction(key)
+        direction = sort_direction(key)
+        return "+" unless direction
+        direction == "+" ? "-" : "+"
+      end
+      
+      # sort_class(:name, "asc", "desc")
+      def sort_class(key, ascending = "ascending", descending = "descending", none = nil)
+        case sort_direction(key)
+        when nil
+          none
+        when "+"
+          ascending
+        when "-"
+          descending
+        end
+      end
+
+      def sort_direction(key)
+        return nil if params["sort"].blank?
+        params["sort"][key.to_s]
+      end
+      
+      def sort_hash
+        {}
+      end
+      
+      def sort_value(attribute = nil, operator = "+")
+        result = []
+        attribute = attribute.to_s
+        sort_hash.each do |key, value|
+          if attribute.present? && attribute == key
+            result << "#{key}#{operator}"
+          else
+            result << "#{key}#{value}"
+          end
+        end
+        if attribute.present? && !sort_hash.has_key?(attribute)
+          result << "#{attribute}#{operator}"
+        end
+        result.join(",")
+      end
+      
+      def with_params(*args)
+        path         = args.shift
+        new_params   = args.shift || {}
+        options      = args.shift || {}
+        params       = query_params.merge(new_params.stringify_keys)
+        params       = params.except(options[:except]) if options[:except].present?
+        params       = params.slice(options[:only]) if options[:only].present?
+        return path if params.blank?
+        query_string = ::Deli::Query.build_query(params)
+
+        "#{path}?#{query_string}"
+      end
+      
+      def link_to_sort(title, attribute)
+        sort_param = sort_value(attribute, opposite_sort_direction(attribute))
+        link_to title, with_params(request.path, :sort => sort_param)
+      end
+
+      # gives you the other direction from the current, if exists
+      def opposite_sort_direction(key)
+        direction = sort_direction(key)
+        return "+" unless direction
+        direction == "+" ? "-" : "+"
+      end
+
+      # sort_class(:name, "asc", "desc")
+      def sort_class(key, ascending = "ascending", descending = "descending", none = nil)
+        case sort_direction(key)
+        when nil
+          none
+        when "+"
+          ascending
+        when "-"
+          descending
+        end
+      end
+
+      def sort_direction(key)
+        return nil if query_params["sort"].blank?
+        key = key.to_s
+        return nil unless sort_hash.has_key?(key)
+        sort_hash[key.to_s]
+      end
+
+      def sort_hash
+        return {} if query_params["sort"].blank?
+        @sort_hash ||= deli_parser.find("sort").hash(query_params["sort"])
       end
 
-      if options.is_a?(Symbol) && options == :up
-        request.path.split("/")[0..-2].join("/")
-      else
-        super(options)
+      def sort_value(attribute = nil, operator = "+")
+        result = []
+        attribute = attribute.to_s
+        sort_hash.each do |key, value|
+          if attribute.present? && attribute == key
+            result << "#{key}#{operator}"
+          else
+            result << "#{key}#{value}"
+          end
+        end
+        if attribute.present? && !sort_hash.has_key?(attribute)
+          result << "#{attribute}#{operator}"
+        end
+        result.join(",")
       end
     end
   end

data/lib/storefront/helpers/tag_helper.rb

@@ -0,0 +1,29 @@
+module Storefront
+  module Helpers
+    # This module is a replacement for some of the common core Rails tag helper methods.  It is not included by default.
+    # 
+    # It adds a few missing features to some of the tags, so you can configure them globally.
+    # It also runs them through haml instead, so the attribute string sequence is normalized.
+    module TagHelper
+      # def link_to(title, path, options = {})
+      #   
+      # end
+      
+      # 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
+      #   
+      #   capture_haml { haml_tag :img, options }
+      # end
+    end
+  end
+end

data/lib/storefront/{proxies/attribute_proxy.rb → models/attribute.rb}

@@ -1,5 +1,5 @@
 module Storefront
-  class AttributeProxy
+  class Attribute
     attr_reader :name, :model, :required, :disabled, :top_level
     
     def initialize(options = {})

data/lib/storefront/{proxies/model_proxy.rb → models/model.rb}

@@ -1,17 +1,15 @@
-require 'ostruct'
-
 module Storefront
-  class ModelProxy
+  class Model
     class << self
       def model_names(array)
         Array(array).flatten.map do |object|
           case object
           when ::Class
-            object.ancestor_classes.map { |i| i.name.underscore }
+            (object.ancestors - object.included_modules).map { |i| i.name.underscore }
           when ::String, ::Symbol
             object
           else
-            object.class.ancestor_classes.map { |i| i.name.underscore }
+            (object.class.ancestors - object.class.included_modules).map { |i| i.name.underscore }
           end
         end.flatten.compact.uniq
       end
@@ -180,7 +178,7 @@ module Storefront
       validations = validations.select do |validation|
         (validation.options.present? ? options_require_validation?(validation.options) : true)
       end unless mode == :all
-
+      
       return validations
     end