trollied 0.1.0

data/test/full_2_3_5_app_with_tests/test/unit/helpers/gets_trollied_helper_test.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class GetsTrolliedHelperTest < ActionView::TestCase
+  include HasTrolleyControllerHelpers::UrlFor
+
+  context "Helpers for stuff that gets trollied" do
+    setup do
+      @item = Factory.create(:item, :label => "a label")
+
+      @form_fragment = "form method=\"post\" action=\"/items/1/line_items\""
+      @input_fragment = "input type=\"submit\" value=\"+ Add to cart\""
+      
+      def current_user
+        @current_user ||= User.first || Factory.create(:user)
+      end
+    end
+
+    should "provide button_to_place_in_trolley that returns a form to add to cart for passed in purchasable_item" do
+      assert_has_button_in(button_to_place_in_trolley(@item))
+    end
+
+    should "provide in_trolley_status_or_button_to_place_in_trolley that returns a form to add to cart for passed in purchasable_item when the item hasn't been added yet" do
+      assert_has_button_in(in_trolley_status_or_button_to_place_in_trolley(@item))
+    end
+
+    context "should provide in_trolley_status_or_button_to_place_in_trolley that" do 
+      setup do
+        @trolley = current_user.trolley
+        @trolley.add(@item)
+      end
+
+      should "return a statement that item is in user's trolley for passed in purchasable_item when has previously been added" do
+        value = in_trolley_status_or_button_to_place_in_trolley(@item)
+
+        assert value.include?("<div class=\"in-trolley\">" +
+                              t('gets_trollied_helper.in_trolley') +
+                              "</div>")
+
+        assert_does_not_have_button_in(value)
+      end
+
+      context "when passed in purchasable_item has previously been added, but order has been checked out" do
+        setup do
+          @order = @trolley.selected_order
+          @order.checkout!
+        end
+
+        should "return a statement that item is in user's trolley " do
+          value = in_trolley_status_or_button_to_place_in_trolley(@item)
+          assert_does_not_have_button_in(value)
+        end
+
+        should "return add to cart after the order has been moved to another state besides in_process" do
+          @order.cancel!
+          assert_has_button_in(in_trolley_status_or_button_to_place_in_trolley(@item))
+        end
+      end
+    end
+
+  end
+
+  private
+
+  def assert_has_button_in(value)
+    assert value.include?(@form_fragment) &&
+      value.include?(@input_fragment)
+  end
+
+  def assert_does_not_have_button_in(value)
+    assert !value.include?(@form_fragment) &&
+      !value.include?(@input_fragment)
+  end
+
+end

data/test/full_2_3_5_app_with_tests/test/unit/helpers/orders_helper_test.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class OrdersHelperTest < ActionView::TestCase
+  context "Helpers for orders" do
+
+    should "respond to button_to event method for an order for all possible events" do
+      Order.workflow_event_names.each do |event_name|
+        assert respond_to?("button_to_#{event_name}")
+      end
+    end
+
+    should "have show_count_for method that takes a number and returns formatted string" do
+      assert_equal ' (2)', show_count_for(2)
+    end
+
+    should "have state_links that returns a list of links to order states" do
+      @order1 = Factory.create(:order)
+      @order1.checkout!
+
+      @order2 = Factory.create(:order)
+      @order2.checkout!
+      @order2.cancel!
+
+      @order3 = Factory.create(:order)
+
+      @state = 'in_process' # default
+
+      html = "<ul id=\"state-links\" class=\"horizontal-list\"><li class=\"state-link first\">#{I18n.t('orders.index.in_process')} (1)</li><li class=\"state-link\"><a href=\"/orders?state=cancelled\">#{I18n.t('orders.index.cancelled')} (1)</a></li><li class=\"state-link\"><a href=\"/orders?state=current\">#{I18n.t('orders.index.current')} (1)</a></li></ul>"
+
+      assert_equal html, state_links
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/test/unit/line_item_test.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class LineItemTest < ActiveSupport::TestCase
+  context "A line_item" do
+    setup do
+      @item = Factory.create(:item)
+
+      @order = Factory.create(:order)
+      
+      @order.add(@item)
+
+      @line_item = @order.line_items.first
+    end
+
+    should "have a user through its order's user" do
+      assert_equal @order.user, @line_item.user
+    end
+
+    should "have a  description_for_purchasing method" do
+      assert_respond_to @line_item, :description_for_purchasing
+    end
+
+    should "return the purchasable_item's purchase_description as delegated" do
+      assert_equal @item.description_for_purchasing, @line_item.description_for_purchasing
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/test/unit/note_test.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class NoteTest < ActiveSupport::TestCase
+  context "A note" do
+    setup do
+      @order = Factory.create(:order)
+    end
+
+    should "be able to be created for an order" do
+      assert_nothing_raised { @order.notes.create!(:body => "a test note", :user => User.first) }
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/test/unit/order_test.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class OrderTest < ActiveSupport::TestCase
+  context "An order" do
+    setup do
+      @item = Factory.create(:item)
+      @order = Factory.create(:order)
+    end
+
+    context "class" do
+
+      context "have a named scope 'in' that takes a state as an argument" do
+        should "return all orders if 'all' is the special case argument" do
+          assert_equal @order, Order.in('all').first
+          @order.checkout!
+          assert_equal @order, Order.in('all').first
+        end
+
+        should "return orders in that state" do
+          @order.checkout!
+          assert_equal @order, Order.in('in_process').first
+        end
+      end
+    end
+
+    should "have a user through its trolley's user" do
+      assert_equal @order.trolley.user, @order.user
+    end
+
+    # test that we have integration with the workflow gem
+    should "have a workflow_state and the default is current" do
+      assert_equal 'current', @order.workflow_state
+    end
+
+    should "have a current_state" do
+      assert @order.respond_to?(:current_state)
+    end
+
+    should "transition to in_process when checked out" do
+      @order.checkout!
+      # assert @order.ordered?
+      assert @order.in_process?
+    end
+
+    context "after adding an item to it" do
+      setup do
+        @order.add(@item)
+      end
+
+      should "create a line_item with the item" do
+        assert_purchasable_item_matches
+      end
+
+      should "return true when it contains an item" do
+        assert @order.contains?(@item)
+      end
+    end
+
+    should "return false when it does not contain an item" do
+      assert @order.contains?(@item) == false
+    end
+
+  end
+end

data/test/full_2_3_5_app_with_tests/test/unit/trolley_test.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class TrolleyTest < ActiveSupport::TestCase
+  context "A trolley" do
+    setup do
+      @item = Factory.create(:item)
+      @trolley = Factory.create(:trolley)
+    end
+    
+    context "when having an item placed in it" do
+      setup do
+        @trolley.add(@item)
+        @order = @trolley.selected_order
+      end
+
+      should "result in an order with a line_item for that item" do
+        assert_purchasable_item_matches
+      end
+
+      should "answer true for contains? method" do
+        assert @trolley.contains?(@item)
+      end
+
+      should "return true for has_active_order_for? purchasable_item" do
+        assert @trolley.has_active_order_for?(@item)
+      end
+
+      context "and the item has already been placed in trolley, but first order has been checked out" do 
+        setup do
+          @order.checkout!
+        end
+
+        should "answer false for contains? method when current state specified" do
+          assert @trolley.contains?(@item, :current) == false
+        end
+
+        should "answer true for contains? method when the item is in order with a given state" do
+          assert @trolley.contains?(@item, :in_process)
+        end
+
+        should "have correct_order be an order that is current, not in_process order" do
+          correct_order = @trolley.correct_order(@item)
+          assert correct_order != @order
+          assert correct_order.current?
+        end
+
+        should "return true for has_active_order_for? purchasable_item" do
+          assert @trolley.has_active_order_for?(@item)
+        end
+
+        context "and the order is then moved from in_process" do
+          should "return false for has_active_order_for? purchasable_item" do
+            @order.cancel!
+            assert !@trolley.has_active_order_for?(@item)
+          end
+        end
+
+      end
+
+    end
+
+    context "when an item is not in a trolley" do
+      should "answer false for contains? method" do
+        assert @trolley.contains?(@item) == false
+      end
+
+      should "answer false for contains? method even if there is an order for the trolley" do
+        @trolley.selected_order
+        
+        assert @trolley.contains?(@item) == false
+      end
+
+      should "return false for has_active_order_for? purchasable_item" do
+        assert !@trolley.has_active_order_for?(@item)
+      end
+    end
+
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/init.rb

@@ -0,0 +1 @@
+require 'routing_filter'

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/base.rb

@@ -0,0 +1,31 @@
+module RoutingFilter
+  class Base
+    class_inheritable_accessor :active
+    self.active = true
+
+    attr_accessor :chain, :options
+
+    def initialize(options = {})
+      @options = options
+      options.each { |name, value| instance_variable_set :"@#{name}", value }
+    end
+
+    def run(method, *args, &block)
+      _next = successor ? lambda { successor.run(method, *args, &block) } : block
+      active ? send(method, *args, &_next) : _next.call(*args)
+    end
+
+    def run_reverse(method, *args, &block)
+      _prev = predecessor ? lambda { predecessor.run(method, *args, &block) } : block
+      active ? send(method, *args, &_prev) : _prev.call(*args)
+    end
+
+    def predecessor
+      @chain.predecessor(self)
+    end
+
+    def successor
+      @chain.successor(self)
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/force_extension.rb

@@ -0,0 +1,57 @@
+require 'routing_filter/base'
+
+module RoutingFilter
+  class ForceExtension < Base
+    attr_reader :extension, :exclude
+
+    def initialize(*args)
+      super
+      @extension ||= 'html'
+      @exclude = %r(^(http.?://[^/]+)?\/?$) if @exclude.nil?
+    end
+
+    def around_recognize(path, env, &block)
+      extract_extension!(path) unless excluded?(path)
+      yield(path, env)
+    end
+
+    def around_generate(*args, &block)
+      returning yield do |result|
+        url = result.is_a?(Array) ? result.first : result
+        append_extension!(url) if append_extension?(url)
+      end
+    end
+
+    protected
+
+      def extract_extension!(path)
+        path.sub! /\.#{extension}$/, ''
+        $1
+      end
+      
+      def append_extension?(url)
+        !(url.blank? || excluded?(url) || mime_extension?(url))
+      end
+      
+      def excluded?(url)
+        case exclude
+        when Regexp
+          url =~ exclude
+        when Proc
+          exclude.call(url)
+        end
+      end
+      
+      def mime_extension?(url)
+        url =~ /\.#{Mime::EXTENSION_LOOKUP.keys.join('|')}(\?|$)/
+      end
+      
+      def append_extension!(url)
+        url.replace url.sub(/(\?|$)/, ".#{extension}\\1")
+      end
+
+      def append_page!(url, page)
+        url.replace "#{url}/pages/#{page}"
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/locale.rb

@@ -0,0 +1,70 @@
+require 'i18n'
+require 'routing_filter/base'
+
+module RoutingFilter
+  class Locale < Base
+    @@include_default_locale = true
+    cattr_writer :include_default_locale
+
+    class << self
+      def include_default_locale?
+        @@include_default_locale
+      end
+
+      def locales
+        @@locales ||= I18n.available_locales.map(&:to_sym)
+      end
+
+      def locales=(locales)
+        @@locales = locales.map(&:to_sym)
+      end
+
+      def locales_pattern
+        @@locales_pattern ||= %r(^/(#{self.locales.map { |l| Regexp.escape(l.to_s) }.join('|')})(?=/|$))
+      end
+    end
+
+    def around_recognize(path, env, &block)
+      locale = extract_locale!(path)                 # remove the locale from the beginning of the path
+      returning yield do |params|                    # invoke the given block (calls more filters and finally routing)
+        params[:locale] = locale if locale           # set recognized locale to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      locale = args.extract_options!.delete(:locale) # extract the passed :locale option
+      locale = I18n.locale if locale.nil?            # default to I18n.locale when locale is nil (could also be false)
+      locale = nil unless valid_locale?(locale)      # reset to no locale when locale is not valid
+
+      returning yield do |result|
+        if locale && prepend_locale?(locale)
+          url = result.is_a?(Array) ? result.first : result
+          prepend_locale!(url, locale)
+        end
+      end
+    end
+
+    protected
+
+      def extract_locale!(path)
+        path.sub! self.class.locales_pattern, ''
+        $1
+      end
+
+      def prepend_locale?(locale)
+        self.class.include_default_locale? || !default_locale?(locale)
+      end
+
+      def valid_locale?(locale)
+        locale && self.class.locales.include?(locale.to_sym)
+      end
+
+      def default_locale?(locale)
+        locale && locale.to_sym == I18n.default_locale.to_sym
+      end
+
+      def prepend_locale!(url, locale)
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{locale}#{$2}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/pagination.rb

@@ -0,0 +1,33 @@
+require 'routing_filter/base'
+
+module RoutingFilter
+  class Pagination < Base
+    def around_recognize(path, env, &block)
+      page = extract_page!(path)
+      returning yield(path, env) do |params|
+        params[:page] = page.to_i if page
+      end
+    end
+
+    def around_generate(*args, &block)
+      page = args.extract_options!.delete(:page)
+      returning yield do |result|
+        if page && page != 1
+          url = result.is_a?(Array) ? result.first : result
+          append_page!(url, page)
+        end
+      end
+    end
+
+    protected
+
+      def extract_page!(path)
+        path.sub! %r(/pages/([\d]+)/?$), ''
+        $1
+      end
+
+      def append_page!(url, page)
+        url.sub!(/($|\?)/) { "/pages/#{page}#{$1}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/uuid_token.rb

@@ -0,0 +1,78 @@
+# This is a routing filter that extracts UUIDs from urls and exposes them via
+# params[:uuid_token]
+#
+# URL scheme: http://example.com/d00fbbd1-82b6-4c1a-a57d-098d529d6854/your_route
+#
+# To enable this filter add map.filter :uuid_token to your routes.rb
+# 
+# To make your restful path helpers use this :uuid_token use:
+# new_post_path(:uuid_token => params[:uuid_token])
+#
+# If don't want to pass the :uuid_token manually you can add a custom module
+# like this to your RAILS_ROOT/lib directory:
+#
+#   module AccessToken
+#     
+#     class << self
+#       def current=(token)
+#         Thread.current[:uuid_token] = token
+#       end
+#       
+#       def current
+#         Thread.current[:uuid_token] ||= ""
+#       end
+#     end
+#     
+#   end
+#
+# Now in your application_controller you can set a before_filter which sets that
+# token for every request:
+# 
+#   before_filter :set_token
+#   
+#   protected
+#   
+#     def set_token
+#       AccessToken.current = params[:uuid_token] if params[:uuid_token]
+#     end
+#
+# As you can see below in the around_generate method, if you don't provide a 
+# :uuid_token argument for your restful path helpers it will try to get the
+# current :uuid_token from the AccessToken module.
+
+require 'routing_filter/base'
+
+module RoutingFilter
+  class UuidToken < Base
+
+    def around_recognize(path, env, &block)
+      token = extract_token!(path)                              # remove the token from the beginning of the path
+      returning yield do |params|                               # invoke the given block (calls more filters and finally routing)
+        params[:uuid_token] = token if token                    # set recognized token to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      token = args.extract_options!.delete(:uuid_token)         # extract the passed :token option
+      token = AccessToken.current if AccessToken && token.nil?  # default to AccessToken.current when token is nil (could also be false)
+
+      returning yield do |result|
+        if token
+          url = result.is_a?(Array) ? result.first : result
+          prepend_token!(url, token)
+        end
+      end
+    end
+
+    protected
+
+      def extract_token!(path)
+        path.sub! /([a-z\d]{8}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{12})\//, ''
+        $1
+      end
+
+      def prepend_token!(url, token)
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{token}#{$2}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter.rb

@@ -0,0 +1,94 @@
+module RoutingFilter
+  mattr_accessor :active
+  @@active = true
+
+  class Chain < Array
+    def << (filter)
+      filter.chain = self
+      super
+    end
+
+    def run(method, *args, &final)
+      RoutingFilter.active && !first.nil? ? first.run(method, *args, &final) : final.call
+    end
+
+    def run_reverse(method, *args, &final)
+      RoutingFilter.active && !last.nil? ? last.run_reverse(method, *args, &final) : final.call
+    end
+
+    def predecessor(filter)
+      ix = index(filter)
+      ix > 0 ? self[ix - 1] : nil
+    end
+
+    def successor(filter)
+      ix = index(filter)
+      ix < length - 1 ? self[ix + 1] : nil
+    end
+  end
+end
+
+# allows to install a filter to the route set by calling: map.filter 'locale'
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  def filter(name, options = {})
+    require options.delete(:file) || "routing_filter/#{name}"
+    klass = RoutingFilter.const_get(name.to_s.camelize)
+    @set.filters << klass.new(options)
+  end
+end
+
+# same here for the optimized url generation in named routes
+ActionController::Routing::RouteSet::NamedRouteCollection.class_eval do
+  # gosh. monkey engineering optimization code
+  def generate_optimisation_block_with_filtering(*args)
+    code = generate_optimisation_block_without_filtering(*args)
+    if match = code.match(%r(^return (.*) if (.*)))
+      # returned string must not contain newlines, or we'll spill out of inline code comments in
+      # ActionController::Routing::RouteSet::NamedRouteCollection#define_url_helper
+      "returning(#{match[1]}) { |result|" +
+      "  ActionController::Routing::Routes.filters.run_reverse(:around_generate, *args, &lambda{ result }) " +
+      "} if #{match[2]}"
+    end
+  end
+  alias_method_chain :generate_optimisation_block, :filtering
+end
+
+ActionController::Routing::RouteSet.class_eval do
+  def clear_with_filtering!
+    @filters.clear if @filters
+    clear_without_filtering!
+  end
+  alias_method_chain :clear!, :filtering
+
+  attr_writer :filters
+
+  def filters
+    @filters ||= RoutingFilter::Chain.new
+  end
+
+  def recognize_path_with_filtering(path, env = {})
+    path = ::URI.unescape(path.dup) # string is frozen due to memoize
+    filters.run(:around_recognize, path, env, &lambda{ recognize_path_without_filtering(path, env) })
+  end
+  alias_method_chain :recognize_path, :filtering
+
+  def generate_with_filtering(*args)
+    filters.run_reverse(:around_generate, args.first, &lambda{ generate_without_filtering(*args) })
+  end
+  alias_method_chain :generate, :filtering
+
+  # add some useful information to the request environment
+  # right, this is from jamis buck's excellent article about routes internals
+  # http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2
+  # TODO move this ... where?
+  alias_method :extract_request_environment_without_host, :extract_request_environment unless method_defined? :extract_request_environment_without_host
+  def extract_request_environment(request)
+    returning extract_request_environment_without_host(request) do |env|
+      env.merge! :host => request.host,
+                 :port => request.port,
+                 :host_with_port => request.host_with_port,
+                 :domain => request.domain,
+                 :subdomain => request.subdomains.first
+    end
+  end
+end