spree_core 0.70.7 → 1.0.0.rc1

data/lib/spree/core/testing_support/factories/product_scope_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :product_scope, :class => Spree::ProductScope do
+    product_group { Factory(:product_group) }
+    name 'on_hand'
+    arguments 'some arguments'
+  end
+end

data/lib/spree/core/testing_support/factories/property_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :property, :class => Spree::Property do
+    name 'baseball_cap_color'
+    presentation 'cap color'
+  end
+end

data/lib/spree/core/testing_support/factories/prototype_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :prototype, :class => Spree::Prototype do
+    name 'Baseball Cap'
+    properties { [Factory(:property)] }
+  end
+end

data/lib/spree/core/testing_support/factories/return_authorization_factory.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :return_authorization, :class => Spree::ReturnAuthorization do
+    number '100'
+    amount 100.00
+    #order { Factory(:order) }
+    order { Factory(:order_with_inventory_unit_shipped) }
+    reason 'no particular reason'
+    state 'received'
+  end
+end

data/lib/spree/core/testing_support/factories/role_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  sequence(:role_sequence) { |n| "Role ##{n}" }
+
+  factory :role, :class => Spree::Role do
+    name { Factory.next(:role_sequence) }
+  end
+
+  factory :admin_role, :parent => :role do
+    name 'admin'
+  end
+end

data/lib/spree/core/testing_support/factories/shipment_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :shipment, :class => Spree::Shipment do
+    order { Factory(:order) }
+    shipping_method { Factory(:shipping_method) }
+    tracking 'U10000'
+    number '100'
+    cost 100.00
+    address { Factory(:address) }
+    state 'pending'
+  end
+end

data/lib/spree/core/testing_support/factories/shipping_category_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  sequence(:shipping_category_sequence) { |n| "ShippingCategory ##{n}" }
+
+  factory :shipping_category, :class => Spree::ShippingCategory do
+    name { Factory.next(:shipping_category_sequence) }
+  end
+end

data/lib/spree/core/testing_support/factories/shipping_method_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :shipping_method, :class => Spree::ShippingMethod do
+    zone { |a| Spree::Zone.find_by_name('GlobalZone') || a.association(:global_zone) }
+    name 'UPS Ground'
+    calculator { |sm| Factory(:calculator, :calculable_id => sm.object_id, :calculable_type => 'Spree::ShippingMethod') }
+  end
+
+  factory :free_shipping_method, :class => Spree::ShippingMethod do
+    zone { |a| Spree::Zone.find_by_name('GlobalZone') || a.association(:global_zone) }
+    name 'UPS Ground'
+    calculator { |sm| Factory(:no_amount_calculator, :calculable_id => sm.object_id, :calculable_type => 'Spree::ShippingMethod') }
+  end
+end

data/lib/spree/core/testing_support/factories/state_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :state, :class => Spree::State do
+    name 'Alabama'
+    abbr 'AL'
+    country do |country|
+      if usa = Spree::Country.find_by_numcode(840)
+        country = usa
+      else
+        country.association(:country)
+      end
+    end
+  end
+end

data/lib/spree/core/testing_support/factories/tax_category_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :tax_category, :class => Spree::TaxCategory do
+    name { "TaxCategory - #{rand(999999)}" }
+    description { Faker::Lorem.sentence }
+  end
+
+  factory :tax_category_with_rates, :parent => :tax_category do
+    after_create do |tax_category|
+      tax_category.tax_rates.create!(:amount => 0.05, :calculator => Spree::Calculator::DefaultTax.new,
+                                     :zone => Spree::Zone.global)
+    end
+  end
+end

data/lib/spree/core/testing_support/factories/tax_rate_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :tax_rate, :class => Spree::TaxRate do
+    zone { Factory(:zone) }
+    amount 100.00
+    tax_category { Factory(:tax_category) }
+  end
+end

data/lib/spree/core/testing_support/factories/taxon_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :taxon, :class => Spree::Taxon do
+    name 'Ruby on Rails'
+    taxonomy { Factory(:taxonomy) }
+    parent_id nil
+  end
+end

data/lib/spree/core/testing_support/factories/taxonomy_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :taxonomy, :class => Spree::Taxonomy do
+    name 'Brand'
+  end
+end

data/lib/spree/core/testing_support/factories/tracker_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :tracker, :class => Spree::Tracker do
+    environment { Rails.env }
+    analytics_id 'A100'
+    active true
+  end
+end

data/lib/spree/core/testing_support/factories/user_factory.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  sequence :user_authentication_token do |n|
+    "xxxx#{Time.now.to_i}#{rand(1000)}#{n}xxxxxxxxxxxxx"
+  end
+
+  factory :user, :class => Spree::User do
+    email { Faker::Internet.email }
+    login { email }
+    password 'secret'
+    password_confirmation 'secret'
+    authentication_token { Factory.next(:user_authentication_token) } if Spree::User.attribute_method? :authentication_token
+  end
+
+  factory :admin_user, :parent => :user do
+    roles { [Spree::Role.find_by_name('admin') || Factory(:role, :name => 'admin')]}
+  end
+end

data/lib/spree/core/testing_support/factories/variant_factory.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+  factory :variant, :class => Spree::Variant do
+    price 19.99
+    cost_price 17.00
+    sku    { Faker::Lorem.sentence }
+    weight { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    height { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    width  { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    depth  { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+
+    # associations:
+    product { |p| p.association(:product) }
+    option_values { [Factory(:option_value)] }
+  end
+end

data/lib/spree/core/testing_support/factories/zone_factory.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :global_zone, :class => Spree::Zone do
+    name 'GlobalZone'
+    description { Faker::Lorem.sentence }
+    zone_members do |proxy|
+      zone = proxy.instance_eval{@instance}
+      Spree::Country.find(:all).map{|c| Spree::ZoneMember.create({:zoneable => c, :zone => zone})}
+    end
+  end
+
+  factory :zone, :class => Spree::Zone do
+    name { Faker::Lorem.words }
+    description { Faker::Lorem.sentence }
+    zone_members { [Spree::ZoneMember.create(:zoneable => Factory(:country) )] }
+  end
+end

data/lib/spree/core/theme_support.rb

@@ -0,0 +1 @@
+require 'spree/core/theme_support/hook_listener'

data/lib/spree/core/theme_support/hook_listener.rb

@@ -0,0 +1,145 @@
+require 'deface'
+
+module Spree
+  module ThemeSupport
+
+    # This class is all deprecated and will be removed, currently being used as bridge
+    # between old style hooks and new Deface methods.
+    class HookListener
+      include Singleton
+
+      def self.replace(hook_name, options = {}, &block)
+        create_deface_override(:replace, hook_name, options, &block)
+      end
+
+      def self.insert_before(hook_name, options = {}, &block)
+        create_deface_override(:insert_before, hook_name, options, &block)
+      end
+
+      def self.insert_after(hook_name, options = {}, &block)
+        create_deface_override(:insert_after, hook_name, options, &block)
+      end
+
+      def self.insert_top(hook_name, options = {}, &block)
+        create_deface_override(:insert_top, hook_name, options, &block)
+      end
+
+      def self.insert_bottom(hook_name, options = {}, &block)
+        create_deface_override(:insert_bottom, hook_name, options, &block)
+      end
+
+      def self.remove(hook_name)
+        add_hook_modifier(hook_name, :replace)
+      end
+
+      private
+        def self.create_deface_override(target, hook_name, options, &block)
+          virtual_path = migratable_hooks.detect{|path, hooks| hooks.include? hook_name.to_sym }.try(:first)
+          return if virtual_path.nil?
+
+          if block_given?
+            action = "text"
+            content = yield
+            content.gsub!(/["]/, '\\\"')
+          else
+            if options.is_a? String
+              action = "partial"
+              content = options
+            else
+              if options.key? :partial
+                action = "partial"
+                content = options[:partial]
+              elsif options.key? :text
+                action = "text"
+                content = options[:text]
+              elsif options.key? :template
+                action = "template"
+                content = options[:template]
+              end
+            end
+          end
+          content ||= ""
+
+          override = %Q{Deface::Override.new(:virtual_path => "#{virtual_path}",
+                     :name => "converted_#{hook_name}_#{rand(1000000000)}",
+                     :#{target} => "[data-hook='#{hook_name}'], ##{hook_name}[data-hook]",
+                     :#{action} => "#{content}",
+                     :disabled => false)}
+
+          warn "[DEPRECATION] `#{target}` hook method is deprecated, replace hook call with: \n#{override}\n"
+          eval override
+        end
+
+        def self.migratable_hooks
+          {
+            'shared/_user_form' => [:signup_below_password_fields],
+            'user_registrations/new' => [:signup, :signup_inside_form, :login_extras],
+            'user_sessions/new' => [:login, :login_extras],
+            'users/show' => [:account_summary, :account_my_orders],
+            'admin/overview/index' => [:admin_dashboard, :admin_dashboard_left, :admin_dashboard_center, :admin_dashboard_right, :admin_dashboard_welcome ],
+            'admin/configurations/index' => [:admin_configurations_menu],
+            'admin/mail_methods/index' => [:admin_mail_methods_index_headers, :admin_mail_methods_index_header_actions,
+                                           :admin_mail_methods_index_rows, :admin_mail_methods_index_row_actions],
+            'admin/orders/_form' => [:admin_order_form_line_items_headers, :admin_order_form_line_items_header_actions,
+                                    :admin_order_form_subtotal, :admin_order_form_adjustments, :admin_order_form_total, :admin_order_form_buttons],
+            'admin/orders/_line_item' => [:admin_order_form_line_item_row, :admin_order_form_line_item_actions],
+            'admin/orders/edit' => [:admin_order_edit_buttons, :admin_order_edit_header, :admin_order_edit_form],
+            'admin/orders/index' => [:admin_orders_index_headers, :admin_orders_index_header_actions, :admin_orders_index_rows, :admin_orders_index_row_actions,
+                                     :admin_orders_index_search, :admin_orders_index_search_buttons],
+            'admin/orders/new' => [:admin_order_new_header, :admin_order_new_form],
+            'admin/orders/show' => [:admin_order_show_buttons, :admin_order_show_addresses, :admin_order_show_details],
+            'admin/payment_methods/index' => [:admin_payment_methods_index_headers, :admin_payment_methods_index_header_actions,
+                                              :admin_payment_methods_index_rows, :admin_payment_methods_index_row_actions],
+            'admin/product_scopes/_form' => [:admin_product_form_left, :admin_product_form_right, :admin_product_form_meta, :admin_product_form_additional_fields],
+            'admin/products/_form' => [:admin_product_form_left, :admin_product_form_right, :admin_product_form_meta, :admin_product_form_additional_fields],
+            'admin/products/index' => [:admin_products_index_headers, :admin_products_index_header_actions, :admin_products_index_rows, :admin_products_index_search,
+                                       :admin_products_index_row_actions, :admin_products_sidebar, :admin_products_index_search_buttons],
+            'spree/admin/shared/_configuration_menu' => [:admin_configurations_sidebar_menu],
+            'spree/admin/shared/_order_tabs' => [:admin_order_tabs],
+            'spree/admin/shared/_product_sub_menu' => [:admin_product_sub_tabs],
+            'spree/admin/shared/_product_tabs' => [:admin_product_tabs],
+            'admin/shipments/_form' => [:admin_shipment_form_inventory_units, :admin_shipment_form_address, :admin_shipment_form_details],
+            'admin/shipments/edit' => [:admin_shipment_edit_buttons, :admin_shipment_edit_header, :admin_shipment_edit_form, :admin_shipment_edit_form_buttons],
+            'admin/shipments/index' => [:admin_shipments_index_headers, :admin_shipments_index_header_actions, :admin_shipments_index_rows,
+                                        :admin_shipments_index_row_actions],
+            'admin/shipments/new' => [:admin_shipment_new_header, :admin_shipment_new_form, :admin_shipment_new_form_buttons],
+            'admin/shipping_methods/_form' => [:admin_shipping_method_form_fields, :admin_shipping_method_form_calculator_fields],
+            'admin/shipping_methods/edit' => [:admin_shipping_method_edit_form_header, :admin_shipping_method_edit_form, :admin_shipping_method_edit_form_buttons],
+            'admin/shipping_methods/index' => [:admin_shipping_methods_index_headers, :admin_shipping_methods_index_header_actions,
+                                               :admin_shipping_methods_index_rows, :admin_shipping_methods_index_row_actions],
+            'admin/shipping_methods/new' => [:admin_shipping_method_new_form_header, :admin_shipping_method_new_form, :admin_shipping_method_new_form_buttons],
+            'admin/taxonomies/_form' => [:admin_inside_taxonomy_form],
+            'admin/taxons/_form' => [:admin_inside_taxon_form],
+            'admin/trackers/_form' => [:additional_tracker_fields],
+            'admin/trackers/index' => [:admin_trackers_index_headers, :admin_trackers_index_rows],
+            'admin/users/_form' => [:admin_user_form_fields, :admin_user_form_roles],
+            'admin/users/edit' => [:admin_user_edit_form_header, :admin_user_edit_form, :admin_user_edit_form_button],
+            'admin/users/index' => [:admin_users_index_headers, :admin_users_index_header_actions, :admin_users_index_rows, :admin_users_index_row_actions,
+                                    :admin_users_index_search, :admin_users_index_search_buttons],
+            'admin/users/new' => [:admin_user_new_form_header, :admin_user_new_form, :admin_user_new_form_buttons],
+            'admin/variants/edit' => [:admin_variant_edit_form],
+            'admin/variants/new' => [:admin_variant_new_form],
+            'checkout/_payment' => [:checkout_payment_step, :coupon_code_field],
+            'checkout/edit' => [:checkout_summary_box],
+            'layouts/admin' => [:admin_inside_head, :admin_login_navigation_bar, :admin_tabs, :admin_footer_scripts],
+            'layouts/spree_application' => [:inside_head, :sidebar],
+            'orders/_form' => [:cart_items_headers],
+            'orders/_line_item' => [:cart_item_image, :cart_item_description, :cart_item_price, :cart_item_quantity, :cart_item_total, :cart_item_delete],
+            'orders/edit' => [:empty_cart, :outside_cart_form, :inside_cart_form, :cart_items],
+            'products/_cart_form' => [:inside_product_cart_form, :product_price],
+            'products/_taxons' => [:product_taxons],
+            'products/index' => [:homepage_sidebar_navigation, :search_results, :homepage_products],
+            'products/show' => [:product_images, :product_description, :product_properties, :cart_form],
+            'shared/_basic_layout' => [:sidebar],
+            'shared/_products' => [:products_list_item],
+            'shared/_footer' => [:footer_left, :footer_right],
+            'shared/_nav_bar' => [:shared_login_bar],
+            'shared/_order_details' => [:order_details_line_items_headers, :order_details_line_item_row, :order_details_subtotal, :order_details_adjustments,
+                                       :order_details_total],
+            'taxons/show' => [:taxon_sidebar_navigation, :taxon_products, :taxon_children]
+          }
+        end
+    end
+
+  end
+end

data/lib/spree/core/version.rb

@@ -0,0 +1,5 @@
+module Spree
+  def self.version
+    "1.0.0.rc1"
+  end
+end

data/lib/spree/product_filters.rb

@@ -0,0 +1,186 @@
+module Spree
+  # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+  #   the exact code probably won't be useful, though you're welcome to modify and reuse
+  #   the current contents are mainly for testing and documentation
+
+  # To override this file...
+  #   1) Make a copy of it in your sites local /lib folder
+  #   2) Add it to the config load path, or require it in an initializer, e.g...
+  #      
+  #      # config/initializers/spree.rb
+  #      require 'product_filters'
+  #
+
+  # set up some basic filters for use with products
+  #
+  # Each filter has two parts
+  #  * a parametrized named scope which expects a list of labels
+  #  * an object which describes/defines the filter
+  #
+  # The filter description has three components
+  #  * a name, for displaying on pages
+  #  * a named scope which will 'execute' the filter
+  #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+  #  * an optional list of labels and values (for use with object selection - see taxons examples below)
+  #
+  # The named scopes here have a suffix '_any', following SearchLogic's convention for a
+  # scope which returns results which match any of the inputs. This is purely a convention,
+  # but might be a useful reminder.
+  #
+  # When creating a form, the name of the checkbox group for a filter F should be
+  # the name of F's scope with [] appended, eg "price_range_any[]", and for
+  # each label you should have a checkbox with the label as its value. On submission,
+  # Rails will send the action a hash containing (among other things) an array named
+  # after the scope whose values are the active labels.
+  #
+  # SearchLogic will then convert this array to a call to the named scope with the array
+  # contents, and the named scope will build a query with the disjunction of the conditions
+  # relating to the labels, all relative to the scope's context.
+  #
+  # The details of how/when filters are used is a detail for specific models (eg products
+  # or taxons), eg see the taxon model/controller.
+
+  # See specific filters below for concrete examples.
+
+  # This module is included by Taxon. In development mode that inclusion does not
+  # happen until Taxon class is loaded. Ensure that Taxon class is loaded before
+  # you try something like Product.price_range_any
+  module ProductFilters
+
+    # Example: filtering by price
+    #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+    #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+    #     we can access the field right away
+    #   The filter identifies which scope to use, then sets the conditions for each price range
+    #
+    # If user checks off three different price ranges then the argument passed to
+    # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+    #
+    Spree::Product.scope :price_range_any,
+      lambda {|*opts|
+        conds = opts.map {|o| Spree::ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+        Spree::Product.scoped(:joins => :master).conditions_any(conds)
+      }
+
+    def ProductFilters.price_filter
+      conds = [ [ "Under $10",    "price             <= 10" ],
+                [ "$10 - $15",    "price between 10 and 15" ],
+                [ "$15 - $18",    "price between 15 and 18" ],
+                [ "$18 - $20",    "price between 18 and 20" ],
+                [ "$20 or over",  "price             >= 20" ] ]
+      { :name   => "Price Range",
+        :scope  => :price_range_any,
+        :conds  => Hash[*conds.flatten],
+        :labels => conds.map {|k,v| [k,k]}
+      }
+    end
+
+
+    # Example: filtering by possible brands
+    #
+    # First, we define the scope. Two interesting points here: (a) we run our conditions
+    #   in the scope where the info for the 'brand' property has been loaded; and (b)
+    #   because we may want to filter by other properties too, we give this part of the
+    #   query a unique name (which must be used in the associated conditions too).
+    #
+    # Secondly, the filter. Instead of a static list of values, we pull out all existing
+    #   brands from the db, and then build conditions which test for string equality on
+    #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+    #   being blank: note that this relies on with_property doing a left outer join
+    #   rather than an inner join.
+
+    if Spree::Property.table_exists? && @@brand_property = Spree::Property.find_by_name("brand")
+      Spree::Product.scope :brand_any,
+        lambda {|*opts|
+          conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?}
+          Spree::Product.with_property("brand").conditions_any(conds)
+        }
+
+      def ProductFilters.brand_filter
+        brands = Spree::ProductProperty.where(:property_id => @@brand_property).map(&:value).compact.uniq
+        conds  = Hash[*brands.map {|b| [b, "#{Spree::ProductProperty.table_name}.value = '#{b}'"]}.flatten]
+        { :name   => "Brands",
+          :scope  => :brand_any,
+          :conds  => conds,
+          :labels => (brands.sort).map {|k| [k,k]}
+        }
+      end
+    end
+
+    # Example: a parameterized filter
+    #   The filter above may show brands which aren't applicable to the current taxon,
+    #   so this one only shows the brands that are relevant to a particular taxon and
+    #   its descendants.
+    #
+    #   We don't have to give a new scope since the conditions here are a subset of the
+    #   more general filter, so decoding will still work - as long as the filters on a
+    #   page all have unique names (ie, you can't use the two brand filters together
+    #   if they use the same scope). To be safe, the code uses a copy of the scope.
+    #
+    #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+    #   parametrized scope names to SearchLogic, only atomic names, so couldn't ask
+    #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+    #   to pass back a hash instead of an array, where the key acts as the (taxon)
+    #   parameter and value is its label array, and then get a modified named scope
+    #   to get its conditions from a particular filter.
+    #
+    #   The brand-finding code can be simplified if a few more named scopes were added to
+    #   the product properties model.
+    if Spree::Property.table_exists? && @@brand_property
+      Spree::Product.scope :selective_brand_any, lambda {|opts| Spree::Product.brand_any(opts) }
+
+      def ProductFilters.selective_brand_filter(taxon = nil)
+        if taxon.nil?
+          taxon = Spree::Taxonomy.first.root
+        end
+        all_brands = Spree::ProductProperty.where(:property_id => @@brand_property).map(&:value).uniq
+        scope = Spree::ProductProperty.scoped(:conditions => ["property_id = ?", @@brand_property]).
+                                       scoped(:joins      => {:product => :taxons},
+                                              :conditions => ["#{Spree::Taxon.table_name}.id in (?)", [taxon] + taxon.descendants])
+        brands = scope.map {|p| p.value}
+
+        { :name   => "Applicable Brands",
+          :scope  => :selective_brand_any,
+          :conds  => Hash[*all_brands.map {|m| [m, "p_colour.value like '%#{m}%'"]}.flatten],
+          :labels => brands.sort.map {|k| [k,k]}
+        }
+      end
+    end
+
+    # Provide filtering on the immediate children of a taxon
+    #
+    # This doesn't fit the pattern of the examples above, so there's a few changes.
+    # Firstly, it uses an existing scope which was not built for filtering - and so
+    # has no need of a conditions mapping, and secondly, it has a mapping of name
+    # to the argument type expected by the other scope.
+    #
+    # This technique is useful for filtering on objects (by passing ids) or with a
+    # scope that can be used directly (eg. testing only ever on a single property).
+    #
+    # This scope selects products in any of the active taxons or their children.
+    #
+    def ProductFilters.taxons_below(taxon)
+      return Spree::ProductFilters.all_taxons if taxon.nil?
+      { :name   => "Taxons under " + taxon.name,
+        :scope  => :taxons_id_in_tree_any,
+        :labels => taxon.children.sort_by(&:position).map {|t| [t.name, t.id]},
+        :conds  => nil
+      }
+    end
+
+    # Filtering by the list of all taxons
+    #
+    # Similar idea as above, but we don't want the descendants' products, hence
+    # it uses one of the auto-generated scopes from SearchLogic.
+    #
+    # idea: expand the format to allow nesting of labels?
+    def ProductFilters.all_taxons
+      taxons = Spree::Taxonomy.all.map {|t| [t.root] + t.root.descendants }.flatten
+      { :name   => "All taxons",
+        :scope  => :taxons_id_equals_any,
+        :labels => taxons.sort_by(&:name).map {|t| [t.name, t.id]},
+        :conds  => nil # not needed
+      }
+    end
+  end
+end