spree_core 0.70.7 → 1.0.0.rc1

data/app/controllers/spree/content_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  class ContentController < BaseController
+    # Don't serve local files or static assets
+    before_filter { render_404 if params[:path] =~ /(\.|\\)/ }
+
+    rescue_from ActionView::MissingTemplate, :with => :render_404
+    caches_page :show, :index, :if => Proc.new { Spree::Config[:cache_static_content] }
+
+    respond_to :html
+
+    def show
+      respond_with do |format|
+        format.html { render :action => params[:path] }
+      end
+    end
+
+    def cvv
+      respond_with do |format|
+        format.html {  render 'cvv', :layout => false }
+      end
+    end
+  end
+end

data/app/controllers/spree/home_controller.rb

@@ -0,0 +1,12 @@
+module Spree
+  class HomeController < BaseController
+    helper 'spree/products'
+    respond_to :html
+
+    def index
+      @searcher = Spree::Config.searcher_class.new(params)
+      @products = @searcher.retrieve_products
+      respond_with(@products)
+    end
+  end
+end

data/app/controllers/spree/locale_controller.rb

@@ -0,0 +1,16 @@
+module Spree
+  class LocaleController < BaseController
+    def set
+      if request.referer && request.referer.starts_with?('http://' + request.host)
+        session['user_return_to'] = request.referer
+      end
+      if params[:locale] && I18n.available_locales.include?(params[:locale].to_sym)
+        session[:locale] = I18n.locale = params[:locale].to_sym
+        flash.notice = t(:locale_changed)
+      else
+        flash[:error] = t(:locale_not_changed)
+      end
+      redirect_back_or_default(root_path)
+    end
+  end
+end

data/app/controllers/spree/orders_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  class OrdersController < BaseController
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/products'
+
+    respond_to :html
+
+    def show
+      @order = Order.find_by_number!(params[:id])
+      respond_with(@order)
+    end
+
+    def update
+      @order = current_order
+      if @order.update_attributes(params[:order])
+        @order.line_items = @order.line_items.select {|li| li.quantity > 0 }
+        fire_event('spree.order.contents_changed')
+        respond_with(@order) { |format| format.html { redirect_to cart_path } }
+      else
+        respond_with(@order)
+      end
+    end
+
+    # Shows the current incomplete order from the session
+    def edit
+      @order = current_order(true)
+    end
+
+    # Adds a new item to the order (creating a new order if none already exists)
+    #
+    # Parameters can be passed using the following possible parameter configurations:
+    #
+    # * Single variant/quantity pairing
+    # +:variants => {variant_id => quantity}+
+    #
+    # * Multiple products at once
+    # +:products => {product_id => variant_id, product_id => variant_id}, :quantity => quantity +
+    # +:products => {product_id => variant_id, product_id => variant_id}}, :quantity => {variant_id => quantity, variant_id => quantity}+
+    def populate
+      @order = current_order(true)
+
+      params[:products].each do |product_id,variant_id|
+        quantity = params[:quantity].to_i if !params[:quantity].is_a?(Hash)
+        quantity = params[:quantity][variant_id.to_i].to_i if params[:quantity].is_a?(Hash)
+        @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+      end if params[:products]
+
+      params[:variants].each do |variant_id, quantity|
+        quantity = quantity.to_i
+        @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+      end if params[:variants]
+
+      fire_event('spree.cart.add')
+      fire_event('spree.order.contents_changed')
+      respond_with(@order) { |format| format.html { redirect_to cart_path } }
+    end
+
+    def empty
+      if @order = current_order
+        @order.line_items.destroy_all
+      end
+
+      redirect_to spree.cart_path
+    end
+
+    def accurate_titles
+      @order && @order.completed? ? "#{Order.model_name.human} #{@order.number}" : t(:shopping_cart)
+    end
+  end
+end

data/app/controllers/spree/products_controller.rb

@@ -0,0 +1,36 @@
+module Spree
+  class ProductsController < BaseController
+    HTTP_REFERER_REGEXP = /^https?:\/\/[^\/]+\/t\/([a-z0-9\-\/]+)$/
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/taxons'
+
+    respond_to :html
+
+    def index
+      @searcher = Spree::Config.searcher_class.new(params)
+      @products = @searcher.retrieve_products
+      respond_with(@products)
+    end
+
+    def show
+      @product = Product.find_by_permalink!(params[:id])
+      return unless @product
+
+      @variants = Variant.active.includes([:option_values, :images]).where(:product_id => @product.id)
+      @product_properties = ProductProperty.includes(:property).where(:product_id => @product.id)
+
+      referer = request.env['HTTP_REFERER']
+
+      if referer && referer.match(HTTP_REFERER_REGEXP)
+        @taxon = Taxon.find_by_permalink($1)
+      end
+
+      respond_with(@product)
+    end
+
+    private
+      def accurate_title
+        @product ? @product.name : super
+      end
+  end
+end

data/app/controllers/spree/states_controller.rb

@@ -0,0 +1,16 @@
+module Spree
+  class StatesController < BaseController
+    ssl_allowed :index
+
+    def index
+      # table of {country.id => [ state.id , state.name ]}, arrays sorted by name
+      # blank is added elsewhere, if needed
+      # we return ALL known information, since billing country isn't restricted
+      #   by shipping country
+      @state_info = Hash.new { |h, k| h[k] = [] }
+      Spree::State.order('name ASC').each { |state|
+        @state_info[state.country_id.to_s].push [state.id, state.name]
+      }
+    end
+  end
+end

data/app/controllers/spree/taxons_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  class TaxonsController < BaseController
+    rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+    helper 'spree/products'
+
+    respond_to :html
+
+    def show
+      @taxon = Taxon.find_by_permalink!(params[:id])
+      return unless @taxon
+
+      @searcher = Spree::Config.searcher_class.new(params.merge(:taxon => @taxon.id))
+      @products = @searcher.retrieve_products
+
+      respond_with(@taxon)
+    end
+
+    private
+      def accurate_title
+        @taxon ? @taxon.name : super
+      end
+  end
+end

data/app/helpers/spree/account_helper.rb

@@ -0,0 +1,4 @@
+module Spree
+  module AccountHelper
+  end
+end

data/app/helpers/spree/admin/base_helper.rb

@@ -0,0 +1,206 @@
+module Spree
+  module Admin
+    module BaseHelper
+      def field_container(model, method, options = {}, &block)
+        css_classes = options[:class].to_a
+        if error_message_on(model, method).present?
+          css_classes << 'withError'
+        end
+        content_tag('p', capture(&block), :class => css_classes.join(' '), :id => "#{model}_#{method}_field")
+      end
+
+      def error_message_on(object, method, options = {})
+        object = convert_to_model(object)
+        obj = object.respond_to?(:errors) ? object : instance_variable_get("@#{object}")
+
+        if obj && obj.errors[method].present?
+          errors = obj.errors[method].map { |err| h(err) }.join('<br />').html_safe
+          content_tag(:span, errors, :class => 'formError')
+        else
+          ''
+        end
+      end
+
+      def class_for_error(model, method)
+        if error_message_on :product, :name
+        end
+      end
+
+      #You can add additional_fields to the product and variant models. See section 4.2 here: http://spreecommerce.com/documentation/extensions.html
+      #If you do choose to add additional_fields, you can utilize the :use parameter to set the input type for any such fields. For example, :use => 'check_box'
+      #In the event that you add this functionality, the following method takes care of rendering the proper input type and logic for the supported input-types, which are text_field, check_box, radio_button, and select.
+      def get_additional_field_value(controller, field)
+        attribute = attribute_name_for(field[:name])
+
+        value = eval("@" + controller.controller_name.singularize + "." + attribute)
+
+        if value.nil? && controller.controller_name == "variants"
+          value = @variant.product.has_attribute?(attribute) ? @variant.product[attribute] : nil
+        end
+
+        if value.nil?
+          return value
+        else
+          return field.key?(:format) ? sprintf(field[:format], value) : value
+        end
+      end
+
+      # This method demonstrates the use of the :child_index option to render a
+      # form partial for, for instance, client side addition of new nested
+      # records.
+      #
+      # This specific example creates a link which uses javascript to add a new
+      # form partial to the DOM.
+      #
+      #   <%= form_for @project do |project_form| %>
+      #     <div id="tasks">
+      #       <%= project_form.fields_for :tasks do |task_form| %>
+      #         <%= render :partial => 'task', :locals => { :f => task_form } %>
+      #       <% end %>
+      #     </div>
+      #   <% end %>
+      def generate_html(form_builder, method, options = {})
+        options[:object] ||= form_builder.object.class.reflect_on_association(method).klass.new
+        options[:partial] ||= method.to_s.singularize
+        options[:form_builder_local] ||= :f
+
+        form_builder.fields_for(method, options[:object], :child_index => 'NEW_RECORD') do |f|
+          render(:partial => options[:partial], :locals => { options[:form_builder_local] => f })
+        end
+
+      end
+
+      def generate_template(form_builder, method, options = {})
+        escape_javascript generate_html(form_builder, method, options)
+      end
+
+      def remove_nested(fields)
+        out = ''
+        out << fields.hidden_field(:_destroy) unless fields.object.new_record?
+        out << (link_to icon('delete'), "#", :class => 'remove')
+        out.html_safe
+      end
+
+      def preference_field_tag(name, value, options)
+        case options[:type]
+        when :integer
+          text_field_tag(name, value, preference_field_options(options))
+        when :boolean
+          hidden_field_tag(name, 0) +
+          check_box_tag(name, 1, value, preference_field_options(options))
+        when :string
+          text_field_tag(name, value, preference_field_options(options))
+        when :password
+          password_field_tag(name, value, preference_field_options(options))
+        when :text
+          text_area_tag(name, value, preference_field_options(options))
+        else
+          text_field_tag(name, value, preference_field_options(options))
+        end
+      end
+
+      def preference_field_for(form, field, options)
+        case options[:type]
+        when :integer
+          form.text_field(field, preference_field_options(options))
+        when :boolean
+          form.check_box(field, preference_field_options(options))
+        when :string
+          form.text_field(field, preference_field_options(options))
+        when :password
+          form.password_field(field, preference_field_options(options))
+        when :text
+          form.text_area(field, preference_field_options(options))
+        else
+          form.text_field(field, preference_field_options(options))
+        end
+      end
+
+      def preference_field_options(options)
+        field_options = case options[:type]
+        when :integer
+          { :size => 10,
+            :class => 'input_integer' }
+        when :boolean
+          {}
+        when :string
+          { :size => 10,
+            :class => 'input_string' }
+        when :password
+          { :size => 10,
+            :class => 'password_string' }
+        when :text
+          { :rows => 15,
+            :cols => 85 }
+        else
+          { :size => 10,
+            :class => 'input_string' }
+        end
+
+        field_options.merge!({
+          :readonly => options[:readonly],
+          :disabled => options[:disabled]
+        })
+      end
+
+      def preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+        object.preferences.keys.map{ |key|
+
+          form.label("preferred_#{key}", t(key) + ": ") +
+            preference_field_for(form, "preferred_#{key}", :type => object.preference_type(key))
+
+        }.join("<br />").html_safe
+      end
+
+      def additional_field_for(controller, field)
+         field[:use] ||= 'text_field'
+         options = field[:options] || {}
+
+         object_name, method = controller.controller_name.singularize, attribute_name_for(field[:name])
+
+         case field[:use]
+         when 'check_box'
+           check_box(object_name, method, options, field[:checked_value] || 1, field[:unchecked_value] || 0)
+         when 'radio_button'
+           html = ''
+           field[:value].call(controller, field).each do |value|
+             html << radio_button(object_name, method, value, options)
+             html << " #{value.to_s} "
+           end
+           html
+         when 'select'
+           select(object_name, method, field[:value].call(controller, field), options, field[:html_options] || {})
+         else
+           value = field[:value] ? field[:value].call(controller, field) : get_additional_field_value(controller, field)
+           __send__(field[:use], object_name, method, options.merge(:value => value))
+         end # case
+       end
+
+      def product_picker_field(name, value)
+        products = Product.with_ids(value)
+        product_names_hash = products.inject({}){|memo,item| memo[item.id] = item.name; memo}
+        %(<input type="text" name="#{name}" value="#{value}" class="tokeninput products" data-names='#{product_names_hash.to_json}' />).html_safe
+      end
+
+      # renders set of hidden fields and button to add new record using nested_attributes
+      def link_to_add_fields(name, append_to_selector, f, association)
+        new_object = f.object.class.reflect_on_association(association).klass.new
+        fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|
+          render(association.to_s.singularize + "_fields", :f => builder)
+        end
+        link_to_function(name, raw("add_fields(\"#{append_to_selector}\", \"#{association}\", \"#{escape_javascript(fields)}\")"), :class => 'add_fields')
+      end
+
+      # renders hidden field and link to remove record using nested_attributes
+      def link_to_remove_fields(name, f)
+        f.hidden_field(:_destroy) + link_to_with_icon(:delete, name, '#', :class => 'remove_fields')
+      end
+
+      private
+        def attribute_name_for(field_name)
+          field_name.gsub(' ', '_').downcase
+        end
+    end
+  end
+end

data/app/helpers/spree/admin/inventory_settings_helper.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    module InventorySettingsHelper
+      def show_not(true_or_false)
+        true_or_false ? '' : t(:not)
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/navigation_helper.rb

@@ -0,0 +1,173 @@
+module Spree
+  module Admin
+    module NavigationHelper
+      # Make an admin tab that coveres one or more resources supplied by symbols
+      # Option hash may follow. Valid options are
+      #   * :label to override link text, otherwise based on the first resource name (translated)
+      #   * :route to override automatically determining the default route
+      #   * :match_path as an alternative way to control when the tab is active, /products would match /admin/products, /admin/products/5/variants etc.
+      def tab(*args)
+        options = {:label => args.first.to_s}
+        if args.last.is_a?(Hash)
+          options = options.merge(args.pop)
+        end
+        options[:route] ||=  "admin_#{args.first}"
+
+        destination_url = options[:url] || spree.send("#{options[:route]}_path")
+
+        titleized_label = t(options[:label], :default => options[:label]).titleize
+
+        link = link_to(titleized_label, destination_url)
+
+        css_classes = []
+
+        selected = if options[:match_path]
+          request.fullpath.starts_with?("/admin#{options[:match_path]}")
+        else
+          args.include?(controller.controller_name.to_sym)
+        end
+        css_classes << 'selected' if selected
+
+        if options[:css_class]
+          css_classes << options[:css_class]
+        end
+        content_tag('li', link, :class => css_classes.join(' '))
+      end
+
+      def link_to_clone(resource, options={})
+        link_to_with_icon('exclamation', t(:clone), clone_admin_product_url(resource), options)
+      end
+
+      def link_to_new(resource)
+        link_to_with_icon('add', t(:new), edit_object_url(resource))
+      end
+
+      def link_to_edit(resource, options={})
+        link_to_with_icon('edit', t(:edit), edit_object_url(resource), options)
+      end
+
+      def link_to_edit_url(url, options={})
+        link_to_with_icon('edit', t(:edit), url, options)
+      end
+
+      def link_to_clone(resource, options={})
+        link_to_with_icon('exclamation', t(:clone), clone_admin_product_url(resource), options)
+      end
+
+      def link_to_delete(resource, options = {}, html_options={})
+        options.assert_valid_keys(:url, :caption, :title, :dataType, :success, :name)
+
+        options.reverse_merge! :url => object_url(resource) unless options.key? :url
+        options.reverse_merge! :caption => t(:are_you_sure)
+        options.reverse_merge! :title => t(:confirm_delete)
+        options.reverse_merge! :dataType => 'script'
+        options.reverse_merge! :success => "function(r){ $('##{dom_id resource}').fadeOut('hide'); }"
+        options.reverse_merge! :name => icon('delete') + ' ' + t(:delete)
+
+        link_to_function_delete(options, html_options)
+        #link_to_function_delete_native(options, html_options)
+      end
+
+      # this function does not use jConfirm
+      def link_to_function_delete_native(options, html_options)
+        fn = %Q{
+          var answer = confirm("#{t(:are_you_sure)}");
+          if (!!answer) { #{link_to_function_delete_ajax(options)} };
+        }
+        link_to_function options[:name], fn, html_options
+      end
+
+      def link_to_function_delete(options, html_options)
+        link_to_function options[:name], "jConfirm('#{options[:caption]}', '#{options[:title]}', function(r) {
+          if(r){ #{link_to_function_delete_ajax(options)} }
+        });", html_options
+      end
+
+      def link_to_function_delete_ajax(options)
+        %Q{
+          $.ajax({
+            type: 'POST',
+            url: '#{options[:url]}',
+            data: ({_method: 'delete', authenticity_token: AUTH_TOKEN}),
+            dataType:'#{options[:dataType]}',
+            success: #{options[:success]}
+          });
+        }
+      end
+
+      def link_to_with_icon(icon_name, text, url, options = {})
+        options[:class] = (options[:class].to_s + ' icon_link').strip
+        link_to(icon(icon_name) + ' ' + text, url, options)
+      end
+
+      def icon(icon_name)
+        icon_name ? image_tag("admin/icons/#{icon_name}.png") : ''
+      end
+
+      def button(text, icon_name = nil, button_type = 'submit', options={})
+        content_tag('button', content_tag('span', icon(icon_name) + ' ' + text), options.merge(:type => button_type))
+      end
+
+      def button_link_to(text, url, html_options = {})
+        if (html_options[:method] &&
+            html_options[:method].to_s.downcase != 'get' &&
+            !html_options[:remote])
+          form_tag(url, :method => html_options[:method]) do
+            button(text, html_options[:icon])
+          end
+        else
+          if html_options['data-update'].nil? && html_options[:remote]
+            object_name, action = url.split('/')[-2..-1]
+            html_options['data-update'] = [action, object_name.singularize].join('_')
+          end
+          html_options.delete('data-update') unless html_options['data-update']
+          link_to(text_for_button_link(text, html_options), url, html_options_for_button_link(html_options))
+        end
+      end
+
+      def button_link_to_function(text, function, html_options = {})
+        link_to_function(text_for_button_link(text, html_options), function, html_options_for_button_link(html_options))
+      end
+
+      # RAILS 3 TODO - no longer needed
+      # def button_link_to_remote(text, url, html_options = {})
+      #   html_options.reverse_merge! :remote => true
+      #   link_to(text_for_button_link(text, html_options), url, html_options_for_button_link(html_options))
+      # end
+      #
+      # def link_to_remote(name, options = {}, html_options = {})
+      #   options[:before] ||= "jQuery(this).parent().hide(); jQuery('#busy_indicator').show();"
+      #   options[:complete] ||= "jQuery('#busy_indicator').hide()"
+      #   link_to_function(name, remote_function(options), html_options || options.delete(:html))
+      # end
+
+      def text_for_button_link(text, html_options)
+        s = ''
+        if html_options[:icon]
+          s << icon(html_options.delete(:icon)) + ' '
+        end
+        s << text
+        content_tag('span', raw(s))
+      end
+
+      def html_options_for_button_link(html_options)
+        options = { :class => 'button' }.update(html_options)
+      end
+
+      def configurations_menu_item(link_text, url, description = '')
+        %(<tr>
+          <td>#{link_to(link_text, url)}</td>
+          <td>#{description}</td>
+        </tr>
+        ).html_safe
+      end
+
+      def configurations_sidebar_menu_item(link_text, url, options = {})
+        options.merge!(:class => url.include?(controller.controller_name) ? 'active' : nil)
+        content_tag(:li, options) do
+          link_to(link_text, url)
+        end
+      end
+    end
+  end
+end