<%= singular_name %>.new_record? ? "New" : "Edit" %> <%= model_name %>
-<%% form_for(@<%= singular_name %>) do |f| %> -
- <%%= f.error_messages %>
-
- <%- if attributes.blank? -%>
- Add your form elements here, please!
- <%- else -%> - <%- attributes.each do |attribute| -%> -
- <%%= f.label :<%= attribute.name %> %>
- <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
-
- <%%= submit_tag "Save" %>
-
-
-<%% end -%>
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html.haml b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html.haml
deleted file mode 100644
index d97eabb9..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html.haml
+++ /dev/null
@@ -1,18 +0,0 @@
-%h1== #{@<%= singular_name %>.new_record? ? "New" : "Edit"} #{<%= model_name %>}
-- form_for @<%= singular_name %> do |f|
- #form_errors= f.error_messages
-<% if attributes.blank? -%>
- %p Add your form elements here, please!
-<% else -%>
- <%- attributes.each do |attribute| -%>
- %p
- = f.label :<%= attribute.name %>
- = f.<%= attribute.field_type %> :<%= attribute.name %>
- <%- end -%>
-<% end -%>
- #commands
- = submit_tag "Save"
-#navigation_commands
- - unless @<%= singular_name %>.new_record?
- = button_to "Show", <%= singular_name %>_path(@<%= singular_name %>), :method => "get", :title => "Show <%= singular_name %>. Unsaved changes will be lost."
- = button_to "Back to List", <%= plural_name %>_path, :class => "cancel", :method => "get", :title => "Return to <%= singular_name %> list without saving changes"
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html_spec.rb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html_spec.rb
deleted file mode 100644
index bc6f6f24..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/form.html_spec.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../../spec_helper'
-
-describe "<%= File.join(controller_class_path, controller_singular_name) %>/form.html.<%= template_language %>" do
- before(:each) do
- @<%= singular_name %> = mock_and_assign(<%= model_name %>, :stub => {
-<% if attributes.blank? -%>
- # Add your stub attributes and return values here like:
- # :name => "Foo", :address => "815 Oceanic Drive"
-<% else -%>
- <%- attributes.each_with_index do |attribute, index| -%>
- <%- case attribute.type when :string, :text -%>
- :<%= attribute.name %> => "foo"<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :integer, :float, :decimal -%>
- :<%= attribute.name %> => 815<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :boolean -%>
- :<%= attribute.name %> => false<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :date, :datetime, :time, :timestamp -%>
- :<%= attribute.name %> => 1.week.ago<%= index < attributes.size - 1 ? "," : "" %>
- <%- else -%>
- :<%= attribute.name %> => nil<%= index < attributes.size - 1 ? "," : "" %> # Could not determine valid attribute
- <%- end -%>
- <%- end -%>
-<% end -%>
- })
- end
-
- it_should_have_form_for :<%= singular_name %>
-<% if attributes.blank? -%>
- # Add specs for editing attributes here, please! Like this:
- #
- # it_should_allow_editing :<%= singular_name %>, :foo
-<% else -%>
- <%- attributes.each do |attribute| -%>
- it_should_allow_editing :<%= singular_name %>, :<%= attribute.name %>
- <%- end -%>
-<% end -%>
-
- it_should_link_to_show :<%= singular_name %>
- it_should_link_to { <%= plural_name %>_path }
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper.rb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper.rb
deleted file mode 100644
index 9bd821b1..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-module <%= controller_class_name %>Helper
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper_spec.rb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper_spec.rb
deleted file mode 100644
index 6a34ca2a..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/helper_spec.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../spec_helper'
-
-describe <%= controller_class_name %>Helper do
- # Add your specs here or remove this file completely, please!
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.erb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.erb
deleted file mode 100644
index 318f94e3..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.erb
+++ /dev/null
@@ -1,31 +0,0 @@
-<%= model_name %> List
-| There are no <%= plural_name.humanize.downcase %> | -||||
| - <%- else -%> - <%- attributes.each do |attribute| -%> - | <%= attribute.name.titleize %> | - <%- end -%> - <%- end -%> -- | - | - |
|---|
- <%%= button_to "New <%= singular_name.titleize %>", new_<%= singular_name %>_path, :method => "get" %>
-
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.haml b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.haml
deleted file mode 100644
index b0c78b28..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html.haml
+++ /dev/null
@@ -1,23 +0,0 @@
-%h1 <%= model_name %> List
-%table
- - if @<%= plural_name %>.empty?
- %tbody
- %tr.empty
- %td== There are no <%= plural_name.humanize.downcase %>
- - else
- %thead
- %tr
-<% if attributes.blank? -%>
- %th= # Generic display column
-<% else -%>
- <%- attributes.each do |attribute| -%>
- %th <%= attribute.name.titleize %>
- <%- end -%>
-<% end -%>
- %th.show= # 'Show' link column
- %th.edit= # 'Edit' link column
- %th.delete= # 'Delete' link column
- %tbody
- = render :partial => @<%= plural_name %>
-#commands
- = button_to "New <%= singular_name.titleize %>", new_<%= singular_name %>_path, :method => "get"
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html_spec.rb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html_spec.rb
deleted file mode 100644
index cfe213f5..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index.html_spec.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../../spec_helper'
-
-describe "<%= File.join(controller_class_path, controller_singular_name) %>/index.html.<%= template_language %>" do
- before(:each) do
- @<%= plural_name %> = mock_and_assign_collection(<%= model_name %>)
- template.stub! :render
- end
-
- it "should render :partial => @<%= plural_name %>" do
- template.should_receive(:render).with(:partial => @<%= plural_name %>)
- do_render
- end
-
- it_should_link_to_new :<%= singular_name %>
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index_partial.html.erb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index_partial.html.erb
deleted file mode 100644
index ecdca836..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/index_partial.html.erb
+++ /dev/null
@@ -1,12 +0,0 @@
-Show <%= model_name %>
-<% if attributes.blank? -%> -Add your customized markup here, please!
-<% else -%> - <%- attributes.each do |attribute| -%> -- - <%%=h @<%= singular_name %>.<%= attribute.name %> %> -
- <%- end -%> -<% end -%> -
- <%%= button_to "Edit", edit_<%= singular_name %>_path(@<%= singular_name %>), :method => "get" %>
- <%%= button_to "Back to List", <%= plural_name %>_path, :method => "get" %>
-
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html.haml b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html.haml
deleted file mode 100644
index d8afe80a..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html.haml
+++ /dev/null
@@ -1,13 +0,0 @@
-%h1== Show #{<%= model_name %>}
-<% if attributes.blank? -%>
-%p Add your customized markup here, please!
-<% else -%>
- <%- attributes.each do |attribute| -%>
-%p
- %label <%= attribute.name.titleize %>:
- =h @<%= singular_name %>.<%= attribute.name %>
- <%- end -%>
-<% end -%>
-#commands
- = button_to "Edit", edit_<%= singular_name %>_path(@<%= singular_name %>), :method => "get"
- = button_to "Back to List", <%= plural_name %>_path, :method => "get"
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html_spec.rb b/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html_spec.rb
deleted file mode 100644
index aefbbe17..00000000
--- a/backup.rails2.3/plugins/skinny_spec/generators/skinny_scaffold/templates/show.html_spec.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../../spec_helper'
-
-describe "<%= File.join(controller_class_path, controller_singular_name) %>/show.html.<%= template_language %>" do
- before(:each) do
-<% if attributes.blank? -%>
- @<%= singular_name %> = mock_and_assign(<%= model_name %>)
-<% else -%>
- @<%= singular_name %> = mock_and_assign(<%= model_name %>, :stub => {
- <%- attributes.each_with_index do |attribute, index| -%>
- <%- case attribute.type when :string, :text -%>
- :<%= attribute.name %> => "foo"<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :integer, :float, :decimal -%>
- :<%= attribute.name %> => 815<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :boolean -%>
- :<%= attribute.name %> => false<%= index < attributes.size - 1 ? "," : "" %>
- <%- when :date, :datetime, :time, :timestamp -%>
- :<%= attribute.name %> => 1.week.ago<%= index < attributes.size - 1 ? "," : "" %>
- <%- else -%>
- :<%= attribute.name %> => nil<%= index < attributes.size - 1 ? "," : "" %>
- <%- end -%>
- <%- end -%>
- })
-<% end -%>
- end
-
- # Add your specs here, please! But remember not to make them brittle
- # by specing specing specific HTML elements and classes.
-
- it_should_link_to_edit :<%= singular_name %>
- it_should_link_to { <%= plural_name %>_path }
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/common_spec_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/common_spec_helpers.rb
deleted file mode 100644
index 0a7acff3..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/common_spec_helpers.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-module LuckySneaks
- # These methods are mostly just called internally by various other spec helper
- # methods but you're welcome to use them as needed in your own specs.
- module CommonSpecHelpers
- # Stubs out Time.now and returns value to use when comparing it. Example:
- #
- # time_now = stub_time_now
- # @foo.some_method_that_resets_updated_at
- # @foo.updated_at.should == time_now
- def stub_time_now
- returning Time.now do |now|
- Time.stub!(:now).and_return(now)
- end
- end
-
- # Returns class for the specified name. Example:
- #
- # class_for("foo") # => Foo
- def class_for(name)
- name.to_s.constantize
- rescue NameError
- name.to_s.pluralize.classify.constantize
- # Let any other error rise!
- end
-
- # Returns instance variable for the specified name. Example:
- #
- # instance_for("foo") # => @foo
- def instance_for(name)
- instance_variable_get("@#{name.to_s.underscore}")
- end
-
- # Wraps a matcher that checks if the receiver contains an A element (link)
- # whose href attribute is set to the specified path.
- def have_link_to(path)
- have_tag("a[href='#{path}']")
- end
-
- # Returns dummy value for specified attribute based on the datatype expected for that
- # attribute.
- def dummy_value_for(instance, attribute)
- if datatype = instance.column_for_attribute(attribute)
- actual = instance.send(attribute)
- case datatype.type
- when :string, :text
- actual == "foo" ? "bar" : "food"
- when :integer, :float, :decimal
- actual == 108 ? 815 : 108
- when :boolean
- actual ? false : true
- when :date, :datetime, :time, :timestamp
- actual == 1.week.ago ? 2.years.ago : 1.week.ago
- end
- end
- end
-
- # Returns class description text
- def class_description_text
- if self.class.respond_to?(:description_text)
- # Old school
- self.class.description_text
- else
- # New school
- self.class.description
- end
- end
-
- # Returns description text
- def self_description_text
- if respond_to?(:description_text)
- # Old school
- description_text
- else
- # New school
- description
- end
- end
-
- def described_type
- self.class.described_type
- end
- end
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_request_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_request_helpers.rb
deleted file mode 100644
index 4aeffaf4..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_request_helpers.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-module LuckySneaks
- module ControllerRequestHelpers # :nodoc:
- def self.included(base)
- base.extend ExampleGroupMethods
- end
-
- private
- def define_implicit_request(method)
- @controller_method = method
- @implicit_request = case method
- when :index, :new, :show, :edit
- proc { get method, params }
- when :create
- proc { post :create, params }
- when :update
- proc { put :update, params }
- when :destroy
- proc { put :destroy, params }
- end
- end
-
- def eval_request
- instance_eval &self.class.instance_variable_get("@the_request")
- rescue ArgumentError # missing block
- try_shared_request_definition
- end
- alias do_request eval_request
-
- def try_shared_request_definition
- if defined?(shared_request) == "method"
- shared_request
- elsif @implicit_request
- try_implicit_request
- else
- error_message = "Could not determine request definition for 'describe' context. "
- error_message << "Please use define_request or define a shared_request."
- raise ArgumentError, error_message
- end
- end
-
- def try_implicit_request
- @implicit_request.call
- end
-
- def get_response(&block)
- eval_request
- block.call(response) if block_given?
- response
- end
-
- module ExampleGroupMethods
- # Defines a request at the example group ("describe") level to be evaluated in the examples. Example:
- #
- # define_request { get :index, params }
- #
- # Note: The following methods all define implicit requests: stub_index, stub_new,
- # stub_create, stub_show, stub_edit, stub_update, and
- # stub_destroy. Using them in your before blocks will allow you to forego
- # defining explicit requests using define_request. See
- # LuckySneaks::ControllerStubHelpers for information on these methods.
- def define_request(&block)
- raise ArgumentError, "Must provide a block to define a request!" unless block_given?
- @the_request = block
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_spec_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_spec_helpers.rb
deleted file mode 100644
index 20bca87e..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_spec_helpers.rb
+++ /dev/null
@@ -1,571 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..")
-require "skinny_spec"
-
-module LuckySneaks
- module ControllerSpecHelpers # :nodoc:
- include LuckySneaks::CommonSpecHelpers
- include LuckySneaks::ControllerRequestHelpers
- include LuckySneaks::ControllerStubHelpers
-
- def self.included(base)
- base.extend ExampleGroupMethods
- base.extend ControllerRequestHelpers::ExampleGroupMethods
- end
-
- # Evaluates the specified block for each of the RESTful controller methods.
- # This is useful to spec that all controller methods redirect when no user is
- # logged in.
- def with_default_restful_actions(params = {}, &block)
- {
- :get => :index,
- :get => :new,
- :post => :create
- }.each do |method_id, message|
- self.send method_id, message, params
- block.call
- end
- {
- :get => :edit,
- :put => :update,
- :delete => :destroy
- }.each do |method_id, message|
- if params[:before]
- params.delete(:before).call
- end
- # Presuming any id will do
- self.send method_id, message, params.merge(:id => 1)
- block.call
- end
- end
-
- private
- def create_ar_class_expectation(name, method, argument = nil, options = {})
- args = []
- unless options.delete(:only_method)
- args << argument unless argument.nil?
- args << hash_including(options) unless options.empty?
- end
- method = options.delete(:find_method) if options[:find_method]
- if args.empty?
- class_for(name).should_receive(method).and_return(instance_for(name))
- else
- class_for(name).should_receive(method).with(*args).and_return(instance_for(name))
- end
- end
-
- def create_positive_ar_instance_expectation(name, method, *args)
- instance = instance_for(name)
- if args.empty?
- instance.should_receive(method).and_return(true)
- else
- instance.should_receive(method).with(*args).and_return(true)
- end
- end
-
- # These methods are designed to be used at the example group [read: "describe"] level
- # to simplify and DRY up common expectations.
- module ExampleGroupMethods
- # Creates an expectation that the controller method calls ActiveRecord::Base.find.
- # Examples:
- #
- # it_should_find :foos # => Foo.should_receive(:find).with(:all)
- # it_should_find :foos, :all # An explicit version of the above
- # it_should_find :foos, :conditions => {:foo => "bar"} # => Foo.should_receive(:find).with(:all, :conditions => {"foo" => "bar"}
- # it_should_find :foos, "joe", :method => :find_all_by_name # Foo.should_receive(:find_all_by_name).with("joe")
- # it_should_find :foo # => Foo.should_recieve(:find).with(@foo.id.to_s)
- # it_should_find :foo, :params => "id" # => Foo.should_receive(:find).with(params[:id].to_s)
- # it_should_find :foo, 2 # => Foo.should_receive(:find).with("2")
- # it_should_find :foo, "joe", :method => :find_by_name # => Foo.should_recieve(:find_by_name).with("joe")
- #
- # Note: All params (key and value) will be strings if they come from a form element and are handled
- # internally with this expectation.
- def it_should_find(name, *args)
- name_string = name.to_s
- name_message = if name_string == name_string.singularize
- "a #{name}"
- else
- name
- end
- it "should find #{name_message}" do
- options = args.extract_options!
- # Blech!
- argument = if param = params[options.delete(:params)]
- param.to_s
- else
- if args.first
- args.first
- elsif (instance = instance_variable_get("@#{name}")).is_a?(ActiveRecord::Base)
- instance.id.to_s
- else
- :all
- end
- end
- find_method = options.delete(:method) || :find
- create_ar_class_expectation name, find_method, argument, options
- eval_request
- end
- end
-
- # Negative version of it_should_find. This creates an expectation that
- # the class never receives find at all.
- def it_should_not_find(name)
- name_string = name.to_s
- name_message = if name_string == name_string.singularize
- "a #{name}"
- else
- name
- end
- it "should not find #{name_message}" do
- if name_string == name_string.singularize
- class_for(name).should_not_receive(:find)
- else
- class_for(name).should_not_receive(:find).with(:all)
- end
- eval_request
- end
- end
-
- # Creates an expectation that the controller method calls ActiveRecord::Base.new.
- # Takes optional params for the initialization arguments. Example
- #
- # it_should_initialize :foo # => Foo.should_receive(:new)
- # it_should_initialize :foo, :params => :bar # => Foo.should_receive(:new).with(params[:bar])
- # it_should_initialize :foo, :bar => "baz" # => Foo.should_receive(:new).with(:bar => "baz")
- def it_should_initialize(name, options = {})
- it "should initialize a #{name}" do
- create_ar_class_expectation name, :new, params[options.delete(:params)], options
- eval_request
- end
- end
-
- # Negative version of it_should_initialize. This creates an expectation
- # that the class never recieves new at all.
- def it_should_not_initialize(name)
- it "should initialize a #{name}" do
- class_for(name).should_not_receive(:new)
- eval_request
- end
- end
-
- # Creates an expectation that the controller method calls ActiveRecord::Base#save on the
- # named instance. Example:
- #
- # it_should_save :foo # => @foo.should_receive(:save).and_return(true)
- #
- # Note: This helper should not be used to spec a failed save call. Use it_should_assign
- # instead, to verify that the instance is captured in an instance variable for the inevitable re-rendering
- # of the form template.
- def it_should_save(name)
- it "should save the #{name}" do
- create_positive_ar_instance_expectation name, :save
- eval_request
- end
- end
-
- # Negative version of it_should_update. This creates an expectation
- # that the instance never receives save at all.
- def it_should_not_save(name)
- it "should not save the #{name}" do
- instance_for(name).should_not_receive(:save)
- eval_request
- end
- end
-
- # Creates an expectation that the controller method calls ActiveRecord::Base#update_attributes
- # on the named instance. Takes optional argument for params to specify in the
- # expectation. Examples:
- #
- # it_should_update :foo # => @foo.should_receive(:update_attributes).and_return(true)
- # it_should_update :foo, :params => :bar # => @foo.should_receive(:update_attributes).with(params[:bar]).and_return(true)
- #
- # Note: This helper should not be used to spec a failed update_attributes call. Use
- # it_should_assign instead, to verify that the instance is captured in an instance variable
- # for the inevitable re-rendering of the form template.
- def it_should_update(name, options = {})
- it "should update the #{name}" do
- create_positive_ar_instance_expectation name, :update_attributes, params[name]
- eval_request
- end
- end
-
- # Negative version of it_should_update. This creates an expectation
- # that the instance never receives update_attributes at all.
- def it_should_not_update(name)
- it "should not update the #{name}" do
- instance_for(name).should_not_receive(:update_attributes)
- eval_request
- end
- end
-
- # Creates an expectation that the controller method calls ActiveRecord::Base#destroy on the named
- # instance. Example:
- #
- # it_should_destroy :foo # => @foo.should_receive(:destroy).and_return(true)
- #
- # Note: This helper should not be used to spec a failed destroy call. Use
- # it_should_assign instead, if you need to verify that the instance is captured in an instance
- # variable if it is re-rendered somehow. This is probably a really edge use case.
- def it_should_destroy(name, options = {})
- it "should delete the #{name}" do
- create_positive_ar_instance_expectation name, :destroy
- eval_request
- end
- end
-
- # Negative version of it_should_destroy. This creates an expectation
- # that the instance never receives destroy at all.
- def it_should_not_destroy(name)
- it "should not destroy the #{name}" do
- instance_for(name).should_not_receive(:destroy)
- eval_request
- end
- end
-
- # Creates expectation[s] that the controller method should assign the specified
- # instance variables along with any specified values. Examples:
- #
- # it_should_assign :foo # => assigns[:foo].should == @foo
- # it_should_assign :foo => "bar" # => assigns[:foo].should == "bar"
- # it_should_assign :foo => :nil # => assigns[:foo].should be_nil
- # it_should_assign :foo => :not_nil # => assigns[:foo].should_not be_nil
- # it_should_assign :foo => :undefined # => controller.send(:instance_variables).should_not include("@foo")
- #
- # Very special thanks to Rick Olsen for the basis of this code. The only reason I even
- # redefine it at all is purely an aesthetic choice for specs like "it should foo"
- # over ones like "it foos".
- def it_should_assign(*names)
- names.each do |name|
- if name.is_a?(Symbol)
- it_should_assign name => name
- elsif name.is_a?(Hash)
- name.each do |key, value|
- it_should_assign_instance_variable key, value
- end
- end
- end
- end
-
- # Essentially shorthand for it_should_assign name => :nil. This method can take multiple
- # instance variable names, creating this shorthand for each name. See the docs for
- # it_should_assign for more information.
- def it_should_not_assign(*names)
- names.each do |name|
- # Assuming name is a symbol
- it_should_assign name => :nil
- end
- end
-
- # Wraps the separate expectations it_should_find and it_should_assign
- # for simple cases. If you need more control over the parameters of the find, this
- # isn't the right helper method and you should write out the two expectations separately.
- def it_should_find_and_assign(*names)
- names.each do |name|
- it_should_find name, :only_method => true
- it_should_assign name
- end
- end
-
- # Negative version of it_should_find_and_assign. This creates an
- # expectation that the class never receives find at all and that
- # no matching instance variable is ever created.
- def it_should_not_find_and_assign(*names)
- names.each do |name|
- it_should_not_find name
- it_should_assign name => :nil
- end
- end
-
- # Wraps the separate expectations it_should_initialize and it_should_assign
- # for simple cases. If you need more control over the parameters of the initialization, this
- # isn't the right helper method and you should write out the two expectations separately.
- #
- # Note: This method is used for controller methods like new, where the instance
- # is initialized without being saved (this includes failed create requests).
- # If you want to spec that the controller method successfully saves the instance,
- # please use it_should_initialize_and_save.
- def it_should_initialize_and_assign(*names)
- names.each do |name|
- it_should_initialize name, :only_method => true
- it_should_assign name
- end
- end
-
- # Negative version of it_should_initialize_and_assign. This creates an
- # expectation that the class never receives new at all and that
- # no matching instance variable is ever created.
- def it_should_not_initialize_and_assign(*names)
- names.each do |name|
- it_should_not_initialize name
- it_should_assign name => :nil
- end
- end
-
- # Wraps the separate expectations it_should_initialize and it_should_save
- # for simple cases. If you need more control over the parameters of the initialization, this
- # isn't the right helper method and you should write out the two expectations separately.
- #
- # Note: This method is used for controller methods like create, where the instance
- # is initialized and successfully saved. If you want to spec that the instance is created
- # but not saved, just use it_should_initialize_and_assign.
- def it_should_initialize_and_save(*names)
- names.each do |name|
- it_should_initialize name, :only_method => true
- it_should_save name
- end
- end
-
- # Wraps the separate expectations it_should_find and it_should_update
- # for simple cases. If you need more control over the parameters of the find, this
- # isn't the right helper method and you should write out the two expectations separately.
- #
- # Note: This method is used for controller methods like update, where the
- # instance is loaded from the database and successfully saved. If you want to spec that the
- # instance is found but not saved, just use it_should_find_and_assign.
- def it_should_find_and_update(*names)
- names.each do |name|
- it_should_find name, :only_method => true
- it_should_update name
- end
- end
-
- # Wraps the separate expectations it_should_find and it_should_destroy
- # for simple cases. If you need more control over the parameters of the find, this
- # isn't the right helper method and you should write out the two expectations separately.
- def it_should_find_and_destroy(*names)
- names.each do |name|
- it_should_find name, :only_method => true
- it_should_destroy name
- end
- end
-
- # Creates an expectation that the specified collection (flash, session,
- # params, cookies) contains the specified key and value. To specify that
- # the collection should be set to nil, specify the value as :nil instead.
- def it_should_set(collection, key, value = nil, &block)
- it "should set #{collection}[:#{key}]#{' with ' + value.inspect if value}" do
- # Allow flash.now[:foo] to remain in the flash
- flash.stub!(:sweep) if collection == :flash
- eval_request
- if value
- if value == :nil
- self.send(collection)[key].should be_nil
- else
- self.send(collection)[key].should == value
- end
- elsif block_given?
- self.send(collection)[key].should == instance_eval(&block)
- else
- self.send(collection)[key].should_not be_nil
- end
- end
- end
-
- # Wraps it_should_set :flash. To specify that the collection should be set
- # to nil, specify the value as :nil instead.
- def it_should_set_flash(name, value = nil, &block)
- it_should_set :flash, name, value, &block
- end
-
- # Wraps it_should_set :flash, :nil.
- def it_should_not_set_flash(name)
- it_should_set :flash, name, :nil
- end
-
- # Wraps it_should_set :session. To specify that the collection should be set
- # to nil, specify the value as :nil instead.
- def it_should_set_session(name, value = nil, &block)
- it_should_set :session, name, value, &block
- end
-
- # Wraps it_should_set :session, :nil.
- def it_should_not_set_session(name)
- it_should_set :session, name, :nil
- end
-
- # Wraps it_should_set :params. To specify that the collection should be set
- # to nil, specify the value as :nil instead.
- def it_should_set_params(name, value = nil, &block)
- it_should_set :params, name, value, &block
- end
-
- # Wraps it_should_set :params, :nil.
- def it_should_not_set_params(name)
- it_should_set :params, name, :nil
- end
-
- # Wraps it_should_set :cookies. To specify that the collection should be set
- # to nil, specify the value as :nil instead.
- def it_should_set_cookies(name, value = nil, &block)
- it_should_set :cookies, name, value, &block
- end
-
- # Wraps it_should_set :cookies, :nil.
- def it_should_not_set_cookies(name)
- it_should_set :cookies, name, :nil
- end
-
- # Wraps the various it_should_render_foo methods:
- # it_should_render_template, it_should_render_partial,
- # it_should_render_xml, it_should_render_json,
- # it_should_render_formatted, and it_should_render_nothing.
- def it_should_render(render_method, *args)
- send "it_should_render_#{render_method}", *args
- end
-
- # Creates an expectation that the controller method renders the specified template.
- # Accepts the following options which create additional expectations.
- #
- # :content_type:: Creates an expectation that the Content-Type header for the response
- # matches the one specified
- # :status:: Creates an expectation that the HTTP status for the response
- # matches the one specified
- def it_should_render_template(name, options = {})
- create_status_expectation options[:status] if options[:status]
- it "should render '#{name}' template" do
- eval_request
- response.should render_template(name)
- end
- create_content_type_expectation(options[:content_type]) if options[:content_type]
- end
-
- # Creates an expectation that the controller method renders the specified partial.
- # Accepts the following options which create additional expectations.
- #
- # :content_type:: Creates an expectation that the Content-Type header for the response
- # matches the one specified
- # :status:: Creates an expectation that the HTTP status for the response
- # matches the one specified
- def it_should_render_partial(name, options = {})
- create_status_expectation options[:status] if options[:status]
- it "should render '#{name}' partial" do
- controller.expect_render(:partial => name)
- eval_request
- end
- create_content_type_expectation(options[:content_type]) if options[:content_type]
- end
-
- # Creates an expectation that the controller method renders the specified record via to_xml.
- # Accepts the following options which create additional expectations.
- #
- # :content_type:: Creates an expectation that the Content-Type header for the response
- # matches the one specified
- # :status:: Creates an expectation that the HTTP status for the response
- # matches the one specified
- def it_should_render_xml(record = nil, options = {}, &block)
- it_should_render_formatted :xml, record, options, &block
- end
-
- # Creates an expectation that the controller method renders the specified record via to_json.
- # Accepts the following options which create additional expectations.
- #
- # :content_type:: Creates an expectation that the Content-Type header for the response
- # matches the one specified
- # :status:: Creates an expectation that the HTTP status for the response
- # matches the one specified
- def it_should_render_json(record = nil, options = {}, &block)
- it_should_render_formatted :json, record, options, &block
- end
-
- # Called internally by it_should_render_xml and it_should_render_json
- # but should not really be called much externally unless you have defined your own
- # formats with a matching to_foo method on the record.
- #
- # Which is probably never.
- def it_should_render_formatted(format, record = nil, options = {}, &block)
- create_status_expectation options[:status] if options[:status]
- it "should render #{format.inspect}" do
- if record.is_a?(Hash)
- options = record
- record = nil
- end
- if record.nil? && !block_given?
- raise ArgumentError, "it_should_render must be called with either a record or a block and neither was given."
- else
- if record
- pieces = record.to_s.split(".")
- record = instance_variable_get("@#{pieces.shift}")
- record = record.send(pieces.shift) until pieces.empty?
- end
- block ||= proc { record.send("to_#{format}") }
- get_response do |response|
- response.should have_text(block.call)
- end
- end
- end
- create_content_type_expectation(options[:content_type]) if options[:content_type]
- end
-
- # Creates an expectation that the controller method returns a blank page. You'd already
- # know when and why to use this so I'm not typing it out.
- def it_should_render_nothing(options = {})
- create_status_expectation options[:status] if options[:status]
- it "should render :nothing" do
- get_response do |response|
- response.body.strip.should be_blank
- end
- end
- end
-
- # Creates an expectation that the controller method redirects to the specified destination. Example:
- #
- # it_should_redirect_to { foos_url }
- #
- # Note: This method takes a block to evaluate the route in the example
- # context rather than the example group context.
- def it_should_redirect_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should redirect to #{(hint || route)}" do
- eval_request
- response.should redirect_to(instance_eval(&route))
- end
- end
-
- # Negative version of it_should_redirect_to.
- def it_should_not_redirect_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should not redirect to #{(hint || route)}" do
- eval_request
- response.should_not redirect_to(instance_eval(&route))
- end
- end
-
- # Creates an expectation that the controller method redirects back to the previous page
- def it_should_redirect_to_referer
- it "should redirect to the referring page" do
- request.env["HTTP_REFERER"] = "http://test.host/referer"
- eval_request
- response.should redirect_to("http://test.host/referer")
- end
- end
- alias it_should_redirect_to_referrer it_should_redirect_to_referer
-
- private
- def it_should_assign_instance_variable(name, value)
- expectation_proc = case value
- when :nil
- proc { assigns[name].should be_nil }
- when :not_nil
- proc { assigns[name].should_not be_nil }
- when :undefined
- proc { controller.send(:instance_variables).should_not include("@{name}") }
- when Symbol
- if (instance_variable = instance_variable_get("@#{name}")).nil?
- proc { assigns[name].should_not be_nil }
- else
- proc { assigns[name].should == instance_variable }
- end
- else
- proc { assigns[name].should == value }
- end
- it "should #{value == :nil ? 'not ' : ''}assign @#{name}" do
- eval_request
- instance_eval &expectation_proc
- end
- end
- end
- end
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_stub_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_stub_helpers.rb
deleted file mode 100644
index 6d78ce54..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/controller_stub_helpers.rb
+++ /dev/null
@@ -1,238 +0,0 @@
-module LuckySneaks # :nodoc:
- # These methods are designed to be used in your example before blocks to accomplish
- # a whole lot of functionality with just a tiny bit of effort. The methods which correspond
- # to the controller methods perform the most duties as they create the mock_model instances,
- # stub out all the necessary methods, and also create implicit requests to DRY up your spec
- # file even more. You are encouraged to use these methods to setup the basic calls for your
- # resources and only resort to the other methods when mocking and stubbing secondary objects
- # and calls.
- module ControllerStubHelpers
- # Stubs out find :all and returns a collection of mock_model
- # instances of that class. Accepts the following options:
- #
- # :find_method:: Method to use as finder call. Default is :find.
- # Note: When specifying the method, the call is stubbed
- # to accept any arguments. Caveat programmer.
- # :format:: Format of the request. Used to only add to_xml and
- # to_json when actually needed.
- # :size:: Number of instances to return in the result. Default is 3.
- # :stub:: Additional methods to stub on the instances
- #
- # Any additional options will be passed as arguments to the class find.
- # You will want to make sure to pass those arguments to the it_should_find spec as well.
- def stub_find_all(klass, options = {})
- returning(Array.new(options[:size] || 3){mock_model(klass)}) do |collection|
- stub_out klass, options.delete(:stub)
- if format = options.delete(:format)
- stub_formatted collection, format
- params[:format] = format
- end
- if find_method = options[:find_method]
- # Not stubbing specific arguments here
- # If you need more specificity, write a custom example
- klass.stub!(find_method).and_return(collection)
- else
- klass.stub!(:find).with(:all).and_return(collection)
- klass.stub!(:find).with(:all, hash_including(options)).and_return(collection)
- end
- end
- end
-
- # Alias for stub_find_all but additionally defines an implicit request get :index.
- def stub_index(klass, options = {})
- define_implicit_request :index
- stub_find_all klass, options
- end
-
- # Stubs out new method and returns a mock_model instance marked as a new record.
- # Accepts the following options:
- #
- # :format:: Format of the request. Used to only add to_xml and
- # to_json when actually needed.
- # :stub:: Additional methods to stub on the instances
- #
- # It also accepts some options used to stub out save with a specified true
- # or false but you should be using stub_create in that case.
- def stub_initialize(klass, options = {})
- returning mock_model(klass) do |member|
- stub_out member, options.delete(:stub)
- if format = options[:format]
- stub_formatted member, format
- params[:format] = format
- end
- klass.stub!(:new).and_return(member)
- if options[:params]
- klass.stub!(:new).with(hash_including(options[:params])).and_return(member)
- end
- if options[:stub_save]
- stub_ar_method member, :save, options[:return]
- else
- member.stub!(:new_record?).and_return(true)
- member.stub!(:id).and_return(nil)
- end
- end
- end
-
- # Alias for stub_initialize which additionally defines an implicit request get :new.
- def stub_new(klass, options = {})
- define_implicit_request :new
- stub_initialize klass, options
- end
-
- # Alias for stub_initialize which additionally defines an implicit request post :create.
- #
- # Note: If stub_create is provided an optional :params hash,
- # those params will be added to the example's params object.
- def stub_create(klass, options = {})
- define_implicit_request :create
- class_name = klass.name.underscore
- options[:params] ||= params[class_name]
- stub_initialize klass, options.merge(:stub_save => true)
- end
-
- # Stubs out find and returns a single mock_model
- # instances of that class. Accepts the following options:
- #
- # :find_method:: Method to use as finder call. Default is :find.
- # :format:: Format of the request. Used to only add to_xml and
- # to_json when actually needed.
- # :stub:: Additional methods to stub on the instances
- # :current_object:: If set to true, find will set params[:id]
- # using the id of the mock_model instance
- # and use that value as an argument when stubbing find
- #
- # Any additional options will be passed as arguments to find.You will want
- # to make sure to pass those arguments to the it_should_find spec as well.
- #
- # Note: The option :stub_ar is used internally by stub_update
- # and stub_destroy. If you need to stub update_attributes or
- # destroy you should be using the aforementioned methods instead.
- def stub_find_one(klass, options = {})
- returning mock_model(klass) do |member|
- stub_out member, options.delete(:stub)
- if format = options.delete(:format)
- stub_formatted member, format
- params[:format] = format
- end
- if options.delete(:current_object)
- params[:id] = member.id
- if ar_stub = options.delete(:stub_ar)
- stub_ar_method member, ar_stub, options.delete(:return), options.delete(:update_params)
- end
- end
- if find_method = options.delete(:find_method)
- klass.stub!(find_method).and_return(member)
- else
- # Stubbing string and non-string just to be safe
- klass.stub!(:find).with(member.id).and_return(member)
- klass.stub!(:find).with(member.id.to_s).and_return(member)
- unless options.empty?
- klass.stub!(:find).with(member.id, hash_including(options)).and_return(member)
- klass.stub!(:find).with(member.id.to_s, hash_including(options)).and_return(member)
- end
- end
- end
- end
-
- # Note: Use of this method with :child options (to mock
- # association) is deprecated. Please use stub_association.
- #
- # Same as stub_find_one but setups the instance as the parent
- # of the specified association. Example:
- #
- # stub_parent(Document, :child => :comments)
- #
- # This stubs Document.find, @document.comments (which
- # will return Comment class), as well as params[:document_id].
- # This method is meant to be used in the controller for the specified child
- # (CommentsController in this instance) in situations like:
- #
- # def index
- # @document = Document.find(params[:document_id])
- # @comments = @document.comments.find(:all)
- # end
- def stub_parent(klass, options = {})
- returning stub_find_one(klass, options) do |member|
- params[klass.name.foreign_key] = member.id
- if offspring = options.delete(:child)
- puts "stub_parent with :child option has been marked for deprecation"
- puts "please use stub_association to create the mock instead"
- member.stub!(offspring).and_return(class_for(offspring))
- end
- end
- end
-
- # Alias for stub_find_one which additionally defines an implicit request get :show.
- def stub_show(klass, options = {})
- define_implicit_request :show
- stub_find_one klass, options.merge(:current_object => true)
- end
-
- # Alias for stub_find_one which additionally defines an implicit request get :edit.
- def stub_edit(klass, options = {})
- define_implicit_request :edit
- stub_find_one klass, options.merge(:current_object => true)
- end
-
- # Alias for stub_find_one which additionally defines an implicit request put :update
- # and stubs out the update_attribute method on the instance as well.
- #
- # Note: If stub_update is provided an optional :params hash,
- # those params will be added to the example's params object.
- def stub_update(klass, options = {})
- define_implicit_request :update
- stub_find_one klass, options.merge(:current_object => true, :stub_ar => :update_attributes)
- end
-
- # Alias for stub_find_one which additionally defines an implicit request delete :destroy
- # and stubs out the destroy method on the instance as well.
- def stub_destroy(klass, options = {})
- define_implicit_request :destroy
- stub_find_one klass, options.merge(:current_object => true, :stub_ar => :destroy)
- end
-
- # Stubs to_xml or to_json respectively based on format argument.
- def stub_formatted(object, format)
- return unless format
- object.stub!("to_#{format}").and_return("#{object.class} formatted as #{format}")
- end
-
- # Creates a mock object representing an association proxy, stubs the appropriate
- # method on the parent object and returns that association proxy.
- # Accepts the following option:
- #
- # :stub:: Additional methods to stub on the mock proxy object
- def stub_association(object, association, options = {})
- # I know options isn't implemented anywhere
- object_name = instance_variables.select{|name| instance_variable_get(name) == object}
- returning mock("Association proxy for #{object_name}.#{association}") do |proxy|
- stub_out proxy, options[:stub] if options[:stub]
- object.stub!(association).and_return(proxy)
- end
- end
-
- private
- # Stubs out multiple methods. You shouldn't be calling this yourself and if you do
- # you should be able to understand the code yourself, right?
- def stub_out(object, stubs = {})
- return if stubs.nil?
- stubs.each do |method, value|
- if value
- object.stub!(method).and_return(value)
- else
- object.stub!(method)
- end
- end
- end
-
- # Stubs out ActiveRecord::Base methods like #save, #update_attributes, etc
- # that may be called on a found or instantiated mock_model instance.
- def stub_ar_method(object, method, return_value, params = {})
- if params.blank?
- object.stub!(method).and_return(return_value ? false : true)
- else
- object.stub!(method).with(hash_including(params)).and_return(return_value ? false : true)
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/model_spec_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/model_spec_helpers.rb
deleted file mode 100644
index 4119acc6..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/model_spec_helpers.rb
+++ /dev/null
@@ -1,496 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..")
-require "skinny_spec"
-
-module LuckySneaks
- # These methods are designed to be used in your example [read: "it"] blocks
- # to make your model specs a little more DRY. You might also be interested
- # in checking out the example block [read: "describe"] level versions in of these
- # methods which can DRY things up even more:
- # LuckySneaks::ModelSpecHelpers::ExampleGroupLevelMethods.
- #
- # Also check out the methods in LuckySneaks::ModelSpecHelpers::AssociationMatcher
- # for some helpful matcher helper methods to use with these methods if you want to spec
- # options on your association setups.
- module ModelSpecHelpers
- include LuckySneaks::CommonSpecHelpers
-
- def self.included(base) # :nodoc:
- base.extend ExampleGroupLevelMethods
- end
-
- # These methods cannot be used alone but are used in compliment with the association
- # matchers in LuckySneaks::ModelSpecHelpers like have_many. Example:
- #
- # describe User do
- # it "should have many memberships" do
- # User.should have_many(:memberships)
- # end
- #
- # it "should have many sites through memberships" do
- # User.should have_many(:sites).through(:memberships)
- # end
- #
- # it "should belong to a manager" do
- # User.should belong_to(:manager).with_counter_cache
- # end
- # end
- #
- # Note: To spec these sorts of options using the example block helpers like
- # it_should_have_many, just add them as options directly. This will use
- # with_options rather than any specific matcher helpers but will have the same
- # effects. Example:
- #
- # describe User do
- # it_should_have_many :sites, :through => :memberships
- # end
- class AssociationMatcher
- def initialize(associated, macro) # :nodoc:
- @associated = associated
- @macro = macro
- @options = {}
- end
-
- def matches?(main_model) # :nodoc:
- unless main_model.respond_to?(:reflect_on_association)
- if main_model.class.respond_to?(:reflect_on_association)
- main_model = main_model.class
- else
- @not_model = main_model
- return false
- end
- end
- if @association = main_model.reflect_on_association(@associated)
- @options.all?{|k, v| @association.options[k] == v ||
- [@association.options[k]] == v} # Stupid to_a being obsoleted!
- end
- end
-
- def failure_message # :nodoc:
- if @not_model
- " expected: #{@not_model} to be a subclass of ActiveRecord::Base class, but was not"
- elsif @association
- " expected: #{association_with(@options)}\n got: #{association_with(@association.options)}"
- else
- " expected: #{association_with(@options)}, but the association does not exist"
- end
- end
-
- def negative_failure_message # :nodoc:
- if @association
- " expected: #{association_with(@options)}\n got: #{association_with(@association.options)}"
- else
- " expected: #{association_with(@options)} to not occur but it does"
- end
- end
-
- # The following public methods are chainable extensions on the main matcher
- # Examples:
- #
- # Foo.should have_many(:bars).through(:foobars).with_dependent(:destroy)
- # Bar.should belong_to(:baz).with_class_name("Unbaz")
- def through(through_model)
- @options[:through] = through_model
- self
- end
-
- def and_includes(included_models)
- @options[:include] = included_models
- self
- end
-
- def and_extends(*modules)
- @options[:extends] = modules
- self
- end
-
- def with_counter_cache(counter_cache = true)
- if counter_cache
- @options[:counter_cache] = counter_cache
- end
- self
- end
-
- def uniq(*irrelevant_args)
- @options[:uniq] = true
- self
- end
- alias and_is_unique uniq
- alias with_unique uniq
-
- def polymorphic(*irrelevant_args)
- @options[:polymorphic] = true
- self
- end
- alias and_is_polymorphic polymorphic
- alias with_polymorphic polymorphic
-
- def as(interface)
- @options[:as] = interface
- end
-
- # Use this to just specify the options as a hash.
- # Note: It will completely override any previously set options
- def with_options(options = {})
- options.each{|k, v| @options[k] = v}
- self
- end
-
- private
- # Takes care of methods like with_dependent(:destroy)
- def method_missing(method_id, *args, &block)
- method_name = method_id.to_s
- if method_name =~ /^with_(.*)/
- @options[$1.to_sym] = args
- self
- else
- super method_id, *args, &block
- end
- end
-
- def association_with(options)
- option_string = (options.nil? || options.empty?) ? "" : options.inspect
- unless option_string.blank?
- option_string.sub! /^\{(.*)\}$/, ', \1'
- option_string.gsub! /\=\>/, ' => '
- end
- "#{@macro} :#{@associated}#{option_string}"
- end
- end
-
- # Creates matcher that checks if the receiver has a belongs_to association
- # with the specified model.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def belong_to(model)
- AssociationMatcher.new model, :belongs_to
- end
-
- # Creates matcher that checks if the receiver has a have_one association
- # with the specified model.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def have_one(model)
- AssociationMatcher.new model, :has_one
- end
-
- # Creates matcher that checks if the receiver has a have_many association
- # with the specified model.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def have_many(models)
- AssociationMatcher.new models, :has_many
- end
-
- # Creates matcher that checks if the receiver has a have_and_belong_to_many association
- # with the specified model.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def have_and_belong_to_many(models)
- AssociationMatcher.new models, :has_and_belongs_to_many
- end
-
- private
- def class_or_instance
- @model_spec_class_or_instance ||= class_for(described_type) || instance
- end
-
- def instance
- @model_spec_instance ||= instance_for(described_type)
- end
-
- # These methods are designed to be used at the example group [read: "describe"] level
- # to simplify and DRY up common expectations. Some of these methods are wrappers for
- # matchers which can also be used on the example level [read: within an "it" block]. See
- # LuckySneaks::ModelSpecHelpers for more information.
- #
- # Note: The validation matchers are only meant to be used for simple validation checking
- # not as a one-size-fits-all solution.
- module ExampleGroupLevelMethods
- # Creates an expectation that the current model being spec'd has a belong_to
- # association with the specified model. Accepts optional arguments which are appended to
- # the belong_to spec like this:
- #
- # it_should_belong_to :document, :counter_cache => true
- #
- # which is the same as writing out:
- #
- # it "should belong to document" do
- # Comment.should belong_to(:document).with_options(:counter_cache => true)
- # end
- #
- # If you want a more detailed spec description text, feel free to write this out in the long
- # form and use belong_to and its related matcher helpers.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def it_should_belong_to(model, options = {})
- it "should belong to a #{model}" do
- if options.empty?
- class_or_instance.should belong_to(model)
- else
- class_or_instance.should belong_to(model).with_options(options)
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd has a have_one
- # association with the specified model. Accepts optional arguments which are appended to
- # the have_one spec like this:
- #
- # it_should_have_one :last_comment, :class_name => "Comment", :order => "created_at DESC"
- #
- # which is the same as writing out:
- #
- # it "should have one document" do
- # Document.should have_one(:last_comment).with_options(:class_name => "Comment", :order => "created_at DESC")
- # end
- #
- # If you want a more detailed spec description text, feel free to write this out in the long
- # form and use have_one and its related matcher helpers.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def it_should_have_one(model, options = {})
- it "should have one #{model}" do
- if options.empty?
- class_or_instance.should have_one(model)
- else
- class_or_instance.should have_one(model).with_options(options)
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd has a have_many
- # association with the specified model. Accepts optional arguments which are appended to
- # the have_many spec like this:
- #
- # it_should_have_many :memberships, :through => :sites
- #
- # which is the same as writing out:
- #
- # it "should have many memberships" do
- # User.should have_many(:memberships).with_options(:through => :sites)
- # end
- #
- # If you want a more detailed spec description text, feel free to write this out in the long
- # form and use have_many and its related matcher helpers.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def it_should_have_many(models, options = {})
- it "should have many #{models}" do
- if options.empty?
- class_or_instance.should have_many(models)
- else
- class_or_instance.should have_many(models).with_options(options)
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd has a have_and_belong_to_many
- # association with the specified model. Accepts optional arguments which are appended to
- # the have_and_belong_to_many spec like this:
- #
- # it_should_have_and_belong_to_many :documents, :include => :attachments
- #
- # which is the same as writing out:
- #
- # it "should belong to document" do
- # User.should have_and_belong_to_many(:documents).with_options(:include => :attachments)
- # end
- #
- # If you want a more detailed spec description text, feel free to write this out in the long
- # form and use have_and_belong_to_many and its related matcher helpers.
- #
- # Note: The argument should be a symbol as in the model's association definition
- # and not the model's class name.
- def it_should_have_and_belong_to_many(models, options = {})
- it "should have and belong to many #{models}" do
- if options.empty?
- class_or_instance.should have_and_belong_to_many(models)
- else
- class_or_instance.should have_and_belong_to_many(models).with_options(options)
- end
- end
- end
-
- # Creates an expectation that new instances of the model being spec'd
- # should initialise the specified attributes with a default value.
- #
- # it_should_default_attributes :status => 'new'
- #
- def it_should_default_attributes(hash_attribute_values)
- hash_attribute_values.each_pair do |a,v|
- it "should default #{a} attribute to #{v}" do
- class_or_instance.new.send(a).should == v
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd validates_presence_of
- # the specified attribute. Takes an optional custom message to match the one in the model's
- # validation.
- def it_should_validate_presence_of(attribute, message = default_error_message(:blank))
- it "should not be valid if #{attribute} is blank" do
- instance.send "#{attribute}=", nil
- instance.errors_on(attribute).should include(message)
- end
- end
-
- # Negative version of it_should_validate_presence_of. See that method for more
- # details. You'd probably only be using this in a nested example block to compare that
- # one scenario validates presence and another does not (because of conditions in
- # :if/:unless).
- def it_should_not_validate_presence_of(attribute, message = default_error_message(:blank))
- it "should be valid if #{attribute} is blank" do
- instance.send "#{attribute}=", nil
- instance.errors_on(attribute).should_not include(message)
- end
- end
-
- # Creates an expectation that the current model being spec'd validates_inclusion_of
- # the specified attribute. Takes an optional custom message to match the one in the model's
- # validation.
- def it_should_validate_inclusion_of(attribute, options = {}, message = default_error_message(:inclusion))
- it "should validate #{attribute} is in #{options[:in].to_s}" do
- # We specifically do not try to go below the range on String and character ranges because that problem set is unpredictable.
- lower = options[:in].first.respond_to?(:-) ? options[:in].first - 0.0001 : nil
- higher = options[:in].last.succ
-
- instance.send "#{attribute}=", lower
- instance.errors_on(attribute).should include(message)
-
- instance.send "#{attribute}=", higher
- instance.errors_on(attribute).should include(message)
-
- instance.send "#{attribute}=", (lower+higher)/2
- instance.errors_on(attribute).should_not include(message)
- end
- end
-
- # Creates an expectation that the current model being spec'd validates_numericality_of
- # the specified attribute. Takes an optional custom message to match the one in the model's
- # validation.
- def it_should_validate_numericality_of(attribute, message = default_error_message(:not_a_number))
- it "should validate #{attribute} is a numeric" do
- instance.send "#{attribute}=", "NaN"
- instance.errors_on(attribute).should include(message)
- end
- end
-
- # Negative version of it_should_validate_numericality_of. See that method for more
- # details. You'd probably only be using this in a nested example block to compare that
- # one scenario validates presence and another does not (because of conditions in
- # :if/:unless).
- def it_should_not_validate_numericality_of(attribute, message = default_error_message(:not_a_number))
- it "should not validate #{attribute} is a numeric" do
- instance.send "#{attribute}=", "NaN"
- instance.errors_on(attribute).should_not include(message)
- end
- end
-
- # Creates an expectation that the current model being spec'd validates_confirmation_of
- # the specified attribute. Takes an optional custom message to match the one in the model's
- # validation.
- def it_should_validate_confirmation_of(attribute, message = default_error_message(:confirmation))
- it "should validate confirmation of #{attribute}" do
- dummy_value = dummy_value_for(instance, attribute) || "try a string"
- instance.send "#{attribute}=", dummy_value
- instance.send "#{attribute}_confirmation=", dummy_value.succ
- instance.errors_on(attribute).should include(message)
- end
- end
-
- # Creates an expectation that the current model being spec'd validates_uniqueness_of
- # the specified attribute. Takes an optional custom message to match the one in the model's
- # validation.
- #
- # Note: This method will fail completely if valid_attributes
- # does not provide all the attributes needed to create a valid record.
- def it_should_validate_uniqueness_of(attribute, message = default_error_message(:taken))
- it "should validate uniqueness of #{attribute}" do
- previous_instance = instance.class.create!(valid_attributes)
- instance.attributes = valid_attributes
- instance.errors_on(attribute).should include(message)
- previous_instance.destroy
- end
- end
-
- # Negative version of it_should_validate_uniqueness_of. See that method for more
- # details. You'd probably only be using this in a nested example block to compare that
- # one scenario validates presence and another does not (because of conditions in
- # :if/:unless).
- def it_should_not_validate_uniqueness_of(attribute, message = default_error_message(:taken))
- it "should not validate uniqueness of #{attribute}" do
- previous_instance = instance.class.create!(valid_attributes)
- instance.attributes = valid_attributes
- instance.errors_on(attribute).should_not include(message)
- previous_instance.destroy
- end
- end
-
- # Creates an expectation that the current model being spec'd accepts the specified values as
- # valid for the specified attribute. This is most likely used with validates_format_of
- # but there's nothing saying it couldn't be another validation.
- def it_should_accept_as_valid(attribute, *values)
- values.flatten.each do |value|
- value_inspect = case value
- when String : "'#{value}'"
- when NilClass : "nil"
- else value
- end
- it "should accept #{value_inspect} as a valid #{attribute}" do
- instance.send "#{attribute}=", value
- instance.errors_on(attribute).should == []
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd does not accept the specified
- # values as valid for the specified attribute. This is most likely used with
- # validates_format_of but there's nothing saying it couldn't be another validation.
- # Takes an optional argument :message => "some custom error messsage" for
- # spec'ing the actual error message.
- def it_should_not_accept_as_valid(attribute, *values)
- options = values.extract_options!
- values.flatten.each do |value|
- value_inspect = case value
- when String : "'#{value}'"
- when NilClass : "nil"
- else value
- end
- it "should not accept #{value_inspect} as a valid #{attribute}" do
- instance.send "#{attribute}=", value
- if options[:message]
- instance.errors_on(attribute).should include(options[:message])
- else
- instance.should have_at_least(1).errors_on(attribute)
- end
- end
- end
- end
-
- # Creates an expectation that the current model being spec'd doesn't allow mass-assignment
- # of the specified attribute.
- def it_should_not_mass_assign(attribute)
- it "should not allow mass-assignment of #{attribute}" do
- lambda {
- instance.send :attributes=, {attribute => dummy_value_for(instance, attribute)}
- }.should_not change(instance, attribute)
- end
- end
-
- def default_error_message(attribute)
- if defined?(I18n)
- I18n.translate attribute, :scope => "activerecord.errors.messages"
- else
- ActiveRecord::Errors.default_error_messages[attribute]
- end
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_spec_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_spec_helpers.rb
deleted file mode 100644
index fb8775a1..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_spec_helpers.rb
+++ /dev/null
@@ -1,577 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..")
-require "skinny_spec"
-
-module LuckySneaks
- # These methods are designed to be used in your example [read: "it"] blocks
- # to make your view specs less brittle and more DRY. You might also be interested
- # in checking out the example block [read: "describe"] level versions in of these
- # methods which can DRY things up even more:
- # LuckySneaks::ViewSpecHelpers::ExampleGroupLevelMethods.
- module ViewSpecHelpers
- include LuckySneaks::CommonSpecHelpers
- include LuckySneaks::ViewStubHelpers
- include ActionController::PolymorphicRoutes
-
- def self.included(base) # :nodoc:
- base.extend ExampleGroupLevelMethods
- end
-
- # Wraps a matcher that checks if the receiver contains a FORM element with
- # its action attribute set to the specified path.
- def submit_to(path)
- have_tag("form[action=#{path}]")
- end
-
- # Wraps a matcher that checks if the receiver contains any of several form elements
- # that would return sufficient named parameters to allow editing of the specified
- # attribute on the specified instance. Example:
- #
- # response.should allow_editing(@foo, "bar")
- #
- # can be satisfied by any of the following HTML elements:
- #
- #
- #
- #
- #
- #
- def allow_editing(instance, attribute)
- instance_name = instance.class.name.underscore.downcase
- column = instance.column_for_attribute(attribute)
- if column && [Date, Time].include?(column.klass)
- have_tag(
- "input[name='#{instance_name}[#{attribute}]'],
- select[name=?]", /#{instance_name}\[#{attribute}\(.*\)\]/
- )
- else
- have_tag(
- "input[type='text'][name='#{instance_name}[#{attribute}]'],
- input[type='password'][name='#{instance_name}[#{attribute}]'],
- select[name='#{instance_name}[#{attribute}]'],
- textarea[name='#{instance_name}[#{attribute}]'],
- input[type='checkbox'][name='#{instance_name}[#{attribute}]'],
- input[type='checkbox'][name='#{instance_name}[#{attribute.to_s.tableize.singularize}_ids][]'],
- input[type='radio'][name='#{instance_name}[#{attribute}]']"
- )
- end
- end
-
- # Wraps a matcher that checks if the receiver contains a FORM element
- # whose enctype attribute is set to "multipart/form-data"
- # and contains an INPUT element whose name attribute correlates
- # with the provided instance and attribute.
- def allow_uploading(instance, attribute)
- instance_name = instance.class.name.underscore.downcase
- have_tag("form[enctype='multipart/form-data'] input[type='file'][name='#{instance_name}[#{attribute}]']")
- end
-
- # Wraps a matcher that checks if the receiver contains an A element (link)
- # whose href attribute is set to the specified path or a FORM
- # element whose action attribute is set to the specified path.
- def have_link_or_button_to(path)
- have_tag(
- "a[href='#{path}'],
- form[action='#{path}'] input,
- form[action='#{path}'] button"
- )
- end
- alias have_link_to have_link_or_button_to
- alias have_button_to have_link_or_button_to
-
- # Wraps have_link_or_button_to new_polymorphic_path for the specified class which
- # corresponds with the new method of the controller.
- #
- # Note: This method may takes a string or symbol representing the model's name
- # to send to have_link_or_button_to_show or the model's name itself.
- def have_link_or_button_to_new(name)
- have_link_or_button_to new_polymorphic_path(name.is_a?(ActiveRecord::Base) ? name : class_for(name))
- end
-
- # Wraps have_link_or_button_to polymorphic_path(instance) which
- # corresponds with the show method of the controller.
- def have_link_or_button_to_show(instance)
- path = polymorphic_path(instance)
- have_tag(
- "a[href='#{path}'],
- form[action='#{path}'][method='get'] input,
- form[action='#{path}'][method='get'] button,
- form[action='#{path}'] input[name='_method'][value='get'] + input,
- form[action='#{path}'] input[name='_method'][value='get'] + button"
- )
- end
- alias have_link_to_show have_link_or_button_to_show
- alias have_button_to_show have_link_or_button_to_show
-
- # Wraps have_link_or_button_to edit_polymorphic_path(instance) which
- # corresponds with the edit method of the controller.
- def have_link_or_button_to_edit(instance)
- have_link_or_button_to edit_polymorphic_path(instance)
- end
- alias have_link_to_edit have_link_or_button_to_edit
- alias have_button_to_edit have_link_or_button_to_edit
-
- # Wraps a matcher that checks if the receiver contains the HTML created by Rails'
- # button_to helper: to wit, a FORM element whose action
- # attribute is pointed at the polymorphic_path of the instance
- # and contains an INPUT named "_method" with a value of "delete".
- def have_button_to_delete(instance)
- path = polymorphic_path(instance)
- have_tag(
- "form[action='#{path}'] input[name='_method'][value='delete'] + input,
- form[action='#{path}'] input[name='_method'][value='delete'] + button,
- a[href=\"#{path}\"][onclick*=\"f.method = 'POST'\"][onclick*=\"m.setAttribute('name', '_method'); m.setAttribute('value', 'delete')\"]"
- )
- end
-
- # Creates a mock_model instance and adds it to the assigns collection
- # using either the name passed as the first argument or the underscore version
- # of its class name. Accepts optional arguments to stub out additional methods
- # (and their return values) on the mock_model instance. Example:
- #
- # mock_and_assign(Foo, :stub => {:bar => "bar"})
- #
- # is the same as running assigns[:foo] = mock_model(Foo, :bar => "bar").
- #
- # mock_and_assign(Foo, "special_foo", :stub => {:bar => "baz"})
- #
- # is the same as running assigns[:special_foo] = mock_model(Foo, :bar => "baz").
- #
- # Note: Adding to the assigns collection returns the object added, so this can
- # be chained a la @foo = mock_and_assign(Foo).
- def mock_and_assign(klass, *args)
- options = args.extract_options!
- mocked = if options[:stub]
- self.respond_to?(:stub_model) ? stub_model(klass, options[:stub]) : mock_model(klass, options[:stub])
- else
- self.respond_to?(:stub_model) ? stub_model(klass) : mock_model(klass)
- end
- yield mocked if block_given?
- self.assigns[args.first || "#{klass}".underscore] = mocked
- end
-
- # Creates an array of mock_model instances in the manner of
- # mock_and_assign. Accepts option[:size] which sets the size
- # of the array (default is 3).
- def mock_and_assign_collection(klass, *args)
- options = args.extract_options!
- return_me = Array.new(options[:size] || 3) do
- mocked = if options[:stub]
- self.respond_to?(:stub_model) ? stub_model(klass, options[:stub]) : mock_model(klass, options[:stub])
- else
- self.respond_to?(:stub_model) ? stub_model(klass) : mock_model(klass)
- end
- yield mocked if block_given?
- mocked
- end
- self.assigns[args.first || "#{klass}".tableize] = return_me
- end
-
- private
- def do_render
- if @the_template
- render @the_template
- elsif File.exists?(File.join(RAILS_ROOT, "app/views", class_description_text))
- render class_description_text
- else
- error_message = "Cannot determine template for render. "
- error_message << "Please define @the_template in the before block "
- error_message << "or name your describe block so that it indicates the correct template."
- raise NameError, error_message
- end
- end
-
- # These methods are designed to be used at the example group [read: "describe"] level
- # to simplify and DRY up common expectations. Most of these methods are wrappers for
- # matchers which can also be used on the example level [read: within an "it" block]. See
- # LuckySneaks::ViewSpecHelpers for more information.
- module ExampleGroupLevelMethods
- include LuckySneaks::CommonSpecHelpers
-
- # Creates an expectation which calls submit_to on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method takes a Proc to evaluate the route not simply a named route
- # helper, which would be undefined in the scope of the example block.
- def it_should_submit_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should submit to #{(hint || route)}" do
- do_render
- response.should submit_to(instance_eval(&route))
- end
- end
-
- # Negative version of it_should_submit_to. See that method for more
- # details.
- def it_should_not_submit_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should not submit to #{(hint || route)}" do
- do_render
- response.should_not submit_to(instance_eval(&route))
- end
- end
-
- # Creates an expectation that the template uses Rails' form_for to generate
- # the proper form action and method to create or update the specified object.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to create the expectation for form_for
- # not an instance variable, which would be nil in the scope of the example block.
- # If you use namespacing for your form_for, you'll have to manually write out
- # a similar spec.
- def it_should_have_form_for(name, options = {})
- it "should have a form_for(@#{name})" do
- if options.empty?
- template.should_receive(:form_for).with(instance_for(name))
- else
- template.should_receive(:form_for).with(instance_for(name), hash_including(options))
- end
- do_render
- end
- end
-
- # Negative version of it_should_have_form_for. See that method for more
- # details.
- def it_should_not_have_form_for(name, options = {})
- it "should not have a form_for(@#{name})" do
- if options.empty?
- template.should_not_receive(:form_for).with(instance_for(name))
- else
- template.should_not_receive(:form_for).with(instance_for(name), hash_including(options))
- end
- do_render
- end
- end
-
- # Creates an expectation which calls allow_editing on the rendered
- # template for each attribute specified. See the docs for allow_editing
- # for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to send to allow_editing
- # not an instance variable, which would be nil in the scope of the example block.
- def it_should_allow_editing(instance_name, *attributes)
- attributes.flatten!
- attributes.each do |attribute|
- it "should allow editing of @#{instance_name}##{attribute}" do
- do_render
- response.should allow_editing(instance_for(instance_name), attribute)
- end
- end
- end
-
- # Negative version of it_should_allow_editing. See that method for more
- # details.
- def it_should_not_allow_editing(instance_name, *attributes)
- attributes.flatten!
- attributes.each do |attribute|
- it "should not allow editing of @#{instance_name}##{attribute}" do
- do_render
- response.should_not allow_editing(instance_for(instance_name), attribute)
- end
- end
- end
-
- # Creates an expectation which calls allow_uploading on the rendered
- # template for each attribute specified. See the docs for allow_uploading
- # for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to send to allow_uploading
- # not an instance variable, which would be nil in the scope of the example block.
- def it_should_allow_uploading(instance_name, *attributes)
- attributes.flatten!
- attributes.each do |attribute|
- it "should allow editing of @#{instance_name}##{attribute}" do
- do_render
- response.should allow_uploading(instance_for(instance_name), attribute)
- end
- end
- end
-
- # Negative version of it_should_allow_uploading. See that method for more
- # details.
- def it_should_not_allow_uploading(instance_name, *attributes)
- attributes.flatten!
- attributes.each do |attribute|
- it "should not allow editing of @#{instance_name}##{attribute}" do
- do_render
- response.should_not allow_uploading(instance_for(instance_name), attribute)
- end
- end
- end
-
- # Creates an expectation that the rendered template contains a FORM element
- # (INPUT, TEXTAREA, or SELECT) with the specified name.
- def it_should_have_form_element_for(name)
- it "should have a form element named '#{name}'" do
- do_render
- response.should have_tag(
- "form input[name='#{name}'],
- form textarea[name='#{name}'],
- form select[name='#{name}']"
- )
- end
- end
-
- # Negative version of it_should_have_form_element_for. See that method
- # for more details.
- def it_should_not_have_form_element_for(name)
- it "should not have a form element named '#{name}'" do
- do_render
- response.should_not have_tag(
- "form input[name='#{name}'],
- form textarea[name='#{name}'],
- form select[name='#{name}']"
- )
- end
- end
-
- # Creates an expectation which calls have_link_or_button_to on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method takes a block to evaluate the route in the example context
- # instead of the example group context.
- def it_should_link_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should have a link/button to #{(hint || route)}" do
- do_render
- response.should have_link_or_button_to(instance_eval(&route))
- end
- end
- alias it_should_have_link_to it_should_link_to
- alias it_should_have_button_to it_should_link_to
- alias it_should_have_button_or_link_to it_should_link_to
-
- # Negative version of it_should_link_to. See that method
- # for more details.
- def it_should_not_link_to(hint = nil, &route)
- if hint.nil? && route.respond_to?(:to_ruby)
- hint = route.to_ruby.gsub(/(^proc \{)|(\}$)/, '').strip
- end
- it "should have a link/button to #{(hint || route)}" do
- do_render
- response.should_not have_link_or_button_to(instance_eval(&route))
- end
- end
- alias it_should_not_have_link_to it_should_not_link_to
- alias it_should_not_have_button_to it_should_not_link_to
- alias it_should_not_have_button_or_link_to it_should_not_link_to
-
- # Creates an expectation which calls have_link_or_button_to_new on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method may takes a string or symbol representing the model's name
- # to send to have_link_or_button_to_show or the model's name itself.
- def it_should_link_to_new(name)
- it "should have a link/button to create a new #{name}" do
- do_render
- response.should have_link_or_button_to_new(name)
- end
- end
- alias it_should_have_link_to_new it_should_link_to_new
- alias it_should_have_button_to_new it_should_link_to_new
- alias it_should_have_button_or_link_to_new it_should_link_to_new
-
- # Negative version of it_should_link_to_show. See that method
- # for more details.
- def it_should_not_link_to_new(name)
- it "should have a link/button to create a new #{name}" do
- do_render
- response.should_not have_link_or_button_to_new(name)
- end
- end
- alias it_should_not_have_link_to_new it_should_not_link_to_new
- alias it_should_not_have_button_to_new it_should_not_link_to_new
- alias it_should_not_have_button_or_link_to_new it_should_not_link_to_new
-
- # Creates an expectation which calls have_link_or_button_to_show on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to send to have_link_or_button_to_show
- # not an instance variable, which would be nil in the scope of the example block.
- def it_should_link_to_show(name)
- it "should have a link/button to show @#{name}" do
- do_render
- response.should have_link_or_button_to_show(instance_for(name))
- end
- end
- alias it_should_have_link_to_show it_should_link_to_show
- alias it_should_have_button_to_show it_should_link_to_show
- alias it_should_have_button_or_link_to_show it_should_link_to_show
-
- # Negative version of it_should_link_to_show. See that method
- # for more details.
- def it_should_not_link_to_show(name)
- it "should have a link/button to show @#{name}" do
- do_render
- response.should_not have_link_or_button_to_show(instance_for(name))
- end
- end
- alias it_should_not_have_link_to_show it_should_not_link_to_show
- alias it_should_not_have_button_to_show it_should_not_link_to_show
- alias it_should_not_have_button_or_link_to_show it_should_not_link_to_show
-
- # Creates an expectation which calls have_link_or_button_to_show
- # for each member of the instance variable matching the specified name
- # on the response from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name and not an instance variable, which would be nil
- # in the scope of the example block.
- def it_should_link_to_show_each(name)
- it "should have a link/button to show each member of @#{name}" do
- do_render
- instance_for(name).each do |member|
- response.should have_link_or_button_to_show(member)
- end
- end
- end
- alias it_should_have_link_to_show_each it_should_link_to_show_each
- alias it_should_have_button_to_show_each it_should_link_to_show_each
- alias it_should_have_button_or_link_to_show_each it_should_link_to_show_each
-
- # Creates an expectation which calls have_link_or_button_to_edit on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to send to have_link_or_button_to_edit
- # not an instance variable, which would be nil in the scope of the example block.
- def it_should_link_to_edit(name)
- it "should have a link/button to edit @#{name}" do
- do_render
- response.should have_link_or_button_to_edit(instance_for(name))
- end
- end
- alias it_should_have_link_to_edit it_should_link_to_edit
- alias it_should_have_button_to_edit it_should_link_to_edit
- alias it_should_have_button_or_link_to_edit it_should_link_to_edit
-
- # Negative version of it_should_link_to_edit. See that method
- # for more details.
- def it_should_not_link_to_edit(name)
- it "should have a link/button to edit @#{name}" do
- do_render
- response.should_not have_link_or_button_to_edit(instance_for(name))
- end
- end
- alias it_should_not_have_link_to_edit it_should_not_link_to_edit
- alias it_should_not_have_button_to_edit it_should_not_link_to_edit
- alias it_should_not_have_button_or_link_to_edit it_should_not_link_to_edit
-
-
- # Creates an expectation which calls have_link_or_button_to_edit
- # for each member of the instance variable matching the specified name
- # on the response from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name and not an instance variable, which would be nil
- # in the scope of the example block.
- def it_should_link_to_edit_each(name)
- it "should have a link/button to edit each member of @#{name}" do
- do_render
- instance_for(name).each do |member|
- response.should have_link_or_button_to_edit(member)
- end
- end
- end
- alias it_should_have_link_to_edit_each it_should_link_to_edit_each
- alias it_should_have_button_to_edit_each it_should_link_to_edit_each
- alias it_should_have_button_or_link_to_edit_each it_should_link_to_edit_each
-
- # Creates an expectation which calls have_link_or_button_to_delete on the response
- # from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name to send to have_link_or_button_to_delete
- # not an instance variable, which would be nil in the scope of the example block.
- def it_should_link_to_delete(name)
- it "should have a link/button to delete @#{name}" do
- do_render
- response.should have_button_to_delete(instance_for(name))
- end
- end
- alias it_should_have_link_to_delete it_should_link_to_delete
- alias it_should_have_button_to_delete it_should_link_to_delete
- alias it_should_have_button_or_link_to_delete it_should_link_to_delete
-
- # Negative version of it_should_link_to_delete. See that method
- # for more details.
- def it_should_not_link_to_delete(name)
- it "should not have a link/button to delete @#{name}" do
- do_render
- response.should_not have_button_to_delete(instance_for(name))
- end
- end
- alias it_should_not_have_link_to_delete it_should_not_link_to_delete
- alias it_should_not_have_button_to_delete it_should_not_link_to_delete
- alias it_should_not_have_button_or_link_to_delete it_should_not_link_to_delete
-
- # Creates an expectation which calls have_link_or_button_to_delete
- # for each member of the instance variable matching the specified name
- # on the response from rendering the template. See that method for more details.
- #
- # Note: This method takes a string or symbol representing the instance
- # variable's name and not an instance variable, which would be nil
- # in the scope of the example block.
- def it_should_link_to_delete_each(name)
- it "should have a link/button to delete each member of @#{name}" do
- do_render
- instance_for(name).each do |member|
- response.should have_button_to_delete(member)
- end
- end
- end
- alias it_should_have_link_to_delete_each it_should_link_to_delete_each
- alias it_should_have_button_to_delete_each it_should_link_to_delete_each
- alias it_should_have_button_or_link_to_delete_each it_should_link_to_delete_each
-
- # Creates an expectation that the template should call render :partial
- # with the specified template.
- def it_should_render_partial(name)
- it "should render :partial => '#{name}'" do
- template.should_receive(:render).with(hash_including(:partial => name))
- do_render
- end
- end
-
- # Negative version of it_should_render_partial. See that method
- # for more details.
- def it_should_not_render_partial(name)
- it "should not render :partial => '#{name}'" do
- template.should_not_receive(:render).with(hash_including(:partial => name))
- do_render
- end
- end
-
- # Sets @the_template (for use in do_render) using the current
- # example group description. Example:
- #
- # describe "users/index.haml.erb" do
- # use_describe_for_template!
- # # ...
- # end
- #
- # This is equivalent to setting @the_template = "users/index.haml.erb"
- # in a before block.
- def use_describe_for_template!
- template = self_description_text
- if File.exists?(File.join(RAILS_ROOT, "app/views", template))
- before(:each) do
- @the_template = template
- end
- else
- error_message = "You called use_describe_for_template! "
- error_message << "but 'app/views/#{template}' does not exist. "
- raise NameError, error_message
- end
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_stub_helpers.rb b/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_stub_helpers.rb
deleted file mode 100644
index 2dde384e..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/lucky_sneaks/view_stub_helpers.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..")
-require "skinny_spec"
-
-module LuckySneaks
- # These methods are designed to be used in your example before blocks to accomplish
- # a whole lot of functionality with just a tiny bit of effort.
- module ViewStubHelpers
- # Shorthand for the following stub:
- #
- # template.stub!(:render).with(hash_including(:partial => anything))
- def stub_partial_rendering!
- template.stub!(:render).with(hash_including(:partial => anything))
- end
- end
-end
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/skinny_spec/lib/skinny_spec.rb b/backup.rails2.3/plugins/skinny_spec/lib/skinny_spec.rb
deleted file mode 100644
index 3c366ce1..00000000
--- a/backup.rails2.3/plugins/skinny_spec/lib/skinny_spec.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# Let's make sure everyone else is loaded
-require File.expand_path(RAILS_ROOT + "/config/environment")
-require 'spec'
-require 'spec/rails'
-begin
- require 'ruby2ruby'
-rescue LoadError
- puts "-----"
- puts "Attention: skinny_spec requires ruby2ruby for nicer route descriptions"
- puts "It is highly recommended that you install it: sudo gem install ruby2ruby"
- puts "-----"
-end
-
-# Let's load our family now
-require "lucky_sneaks/common_spec_helpers"
-require "lucky_sneaks/controller_request_helpers"
-require "lucky_sneaks/controller_spec_helpers"
-require "lucky_sneaks/controller_stub_helpers"
-require "lucky_sneaks/model_spec_helpers"
-require "lucky_sneaks/view_spec_helpers"
-
-# Let's all come together
-Spec::Rails::Example::ViewExampleGroup.send :include, LuckySneaks::ViewSpecHelpers
-Spec::Rails::Example::HelperExampleGroup.send :include, LuckySneaks::CommonSpecHelpers
-Spec::Rails::Example::ControllerExampleGroup.send :include, LuckySneaks::ControllerSpecHelpers
-Spec::Rails::Example::ModelExampleGroup.send :include, LuckySneaks::ModelSpecHelpers
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/swf_fu/CHANGELOG.rdoc b/backup.rails2.3/plugins/swf_fu/CHANGELOG.rdoc
deleted file mode 100644
index 7b99496e..00000000
--- a/backup.rails2.3/plugins/swf_fu/CHANGELOG.rdoc
+++ /dev/null
@@ -1,46 +0,0 @@
-= swf_fu --- History
-
-== Version 1.4.0 - May 8, 2010
-
-* Any option can be a block, in which case it is called (with the source swf passed as argument)
-
-== Version 1.3.1 - February 5, 2010
-
-* Improved compatibility with Rails 3.0: swf_tag now outputs html_safe content.
-
-* Got rid of deprecation warning in Rails 2.2+ when using swf_tag in block form.
-
-== Version 1.3.0 - June 20, 2009
-
-* Updated to swf_object v2.2. Change should not be noticeable to users, except compatibility improvements and better auto install. Added the option +switch_off_auto_hide_show+.
-
-== Version 1.2.0 - January 14, 2009
-
-* flashvars[:id] will now default to the DOM id of the object. I didn't want to have any extra defaults than the very basic ones, but there is no easy way to get this from Flash (see http://www.actionscript.org/forums/showthread.php3?t=136044 ) and no easy way to specify that using +swf_default_options+.
-* If flashvars is a string (e.g. "myVar=myValue") it will be parsed into a hash so that the behaviour for default values apply to strings or hashes. swf_default_options[:flashvars] can also be a string and will also be parsed before being merged.
-* Small bug fix: the options passed as hashes (:flashvars, :parameters and :html_options) were changed if swf_default_options[:flashvars, ...] existed. They are now left unchanged.
-
-== Version 1.1.0 - January 3, 2009
-
-* Improved the way to specify alternate content
-
-== Version 1.0.3 - January 3, 2009
-
-* Improved javascript initialization
-
- :initialize => [1, 2, 3] # produces in javascript: obj.initialize(1,2,3) instead of ([1,2,3])
- # no :initialize produces in javascript: obj.initialize() instead of (null)
- :initialize => nil # stil produces obj.initialize(null)
-
-== Version 1.0.2 - January 3, 2009
-
-* Bug fix for flashvars in dynamic method
-
-== Version 1.0.1 - January 2, 2009
-
-* File reorganization
-* Bug fix for default options
-
-== Version 1.0 - X-mas, 2008
-
-=== Initial release.
diff --git a/backup.rails2.3/plugins/swf_fu/FLASH_OBJECT.rdoc b/backup.rails2.3/plugins/swf_fu/FLASH_OBJECT.rdoc
deleted file mode 100644
index 87a0e72f..00000000
--- a/backup.rails2.3/plugins/swf_fu/FLASH_OBJECT.rdoc
+++ /dev/null
@@ -1,31 +0,0 @@
-== Compatibility with FlashObject
-
-This document is intended for users of FlashObject, a (much older) swf embedding plugin that inspired swf_fu.
-
-You can choose to:
-
-1) keep both. They won't interfere and +flashobject_tag+ will continue to use the older SWFObject 1.5 library.
-
-2) remove FlashObject:
-
- script/plugin remove flashobject_helper
-
-You can also manually remove javascripts/flashobject.js
-
-+swf_fu+ will take over the +flashobject_tag+ and will use the new SWFObject 2.2 library.
-This should not have impacts as long as:
-* your swf path is absolute (e.g. "/path/to/my_flash.swf"). If it is relative, move your swf file from 'public/' to the new 'public/swfs/' asset folder
-* you include the default javascripts (otherwise you need to include 'swfobject' explicitely and stop including 'flashobject')
-* you don't use the javascript object before the page is loaded. SWFObject 2.2 makes the changes to the web page later
-* you don't rely on the +verify_file_exists+ option (it doesn't do anything anymore)
-
-In either case 1 or 2, you change existing calls to +flashobject_tag+ for +swf_tag+ at your leisure.
-The interface is similar and the main differences are some options name changes:
- :flash_id => :id
- :variables => :flashvars
- :background_color => options[:parameters][:bgcolor]
-
-Moreover, the following defaults are gone:
- :flashvars[:lzproxied]
- :parameters[:scale]
- :parameters[:bgcolor]
diff --git a/backup.rails2.3/plugins/swf_fu/LICENSE b/backup.rails2.3/plugins/swf_fu/LICENSE
deleted file mode 100644
index efd683ff..00000000
--- a/backup.rails2.3/plugins/swf_fu/LICENSE
+++ /dev/null
@@ -1,29 +0,0 @@
-# swf_fu plugin for rails
-# Copyright (c) 2010, Marc-André Lafortune.
-# All rights reserved.
-# Inspired by FlashObject by Davide D'Agostino aka DAddYE (http://www.lipsiasoft.com)
-# Uses SWFObject.js 2.1 (http://code.google.com/p/swfobject)
-#
-# Licensed under the terms of the (modified) BSD License below:
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-# * Neither the name of the 
-
- EOS
- }.freeze
-
- class Generator # :nodoc:
- VALID_MODES = [:static, :dynamic]
- def initialize(source, options, view)
- @view = view
- @source = view.swf_path(source)
- options = ActionView::Base.swf_default_options.merge(options)
- options.each do |key, value|
- options[key] = value.call(source) if value.respond_to?(:call)
- end
- [:html_options, :parameters, :flashvars].each do |k|
- options[k] = convert_to_hash(options[k]).reverse_merge convert_to_hash(ActionView::Base.swf_default_options[k])
- end
- options.reverse_merge!(DEFAULTS)
- options[:id] ||= source.gsub(/^.*\//, '').gsub(/\.swf$/,'')
- options[:id] = force_to_valid_id(options[:id])
- options[:div_id] ||= options[:id]+"_div"
- options[:div_id] = force_to_valid_id(options[:div_id])
- options[:width], options[:height] = options[:size].scan(/^(\d*%?)x(\d*%?)$/).first if options[:size]
- options[:auto_install] &&= @view.swf_path(options[:auto_install])
- options[:flashvars][:id] ||= options[:id]
- @mode = options.delete(:mode)
- @options = options
- unless VALID_MODES.include? @mode
- raise ArgumentError, "options[:mode] should be either #{VALID_MODES.join(' or ')}"
- end
- end
-
- def force_to_valid_id(id)
- id = id.gsub /[^A-Za-z0-9\-_]/, "_" # HTML id can only contain these characters
- id = "swf_" + id unless id =~ /^[A-Z]/i # HTML id must start with alpha
- id
- end
-
- def generate(&block)
- if block_given?
- @options[:alt] = @view.capture(&block)
- if Rails::VERSION::STRING >= "3.0"
- send(@mode)
- elsif Rails::VERSION::STRING < "2.2"
- @view.concat(send(@mode), block.binding)
- else
- @view.concat(send(@mode))
- end
- else
- send(@mode)
- end
- end
-
- private
- CONCAT = ActiveSupport.const_defined?(:SafeBuffer) ? :safe_concat : :concat
- def convert_to_hash(s)
- case s
- when Hash
- s
- when nil
- {}
- when String
- s.split("&").inject({}) do |h, kvp|
- key, value = kvp.split("=")
- h[key.to_sym] = CGI::unescape(value)
- h
- end
- else
- raise ArgumentError, "#{s} should be a Hash, a String or nil"
- end
- end
-
- def convert_to_string(h)
- h.map do |key_value|
- key_value.map{|val| CGI::escape(val.to_s)}.join("=")
- end.join("&")
- end
-
- def static
- param_list = @options[:parameters].map{|k,v| %() }.join("\n")
- param_list += %(\n) unless @options[:flashvars].empty?
- html_options = @options[:html_options].map{|k,v| %(#{k}="#{v}")}.join(" ")
- r = @view.javascript_tag(
- %(swfobject.registerObject("#{@options[:id]}_container", "#{@options[:flash_version]}", #{@options[:auto_install].to_json});)
- )
- r.send CONCAT, <<-"EOS".strip
-
- EOS
- r << @view.javascript_tag(extend_js) if @options[:javascript_class]
- r.send CONCAT, library_check
- r
- end
-
- def dynamic
- @options[:html_options] = @options[:html_options].merge(:id => @options[:id])
- @options[:parameters] = @options[:parameters].dup # don't modify the original parameters
- args = (([@source] + @options.values_at(:div_id,:width,:height,:flash_version)).map(&:to_s) +
- @options.values_at(:auto_install,:flashvars,:parameters,:html_options)
- ).map(&:to_json).join(",")
- preambule = @options[:switch_off_auto_hide_show] ? "swfobject.switchOffAutoHideShow();" : ""
- r = @view.javascript_tag(preambule + "swfobject.embedSWF(#{args})")
- r.send CONCAT, <<-"EOS".strip
-
- #{@options[:alt]}
-
- EOS
- r << @view.javascript_tag("swfobject.addDomLoadEvent(function(){#{extend_js}})") if @options[:javascript_class]
- r.send CONCAT, library_check
- r
- end
-
- def extend_js
- arglist = case
- when @options[:initialize].instance_of?(Array)
- @options[:initialize].map(&:to_json).join(",")
- when @options.has_key?(:initialize)
- @options[:initialize].to_json
- else
- ""
- end
- "Object.extend($('#{@options[:id]}'), #{@options[:javascript_class]}.prototype).initialize(#{arglist})"
- end
-
- def library_check
- return "" unless 'development' == ENV['RAILS_ENV']
- @view.javascript_tag(<<-"EOS")
- if (typeof swfobject == 'undefined') {
- document.getElementById('#{@options[:div_id]}').innerHTML = 'Warning: SWFObject.js was not loaded properly. Make sure you <%= javascript_include_tag :defaults %> or <%= javascript_include_tag :swfobject %>';
- }
- EOS
- end
- end #class Generator
- end
- end
-end
diff --git a/backup.rails2.3/plugins/swf_fu/test/results.rb b/backup.rails2.3/plugins/swf_fu/test/results.rb
deleted file mode 100644
index a7306b0d..00000000
--- a/backup.rails2.3/plugins/swf_fu/test/results.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-DYNAMIC_RESULT = <<'EOS'
-
-
-
-
-
-EOS
-
-STATIC_RESULT = <<'EOS'
-
-EOS
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/swf_fu/test/swf_fu_test.rb b/backup.rails2.3/plugins/swf_fu/test/swf_fu_test.rb
deleted file mode 100644
index 64a2a8bf..00000000
--- a/backup.rails2.3/plugins/swf_fu/test/swf_fu_test.rb
+++ /dev/null
@@ -1,159 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/test_helper')
-require File.expand_path(File.dirname(__FILE__)+'/results')
-
-class SwfFuTest < ActionView::TestCase
- def assert_same_stripped(expect, test)
- expect, test = [expect, test].map{|s| s.split("\n").map(&:strip)}
- same = expect & test
- delta_expect, delta_test = [expect, test].map{|a| a-same}
- STDOUT << "\n\n---- Actual result: ----\n" << test.join("\n") << "\n---------\n" unless delta_expect == delta_test
- assert_equal delta_expect, delta_test
- end
-
- context "swf_path" do
- context "with no special asset host" do
- should "deduce the extension" do
- assert_equal swf_path("example.swf"), swf_path("example")
- assert_starts_with "/swfs/example.swf", swf_path("example.swf")
- end
-
- should "accept relative paths" do
- assert_starts_with "/swfs/whatever/example.swf", swf_path("whatever/example.swf")
- end
-
- should "leave full paths alone" do
- ["/full/path.swf", "http://www.example.com/whatever.swf"].each do |p|
- assert_starts_with p, swf_path(p)
- end
- end
- end
-
- context "with custom asset host" do
- HOST = "http://assets.example.com"
- setup do
- ActionController::Base.asset_host = HOST
- end
-
- teardown do
- ActionController::Base.asset_host = nil
- end
-
- should "take it into account" do
- assert_equal "#{HOST}/swfs/whatever.swf", swf_path("whatever")
- end
- end
- end
-
- context "swf_tag" do
- COMPLEX_OPTIONS = { :width => "456", :height => 123,
- :flashvars => {:myVar => "value 1 > 2"}.freeze,
- :javascript_class => "SomeClass",
- :initialize => {:be => "good"}.freeze,
- :parameters => {:play => true}.freeze
- }.freeze
-
- should "understand size" do
- assert_equal swf_tag("hello", :size => "123x456"),
- swf_tag("hello", :width => 123, :height => "456")
- end
-
- should "only accept valid modes" do
- assert_raise(ArgumentError) { swf_tag("xyz", :mode => :xyz) }
- end
-
- context "with custom defaults" do
- setup do
- test = {:flashvars=> {:xyz => "abc", :hello => "world"}.freeze, :mode => :static, :size => "400x300"}.freeze
- @expect = swf_tag("test", test)
- @expect_with_hello = swf_tag("test", :flashvars => {:xyz => "abc", :hello => "my friend"}, :mode => :static, :size => "400x300")
- ActionView::Base.swf_default_options = test
- end
-
- should "respect them" do
- assert_equal @expect, swf_tag("test")
- end
-
- should "merge suboptions" do
- assert_equal @expect_with_hello, swf_tag("test", :flashvars => {:hello => "my friend"}.freeze)
- end
-
- teardown { ActionView::Base.swf_default_options = {} }
- end
-
- context "with proc options" do
- should "call them" do
- expect = swf_tag("test", :id => "generated_id_for_test")
- assert_equal expect, swf_tag("test", :id => Proc.new{|arg| "generated_id_for_#{arg}"})
- end
-
- should "call global default's everytime" do
- expect1 = swf_tag("test", :id => "call_number_1")
- expect2 = swf_tag("test", :id => "call_number_2")
- cnt = 0
- ActionView::Base.swf_default_options = { :id => Proc.new{ "call_number_#{cnt+=1}" }}
- assert_equal expect1, swf_tag("test")
- assert_equal expect2, swf_tag("test")
- end
- end
-
- context "with static mode" do
- setup { ActionView::Base.swf_default_options = {:mode => :static} }
-
- should "deal with string flashvars" do
- assert_equal swf_tag("hello", :flashvars => "xyz=abc", :mode => :static),
- swf_tag("hello", :flashvars => {:xyz => "abc"}, :mode => :static)
- end
-
- should "produce the expected code" do
- assert_same_stripped STATIC_RESULT, swf_tag("mySwf", COMPLEX_OPTIONS.merge(:html_options => {:class => "lots"}.freeze).freeze)
- end
-
- teardown { ActionView::Base.swf_default_options = {} }
- end
-
- context "with dynamic mode" do
- should "produce the expected code" do
- assert_same_stripped DYNAMIC_RESULT, swf_tag("mySwf", COMPLEX_OPTIONS)
- end
-
- end
-
- should "enforce HTML id validity" do
- div_result = '
-
-'
- assert_match /#{div_result}/, swf_tag("123-456_ok$!+X")
- obj_result = '"id":"swf_123-456_ok___X"'
- assert_match /#{obj_result}/, swf_tag("123-456_ok$!+X")
- end
-
- should "treat initialize arrays as list of parameters" do
- assert_match 'initialize("hello","world")', swf_tag("mySwf", :initialize => ["hello", "world"], :javascript_class => "SomeClass")
- end
-
- if ActiveSupport.const_defined?(:SafeBuffer)
- should "be html safe" do
- assert swf_tag("test").html_safe?
- end
- end
- end
-
- context "flashobject_tag" do
- should "be the same as swf_tag with different defaults" do
- assert_same_stripped swf_tag("mySwf",
- :auto_install => nil,
- :parameters => {:scale => "noscale", :bgcolor => "#ffffff"},
- :flashvars => {:lzproxied => false},
- :id => "myFlash"
- ), flashobject_tag("mySwf", :flash_id => "myFlash")
- end
-
- should "be the same with custom settings" do
- assert_same_stripped swf_tag("mySwf",
- :auto_install => nil,
- :parameters => {:scale => "noborder", :bgcolor => "#ffffff"},
- :flashvars => {:answer_is => 42},
- :id => "myFlash"
- ), flashobject_tag("mySwf", :flash_id => "myFlash", :parameters => {:scale => "noborder"}, :variables => {:answer_is => 42})
- end
- end
-end
-
diff --git a/backup.rails2.3/plugins/swf_fu/test/test_helper.rb b/backup.rails2.3/plugins/swf_fu/test/test_helper.rb
deleted file mode 100644
index 58d113f8..00000000
--- a/backup.rails2.3/plugins/swf_fu/test/test_helper.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-gem 'activesupport', '~> 2.3'
-require 'active_support'
-gem 'activerecord', '~> 2.3'
-require 'active_record'
-gem 'actionpack', '~> 2.3'
-require 'active_support'
-require 'action_view'
-require 'action_controller'
-
-#require File.dirname(__FILE__)+'/../../../../config/environment.rb'
-require 'action_view/test_case'
-require "action_controller/test_process"
-require 'shoulda'
-require File.dirname(__FILE__) + '/../init'
-
-def assert_starts_with(start, what)
- assert what.starts_with?(start), "#{what} does not start with #{start}"
-end
diff --git a/backup.rails2.3/plugins/swf_fu/uninstall.rb b/backup.rails2.3/plugins/swf_fu/uninstall.rb
deleted file mode 100644
index bc3c1b57..00000000
--- a/backup.rails2.3/plugins/swf_fu/uninstall.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-require "fileutils"
-
-dest = File.dirname(__FILE__) + "/../../../public"
-FileUtils.rm "#{dest}/javascripts/swfobject.js" rescue puts "Warning: swfobject.js could not be deleted"
-FileUtils.rm "#{dest}/swfs/expressInstall.swf" rescue puts "Warning: expressInstall.swf could not be deleted"
-Dir.rmdir "#{dest}/swfs/" rescue "don't worry if directory is not empty"
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/translate/MIT-LICENSE b/backup.rails2.3/plugins/translate/MIT-LICENSE
deleted file mode 100644
index 9376605b..00000000
--- a/backup.rails2.3/plugins/translate/MIT-LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2009 [name of plugin creator]
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/backup.rails2.3/plugins/translate/README b/backup.rails2.3/plugins/translate/README
deleted file mode 100644
index e2732dc9..00000000
--- a/backup.rails2.3/plugins/translate/README
+++ /dev/null
@@ -1,63 +0,0 @@
-Translate
-=========
-
-This plugin provides a web interface for translating Rails I18n texts (requires Rails 2.2 or higher) from one locale to another. The plugin has been tested only with the simple I18n backend that ships with Rails. I18n texts are read from and written to YAML files under config/locales.
-
-To translate to a new locale you need to add a YAML file for that locale that contains the locale as the top key and at least one translation.
-
-Please note that there are certain I18n keys that map to Array objects rather than strings and those are currently not dealt with by the translation UI. This means that Rails built in keys such as date.day_names need to be translated manually directly in the YAML file.
-
-To get the translation UI to write the YAML files in UTF8 you need to install the ya2yaml gem.
-
-The translation UI finds all I18n keys by extracting them from I18n lookups in your application source code. In addition it adds all :en and default locale keys from the I18n backend.
-
-- Updated: Each string in the UI now has an "Auto Translate" link which will send the original text to Google Translate and will input the returned translation into the form field for further clean up and review prior to saving.
-
-
-Rake Tasks
-=========
-
-In addition to the web UI this plugin adds the following rake tasks:
-
-translate:untranslated
-translate:missing
-translate:remove_obsolete_keys
-translate:merge_keys
-translate:google
-translate:changed
-
-The missing task shows you any I18n keys in your code that do not have translations in the YAML file for your default locale, i.e. config/locales/sv.yml.
-
-The merge_keys task is supposed to be used in conjunction with Sven Fuch's Rails I18n TextMate bundle (http://github.com/svenfuchs/rails-i18n/tree/master). Texts and keys extracted with the TextMate bundle end up in the temporary file log/translations.yml. When you run the merge_keys rake task the keys are moved over to the corresponding I18n locale file, i.e. config/locales/sv.yml. The merge_keys task also checks for overwrites of existing keys by warning you that one of your extracted keys already exists with a different translation.
-
-The google task is used for auto translating from one locale to another using Google Translate.
-
-The changed rake task can show you between one YAML file to another which keys have had their texts changed.
-
-Installation
-=========
-Obtain the source with:
-
-./script/plugin install git://github.com/newsdesk/translate.git
-
-To mount the plugin, add the following to your config/routes.rb file:
-
-Translate::Routes.translation_ui(map) if RAILS_ENV != "production"
-
-Now visit /translate in your web browser to start translating.
-
-Dependencies
-=========
-
-- Rails 2.2 or higher
-- The ya2yaml gem if you want your YAML files written in UTF8 encoding.
-
-Authors
-=========
-
-- Peter Marklund (programming)
-- Joakim Westerlund (web design)
-
-Many thanks to http://newsdesk.se for sponsoring the development of this plugin.
-
-Copyright (c) 2009 Peter Marklund, released under the MIT license
diff --git a/backup.rails2.3/plugins/translate/Rakefile b/backup.rails2.3/plugins/translate/Rakefile
deleted file mode 100644
index 7e1954b7..00000000
--- a/backup.rails2.3/plugins/translate/Rakefile
+++ /dev/null
@@ -1,11 +0,0 @@
-require 'rake'
-require 'spec/rake/spectask'
-
-desc 'Default: run specs.'
-task :default => :spec
-
-desc 'Run the specs'
-Spec::Rake::SpecTask.new(:spec) do |t|
- t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
- t.spec_files = FileList['spec/**/*_spec.rb']
-end
diff --git a/backup.rails2.3/plugins/translate/init.rb b/backup.rails2.3/plugins/translate/init.rb
deleted file mode 100644
index 18707f83..00000000
--- a/backup.rails2.3/plugins/translate/init.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require 'translate'
-
-# TODO: Use new method available_locales once Rails is upgraded, see:
-# http://github.com/svenfuchs/i18n/commit/411f8fe7c8f3f89e9b6b921fa62ed66cb92f3af4
-def I18n.valid_locales
- I18n.backend.send(:init_translations) unless I18n.backend.initialized?
- backend.send(:translations).keys.reject { |locale| locale == :root }
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate.rb b/backup.rails2.3/plugins/translate/lib/translate.rb
deleted file mode 100644
index 39629bf4..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-module Translate
-end
-
-require File.join(File.dirname(__FILE__), "translate_controller")
-require File.join(File.dirname(__FILE__), "translate_helper")
-Dir[File.join(File.dirname(__FILE__), "translate", "*.rb")].each do |file|
- require file
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate/file.rb b/backup.rails2.3/plugins/translate/lib/translate/file.rb
deleted file mode 100644
index c8ae93b0..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate/file.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-require 'fileutils'
-
-class Translate::File
- attr_accessor :path
-
- def initialize(path)
- self.path = path
- end
-
- def write(keys)
- FileUtils.mkdir_p File.dirname(path)
- File.open(path, "w") do |file|
- file.puts keys_to_yaml(Translate::File.deep_stringify_keys(keys))
- end
- end
-
- def read
- File.exists?(path) ? YAML::load(IO.read(path)) : {}
- end
-
- # Stringifying keys for prettier YAML
- def self.deep_stringify_keys(hash)
- hash.inject({}) { |result, (key, value)|
- value = deep_stringify_keys(value) if value.is_a? Hash
- result[(key.to_s rescue key) || key] = value
- result
- }
- end
-
- private
- def keys_to_yaml(keys)
- # Using ya2yaml, if available, for UTF8 support
- keys.respond_to?(:ya2yaml) ? keys.ya2yaml(:escape_as_utf8 => true) : keys.to_yaml
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate/keys.rb b/backup.rails2.3/plugins/translate/lib/translate/keys.rb
deleted file mode 100644
index 3bee3c41..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate/keys.rb
+++ /dev/null
@@ -1,152 +0,0 @@
-require 'pathname'
-
-class Translate::Keys
- # Allows keys extracted from lookups in files to be cached
- def self.files
- @@files ||= Translate::Keys.new.files
- end
-
- # Allows flushing of the files cache
- def self.files=(files)
- @@files = files
- end
-
- def files
- @files ||= extract_files
- end
- alias_method :to_hash, :files
-
- def keys
- files.keys
- end
- alias_method :to_a, :keys
-
- def i18n_keys(locale)
- I18n.backend.send(:init_translations) unless I18n.backend.initialized?
- Translate::Keys.to_shallow_hash(I18n.backend.send(:translations)[locale.to_sym]).keys.sort
- end
-
- def untranslated_keys
- Translate::Keys.translated_locales.inject({}) do |missing, locale|
- missing[locale] = i18n_keys(I18n.default_locale).map do |key|
- I18n.backend.send(:lookup, locale, key).nil? ? key : nil
- end.compact
- missing
- end
- end
-
- def missing_keys
- locale = I18n.default_locale; yaml_keys = {}
- yaml_keys = Translate::Storage.file_paths(locale).inject({}) do |keys, path|
- keys = keys.deep_merge(Translate::File.new(path).read[locale.to_s])
- end
- files.reject { |key, file| self.class.contains_key?(yaml_keys, key) }
- end
-
- def self.translated_locales
- I18n.available_locales.reject { |locale| [:root, I18n.default_locale.to_sym].include?(locale) }
- end
-
- # Checks if a nested hash contains the keys in dot separated I18n key.
- #
- # Example:
- #
- # hash = {
- # :foo => {
- # :bar => {
- # :baz => 1
- # }
- # }
- # }
- #
- # contains_key?("foo", key) # => true
- # contains_key?("foo.bar", key) # => true
- # contains_key?("foo.bar.baz", key) # => true
- # contains_key?("foo.bar.baz.bla", key) # => false
- #
- def self.contains_key?(hash, key)
- keys = key.to_s.split(".")
- return false if keys.empty?
- !keys.inject(HashWithIndifferentAccess.new(hash)) do |memo, key|
- memo.is_a?(Hash) ? memo.try(:[], key) : nil
- end.nil?
- end
-
- # Convert something like:
- #
- # {
- # :pressrelease => {
- # :label => {
- # :one => "Pressmeddelande"
- # }
- # }
- # }
- #
- # to:
- #
- # {'pressrelease.label.one' => "Pressmeddelande"}
- #
- def self.to_shallow_hash(hash)
- hash.inject({}) do |shallow_hash, (key, value)|
- if value.is_a?(Hash)
- to_shallow_hash(value).each do |sub_key, sub_value|
- shallow_hash[[key, sub_key].join(".")] = sub_value
- end
- else
- shallow_hash[key.to_s] = value
- end
- shallow_hash
- end
- end
-
- # Convert something like:
- #
- # {'pressrelease.label.one' => "Pressmeddelande"}
- #
- # to:
- #
- # {
- # :pressrelease => {
- # :label => {
- # :one => "Pressmeddelande"
- # }
- # }
- # }
- def self.to_deep_hash(hash)
- hash.inject({}) do |deep_hash, (key, value)|
- keys = key.to_s.split('.').reverse
- leaf_key = keys.shift
- key_hash = keys.inject({leaf_key.to_sym => value}) { |hash, key| {key.to_sym => hash} }
- deep_merge!(deep_hash, key_hash)
- deep_hash
- end
- end
-
- # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
- def self.deep_merge!(hash1, hash2)
- merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
- hash1.merge!(hash2, &merger)
- end
-
- private
-
- def extract_files
- files_to_scan.inject(HashWithIndifferentAccess.new) do |files, file|
- IO.read(file).scan(i18n_lookup_pattern).flatten.map(&:to_sym).each do |key|
- files[key] ||= []
- path = Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(Rails.root)).to_s
- files[key] << path if !files[key].include?(path)
- end
- files
- end
- end
-
- def i18n_lookup_pattern
- /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?'([a-z0-9_]+.[a-z0-9_.]+)'\)?/
- end
-
- def files_to_scan
- Dir.glob(File.join(Translate::Storage.root_dir, "{app,config,lib}", "**","*.{rb,erb,rhtml}")) +
- Dir.glob(File.join(Translate::Storage.root_dir, "public", "javascripts", "**","*.js"))
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate/log.rb b/backup.rails2.3/plugins/translate/lib/translate/log.rb
deleted file mode 100644
index 9b5b3148..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate/log.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-class Translate::Log
- attr_accessor :from_locale, :to_locale, :keys
-
- def initialize(from_locale, to_locale, keys)
- self.from_locale = from_locale
- self.to_locale = to_locale
- self.keys = keys
- end
-
- def write_to_file
- current_texts = File.exists?(file_path) ? file.read : {}
- current_texts.merge!(from_texts)
- file.write(current_texts)
- end
-
- def read
- file.read
- end
-
- private
- def file
- @file ||= Translate::File.new(file_path)
- end
-
- def from_texts
- Translate::File.deep_stringify_keys(Translate::Keys.to_deep_hash(keys.inject({}) do |hash, key|
- hash[key] = I18n.backend.send(:lookup, from_locale, key)
- hash
- end))
- end
-
- def file_path
- File.join(Rails.root, "config", "locales", "log", "from_#{from_locale}_to_#{to_locale}.yml")
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate/routes.rb b/backup.rails2.3/plugins/translate/lib/translate/routes.rb
deleted file mode 100644
index 8d02c869..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate/routes.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-module Translate
- class Routes
- def self.translation_ui(map)
- map.with_options(:controller => 'translate') do |t|
- t.translate_list 'translate'
- t.translate 'translate/translate', :action => 'translate'
- t.translate_reload 'translate/reload', :action => 'reload'
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate/storage.rb b/backup.rails2.3/plugins/translate/lib/translate/storage.rb
deleted file mode 100644
index 2b9a3858..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate/storage.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-class Translate::Storage
- attr_accessor :locale
-
- def initialize(locale)
- self.locale = locale.to_sym
- end
-
- def write_to_file
- Translate::File.new(file_path).write(keys)
- end
-
- def self.file_paths(locale)
- Dir.glob(File.join(root_dir, "config", "locales", "**","#{locale}.yml"))
- end
-
- def self.root_dir
- Rails.root
- end
-
- private
- def keys
- {locale => I18n.backend.send(:translations)[locale]}
- end
-
- def file_path
- File.join(Translate::Storage.root_dir, "config", "locales", "#{locale}.yml")
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate_controller.rb b/backup.rails2.3/plugins/translate/lib/translate_controller.rb
deleted file mode 100644
index d06e171e..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate_controller.rb
+++ /dev/null
@@ -1,165 +0,0 @@
-class TranslateController < ActionController::Base
- # It seems users with active_record_store may get a "no :secret given" error if we don't disable csrf protection,
- skip_before_filter :verify_authenticity_token
-
- prepend_view_path(File.join(File.dirname(__FILE__), "..", "views"))
- layout 'translate'
-
- before_filter :init_translations
- before_filter :set_locale
-
- def index
- initialize_keys
- filter_by_key_pattern
- filter_by_text_pattern
- filter_by_translated_or_changed
- sort_keys
- paginate_keys
- @total_entries = @keys.size
- end
-
- def translate
- I18n.backend.store_translations(@to_locale, Translate::Keys.to_deep_hash(params[:key]))
- Translate::Storage.new(@to_locale).write_to_file
- Translate::Log.new(@from_locale, @to_locale, params[:key].keys).write_to_file
- force_init_translations # Force reload from YAML file
- flash[:notice] = "Translations stored"
- redirect_to params.slice(:filter, :sort_by, :key_type, :key_pattern, :text_type, :text_pattern).merge({:action => :index})
- end
-
- def reload
- Translate::Keys.files = nil
- redirect_to :action => 'index'
- end
-
- private
- def initialize_keys
- @files = Translate::Keys.files
- @keys = (@files.keys.map(&:to_s) + Translate::Keys.new.i18n_keys(@from_locale)).uniq
- @keys.reject! do |key|
- from_text = lookup(@from_locale, key)
- # When translating from one language to another, make sure there is a text to translate from.
- # Always exclude non string translation objects as we don't support editing them in the UI.
- (@from_locale != @to_locale && !from_text.present?) || (from_text.present? && !from_text.is_a?(String))
- end
- end
-
- def lookup(locale, key)
- I18n.backend.send(:lookup, locale, key)
- end
- helper_method :lookup
-
- def filter_by_translated_or_changed
- params[:filter] ||= 'all'
- return if params[:filter] == 'all'
- @keys.reject! do |key|
- case params[:filter]
- when 'untranslated'
- lookup(@to_locale, key).present?
- when 'translated'
- lookup(@to_locale, key).blank?
- when 'changed'
- old_from_text(key).blank? || lookup(@from_locale, key) == old_from_text(key)
- else
- raise "Unknown filter '#{params[:filter]}'"
- end
- end
- end
-
- def filter_by_key_pattern
- return if params[:key_pattern].blank?
- @keys.reject! do |key|
- case params[:key_type]
- when "starts_with"
- !key.starts_with?(params[:key_pattern])
- when "contains"
- key.index(params[:key_pattern]).nil?
- else
- raise "Unknown key_type '#{params[:key_type]}'"
- end
- end
- end
-
- def filter_by_text_pattern
- return if params[:text_pattern].blank?
- @keys.reject! do |key|
- case params[:text_type]
- when 'contains'
- !lookup(@from_locale, key).present? || !lookup(@from_locale, key).to_s.downcase.index(params[:text_pattern].downcase)
- when 'equals'
- !lookup(@from_locale, key).present? || lookup(@from_locale, key).to_s.downcase != params[:text_pattern].downcase
- else
- raise "Unknown text_type '#{params[:text_type]}'"
- end
- end
- end
-
- def sort_keys
- params[:sort_by] ||= "key"
- case params[:sort_by]
- when "key"
- @keys.sort!
- when "text"
- @keys.sort! do |key1, key2|
- if lookup(@from_locale, key1).present? && lookup(@from_locale, key2).present?
- lookup(@from_locale, key1).to_s.downcase <=> lookup(@from_locale, key2).to_s.downcase
- elsif lookup(@from_locale, key1).present?
- -1
- else
- 1
- end
- end
- else
- raise "Unknown sort_by '#{params[:sort_by]}'"
- end
- end
-
- def paginate_keys
- params[:page] ||= 1
- @paginated_keys = @keys[offset, per_page]
- end
-
- def offset
- (params[:page].to_i - 1) * per_page
- end
-
- def per_page
- 50
- end
- helper_method :per_page
-
- def init_translations
- I18n.backend.send(:init_translations) unless I18n.backend.initialized?
- end
-
- def force_init_translations
- I18n.backend.send(:init_translations)
- end
-
- def default_locale
- I18n.default_locale
- end
-
- def set_locale
- session[:from_locale] ||= default_locale
- session[:to_locale] ||= :en
- session[:from_locale] = params[:from_locale] if params[:from_locale].present?
- session[:to_locale] = params[:to_locale] if params[:to_locale].present?
- @from_locale = session[:from_locale].to_sym
- @to_locale = session[:to_locale].to_sym
- end
-
- def old_from_text(key)
- return @old_from_text[key] if @old_from_text && @old_from_text[key]
- @old_from_text = {}
- text = key.split(".").inject(log_hash) do |hash, k|
- hash ? hash[k] : nil
- end
- @old_from_text[key] = text
- end
- helper_method :old_from_text
-
- def log_hash
- @log_hash ||= Translate::Log.new(@from_locale, @to_locale, {}).read
- end
-end
diff --git a/backup.rails2.3/plugins/translate/lib/translate_helper.rb b/backup.rails2.3/plugins/translate/lib/translate_helper.rb
deleted file mode 100644
index cb4c400f..00000000
--- a/backup.rails2.3/plugins/translate/lib/translate_helper.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-module TranslateHelper
- def simple_filter(labels, param_name = 'filter', selected_value = nil)
- selected_value ||= params[param_name]
- filter = []
- labels.each do |item|
- if item.is_a?(Array)
- type, label = item
- else
- type = label = item
- end
- if type.to_s == selected_value.to_s
- filter << "#{label}"
- else
- link_params = params.merge({param_name.to_s => type})
- link_params.merge!({"page" => nil}) if param_name.to_s != "page"
- filter << link_to(label, link_params)
- end
- end
- filter.join(" | ")
- end
-
- def n_lines(text, line_size)
- n_lines = 1
- if text.present?
- n_lines = text.split("\n").size
- if n_lines == 1 && text.length > line_size
- n_lines = text.length / line_size + 1
- end
- end
- n_lines
- end
-
- def translate_javascript_includes
- sources = []
- if File.exists?(File.join(Rails.root, "public", "javascripts", "prototype.js"))
- sources << "/javascripts/prototype.js"
- else
- sources << "http://ajax.googleapis.com/ajax/libs/prototype/1.6.1.0/prototype.js"
- end
- sources << "http://www.google.com/jsapi"
- sources.map do |src|
- %Q{}
- end.join("\n")
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/controllers/translate_controller_spec.rb b/backup.rails2.3/plugins/translate/spec/controllers/translate_controller_spec.rb
deleted file mode 100644
index e384811b..00000000
--- a/backup.rails2.3/plugins/translate/spec/controllers/translate_controller_spec.rb
+++ /dev/null
@@ -1,129 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe TranslateController do
- describe "index" do
- before(:each) do
- controller.stub!(:per_page).and_return(1)
- I18n.backend.stub!(:translations).and_return(i18n_translations)
- I18n.backend.instance_eval { @initialized = true }
- keys = mock(:keys)
- keys.stub!(:i18n_keys).and_return(['vendor.foobar'])
- Translate::Keys.should_receive(:new).and_return(keys)
- Translate::Keys.should_receive(:files).and_return(files)
- I18n.stub!(:valid_locales).and_return([:en, :sv])
- I18n.stub!(:default_locale).and_return(:sv)
- end
-
- it "shows sorted paginated keys from the translate from locale and extracted keys by default" do
- get_page :index
- assigns(:from_locale).should == :sv
- assigns(:to_locale).should == :en
- assigns(:files).should == files
- assigns(:keys).sort.should == ['articles.new.page_title', 'home.page_title', 'vendor.foobar']
- assigns(:paginated_keys).should == ['articles.new.page_title']
- end
-
- it "can be paginated with the page param" do
- get_page :index, :page => 2
- assigns(:files).should == files
- assigns(:paginated_keys).should == ['home.page_title']
- end
-
- it "accepts a key_pattern param with key_type=starts_with" do
- get_page :index, :key_pattern => 'articles', :key_type => 'starts_with'
- assigns(:files).should == files
- assigns(:paginated_keys).should == ['articles.new.page_title']
- assigns(:total_entries).should == 1
- end
-
- it "accepts a key_pattern param with key_type=contains" do
- get_page :index, :key_pattern => 'page_', :key_type => 'contains'
- assigns(:files).should == files
- assigns(:total_entries).should == 2
- assigns(:paginated_keys).should == ['articles.new.page_title']
- end
-
- it "accepts a filter=untranslated param" do
- get_page :index, :filter => 'untranslated'
- assigns(:total_entries).should == 2
- assigns(:paginated_keys).should == ['articles.new.page_title']
- end
-
- it "accepts a filter=translated param" do
- get_page :index, :filter => 'translated'
- assigns(:total_entries).should == 1
- assigns(:paginated_keys).should == ['vendor.foobar']
- end
-
- it "accepts a filter=changed param" do
- log = mock(:log)
- old_translations = {:home => {:page_title => "Skapar ny artikel"}}
- log.should_receive(:read).and_return(Translate::File.deep_stringify_keys(old_translations))
- Translate::Log.should_receive(:new).with(:sv, :en, {}).and_return(log)
- get_page :index, :filter => 'changed'
- assigns(:total_entries).should == 1
- assigns(:keys).should == ["home.page_title"]
- end
-
- def i18n_translations
- HashWithIndifferentAccess.new({
- :en => {
- :vendor => {
- :foobar => "Foo Baar"
- }
- },
- :sv => {
- :articles => {
- :new => {
- :page_title => "Skapa ny artikel"
- }
- },
- :home => {
- :page_title => "Välkommen till I18n"
- },
- :vendor => {
- :foobar => "Fobar"
- }
- }
- })
- end
-
- def files
- HashWithIndifferentAccess.new({
- :'home.page_title' => ["app/views/home/index.rhtml"],
- :'general.back' => ["app/views/articles/new.rhtml", "app/views/categories/new.rhtml"],
- :'articles.new.page_title' => ["app/views/articles/new.rhtml"]
- })
- end
- end
-
- describe "translate" do
- it "should store translations to I18n backend and then write them to a YAML file" do
- session[:from_locale] = :sv
- session[:to_locale] = :en
- translations = {
- :articles => {
- :new => {
- :title => "New Article"
- }
- },
- :category => "Category"
- }
- key_param = {'articles.new.title' => "New Article", "category" => "Category"}
- I18n.backend.should_receive(:store_translations).with(:en, translations)
- storage = mock(:storage)
- storage.should_receive(:write_to_file)
- Translate::Storage.should_receive(:new).with(:en).and_return(storage)
- log = mock(:log)
- log.should_receive(:write_to_file)
- Translate::Log.should_receive(:new).with(:sv, :en, key_param.keys).and_return(log)
- post :translate, "key" => key_param
- response.should be_redirect
- end
- end
-
- def get_page(*args)
- get(*args)
- response.should be_success
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/file_spec.rb b/backup.rails2.3/plugins/translate/spec/file_spec.rb
deleted file mode 100644
index 5f94f5a9..00000000
--- a/backup.rails2.3/plugins/translate/spec/file_spec.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require 'fileutils'
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Translate::File do
- describe "write" do
- before(:each) do
- @file = Translate::File.new(file_path)
- end
-
- after(:each) do
- FileUtils.rm(file_path)
- end
-
- it "writes all I18n messages for a locale to YAML file" do
- @file.write(translations)
- @file.read.should == Translate::File.deep_stringify_keys(translations)
- end
-
- def translations
- {
- :en => {
- :article => {
- :title => "One Article"
- },
- :category => "Category"
- }
- }
- end
- end
-
- describe "deep_stringify_keys" do
- it "should convert all keys in a hash to strings" do
- Translate::File.deep_stringify_keys({
- :en => {
- :article => {
- :title => "One Article"
- },
- :category => "Category"
- }
- }).should == {
- "en" => {
- "article" => {
- "title" => "One Article"
- },
- "category" => "Category"
- }
- }
- end
- end
-
- def file_path
- File.join(File.dirname(__FILE__), "files", "en.yml")
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/app/models/article.rb b/backup.rails2.3/plugins/translate/spec/files/translate/app/models/article.rb
deleted file mode 100644
index d151e316..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/app/models/article.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-class Article < ActiveRecord::Base
- def validate
- # t('li')
- errors.add_to_base([t(:'article.key1') + "#{t('article.key2')}"])
- I18n.t 'article.key3'
- I18n.t 'article.key3'
- I18n.t :'article.key4'
- I18n.translate :'article.key5'
- 'bla bla t' + "blubba bla" + ' foobar'
- 'bla bla t ' + "blubba bla" + ' foobar'
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.erb b/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.erb
deleted file mode 100644
index 2146f874..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t(:'category_erb.key1') %>
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html b/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html
deleted file mode 100644
index 0947d174..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html
+++ /dev/null
@@ -1 +0,0 @@
-t(:'category_html.key1')
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html.erb b/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html.erb
deleted file mode 100644
index a226ccff..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t(:'category_html_erb.key1') %>
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.rhtml b/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.rhtml
deleted file mode 100644
index 235e5173..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/app/views/category.rhtml
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-<%= t(:'category_rhtml.key1') %>
diff --git a/backup.rails2.3/plugins/translate/spec/files/translate/public/javascripts/application.js b/backup.rails2.3/plugins/translate/spec/files/translate/public/javascripts/application.js
deleted file mode 100644
index a673ca02..00000000
--- a/backup.rails2.3/plugins/translate/spec/files/translate/public/javascripts/application.js
+++ /dev/null
@@ -1 +0,0 @@
-I18n.t('js.alert')
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/translate/spec/keys_spec.rb b/backup.rails2.3/plugins/translate/spec/keys_spec.rb
deleted file mode 100644
index 3b0bd629..00000000
--- a/backup.rails2.3/plugins/translate/spec/keys_spec.rb
+++ /dev/null
@@ -1,179 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'fileutils'
-
-describe Translate::Keys do
- before(:each) do
- I18n.stub!(:default_locale).and_return(:en)
- @keys = Translate::Keys.new
- Translate::Storage.stub!(:root_dir).and_return(i18n_files_dir)
- end
-
- describe "to_a" do
- it "extracts keys from I18n lookups in .rb, .html.erb, and .rhtml files" do
- @keys.to_a.map(&:to_s).sort.should == ['article.key1', 'article.key2', 'article.key3', 'article.key4', 'article.key5',
- 'category_erb.key1', 'category_html_erb.key1', 'category_rhtml.key1', 'js.alert']
- end
- end
-
- describe "to_hash" do
- it "return a hash with I18n keys and file lists" do
- @keys.to_hash[:'article.key3'].should == ["vendor/plugins/translate/spec/files/translate/app/models/article.rb"]
- end
- end
-
- describe "i18n_keys" do
- before(:each) do
- I18n.backend.send(:init_translations) unless I18n.backend.initialized?
- end
-
- it "should return all keys in the I18n backend translations hash" do
- I18n.backend.should_receive(:translations).and_return(translations)
- @keys.i18n_keys(:en).should == ['articles.new.page_title', 'categories.flash.created', 'empty', 'home.about']
- end
-
- describe "untranslated_keys" do
- before(:each) do
- I18n.backend.stub!(:translations).and_return(translations)
- end
-
- it "should return a hash with keys with missing translations in each locale" do
- @keys.untranslated_keys.should == {
- :sv => ['articles.new.page_title', 'categories.flash.created', 'empty']
- }
- end
- end
-
- describe "missing_keys" do
- before(:each) do
- @file_path = File.join(i18n_files_dir, "config", "locales", "en.yml")
- Translate::File.new(@file_path).write({
- :en => {
- :home => {
- :page_title => false,
- :intro => {
- :one => "intro one",
- :other => "intro other"
- }
- }
- }
- })
- end
-
- after(:each) do
- FileUtils.rm(@file_path)
- end
-
- it "should return a hash with keys that are not in the locale file" do
- @keys.stub!(:files).and_return({
- :'home.page_title' => "app/views/home/index.rhtml",
- :'home.intro' => 'app/views/home/index.rhtml',
- :'home.signup' => "app/views/home/_signup.rhtml",
- :'about.index.page_title' => "app/views/about/index.rhtml"
- })
- @keys.missing_keys.should == {
- :'home.signup' => "app/views/home/_signup.rhtml",
- :'about.index.page_title' => "app/views/about/index.rhtml"
- }
- end
- end
-
- describe "contains_key?" do
- it "works" do
- hash = {
- :foo => {
- :bar => {
- :baz => false
- }
- }
- }
- Translate::Keys.contains_key?(hash, "").should be_false
- Translate::Keys.contains_key?(hash, "foo").should be_true
- Translate::Keys.contains_key?(hash, "foo.bar").should be_true
- Translate::Keys.contains_key?(hash, "foo.bar.baz").should be_true
- Translate::Keys.contains_key?(hash, :"foo.bar.baz").should be_true
- Translate::Keys.contains_key?(hash, "foo.bar.baz.bla").should be_false
- end
- end
-
- describe "translated_locales" do
- before(:each) do
- I18n.stub!(:default_locale).and_return(:en)
- I18n.stub!(:available_locales).and_return([:sv, :no, :en, :root])
- end
-
- it "returns all avaiable except :root and the default" do
- Translate::Keys.translated_locales.should == [:sv, :no]
- end
- end
-
- describe "to_deep_hash" do
- it "convert shallow hash with dot separated keys to deep hash" do
- Translate::Keys.to_deep_hash(shallow_hash).should == deep_hash
- end
- end
-
- describe "to_shallow_hash" do
- it "converts a deep hash to a shallow one" do
- Translate::Keys.to_shallow_hash(deep_hash).should == shallow_hash
- end
- end
-
- ##########################################################################
- #
- # Helper Methods
- #
- ##########################################################################
-
- def translations
- {
- :en => {
- :home => {
- :about => "This site is about making money"
- },
- :articles => {
- :new => {
- :page_title => "New Article"
- }
- },
- :categories => {
- :flash => {
- :created => "Category created"
- }
- },
- :empty => nil
- },
- :sv => {
- :home => {
- :about => false
- }
- }
- }
- end
- end
-
- def shallow_hash
- {
- 'pressrelease.label.one' => "Pressmeddelande",
- 'pressrelease.label.other' => "Pressmeddelanden",
- 'article' => "Artikel",
- 'category' => ''
- }
- end
-
- def deep_hash
- {
- :pressrelease => {
- :label => {
- :one => "Pressmeddelande",
- :other => "Pressmeddelanden"
- }
- },
- :article => "Artikel",
- :category => ''
- }
- end
-
- def i18n_files_dir
- File.join(ENV['PWD'], "spec", "files", "translate")
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/log_spec.rb b/backup.rails2.3/plugins/translate/spec/log_spec.rb
deleted file mode 100644
index 7dc9f542..00000000
--- a/backup.rails2.3/plugins/translate/spec/log_spec.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require 'fileutils'
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Translate::Log do
- describe "write_to_file" do
- before(:each) do
- I18n.locale = :sv
- I18n.backend.store_translations(:sv, from_texts)
- keys = Translate::Keys.new
- @log = Translate::Log.new(:sv, :en, Translate::Keys.to_shallow_hash(from_texts).keys)
- @log.stub!(:file_path).and_return(file_path)
- FileUtils.rm_f file_path
- end
-
- after(:each) do
- FileUtils.rm_f file_path
- end
-
- it "writes new log file with from texts" do
- File.exists?(file_path).should be_false
- @log.write_to_file
- File.exists?(file_path).should be_true
- Translate::File.new(file_path).read.should == Translate::File.deep_stringify_keys(from_texts)
- end
-
- it "merges from texts with current texts in log file and re-writes the log file" do
- @log.write_to_file
- I18n.backend.store_translations(:sv, {:category => "Kategori ny"})
- @log.keys = ['category']
- @log.write_to_file
- Translate::File.new(file_path).read['category'].should == "Kategori ny"
- end
-
- def file_path
- File.join(File.dirname(__FILE__), "files", "from_sv_to_en.yml")
- end
-
- def from_texts
- {
- :article => {
- :title => "En artikel"
- },
- :category => "Kategori"
- }
- end
- end
-end
diff --git a/backup.rails2.3/plugins/translate/spec/spec_helper.rb b/backup.rails2.3/plugins/translate/spec/spec_helper.rb
deleted file mode 100644
index 5a919082..00000000
--- a/backup.rails2.3/plugins/translate/spec/spec_helper.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-begin
- # Using PWD here instead of File.dirname(__FILE__) to be able to symlink to plugin
- # from within a Rails app.
- require File.expand_path(ENV['PWD'] + '/../../../spec/spec_helper')
-rescue LoadError => e
- puts "You need to install rspec in your base app\n#{e.message}: #{e.backtrace.join("\n")}"
- exit
-end
-
-plugin_spec_dir = File.dirname(__FILE__)
-ActiveRecord::Base.logger = Logger.new(plugin_spec_dir + "/debug.log")
diff --git a/backup.rails2.3/plugins/translate/spec/storage_spec.rb b/backup.rails2.3/plugins/translate/spec/storage_spec.rb
deleted file mode 100644
index e6110c3d..00000000
--- a/backup.rails2.3/plugins/translate/spec/storage_spec.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Translate::Storage do
- describe "write_to_file" do
- before(:each) do
- @storage = Translate::Storage.new(:en)
- end
-
- it "writes all I18n messages for a locale to YAML file" do
- I18n.backend.should_receive(:translations).and_return(translations)
- @storage.stub!(:file_path).and_return(file_path)
- file = mock(:file)
- file.should_receive(:write).with(translations)
- Translate::File.should_receive(:new).with(file_path).and_return(file)
- @storage.write_to_file
- end
-
- def file_path
- File.join(File.dirname(__FILE__), "files", "en.yml")
- end
-
- def translations
- {
- :en => {
- :article => {
- :title => "One Article"
- },
- :category => "Category"
- }
- }
- end
- end
-end
diff --git a/backup.rails2.3/plugins/translate/tasks/translate.rake b/backup.rails2.3/plugins/translate/tasks/translate.rake
deleted file mode 100644
index a70b934c..00000000
--- a/backup.rails2.3/plugins/translate/tasks/translate.rake
+++ /dev/null
@@ -1,178 +0,0 @@
-require 'yaml'
-
-class Hash
- def deep_merge(other)
- # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
- merger = proc { |key, v1, v2| (Hash === v1 && Hash === v2) ? v1.merge(v2, &merger) : v2 }
- merge(other, &merger)
- end
-
- def set(keys, value)
- key = keys.shift
- if keys.empty?
- self[key] = value
- else
- self[key] ||= {}
- self[key].set keys, value
- end
- end
-
- if ENV['SORT']
- # copy of ruby's to_yaml method, prepending sort.
- # before each so we get an ordered yaml file
- def to_yaml( opts = {} )
- YAML::quick_emit( self, opts ) do |out|
- out.map( taguri, to_yaml_style ) do |map|
- sort.each do |k, v| #<- Adding sort.
- map.add( k, v )
- end
- end
- end
- end
- end
-end
-
-namespace :translate do
- desc "Show untranslated keys for locale LOCALE"
- task :untranslated => :environment do
- from_locale = I18n.default_locale
- untranslated = Translate::Keys.new.untranslated_keys
-
- messages = []
- untranslated.each do |locale, keys|
- keys.each do |key|
- from_text = I18n.backend.send(:lookup, from_locale, key)
- messages << "#{locale}.#{key} (#{from_locale}.#{key}='#{from_text}')"
- end
- end
-
- if messages.present?
- messages.each { |m| puts m }
- else
- puts "No untranslated keys"
- end
- end
-
- desc "Show I18n keys that are missing in the config/locales/default_locale.yml YAML file"
- task :missing => :environment do
- missing = Translate::Keys.new.missing_keys.inject([]) do |keys, (key, filename)|
- keys << "#{key} in \t #{filename} is missing"
- end
- puts missing.present? ? missing.join("\n") : "No missing translations in the default locale file"
- end
-
- desc "Remove all translation texts that are no longer present in the locale they were translated from"
- task :remove_obsolete_keys => :environment do
- I18n.backend.send(:init_translations)
- master_locale = ENV['LOCALE'] || I18n.default_locale
- Translate::Keys.translated_locales.each do |locale|
- texts = {}
- Translate::Keys.new.i18n_keys(locale).each do |key|
- if I18n.backend.send(:lookup, master_locale, key).to_s.present?
- texts[key] = I18n.backend.send(:lookup, locale, key)
- end
- end
- I18n.backend.send(:translations)[locale] = nil # Clear out all current translations
- I18n.backend.store_translations(locale, Translate::Keys.to_deep_hash(texts))
- Translate::Storage.new(locale).write_to_file
- end
- end
-
- desc "Merge I18n keys from log/translations.yml into config/locales/*.yml (for use with the Rails I18n TextMate bundle)"
- task :merge_keys => :environment do
- I18n.backend.send(:init_translations)
- new_translations = YAML::load(IO.read(File.join(Rails.root, "log", "translations.yml")))
- raise("Can only merge in translations in single locale") if new_translations.keys.size > 1
- locale = new_translations.keys.first
-
- overwrites = false
- Translate::Keys.to_shallow_hash(new_translations[locale]).keys.each do |key|
- new_text = key.split(".").inject(new_translations[locale]) { |hash, sub_key| hash[sub_key] }
- existing_text = I18n.backend.send(:lookup, locale.to_sym, key)
- if existing_text && new_text != existing_text
- puts "ERROR: key #{key} already exists with text '#{existing_text.inspect}' and would be overwritten by new text '#{new_text}'. " +
- "Set environment variable OVERWRITE=1 if you really want to do this."
- overwrites = true
- end
- end
-
- if !overwrites || ENV['OVERWRITE']
- I18n.backend.store_translations(locale, new_translations[locale])
- Translate::Storage.new(locale).write_to_file
- end
- end
-
- desc "Apply Google translate to auto translate all texts in locale ENV['FROM'] to locale ENV['TO']"
- task :google => :environment do
- raise "Please specify FROM and TO locales as environment variables" if ENV['FROM'].blank? || ENV['TO'].blank?
-
- # Depends on httparty gem
- # http://www.robbyonrails.com/articles/2009/03/16/httparty-goes-foreign
- class GoogleApi
- include HTTParty
- base_uri 'ajax.googleapis.com'
- def self.translate(string, to, from)
- tries = 0
- begin
- get("/ajax/services/language/translate",
- :query => {:langpair => "#{from}|#{to}", :q => string, :v => 1.0},
- :format => :json)
- rescue
- tries += 1
- puts("SLEEPING - retrying in 5...")
- sleep(5)
- retry if tries < 10
- end
- end
- end
-
- I18n.backend.send(:init_translations)
-
- start_at = Time.now
- translations = {}
- Translate::Keys.new.i18n_keys(ENV['FROM']).each do |key|
- from_text = I18n.backend.send(:lookup, ENV['FROM'], key).to_s
- to_text = I18n.backend.send(:lookup, ENV['TO'], key)
- if !from_text.blank? && to_text.blank?
- print "#{key}: '#{from_text[0, 40]}' => "
- if !translations[from_text]
- response = GoogleApi.translate(from_text, ENV['TO'], ENV['FROM'])
- translations[from_text] = response["responseData"] && response["responseData"]["translatedText"]
- end
- if !(translation = translations[from_text]).blank?
- translation.gsub!(/\(\(([a-z_.]+)\)\)/i, '{{\1}}')
- # Google translate sometimes replaces {{foobar}} with (()) foobar. We skip these
- if translation !~ /\(\(\)\)/
- puts "'#{translation[0, 40]}'"
- I18n.backend.store_translations(ENV['TO'].to_sym, Translate::Keys.to_deep_hash({key => translation}))
- else
- puts "SKIPPING since interpolations were messed up: '#{translation[0,40]}'"
- end
- else
- puts "NO TRANSLATION - #{response.inspect}"
- end
- end
- end
-
- puts "\nTime elapsed: #{(((Time.now - start_at) / 60) * 10).to_i / 10.to_f} minutes"
- Translate::Storage.new(ENV['TO'].to_sym).write_to_file
- end
-
- desc "List keys that have changed I18n texts between YAML file ENV['FROM_FILE'] and YAML file ENV['TO_FILE']. Set ENV['VERBOSE'] to see changes"
- task :changed => :environment do
- from_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['FROM_FILE']).read)
- to_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['TO_FILE']).read)
- from_hash.each do |key, from_value|
- if (to_value = to_hash[key]) && to_value != from_value
- key_without_locale = key[/^[^.]+\.(.+)$/, 1]
- if ENV['VERBOSE']
- puts "KEY: #{key_without_locale}"
- puts "FROM VALUE: '#{from_value}'"
- puts "TO VALUE: '#{to_value}'"
- else
- puts key_without_locale
- end
- end
- end
- end
-end
diff --git a/backup.rails2.3/plugins/translate/views/layouts/translate.rhtml b/backup.rails2.3/plugins/translate/views/layouts/translate.rhtml
deleted file mode 100644
index 58dbc5c3..00000000
--- a/backup.rails2.3/plugins/translate/views/layouts/translate.rhtml
+++ /dev/null
@@ -1,359 +0,0 @@
-
-
-
-
-
- <%= h(@page_title) %>
-
- <%= translate_javascript_includes %>
-
-
-
-
-
-
-
- this.values[handleIdx+1]))
- sliderValue = this.values[handleIdx+1];
- }
- sliderValue = this.getNearestValue(sliderValue);
- this.values[handleIdx] = sliderValue;
- this.value = this.values[0]; // assure backwards compat
-
- this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] =
- this.translateToPx(sliderValue);
-
- this.drawSpans();
- if(!this.dragging || !this.event) this.updateFinished();
- },
- setValueBy: function(delta, handleIdx) {
- this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta,
- handleIdx || this.activeHandleIdx || 0);
- },
- translateToPx: function(value) {
- return Math.round(
- ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) *
- (value - this.range.start)) + "px";
- },
- translateToValue: function(offset) {
- return ((offset/(this.trackLength-this.handleLength) *
- (this.range.end-this.range.start)) + this.range.start);
- },
- getRange: function(range) {
- var v = this.values.sortBy(Prototype.K);
- range = range || 0;
- return $R(v[range],v[range+1]);
- },
- minimumOffset: function(){
- return(this.isVertical() ? this.alignY : this.alignX);
- },
- maximumOffset: function(){
- return(this.isVertical() ?
- this.track.offsetHeight - this.alignY : this.track.offsetWidth - this.alignX);
- },
- isVertical: function(){
- return (this.axis == 'vertical');
- },
- drawSpans: function() {
- var slider = this;
- if(this.spans)
- $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
- if(this.options.startSpan)
- this.setSpan(this.options.startSpan,
- $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
- if(this.options.endSpan)
- this.setSpan(this.options.endSpan,
- $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
- },
- setSpan: function(span, range) {
- if(this.isVertical()) {
- span.style.top = this.translateToPx(range.start);
- span.style.height = this.translateToPx(range.end - range.start + this.range.start);
- } else {
- span.style.left = this.translateToPx(range.start);
- span.style.width = this.translateToPx(range.end - range.start + this.range.start);
- }
- },
- updateStyles: function() {
- this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
- Element.addClassName(this.activeHandle, 'selected');
- },
- startDrag: function(event) {
- if(Event.isLeftClick(event)) {
- if(!this.disabled){
- this.active = true;
-
- var handle = Event.element(event);
- var pointer = [Event.pointerX(event), Event.pointerY(event)];
- if(handle==this.track) {
- var offsets = Position.cumulativeOffset(this.track);
- this.event = event;
- this.setValue(this.translateToValue(
- (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
- ));
- var offsets = Position.cumulativeOffset(this.activeHandle);
- this.offsetX = (pointer[0] - offsets[0]);
- this.offsetY = (pointer[1] - offsets[1]);
- } else {
- // find the handle (prevents issues with Safari)
- while((this.handles.indexOf(handle) == -1) && handle.parentNode)
- handle = handle.parentNode;
-
- this.activeHandle = handle;
- this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
- this.updateStyles();
-
- var offsets = Position.cumulativeOffset(this.activeHandle);
- this.offsetX = (pointer[0] - offsets[0]);
- this.offsetY = (pointer[1] - offsets[1]);
- }
- }
- Event.stop(event);
- }
- },
- update: function(event) {
- if(this.active) {
- if(!this.dragging) this.dragging = true;
- this.draw(event);
- // fix AppleWebKit rendering
- if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
- Event.stop(event);
- }
- },
- draw: function(event) {
- var pointer = [Event.pointerX(event), Event.pointerY(event)];
- var offsets = Position.cumulativeOffset(this.track);
- pointer[0] -= this.offsetX + offsets[0];
- pointer[1] -= this.offsetY + offsets[1];
- this.event = event;
- this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
- if(this.initialized && this.options.onSlide)
- this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
- },
- endDrag: function(event) {
- if(this.active && this.dragging) {
- this.finishDrag(event, true);
- Event.stop(event);
- }
- this.active = false;
- this.dragging = false;
- },
- finishDrag: function(event, success) {
- this.active = false;
- this.dragging = false;
- this.updateFinished();
- },
- updateFinished: function() {
- if(this.initialized && this.options.onChange)
- this.options.onChange(this.values.length>1 ? this.values : this.value, this);
- this.event = null;
- }
-}
\ No newline at end of file
diff --git a/backup.rails2.3/spec/controllers/projects_controller_spec.rb b/backup.rails2.3/spec/controllers/projects_controller_spec.rb
deleted file mode 100644
index 3ee3b81b..00000000
--- a/backup.rails2.3/spec/controllers/projects_controller_spec.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe ProjectsController do
- it "should save default tags" do
- project = Project.new
-
- projects = mock(:project_list, :build => project,
- :active => mock(:meh, :count => 0), :size => 0)
-
- user = mock_model(User, :projects => projects, :prefs => mock(:locale => :en),
- :contexts => mock(:context_list, :find => []))
- controller.stub!(:current_user).and_return(user)
- controller.stub!(:login_required).and_return(true)
- controller.stub!(:set_time_zone).and_return(true)
- controller.stub!(:mobile?).and_return(true)
-
- get 'create', :project => {:name => "fooproject", :default_tags => "a,b"}
-
- project.default_tags.should == 'a,b'
- end
-end
diff --git a/backup.rails2.3/spec/controllers/todos_controller_spec.rb b/backup.rails2.3/spec/controllers/todos_controller_spec.rb
deleted file mode 100644
index 0bd0870c..00000000
--- a/backup.rails2.3/spec/controllers/todos_controller_spec.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe TodosController do
-end
diff --git a/backup.rails2.3/spec/factories/factories.rb b/backup.rails2.3/spec/factories/factories.rb
deleted file mode 100644
index 8a2c550f..00000000
--- a/backup.rails2.3/spec/factories/factories.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-begin
- Factory.define :user do |u|
- u.sequence(:login) { |n| "testuser#{n}" }
- u.password "secret"
- u.password_confirmation { |user| user.password }
- u.is_admin false
- end
-
- Factory.define :context do |c|
- c.sequence(:name) { |n| "testcontext#{n}" }
- c.hide false
- c.created_at Time.now.utc
- end
-
- Factory.define :project do |p|
- p.sequence(:name) { |n| "testproject#{n}" }
- end
-
- Factory.define :todo do |t|
- t.sequence(:description) { |n| "testtodo#{n}" }
- t.association :context
- end
-
-rescue FactoryGirl::DuplicateDefinitionError
- # No problem, apparently this file was included already.
-end
diff --git a/backup.rails2.3/spec/fixtures/contexts.yml b/backup.rails2.3/spec/fixtures/contexts.yml
deleted file mode 100644
index a0513ccc..00000000
--- a/backup.rails2.3/spec/fixtures/contexts.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-
-agenda:
- id: 2
- name: agenda
- position: 2
- hide: false
- user: admin_user
-
-call:
- id: 3
- name: call
- position: 3
- hide: true
- user: admin_user
-
-email:
- id: 4
- name: email
- position: 4
- hide: false
- user: admin_user
diff --git a/backup.rails2.3/spec/fixtures/preferences.yml b/backup.rails2.3/spec/fixtures/preferences.yml
deleted file mode 100644
index 66d41ee8..00000000
--- a/backup.rails2.3/spec/fixtures/preferences.yml
+++ /dev/null
@@ -1,34 +0,0 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-admin_user_prefs:
- user: admin_user
- staleness_starts: 7
- date_format: "%d/%m/%Y"
- title_date_format: "%A, %d %B %Y"
- show_number_completed: 5
- show_completed_projects_in_sidebar: true
- show_hidden_contexts_in_sidebar: true
- show_hidden_projects_in_sidebar: true
- admin_email: butshesagirl@rousette.org.uk
- week_starts: 1
- due_style: 0
- refresh: 0
- time_zone: "London"
- verbose_action_descriptors: true
- show_project_on_todo_done: false
-
-other_user_prefs:
- user: jane
- staleness_starts: 7
- date_format: "%d/%m/%Y"
- title_date_format: "%A, %d %B %Y"
- show_number_completed: 5
- show_completed_projects_in_sidebar: true
- show_hidden_contexts_in_sidebar: true
- show_hidden_projects_in_sidebar: true
- admin_email: butshesagirl@rousette.org.uk
- week_starts: 1
- due_style: 0
- refresh: 0
- time_zone: "London"
- verbose_action_descriptors: false
- show_project_on_todo_done: true
diff --git a/backup.rails2.3/spec/fixtures/todos.yml b/backup.rails2.3/spec/fixtures/todos.yml
deleted file mode 100644
index b8af3088..00000000
--- a/backup.rails2.3/spec/fixtures/todos.yml
+++ /dev/null
@@ -1,68 +0,0 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-<%
-
-def today
- Time.zone.now.beginning_of_day.to_s(:db)
-end
-
-def next_week
- 1.week.from_now.beginning_of_day.to_s(:db)
-end
-
-def last_week
- 1.week.ago.beginning_of_day.to_s(:db)
-end
-
-def two_weeks_ago
- 2.weeks.ago.beginning_of_day.to_s(:db)
-end
-
-def two_weeks_hence
- 2.weeks.from_now.beginning_of_day.to_s(:db)
-end
-
-%>
-
-billgates:
- id: 2
- context_id: 2
- project_id: 2
- description: Call Bill Gates to find out how much he makes per day
- notes: ~
- state: active
- due: <%= two_weeks_hence %>
- completed_at: ~
- user: admin_user
-
-dinoexterm:
- id: 3
- context_id: 2
- project_id: 3
- description: Call dinosaur exterminator
- notes: Ask him if I need to hire a skip for the corpses.
- state: active
- due: <%= two_weeks_hence %>
- completed_at: ~
- user: admin_user
-
-buymilk:
- id: 4
- context_id: 2
- project_id: ~
- description: Buy milk
- notes: ~
- state: completed
- due: ~
- completed_at: <%= today %>
- user: admin_user
-
-callmom:
- id: 5
- context_id: 3 # call
- project_id: ~
- description: Call mom
- notes: Remember her birthday
- state: active
- due: ~
- completed_at: ~
- user: admin_user
diff --git a/backup.rails2.3/spec/fixtures/users.yml b/backup.rails2.3/spec/fixtures/users.yml
deleted file mode 100644
index cdd9a914..00000000
--- a/backup.rails2.3/spec/fixtures/users.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-admin_user:
- login: admin
- crypted_password: <%= BCrypt::Password.create("abracadabra") %>
- token: <%= Digest::SHA1.hexdigest("adminSat Feb 25 17:14:00 GMT 20060.236961325863376") %>
- is_admin: true
- first_name: Admin
- last_name: Schmadmin
- auth_type: database
-
-other_user:
- login: jane
- crypted_password: <%= BCrypt::Password.create("sesame") %>
- token: <%= Digest::SHA1.hexdigest("janeSun Feb 19 14:42:45 GMT 20060.408173979260027") %>
- is_admin: false
- first_name: Jane
- last_name: Doe
- auth_type: database
-
-ldap_user:
- login: john
- crypted_password: test
- token: <%= Digest::SHA1.hexdigest("johnSun Feb 19 14:42:45 GMT 20060.408173979260027") %>
- is_admin: false
- first_name: John
- last_name: Deere
- auth_type: ldap
diff --git a/backup.rails2.3/spec/models/context_spec.rb b/backup.rails2.3/spec/models/context_spec.rb
deleted file mode 100644
index 562f285f..00000000
--- a/backup.rails2.3/spec/models/context_spec.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Context do
- def valid_attributes
- {:name => 'Errands'}
- end
-
- before(:each) do
- @context = Context.new
- end
-
- it 'has many users' do
- Context.should have_many(:todos).
- with_order('todos.due IS NULL, todos.due ASC, todos.created_at ASC').
- with_dependent(:delete_all).
- with_include(:project)
- end
-
- it_should_belong_to :user
-
- it_should_validate_presence_of :name, 'context must have a name'
- it_should_validate_length_of :name, :maximum => 255,
- :message_too_long => 'context name must be less than 256 characters'
- it_should_validate_uniqueness_of :name, 'already exists' # TODO: scope user_id
- it_should_not_accept_as_valid :name, ',',
- :message => "cannot contain the comma (',') character"
-
- it 'is hidden when hide is true' do
- Context.new(:hide => false).should_not be_hidden
- Context.new(:hide => true).should be_hidden
- end
-
- it 'returns name as title' do
- Context.new(:name => 'foo').title.should == 'foo'
- end
-
- it 'returns an instance NullContext for null_object' do
- Context.null_object.should be_an_instance_of(NullContext)
- end
-
- it "returns feed options with description containing user's name" do
- user = mock_model(User, :display_name => 'simon')
- feed_options_for_user = Context.feed_options(user)
- feed_options_for_user[:title].should == 'Tracks Contexts'
- feed_options_for_user[:description].should == 'Lists all the contexts for simon'
- end
-
- describe 'when finding by namepart' do
- fixtures :todos, :contexts
-
- it 'finds with exact match' do
- Context.find_by_namepart('agenda').should == contexts(:agenda)
- end
-
- it 'finds with partial match' do
- Context.find_by_namepart('age').should == contexts(:agenda)
- end
-
- it 'deletes todos within context when context deleted' do
- contexts(:agenda).should have(3).todos
- call_todos = contexts(:agenda).todos
- contexts(:agenda).destroy
- Todo.find(:all).should_not include(call_todos)
- end
- end
-
- describe 'when counting todos' do
- fixtures :todos, :contexts, :users, :preferences
-
- it 'returns correct number of completed todos' do
- contexts(:call).done_todos.should_not have(:any).items
- contexts(:call).todos.first.complete!
- Context.find(contexts(:call).id).done_todos.should have(1).items
- end
-
- it 'returns correct number of not done todos' do
- contexts(:agenda).todos.not_completed.should have(2).items
- contexts(:agenda).todos.last.complete!
- contexts(:agenda).todos.not_completed.should have(1).items
- end
- end
-end
-
-describe NullContext do
- before(:each) do
- @context = NullContext.new
- end
-
- it 'is nil' do
- @context.should be_nil
- end
-
- it 'has no id' do
- @context.id.should be_nil
- end
-
- it 'has a blank name' do
- @context.name.should be_blank
- end
-end
diff --git a/backup.rails2.3/spec/models/message_gateway_spec.rb b/backup.rails2.3/spec/models/message_gateway_spec.rb
deleted file mode 100644
index 188093ee..00000000
--- a/backup.rails2.3/spec/models/message_gateway_spec.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe MessageGateway do
- before :each do
- todo = mock_model(Todo, :description= => nil, :raw_notes= => nil, :context_id= => nil, :save! => nil)
-
- @user = mock_model(User,
- :prefs => mock_model(Preference, :sms_context => mock_model(Context)),
- :todos => mock('Todo collection', :find => nil, :build => todo),
- :contexts => mock('Context collection', :exists? => true, :find => nil))
-
- User.stub!(:find).and_return(@user)
- end
-
- def load_message(filename)
- MessageGateway.receive(File.read(File.join(RAILS_ROOT, 'test', 'fixtures', filename)))
- end
-
-
- it "should dispatch on From: or To: according to site.yml" do
- SITE_CONFIG['email_dispatch'] = 'from'
- User.should_receive(:find).with(:first, :include => [:preference], :conditions => ["preferences.sms_email = ?", '5555555555@tmomail.net'])
- load_message('sample_email.txt')
-
- SITE_CONFIG['email_dispatch'] = 'to'
- User.should_receive(:find).with(:first, :include => [:preference], :conditions => ["preferences.sms_email = ?", 'gtd@tracks.com'])
- load_message('sample_email.txt')
- end
-end
diff --git a/backup.rails2.3/spec/models/todo_spec.rb b/backup.rails2.3/spec/models/todo_spec.rb
deleted file mode 100644
index b31ab7a2..00000000
--- a/backup.rails2.3/spec/models/todo_spec.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Todo do
- def valid_attributes(attributes={})
- {
- :description => "don't forget the milk",
- :context => mock_model(Context, :name => 'errands', :destroyed? => false)
- }.merge(attributes)
- end
-
- def create_todo(attributes={})
- todo = Todo.new(valid_attributes(attributes))
- todo.stub!(:user).and_return(mock_model(User, :date => Time.zone.now))
- todo.save!
- todo
- end
-
- before(:each) do
- @todo = Todo.new
- end
-
- it_should_belong_to :context
- it_should_belong_to :project
- it_should_belong_to :user
-
- it_should_validate_presence_of :description
- it_should_validate_presence_of :context
- it_should_validate_length_of :description, :maximum => 100
- it_should_validate_length_of :notes, :maximum => 60_000
-
- it 'validates presence of show_from when deferred'
-
- it 'ensures that show_from is a date in the future' do
- todo = Todo.new(valid_attributes)
- todo.stub!(:user).and_return(mock_model(User, :date => Time.zone.now))
- todo.show_from = 3.days.ago
- todo.should have(1).error_on(:show_from)
- end
-
- it 'allows show_from to be blank' do
- todo = Todo.new(valid_attributes(:show_from => ''))
- todo.should_not have(:any).error_on(:show_from)
- end
-
- describe 'states' do
- it 'is active on initializing' do
- create_todo.should be_active
- end
-
- it 'is deferred when show from is in the future' do
- todo = create_todo
- todo.show_from = 1.week.from_now
- todo.should be_deferred
- end
-
- describe 'active' do
- %w(project_hidden completed deferred).each do |from_state|
- it "is activable from `#{from_state}'" do
- todo = create_todo
- todo.state = from_state
- todo.send("#{from_state}?").should be_true
- todo.activate!
- todo.should be_active
- end
- end
-
- it 'clears show_from when entering active state' do
- todo = create_todo
- todo.show_from = 3.days.from_now
- todo.should be_deferred
- todo.activate!
- todo.should be_active
- todo.show_from.should be_nil
- end
-
- it 'clears completed_at when entering active state' do
- todo = create_todo
- todo.complete!
- todo.should be_completed
- todo.activate!
- todo.should be_active
- todo.completed_at.should be_nil
- end
- end
-
- describe 'completed' do
- %w(active project_hidden deferred).each do |from_state|
- it "is completable from `#{from_state}'" do
- todo = create_todo
- todo.state = from_state
- todo.send("#{from_state}?").should be_true
- todo.complete!
- todo.should be_completed
- end
- end
-
- it 'sets complated_at' do
- todo = create_todo
- todo.complete!
- todo.completed_at.should_not be_nil
- end
- end
-
- describe 'project_hidden' do
- %w(active deferred).each do |from_state|
- it "is hiddable from `#{from_state}'" do
- todo = create_todo
- todo.state = from_state
- todo.send("#{from_state}?").should be_true
- todo.hide!
- todo.should be_project_hidden
- end
- end
-
- it 'unhides to active when not show_from' do
- todo = create_todo(:show_from => '')
- todo.hide!
- todo.should be_project_hidden
- todo.unhide!
- todo.should be_active
- end
- end
- end
-
- describe 'when toggling completion' do
- it 'toggles to active when completed' do
- todo = create_todo
- todo.complete!
- todo.should be_completed
- todo.toggle_completion!
- todo.should be_active
- end
-
- it 'toggles to completed when not completed' do
- todo = create_todo
- todo.should_not be_completed
- todo.toggle_completion!
- todo.should be_completed
- end
- end
-
- describe 'when retrieving project' do
- it 'returns project if set' do
- project = mock_model(Project)
- todo = Todo.new(:project => project)
- todo.project.should == project
- end
-
- it 'returns a NullProject if not set' do
- Todo.new.project.should be_an_instance_of(NullProject)
- end
- end
-
- describe('when setting show_from') { it 'is speced' }
-
- it 'is starred if tag is "starred"' do
- todo = create_todo
- todo.should_not be_starred
- todo._add_tags('starred')
- todo.reload
- todo.should be_starred
- end
-
- describe 'when toggling star flag' do
- it 'toggles to not starred when starred' do
- todo = create_todo
- todo._add_tags('starred')
- todo.should be_starred
- todo.toggle_star!
- todo.reload
- todo.should_not be_starred
- end
-
- it 'toggles to starred when not starred' do
- todo = create_todo
- todo.should_not be_starred
- todo.toggle_star!
- todo.reload
- todo.should be_starred
- end
- end
-end
diff --git a/backup.rails2.3/spec/models/user_spec.rb b/backup.rails2.3/spec/models/user_spec.rb
deleted file mode 100644
index 035960ad..00000000
--- a/backup.rails2.3/spec/models/user_spec.rb
+++ /dev/null
@@ -1,168 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe User do
- def valid_attributes(attributes={})
- {
- :login => 'simon',
- :password => 'foobarspam',
- :password_confirmation => 'foobarspam'
- }.merge(attributes)
- end
-
- before(:each) do
- @user = User.new
- end
-
- describe 'associations' do
- it 'has many contexts' do
- User.should have_many(:contexts).
- with_order('position ASC').
- with_dependent(:delete_all)
- end
-
- it 'has many projects' do
- User.should have_many(:projects).
- with_order('projects.position ASC').
- with_dependent(:delete_all)
- end
-
- it 'has many todos' do
- User.should have_many(:todos).
- with_order('todos.completed_at DESC, todos.created_at DESC').
- with_dependent(:delete_all)
- end
-
- it 'has many deferred todos' do
- User.should have_many(:deferred_todos).
- with_order('show_from ASC, todos.created_at DESC').
- with_conditions('state = ?', 'deferred').
- with_class_name('Todo')
- end
-
- it 'has many notes' do
- User.should have_many(:notes).
- with_order('created_at DESC').
- with_dependent(:delete_all)
- end
-
- it 'has one preference' do
- User.should have_one(:preference)
- end
- end
-
- it_should_validate_presence_of :login
- it_should_validate_presence_of :password
- it_should_validate_presence_of :password_confirmation
-
- it_should_validate_length_of :password, :within => 5..40
- it_should_validate_length_of :login, :within => 3..80
-
- it_should_validate_uniqueness_of :login
- it_should_validate_confirmation_of :password
-
- it 'validates presence of password only when password is required'
- it 'validates presence of password_confirmation only when password is required'
- it 'validates confirmation of password only when password is required'
- it 'validates presence of open_id_url only when using openid'
-
- it 'accepts only allow auth_type authorized by the admin' do
- Tracks::Config.should_receive(:auth_schemes).exactly(3).times.and_return(%w(database open_id))
- User.new(valid_attributes(:auth_type => 'database')).should_not have(:any).error_on(:auth_type)
- User.new(valid_attributes(:auth_type => 'open_id')).should_not have(:any).error_on(:auth_type)
- User.new(valid_attributes(:auth_type => 'ldap')).should have(1).error_on(:auth_type)
- end
-
- it 'returns login for #to_param' do
- @user.login = 'john'
- @user.to_param.should == 'john'
- end
-
- it 'has a custom finder to find admin' do
- User.should_receive(:find).with(:first, :conditions => ['is_admin = ?', true])
- User.find_admin
- end
-
- it 'has a custom finder to find by openid url'
- it 'knows if there is any user through #no_users_yet? (TODO: better description)'
-
- describe 'when choosing what do display as a name' do
- it 'displays login when no first name and last name' do
- User.new(valid_attributes).display_name.should == 'simon'
- end
-
- it 'displays last name when no first name' do
- User.new(valid_attributes(:last_name => 'foo')).display_name.should == 'foo'
- end
-
- it 'displays first name when no last name' do
- User.new(valid_attributes(:first_name => 'bar')).display_name.should == 'bar'
- end
-
- it 'displays first name and last name when both specified' do
- User.new(valid_attributes(:first_name => 'foo', :last_name => 'bar')).display_name.should == 'foo bar'
- end
- end
-
- describe 'authentication' do
- before(:each) do
- @user = User.create!(valid_attributes)
- end
-
- it 'authenticates user' do
- User.authenticate('simon', 'foobarspam').id.should be @user.id
- end
-
- it 'resets password' do
- @user.update_attributes(
- :password => 'new password',
- :password_confirmation => 'new password'
- )
- User.authenticate('simon', 'foobarspam').should be_nil
- User.authenticate('simon', 'new password').id.should be @user.id
- end
-
- it 'does not rehash password after update of login' do
- @user.update_attribute(:login, 'foobar')
- User.authenticate('foobar', 'foobarspam').id.should be @user.id
- end
-
- it 'sets remember token' do
- @user.remember_me
- @user.remember_token.should_not be_nil
- @user.remember_token_expires_at.should_not be_nil
- end
-
- it 'unsets remember token' do
- @user.remember_me
- @user.remember_token.should_not be_nil
- @user.forget_me
- @user.remember_token.should be_nil
- end
-
- it 'remembers me default two weeks' do
- before = 2.weeks.from_now.utc
- @user.remember_me
- after = 2.weeks.from_now.utc
- @user.remember_token.should_not be_nil
- @user.remember_token_expires_at.should_not be_nil
- @user.remember_token_expires_at.should be_between(before, after)
- end
- end
-
- it "should not activate todos that are showing when UTC is tomorrow" do
- context = Context.create(:name => 'a context')
- user = User.create(:login => 'user7', :password => 'foobar', :password_confirmation => 'foobar')
- user.save!
- user.create_preference
- user.preference.update_attribute('time_zone', 'Pacific Time (US & Canada)')
-# Time.zone = 'Pacific Time (US & Canada)'
- Time.stub!(:now).and_return(Time.new.end_of_day - 20.minutes)
- todo = user.todos.build(:description => 'test task', :context => context)
- todo.show_from = user.date + 1.days
- todo.save!
-
- user.deferred_todos.find_and_activate_ready
- user = User.find(user.id)
- user.deferred_todos.should include(todo)
- end
-end
diff --git a/backup.rails2.3/spec/rcov.opts b/backup.rails2.3/spec/rcov.opts
deleted file mode 100644
index 274ed51a..00000000
--- a/backup.rails2.3/spec/rcov.opts
+++ /dev/null
@@ -1,2 +0,0 @@
---exclude "spec/*,gems/*"
---rails
\ No newline at end of file
diff --git a/backup.rails2.3/spec/spec.opts b/backup.rails2.3/spec/spec.opts
deleted file mode 100644
index 391705bf..00000000
--- a/backup.rails2.3/spec/spec.opts
+++ /dev/null
@@ -1,4 +0,0 @@
---colour
---format progress
---loadby mtime
---reverse
diff --git a/backup.rails2.3/spec/spec_helper.rb b/backup.rails2.3/spec/spec_helper.rb
deleted file mode 100644
index e83f9daa..00000000
--- a/backup.rails2.3/spec/spec_helper.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# This file is copied to ~/spec when you run 'ruby script/generate rspec'
-# from the project root directory.
-ENV["RAILS_ENV"] ||= 'test'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','config','environment'))
-require 'spec/autorun'
-require 'spec/rails'
-require 'skinny_spec'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
-
-Spec::Runner.configure do |config|
- # If you're not using ActiveRecord you should remove these
- # lines, delete config/database.yml and disable :active_record
- # in your config/boot.rb
- config.use_transactional_fixtures = true
- config.use_instantiated_fixtures = false
- config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
-
- # == Fixtures
- #
- # You can declare fixtures for each example_group like this:
- # describe "...." do
- # fixtures :table_a, :table_b
- #
- # Alternatively, if you prefer to declare them only once, you can
- # do so right here. Just uncomment the next line and replace the fixture
- # names with your fixtures.
- #
- # config.global_fixtures = :table_a, :table_b
- #
- # If you declare global fixtures, be aware that they will be declared
- # for all of your examples, even those that don't use them.
- #
- # You can also declare which fixtures to use (for example fixtures for test/fixtures):
- #
- # config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
- #
- # == Mock Framework
- #
- # RSpec uses it's own mocking framework by default. If you prefer to
- # use mocha, flexmock or RR, uncomment the appropriate line:
- #
- # config.mock_with :mocha
- # config.mock_with :flexmock
- # config.mock_with :rr
- #
- # == Notes
- #
- # For more information take a look at Spec::Runner::Configuration and Spec::Runner
-end
diff --git a/backup.rails2.3/spec/support/should_validate_length_of.rb b/backup.rails2.3/spec/support/should_validate_length_of.rb
deleted file mode 100644
index ae7b5a1a..00000000
--- a/backup.rails2.3/spec/support/should_validate_length_of.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module LuckySneaks
- module ModelSpecHelpers
- module ExampleGroupLevelMethods
- def it_should_validate_length_of(attribute, options={})
- maximum = options[:maximum] || (options[:within] || []).last || false
- minimum = options[:minimum] || (options[:within] || []).first || false
- raise ArgumentError unless maximum || minimum
-
- it "should not be valid if #{attribute} length is more than #{maximum}" do
- instance.send "#{attribute}=", 'x'*(maximum+1)
- instance.errors_on(attribute).should include(
- options[:message_too_long] || I18n.t('activerecord.errors.messages.too_long', :count => maximum)
- )
- end if maximum
-
- it "should not be valid if #{attribute} length is less than #{minimum}" do
- instance.send "#{attribute}=", 'x'*(minimum-1)
- instance.errors_on(attribute).should include(
- options[:message_to_short] || I18n.t('activerecord.errors.messages.too_short', :count => minimum)
- )
- end if minimum
- end
- end
- end
-end
diff --git a/backup.rails2.3/spec/views/login/login_mobile.html.erb_spec.rb b/backup.rails2.3/spec/views/login/login_mobile.html.erb_spec.rb
deleted file mode 100644
index b3bce82d..00000000
--- a/backup.rails2.3/spec/views/login/login_mobile.html.erb_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "/login/login_mobile.html.erb" do
- it "should render without an error" do
- @controller.template.stub!(:set_default_external!)
- render :action => 'login/login_mobile.html.erb', :layout => 'mobile.m.erb'
- response.should_not have_tag("div#Application-Trace")
- end
-end
diff --git a/backup.rails2.3/spec/views/notes/_notes.rhtml_spec.rb b/backup.rails2.3/spec/views/notes/_notes.rhtml_spec.rb
deleted file mode 100644
index 477e66b5..00000000
--- a/backup.rails2.3/spec/views/notes/_notes.rhtml_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "/notes/_notes.rhtml" do
- before :each do
- @project = mock_model(Project, :name => "a project")
- @note = mock_model(Note, :body => "this is a note", :project => @project, :project_id => @project.id,
- :created_at => Time.now, :updated_at? => false)
- @controller.template.stub!(:format_date)
- # @controller.template.stub!(:render)
- # @controller.template.stub!(:form_remote_tag)
- end
-
- it "should render" do
- pending "figure out how to mock or work with with UJS"
- render :partial => "/notes/notes", :object => @note
- response.should have_tag("div.note_footer")
- end
-
- it "should auto-link URLs" do
- pending "figure out how to mock or work with with UJS"
- @note.stub!(:body).and_return("http://www.google.com/")
- render :partial => "/notes/notes", :object => @note
- response.should have_tag("a[href=\"http://www.google.com/\"]")
- end
-
- it "should auto-link embedded URLs" do
- pending "figure out how to mock or work with with UJS"
- @note.stub!(:body).and_return("this is cool: http://www.google.com/")
- render :partial => "/notes/notes", :object => @note
- response.should have_tag("a[href=\"http://www.google.com/\"]")
- end
-
- it "should parse Textile links correctly" do
- pending "figure out how to mock or work with with UJS"
- @note.stub!(:body).and_return("\"link\":http://www.google.com/")
- render :partial => "/notes/notes", :locals => {:notes => @note}
- response.should have_tag("a[href=\"http://www.google.com/\"]")
- end
-end
diff --git a/backup.rails2.3/test_helper.rb.rails2 b/backup.rails2.3/test_helper.rb.rails2
deleted file mode 100644
index 40d8a464..00000000
--- a/backup.rails2.3/test_helper.rb.rails2
+++ /dev/null
@@ -1,152 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-require 'thread'
-require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
-require File.expand_path(File.dirname(__FILE__) + "/../app/controllers/application_controller")
-require 'test_help'
-require 'flexmock/test_unit' #and the flexmock gem, too!
-require 'action_web_service/test_invoke'
-
-module Tracks
- class Config
- def self.salt
- "change-me"
- end
- def self.auth_schemes
- return ["database","open_id"]
- end
- end
-end
-
-class Test::Unit::TestCase
- include AuthenticatedTestHelper
-
- def xml_document
- @xml_document ||= HTML::Document.new(@response.body, false, true)
- end
-
- def assert_xml_select(*args, &block)
- @html_document = xml_document
- assert_select(*args, &block)
- end
-
- def assert_error_on(model_instance, attribute, expected_error)
- actual_error = model_instance.errors.on attribute.to_sym
- assert_equal expected_error, actual_error
- end
-
- alias_method :assert_errors_on, :assert_error_on
-
- def assert_value_changed(object, method = nil)
- initial_value = object.send(method)
- yield
- assert_not_equal initial_value, object.send(method), "#{object}##{method}"
- end
-
-end
-
-class ActiveSupport::TestCase
-
- # Generates a random string of ascii characters (a-z, "1 0")
- # of a given length for testing assignment to fields
- # for validation purposes
- #
- def generate_random_string(length)
- string = ""
- characters = %w(a b c d e f g h i j k l m n o p q r s t u v w z y z 1\ 0)
- length.times do
- pick = characters[rand(26)]
- string << pick
- end
- return string
- end
-
- def next_week
- 1.week.from_now.utc
- end
-
- # Courtesy of http://habtm.com/articles/2006/02/20/assert-yourself-man-redirecting-with-rjs
- def assert_js_redirected_to(options={}, message=nil)
- clean_backtrace do
- assert_response(:success, message)
- assert_equal 'text/javascript', @response.content_type, 'Response should be Javascript content-type';
- js_regexp = %r{(\w+://)?.*?(/|$|\\\?)(.*)}
- url_regexp = %r{^window\.location\.href [=] ['"]#{js_regexp}['"][;]$}
- redirected_to = @response.body.match(url_regexp)
- assert_not_nil(redirected_to, message)
- redirected_to = redirected_to[3]
- msg = build_message(message, "expected a JS redirect to , found one to ", options, redirected_to)
-
- if options.is_a?(String)
- assert_equal(options.gsub(/^\//, ''), redirected_to, message)
- elsif options.is_a?(Regexp)
- assert(options =~ redirected_to, "#{message} #{options} #{redirected_to}")
- else
- msg = build_message(message, "response is not a redirection to all of the options supplied (redirection is )", redirected_to)
- assert_equal(@controller.url_for(options).match(js_regexp)[3], redirected_to, msg)
- end
- end
- end
-
- def set_user_to_current_time_zone(user)
- jan_offset = Time.now.beginning_of_year.utc_offset
- jul_offset = Time.now.beginning_of_year.change(:month => 7).utc_offset
- offset = jan_offset < jul_offset ? jan_offset : jul_offset
- offset = if offset.to_s.match(/(\+|-)?(\d+):(\d+)/)
- sign = $1 == '-' ? -1 : 1
- hours, minutes = $2.to_f, $3.to_f
- ((hours * 3600) + (minutes.to_f * 60)) * sign
- elsif offset.to_f.abs <= 13
- offset.to_f * 3600
- else
- offset.to_f
- end
- zone = ActiveSupport::TimeZone.all.find{|t| t.utc_offset == offset}
- user.prefs.update_attribute(:time_zone, zone.name)
- end
-end
-
-class ActionController::IntegrationTest
- Tag #avoid errors in integration tests
-
- def assert_test_environment_ok
- assert_equal "test", ENV['RAILS_ENV']
- assert_equal "change-me", Tracks::Config.salt
- end
-
- def authenticated_post_xml(url, username, password, parameters, headers = {})
- post url,
- parameters,
- {'AUTHORIZATION' => "Basic " + Base64.encode64("#{username}:#{password}"),
- 'ACCEPT' => 'application/xml',
- 'CONTENT_TYPE' => 'application/xml'
- }.merge(headers)
- end
-
- def authenticated_get_xml(url, username, password, parameters, headers = {})
- get url,
- parameters,
- {'AUTHORIZATION' => "Basic " + Base64.encode64("#{username}:#{password}"),
- 'ACCEPT' => 'application/xml',
- 'CONTENT_TYPE' => 'application/xml'
- }.merge(headers)
- end
-
- def assert_response_and_body(type, body, message = nil)
- assert_equal body, @response.body, message
- assert_response type, message
- end
-
- def assert_response_and_body_matches(type, body_regex, message = nil)
- assert_response type, message
- assert_match body_regex, @response.body, message
- end
-
- def assert_401_unauthorized
- assert_response_and_body 401, "401 Unauthorized: You are not authorized to interact with Tracks."
- end
-
- def assert_401_unauthorized_admin
- assert_response_and_body 401, "401 Unauthorized: Only admin users are allowed access to this function."
- end
-
-end
diff --git a/backup.rails2.3/test_views/views/context_helper_test.rb b/backup.rails2.3/test_views/views/context_helper_test.rb
deleted file mode 100644
index 8aa0bd4b..00000000
--- a/backup.rails2.3/test_views/views/context_helper_test.rb
+++ /dev/null
@@ -1,7 +0,0 @@
- def test_summary
- undone_todo_count = '5 actions'
- assert_equal "
}
- assert_behavior_registered
- end
-
- def test_remote_star_icon_starred
- @todo = flexmock(:id => 1, :to_param => 1, :description => 'Get gas', :starred? => true)
- # added dot (.) to regexp because somehouw the extra dot is added in the tests while its not in the rendered html
- assert_remote_star_icon_helper_matches %r{}
- assert_behavior_registered
- end
-
- def assert_remote_star_icon_helper_matches(regex)
- @controller.send :initialise_js_behaviours #simulate before filter
- output = remote_star_icon
- # puts output
- assert output =~ regex
- @controller.send :store_js_behaviours #simulate after filter
- end
-
- def assert_behavior_registered
- behaviors = @controller.session[:js_behaviours]
- assert behaviors[:options][:reapply_after_ajax]
- assert_equal 1, behaviors[:rules].length
- rule = behaviors[:rules][0]
- assert_equal ".item-container a.star_item:click", rule[0]
- assert_equal "new Ajax.Request(this.href, {asynchronous:true, evalScripts:true, method:'put', parameters:{ _source_view : '' }})\n; return false;",
- rule[1]
- end
-
- def protect_against_forgery?
- false
- end
-end
- <% if @page_title -%>
-
-
diff --git a/backup.rails2.3/plugins/translate/views/translate/_pagination.rhtml b/backup.rails2.3/plugins/translate/views/translate/_pagination.rhtml
deleted file mode 100644
index 64f4d690..00000000
--- a/backup.rails2.3/plugins/translate/views/translate/_pagination.rhtml
+++ /dev/null
@@ -1,24 +0,0 @@
-<%
- # Expects locals:
- #
- # total_entries
- # per_page
-
- n_pages = total_entries/per_page + (total_entries % per_page > 0 ? 1 : 0)
- current_page = (params[:page] || 1).to_i
-%>
-
-<% if n_pages > 1 %>
-<%=h @page_title %>
<% end -%> - <% [:notice, :error].each do |message| %> - <%if flash[message] %> -
- <%= h(flash[message]) if flash[message] %>
-
- <% end %>
- <% end %>
- <%= yield %>
- Pages:
-
-
-<% end %>
\ No newline at end of file
diff --git a/backup.rails2.3/plugins/translate/views/translate/index.rhtml b/backup.rails2.3/plugins/translate/views/translate/index.rhtml
deleted file mode 100644
index a057659d..00000000
--- a/backup.rails2.3/plugins/translate/views/translate/index.rhtml
+++ /dev/null
@@ -1,114 +0,0 @@
-<%
- @page_title = "Translate"
- show_filters = ["all", "untranslated", "translated"]
- show_filters << "changed" if @from_locale != @to_locale
-%>
-
-
-
-
--
- <% (1..n_pages).each do |page_number| %>
- <% if current_page == page_number %>
-
- <%= link_to(page_number, params.merge(:page => page_number), :title => "Page #{page_number}" ) %> - <% else %> -
- <%= link_to(page_number, params.merge(:page => page_number), :title => "Page #{page_number}") %> - <% end %> - <% end %> -
- <%= render :partial => 'pagination', :locals => {:total_entries => @total_entries, :per_page => per_page} %>
-
-
-<% if @total_entries > 0 %>
-<% form_tag(translate_path) do %>
-
- <%= hidden_field_tag(:filter, params[:filter], :id => "hid_filter") %>
- <%= hidden_field_tag(:sort_by, params[:sort_by], :id => "hid_sort_by") %>
- <%= hidden_field_tag(:key_type, params[:key_type], :id => "hid_key_type") %>
- <%= hidden_field_tag(:key_pattern, params[:key_pattern], :id => "hid_key_pattern") %>
- <%= hidden_field_tag(:text_type, params[:text_type], :id => "hid_text_type") %>
- <%= hidden_field_tag(:text_pattern, params[:text_pattern], :id => "hid_text_pattern") %>
-
-
-
-<% end %>
-<% end %>
-
-Translations from <%= @from_locale %> to <%= @to_locale %>
-- <%= submit_tag "Save Translations" %> -
- <% @paginated_keys.each do |key| - from_text = lookup(@from_locale, key) - to_text = lookup(@to_locale, key) - line_size = 100 - n_lines = n_lines(from_text, line_size) - field_name = "key[#{key}]" - %> -
- <% if from_text.present? %>
-
-<% end %>
- - <%= simple_format(h(from_text)) %> -
- <% end %> -- <% if n_lines > 1 %> - <%= text_area_tag(field_name, to_text, :size => "#{line_size}x#{n_lines}", :id => key) %> - <% else %> - <%= text_field_tag(field_name, to_text, :size => line_size, :id => key) %> - <% end %> -
-
-
- <%= link_to_function 'Auto Translate', "getGoogleTranslation('#{key}', \"#{escape_javascript(from_text)}\", '#{@from_locale}', '#{@to_locale}')", :style => 'padding: 0; margin: 0;' %>
-
- Key:<%=h key %>
- <% if @files[key] %>
- File:<%= @files[key].join("
") %>
- <% end %>
-
-
- <%= submit_tag "Save Translations" %> -
-
- <%= render :partial => 'pagination', :locals => {:total_entries => @total_entries, :per_page => per_page} %>
-
\ No newline at end of file
diff --git a/backup.rails2.3/production.rb.rails2 b/backup.rails2.3/production.rb.rails2
deleted file mode 100644
index 56470f47..00000000
--- a/backup.rails2.3/production.rb.rails2
+++ /dev/null
@@ -1,17 +0,0 @@
-# The production environment is meant for finished, "live" apps.
-# Code is not reloaded between requests
-config.cache_classes = true
-
-# Use a different logger for distributed setups
-# config.logger = SyslogLogger.new
-
-
-# Full error reports are disabled and caching is turned on
-config.action_controller.consider_all_requests_local = false
-config.action_controller.perform_caching = true
-
-# Enable serving of images, stylesheets, and javascripts from an asset server
-# config.action_controller.asset_host = "http://assets.example.com"
-
-# Disable delivery errors if you bad email addresses should just be ignored
-# config.action_mailer.raise_delivery_errors = false
\ No newline at end of file
diff --git a/backup.rails2.3/routes.rb.rails2 b/backup.rails2.3/routes.rb.rails2
deleted file mode 100644
index ec0ed738..00000000
--- a/backup.rails2.3/routes.rb.rails2
+++ /dev/null
@@ -1,113 +0,0 @@
-ActionController::Routing::Routes.draw do |map|
- map.resources :users,
- :member => {:change_password => :get, :update_password => :post,
- :change_auth_type => :get, :update_auth_type => :post, :complete => :get,
- :refresh_token => :post }
-
- map.with_options :controller => :users do |users|
- users.signup 'signup', :action => "new"
- end
-
- map.resources :contexts, :collection => {:order => :post, :done => :get}, :member => {:done_todos => :get, :all_done_todos => :get} do |contexts|
- contexts.resources :todos, :name_prefix => "context_"
- end
-
- map.resources :projects,
- :collection => {:order => :post, :alphabetize => :post, :actionize => :post, :done => :get},
- :member => {:done_todos => :get, :all_done_todos => :get, :set_reviewed => :get} do |projects|
- projects.resources :todos, :name_prefix => "project_"
- end
-
- map.with_options :controller => :projects do |projects|
- projects.review 'review', :action => :review
- end
-
- map.resources :notes
-
- map.resources :todos,
- :member => {:toggle_check => :put, :toggle_star => :put, :defer => :put},
- :collection => {:check_deferred => :post, :filter_to_context => :post, :filter_to_project => :post, :done => :get, :all_done => :get
- }
-
- map.with_options :controller => :todos do |todos|
- todos.home '', :action => "index"
- todos.tickler 'tickler.:format', :action => "list_deferred"
- todos.mobile_tickler 'tickler.m', :action => "list_deferred", :format => 'm'
-
- # This route works for tags with dots like /todos/tag/version1.5
- # please note that this pattern consumes everything after /todos/tag
- # so /todos/tag/version1.5.xml will result in :name => 'version1.5.xml'
- # UPDATE: added support for mobile view. All tags ending on .m will be
- # routed to mobile view of tags.
- todos.mobile_tag 'todos/tag/:name.m', :action => "tag", :format => 'm'
- todos.text_tag 'todos/tag/:name.txt', :action => "tag", :format => 'txt'
- todos.tag 'todos/tag/:name', :action => "tag", :name => /.*/
- todos.done_tag 'todos/done/tag/:name', :action => "done_tag"
- todos.all_done_tag 'todos/all_done/tag/:name', :action => "all_done_tag"
-
- todos.tags 'tags.autocomplete', :action => "tags", :format => 'autocomplete'
- todos.auto_complete_for_predecessor 'auto_complete_for_predecessor', :action => 'auto_complete_for_predecessor'
-
- todos.calendar 'calendar.ics', :action => "calendar", :format => 'ics'
- todos.calendar 'calendar.xml', :action => "calendar", :format => 'xml'
- todos.calendar 'calendar', :action => "calendar"
-
- todos.hidden 'hidden.xml', :action => "list_hidden", :format => 'xml'
-
- todos.mobile 'mobile', :action => "index", :format => 'm'
- todos.mobile_abbrev 'm', :action => "index", :format => 'm'
- todos.mobile_abbrev_new 'm/new', :action => "new", :format => 'm'
-
- todos.mobile_todo_show_notes 'todos/notes/:id.m', :action => "show_notes", :format => 'm'
- todos.todo_show_notes 'todos/notes/:id', :action => "show_notes"
- todos.done_todos 'todos/done', :action => :done
- todos.all_done_todos 'todos/all_done', :action => :all_done
- end
- map.root :controller => 'todos' # Make OpenID happy because it needs #root_url defined
-
- map.resources :recurring_todos, :collection => {:done => :get},
- :member => {:toggle_check => :put, :toggle_star => :put}
- map.with_options :controller => :recurring_todos do |rt|
- rt.recurring_todos 'recurring_todos', :action => 'index'
- end
-
- map.with_options :controller => :login do |login|
- login.login 'login', :action => 'login'
- login.login_cas 'login_cas', :action => 'login_cas'
- login.formatted_login 'login.:format', :action => 'login'
- login.logout 'logout', :action => 'logout'
- login.formatted_logout 'logout.:format', :action => 'logout'
- end
-
- map.with_options :controller => :feedlist do |fl|
- fl.mobile_feeds 'feeds.m', :action => 'index', :format => 'm'
- fl.feeds 'feeds', :action => 'index'
- end
-
- map.with_options :controller => :integrations do |i|
- i.integrations 'integrations', :action => 'index'
- i.rest_api_docs 'integrations/rest_api', :action => "rest_api"
- i.search_plugin 'integrations/search_plugin.xml', :action => 'search_plugin', :format => 'xml'
- i.google_gadget 'integrations/google_gadget.xml', :action => 'google_gadget', :format => 'xml'
- i.cloudmailin 'integrations/cloudmailin', :action => 'cloudmailin'
- end
-
- map.with_options :controller => :preferences do |p|
- p.preferences 'preferences', :action => 'index'
- p.preferences_date_format 'preferences/render_date_format', :action => 'render_date_format'
- end
-
- map.with_options :controller => :stats do |stats|
- stats.stats 'stats', :action => 'index'
- stats.done_overview 'done', :action => 'done'
- end
-
- map.search 'search', :controller => 'search', :action => 'index'
- map.data 'data', :controller => 'data', :action => 'index'
-
- Translate::Routes.translation_ui(map) if Rails.env != "production"
-
- # Install the default route as the lowest priority.
- map.connect ':controller/:action/:id'
-
-end
diff --git a/backup.rails2.3/slider.js b/backup.rails2.3/slider.js
deleted file mode 100644
index c0f1fc01..00000000
--- a/backup.rails2.3/slider.js
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright (c) 2005 Marty Haught, Thomas Fuchs
-//
-// See http://script.aculo.us for more info
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-if(!Control) var Control = {};
-Control.Slider = Class.create();
-
-// options:
-// axis: 'vertical', or 'horizontal' (default)
-//
-// callbacks:
-// onChange(value)
-// onSlide(value)
-Control.Slider.prototype = {
- initialize: function(handle, track, options) {
- var slider = this;
-
- if(handle instanceof Array) {
- this.handles = handle.collect( function(e) { return $(e) });
- } else {
- this.handles = [$(handle)];
- }
-
- this.track = $(track);
- this.options = options || {};
-
- this.axis = this.options.axis || 'horizontal';
- this.increment = this.options.increment || 1;
- this.step = parseInt(this.options.step || '1');
- this.range = this.options.range || $R(0,1);
-
- this.value = 0; // assure backwards compat
- this.values = this.handles.map( function() { return 0 });
- this.spans = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
- this.options.startSpan = $(this.options.startSpan || null);
- this.options.endSpan = $(this.options.endSpan || null);
-
- this.restricted = this.options.restricted || false;
-
- this.maximum = this.options.maximum || this.range.end;
- this.minimum = this.options.minimum || this.range.start;
-
- // Will be used to align the handle onto the track, if necessary
- this.alignX = parseInt(this.options.alignX || '0');
- this.alignY = parseInt(this.options.alignY || '0');
-
- this.trackLength = this.maximumOffset() - this.minimumOffset();
- this.handleLength = this.isVertical() ? this.handles[0].offsetHeight : this.handles[0].offsetWidth;
-
- this.active = false;
- this.dragging = false;
- this.disabled = false;
-
- if(this.options.disabled) this.setDisabled();
-
- // Allowed values array
- this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
- if(this.allowedValues) {
- this.minimum = this.allowedValues.min();
- this.maximum = this.allowedValues.max();
- }
-
- this.eventMouseDown = this.startDrag.bindAsEventListener(this);
- this.eventMouseUp = this.endDrag.bindAsEventListener(this);
- this.eventMouseMove = this.update.bindAsEventListener(this);
-
- // Initialize handles in reverse (make sure first handle is active)
- this.handles.each( function(h,i) {
- i = slider.handles.length-1-i;
- slider.setValue(parseFloat(
- (slider.options.sliderValue instanceof Array ?
- slider.options.sliderValue[i] : slider.options.sliderValue) ||
- slider.range.start), i);
- Element.makePositioned(h); // fix IE
- Event.observe(h, "mousedown", slider.eventMouseDown);
- });
-
- Event.observe(this.track, "mousedown", this.eventMouseDown);
- Event.observe(document, "mouseup", this.eventMouseUp);
- Event.observe(document, "mousemove", this.eventMouseMove);
-
- this.initialized = true;
- },
- dispose: function() {
- var slider = this;
- Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
- Event.stopObserving(document, "mouseup", this.eventMouseUp);
- Event.stopObserving(document, "mousemove", this.eventMouseMove);
- this.handles.each( function(h) {
- Event.stopObserving(h, "mousedown", slider.eventMouseDown);
- });
- },
- setDisabled: function(){
- this.disabled = true;
- },
- setEnabled: function(){
- this.disabled = false;
- },
- getNearestValue: function(value){
- if(this.allowedValues){
- if(value >= this.allowedValues.max()) return(this.allowedValues.max());
- if(value <= this.allowedValues.min()) return(this.allowedValues.min());
-
- var offset = Math.abs(this.allowedValues[0] - value);
- var newValue = this.allowedValues[0];
- this.allowedValues.each( function(v) {
- var currentOffset = Math.abs(v - value);
- if(currentOffset <= offset){
- newValue = v;
- offset = currentOffset;
- }
- });
- return newValue;
- }
- if(value > this.range.end) return this.range.end;
- if(value < this.range.start) return this.range.start;
- return value;
- },
- setValue: function(sliderValue, handleIdx){
- if(!this.active) {
- this.activeHandle = this.handles[handleIdx];
- this.activeHandleIdx = handleIdx;
- this.updateStyles();
- }
- handleIdx = handleIdx || this.activeHandleIdx || 0;
- if(this.initialized && this.restricted) {
- if((handleIdx>0) && (sliderValue#{undone_todo_count}. Context is Active.
", @agenda.summary(undone_todo_count) - @agenda.hide = true - @agenda.save! - assert_equal "#{undone_todo_count}. Context is Hidden.
", @agenda.summary(undone_todo_count) - end diff --git a/backup.rails2.3/test_views/views/todos_helper_test.rb b/backup.rails2.3/test_views/views/todos_helper_test.rb deleted file mode 100644 index 441ec2b5..00000000 --- a/backup.rails2.3/test_views/views/todos_helper_test.rb +++ /dev/null @@ -1,98 +0,0 @@ -require File.dirname(__FILE__) + '/../test_helper' - -class TodosHelperTest < ActiveSupport::HelperTestCase - fixtures :users - - def setup - super - end - - include ActionView::Helpers::DateHelper - include ApplicationHelper - include TodosHelper - - def current_user - if @user.nil? - @user = users(:admin_user) - class << @user - def prefs - Preference.new - end - end - end - @user - end - - def format_date(date) - if date - date_format = "%d/%m/%Y" - date.strftime("#{date_format}") - else - '' - end - end - - def test_show_date_in_past - date = 3.days.ago - html = show_date(date) - formatted_date = format_date(date) - assert_equal %Q{Scheduled to show 3 days ago }, html - end - - def test_show_date_today - date = Time.zone.now - html = show_date(date) - formatted_date = format_date(date) - assert_equal %Q{Show Today }, html - end - - def test_show_date_tomorrow - date = 1.day.from_now - html = show_date(date) - formatted_date = format_date(date) - assert_equal %Q{Show Tomorrow }, html - end - - def test_show_date_future - date = 10.days.from_now - html = show_date(date) - formatted_date = format_date(date) - assert_equal %Q{Show in 10 days }, html - end - - def test_remote_star_icon_unstarred - @todo = flexmock(:id => 1, :to_param => 1, :description => 'Get gas', :starred? => false) - # added dot (.) to regexp because somehouw the extra dot is added in the tests while its not in the rendered html - assert_remote_star_icon_helper_matches %r{}
- assert_behavior_registered
- end
-
- def test_remote_star_icon_starred
- @todo = flexmock(:id => 1, :to_param => 1, :description => 'Get gas', :starred? => true)
- # added dot (.) to regexp because somehouw the extra dot is added in the tests while its not in the rendered html
- assert_remote_star_icon_helper_matches %r{}
- assert_behavior_registered
- end
-
- def assert_remote_star_icon_helper_matches(regex)
- @controller.send :initialise_js_behaviours #simulate before filter
- output = remote_star_icon
- # puts output
- assert output =~ regex
- @controller.send :store_js_behaviours #simulate after filter
- end
-
- def assert_behavior_registered
- behaviors = @controller.session[:js_behaviours]
- assert behaviors[:options][:reapply_after_ajax]
- assert_equal 1, behaviors[:rules].length
- rule = behaviors[:rules][0]
- assert_equal ".item-container a.star_item:click", rule[0]
- assert_equal "new Ajax.Request(this.href, {asynchronous:true, evalScripts:true, method:'put', parameters:{ _source_view : '' }})\n; return false;",
- rule[1]
- end
-
- def protect_against_forgery?
- false
- end
-end