easy_admin_ui 0.5.9 → 0.5.11

data/vendor/plugins/make_resourceful/spec/rspec-rails/redirect_to.rb

@@ -1,113 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-
-      class RedirectTo  #:nodoc:
-
-        def initialize(request, expected)
-          @expected = expected
-          @request = request
-        end
-
-        def matches?(response)
-          @redirected = response.redirect?
-          @actual = response.redirect_url
-          return false unless @redirected
-          if @expected.instance_of? Hash
-            return false unless @actual =~ %r{^\w+://#{@request.host}}
-            return false unless actual_redirect_to_valid_route
-            return actual_hash == expected_hash
-          else
-            return @actual == expected_url
-          end
-        end
-
-        def actual_hash
-          hash_from_url @actual
-        end
-
-        def expected_hash
-          hash_from_url expected_url
-        end
-
-        def actual_redirect_to_valid_route
-          actual_hash
-        end
-
-        def hash_from_url(url)
-          query_hash(url).merge(path_hash(url)).with_indifferent_access
-        end
-
-        def path_hash(url)
-          path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
-          ActionController::Routing::Routes.recognize_path path
-        end
-
-        def query_hash(url)
-          query = url.split("?", 2)[1] || ""
-          QueryParameterParser.parse_query_parameters(query, @request)
-        end
-
-       def expected_url
-          case @expected
-            when Hash
-              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
-            when :back
-              return @request.env['HTTP_REFERER']
-            when %r{^\w+://.*}
-              return @expected
-            else
-              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
-          end
-        end
-
-        def failure_message
-          if @redirected
-            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
-          else
-            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
-          end
-        end
-
-        def negative_failure_message
-            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
-        end
-
-        def description
-          "redirect to #{@actual.inspect}"
-        end
-
-        class QueryParameterParser
-          def self.parse_query_parameters(query, request)
-            if defined?(CGIMethods)
-              CGIMethods.parse_query_parameters(query)
-            else
-              request.class.parse_query_parameters(query)
-            end
-          end
-        end
-      end
-
-      # :call-seq:
-      #   response.should redirect_to(url)
-      #   response.should redirect_to(:action => action_name)
-      #   response.should redirect_to(:controller => controller_name, :action => action_name)
-      #   response.should_not redirect_to(url)
-      #   response.should_not redirect_to(:action => action_name)
-      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
-      #
-      # Passes if the response is a redirect to the url, action or controller/action.
-      # Useful in controller specs (integration or isolation mode).
-      #
-      # == Examples
-      #
-      #   response.should redirect_to("path/to/action")
-      #   response.should redirect_to("http://test.host/path/to/action")
-      #   response.should redirect_to(:action => 'list')
-      def redirect_to(opts)
-        RedirectTo.new(request, opts)
-      end
-    end
-
-  end
-end

data/vendor/plugins/make_resourceful/spec/rspec-rails/render_template.rb

@@ -1,90 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-    
-      class RenderTemplate #:nodoc:
-    
-        def initialize(expected, controller)
-          @controller = controller
-          @expected = expected
-        end
-      
-        def matches?(response)
-          
-          if response.respond_to?(:rendered_file)
-            @actual = response.rendered_file
-          else
-            @actual = response.rendered_template.to_s
-          end
-          return false if @actual.blank?
-          given_controller_path, given_file = path_and_file(@actual)
-          expected_controller_path, expected_file = path_and_file(@expected)
-          given_controller_path == expected_controller_path && given_file.match(expected_file)
-        end
-        
-        def failure_message
-          "expected #{@expected.inspect}, got #{@actual.inspect}"
-        end
-        
-        def negative_failure_message
-          "expected not to render #{@expected.inspect}, but did"
-        end
-        
-        def description
-          "render template #{@expected.inspect}"
-        end
-      
-        private
-          def path_and_file(path)
-            parts = path.split('/')
-            file = parts.pop
-            controller = parts.empty? ? current_controller_path : parts.join('/')
-            return controller, file
-          end
-        
-          def controller_path_from(path)
-            parts = path.split('/')
-            parts.pop
-            parts.join('/')
-          end
-
-          def current_controller_path
-            @controller.class.to_s.underscore.gsub(/_controller$/,'')
-          end
-        
-      end
-
-      # :call-seq:
-      #   response.should render_template(path)
-      #   response.should_not render_template(path)
-      #
-      # Passes if the specified template is rendered by the response.
-      # Useful in controller specs (integration or isolation mode).
-      #
-      # <code>path</code> can include the controller path or not. It
-      # can also include an optional extension (no extension assumes .rhtml).
-      #
-      # Note that partials must be spelled with the preceding underscore.
-      #
-      # == Examples
-      #
-      #   response.should render_template('list')
-      #   response.should render_template('same_controller/list')
-      #   response.should render_template('other_controller/list')
-      #
-      #   #rjs
-      #   response.should render_template('list.rjs')
-      #   response.should render_template('same_controller/list.rjs')
-      #   response.should render_template('other_controller/list.rjs')
-      #
-      #   #partials
-      #   response.should render_template('_a_partial')
-      #   response.should render_template('same_controller/_a_partial')
-      #   response.should render_template('other_controller/_a_partial')
-      def render_template(path)
-        RenderTemplate.new(path.to_s, @controller)
-      end
-
-    end
-  end
-end

data/vendor/plugins/make_resourceful/spec/serialize_spec.rb

@@ -1,133 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Resourceful::Serialize, ".normalize_attributes" do
-  it "should return nil if given nil" do
-    Resourceful::Serialize.normalize_attributes(nil).should be_nil
-  end
-
-  it "should return a basic hash if given a non-injectable attribute" do
-    Resourceful::Serialize.normalize_attributes(:foo).should == {:foo => nil}
-    Resourceful::Serialize.normalize_attributes(12).should == {12 => nil}
-  end
-
-  it "should return a basic hash with a symbol key if given a string attribute" do
-    Resourceful::Serialize.normalize_attributes("foo").should == {:foo => nil}
-  end
-
-  it "should preserve hashes" do
-    Resourceful::Serialize.normalize_attributes({:foo => nil, :bar => nil, :baz => nil}).should ==
-      {:foo => nil, :bar => nil, :baz => nil}
-    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => 4}).should ==
-      {:foo => 3, :bar => 1, :baz => 4}
-    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => [:foo, :bar]}).should ==
-      {:foo => 3, :bar => 1, :baz => [:foo, :bar]}
-  end
-
-  it "should merge injectable attributes into one big hash" do
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, :baz]).should ==
-      {:foo => nil, :bar => nil, :baz => nil}
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => nil},
-                                                 :boom, {:bop => nil, :blat => nil}]).should ==
-      {:foo => nil, :bar => nil, :baz => nil, :boom => nil, :bop => nil, :blat => nil}
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => 12},
-                                                 :boom, {:bop => "foo", :blat => [:fee, :fi, :fo]}]).should ==
-      {:foo => nil, :bar => nil, :baz => 12, :boom => nil, :bop => "foo", :blat => [:fee, :fi, :fo]}
-  end
-end
-
-describe Array, " of non-serializable objects" do
-  before :each do
-    @array = [1, 2, 3, 4, "foo"]
-  end
-
-  it "should return itself for #to_serializable" do
-    @array.to_serializable(nil).should == @array
-  end
-
-  it "should raise an error for #serialize" do
-    lambda { @array.serialize(:yaml, :attributes => [:foo]) }.should raise_error("Not all elements respond to to_serializable")
-  end
-end
-
-describe Array, " of serializable objects" do
-  before :each do
-    @cat = stub_model("Cat")
-    @dog = stub_model("Dog")
-    @array = %w{brown yellow green}.zip(%w{rex rover fido}).
-      map { |c, d| @cat.new(:fur => c, :friend => @dog.new(:name => d)) }
-  end
-
-  it "should return an array of serializable hashes for #to_serializable" do
-    @array.to_serializable([:fur]).should == [{'fur' => 'brown'}, {'fur' => 'yellow'}, {'fur' => 'green'}]
-  end
-
-  it "should follow deep attributes for #to_serializable" do
-    @array.to_serializable([:fur, {:friend => :name}]).should ==
-      [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
-       {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
-       {'fur' => 'green',  'friend' => {'name' => 'fido'}}]
-  end
-
-  it "should raise an error if #serialize is called without the :attributes option" do
-    lambda { @array.serialize(:yaml, {}) }.should raise_error("Must specify :attributes option")
-  end
-
-  it "should serialize to a hash with a pluralized root for #serialize" do
-    YAML.load(@array.serialize(:yaml, :attributes => [:fur, {:friend => :name}])).should ==
-      {"cats" => [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
-                  {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
-                  {'fur' => 'green',  'friend' => {'name' => 'fido'}}]}
-  end
-
-  it "should serialize to an XML document with a pluralized root for #serialize(:xml, ...)" do
-    doc = REXML::Document.new(@array.serialize(:xml, :attributes => [:fur, {:friend => :name}]),
-                              :ignore_whitespace_nodes => :all)
-    doc.root.name.should == "cats"
-    cats = doc.get_elements('/cats/cat')
-    cats.size.should == 3
-    cats.zip(%w{brown yellow green}, %w{rex rover fido}) do |cat, fur, dog|
-      cat.children.find { |e| e.name == "fur" }.text.should == fur
-      cat.children.find { |e| e.name == "friend" }.children[0].text.should == dog
-    end
-  end
-end
-
-describe ActiveRecord::Base, " with a few attributes and an association" do
-  before :each do
-    @person = stub_model("Person")
-    @party_hat = stub_model("PartyHat")
-    @model = @person.new(:name => "joe", :eye_color => "blue", :hairs => 567,
-                         :party_hat => @party_hat.new(:color => 'blue', :size => 12, :pattern => 'stripey'))
-  end
-
-  it "should raise an error if #to_serializable is called without attributes" do
-    lambda { @model.to_serializable(nil) }.should raise_error("Must specify attributes for #<Person>.to_serializable")
-  end
-
-  it "should return an attributes hash for #to_serializable" do
-    @model.to_serializable([:name, :hairs, {:party_hat => [:color, :size]}]).should ==
-      {'name' => 'joe', 'hairs' => 567, 'party_hat' => {
-        'color' => 'blue', 'size' => 12
-      }}
-  end
-
-  it "should raise an error if #serialize is called without the :attributes option" do
-    lambda { @model.serialize(:yaml, {}) }.should raise_error("Must specify :attributes option")
-  end
-
-  it "should serialize to a hash for #serialize" do
-    YAML.load(@model.serialize(:yaml, :attributes => [:hairs, :eye_color, {:party_hat => :size}])).should ==
-      {"person" => {'hairs' => 567, 'eye_color' => 'blue', 'party_hat' => {'size' => 12}}}
-  end
-
-  it "should serialize to an XML document for #serialize(:xml, ...)" do
-    doc = REXML::Document.new(@model.serialize(:xml, :attributes => [:name, :eye_color, {:party_hat => :pattern}]),
-                              :ignore_whitespace_nodes => :all)
-    doc.root.name.should == "person"
-    doc.root.children.find { |e| e.name == "name"      }.text.should == "joe"
-    doc.root.children.find { |e| e.name == "eye-color" }.text.should == "blue"
-
-    hat = doc.root.children.find { |e| e.name == "party-hat" }
-    hat.children.find { |e| e.name == "pattern" }.text.should == "stripey"
-  end
-end

data/vendor/plugins/make_resourceful/spec/spec_helper.rb

@@ -1,319 +0,0 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-%w[spec rails/version action_pack active_record resourceful/maker
-   action_controller action_controller/test_process action_controller/integration
-   spec/rspec-rails/redirect_to spec/rspec-rails/render_template].each &method(:require)
-
-Spec::Runner.configure do |config|
-  config.mock_with :mocha
-end
-
-module MetaClass
-  def metaclass
-    class << self; self; end
-  end
-end
-
-def should_be_called(&block)
-  pstub = stub
-  pstub.expects(:call).instance_eval(&(block || proc {}))
-  proc { |*args| pstub.call(*args) }
-end
-
-def stub_model(name)
-  model = Class.new do
-    include Resourceful::Serialize::Model
-
-    def self.to_s
-      @name
-    end
-
-    def initialize(attrs = {})
-      attrs.each do |k, v|
-        self.stubs(k).returns(v)
-      end
-    end
-
-    def inspect
-      "#<#{self.class.send(:instance_variable_get, '@name')}>"
-    end
-  end
-  model.send(:instance_variable_set, '@name', name)
-  model
-end
-
-def stub_const(name)
-  unless Object.const_defined?(name)
-    obj = Object.new
-    obj.extend MetaClass
-    obj.metaclass.send(:define_method, :to_s) { name.to_s }
-    obj.metaclass.send(:alias_method, :inspect, :to_s)
-    Object.const_set(name, obj)
-  end
-  Object.const_get(name)
-end
-
-def stub_list(size, name = nil, &block)
-  list = Array.new(size) { |i| name ? stub("#{name}_#{i}") : stub }
-  list.each(&block) if block
-  list
-end
-
-module Spec::Matchers
-  def have_any(&proc)
-    satisfy { |a| a.any?(&proc) }
-  end
-end
-
-module ControllerMocks
-  def mock_kontroller(*to_extend)
-    options = to_extend.last.is_a?(Hash) ? to_extend.slice!(-1) : {}
-    @kontroller = Class.new
-    @kontroller.extend Resourceful::Maker
-    to_extend.each(&@kontroller.method(:extend))
-
-    @hidden_actions = Resourceful::ACTIONS.dup
-    @kontroller.stubs(:hidden_actions).returns(@hidden_actions)
-    @kontroller.stubs(:plural_action?).returns(false)
-    @kontroller.stubs(:include)
-    @kontroller.stubs(:before_filter)
-    @kontroller.stubs(:helper_method)
-  end
-
-  def mock_controller(*to_extend)
-    mock_kontroller
-    @controller = @kontroller.new
-    to_extend.each(&@controller.method(:extend))
-  end
-
-  def mock_builder(inherited = false)
-    @builder = stub
-    @builder.stubs(:response_for)
-    @builder.stubs(:apply)
-    @builder.stubs(:instance_eval).yields(@buildercc )
-    @builder.stubs(:inherited?).returns(inherited)
-    Resourceful::Base.stubs(:made_resourceful).returns([])
-    Resourceful::Builder.stubs(:new).returns(@builder)
-  end
-
-  def create_builder
-    @builder = Resourceful::Builder.new(@kontroller)
-    class << @builder
-      alias_method :made_resourceful, :instance_eval
-    end
-  end
-
-  def responses
-    @kontroller.resourceful_responses
-  end
-
-  def callbacks
-    @kontroller.resourceful_callbacks
-  end
-
-  def parents
-    @kontroller.parents
-  end
-
-  # Evaluates the made_resourceful block of mod (a module)
-  # in the context of @builder.
-  # @builder should be initialized via create_builder.
-  def made_resourceful(mod)
-    mod.included(@builder)
-  end
-end
-
-module RailsMocks
-  attr_reader :response, :request, :controller, :kontroller
-
-  def included(mod)
-    require 'ruby-debug'
-    debugger
-  end
-
-  def mock_resourceful(options = {}, &block)
-    options = {
-      :name => "things"
-    }.merge options
-
-    init_kontroller options
-    init_routes options
-
-    stub_const(options[:name].singularize.camelize)
-    kontroller.make_resourceful(&block)
-
-    init_controller options
-  end
-
-  def assigns(name)
-    controller.instance_variable_get("@#{name}")
-  end
-
-  def redirect_to(opts)
-    Spec::Rails::Matchers::RedirectTo.new(request, opts)
-  end
-
-  def render_template(path)
-    Spec::Rails::Matchers::RenderTemplate.new(path.to_s, @controller)
-  end
-
-  private
-
-  def init_kontroller(options)
-    @kontroller = Class.new ActionController::Base
-    @kontroller.extend Resourceful::Maker
-    @kontroller.extend MetaClass
-
-    @kontroller.metaclass.send(:define_method, :controller_name) { options[:name] }
-    @kontroller.metaclass.send(:define_method, :controller_path) { options[:name] }
-    @kontroller.metaclass.send(:define_method, :inspect) { "#{options[:name].camelize}Controller" }
-    @kontroller.metaclass.send(:alias_method, :to_s, :inspect)
-
-    @kontroller.send(:define_method, :controller_name) { options[:name] }
-    @kontroller.send(:define_method, :controller_path) { options[:name] }
-    @kontroller.send(:define_method, :inspect) { "#<#{options[:name].camelize}Controller>" }
-    @kontroller.send(:alias_method, :to_s, :inspect)
-    @kontroller.send(:include, ControllerMethods)
-    @kontroller.send(:view_paths=, [File.join(File.dirname(__FILE__), 'views')])
-
-    @kontroller
-  end
-
-  def init_routes(options)
-    ActionController::Routing::Routes.clear!
-    route_block = options[:routes] || proc { |map| map.resources options[:name] }
-    ActionController::Routing::Routes.draw(&route_block)
-  end
-
-  def init_controller(options)
-    @controller = kontroller.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-
-    @controller.request = @request
-    @controller.response = @response
-    @request.accept = '*/*'
-    @request.env['HTTP_REFERER'] = 'http://test.host'
-
-    @controller
-  end
-
-  def action_params(action, params = {})
-    params.merge case action
-                 when :show, :edit, :destroy: {:id => 12}
-                 when :update: {:id => 12, :thing => {}}
-                 when :create: {:thing => {}}
-                 else {}
-                 end
-  end
-
-  def action_method(action)
-    method case action
-           when :index, :show, :edit, :new: :get
-           when :update: :put
-           when :create: :post
-           when :destroy: :delete
-           end
-  end
-
-  module ControllerMethods
-    # From rspec-rails ControllerExampleGroup  
-    
-    def render(options=nil, deprecated_status_or_extra_options=nil, &block)
-      if ::Rails::VERSION::STRING >= '2.0.0' && deprecated_status_or_extra_options.nil?
-        deprecated_status_or_extra_options = {}
-      end
-      
-      unless block_given?
-        if @template.respond_to?(:finder)
-          (class << @template.finder; self; end).class_eval do
-            define_method :file_exists? do; true; end
-          end
-        else
-          (class << @template; self; end).class_eval do
-            define_method :file_exists? do; true; end
-          end
-        end
-        (class << @template; self; end).class_eval do
-          define_method :render_file do |*args|
-            @first_render ||= args[0] unless args[0] =~ /^layouts/
-            @_first_render ||= args[0] unless args[0] =~ /^layouts/
-          end
-          
-          define_method :_pick_template do |*args|
-            @_first_render ||= args[0] unless args[0] =~ /^layouts/
-            PickedTemplate.new
-          end
-        end
-      end
-
-      super(options, deprecated_status_or_extra_options, &block)
-    end
-    
-    class PickedTemplate
-      def render_template(*ignore_args); end
-      def render_partial(*ignore_args);  end
-    end
-  end
-  
-end
-
-module Spec::Example::ExampleGroupMethods
-  def should_render_html(action)
-    it "should render HTML by default for #{action_string(action)}" do
-      action_method(action)[action, action_params(action)]
-      response.body.should include("as HTML")
-      response.content_type.should == 'text/html'
-    end
-  end
-  
-  def should_render_js(action)
-    it "should render JS for #{action_string(action)}" do
-      action_method(action)[action, action_params(action, :format => 'js')]
-      response.body.should include("insert(\"#{action}")
-      response.should be_success
-      response.content_type.should == 'text/javascript'
-    end
-  end
-
-  def shouldnt_render_xml(action)
-    it "shouldn't render XML for #{action_string(action)}" do
-      action_method(action)[action, action_params(action, :format => 'xml')]
-      response.should_not be_success
-      response.code.should == '406'
-    end
-  end
-
-  def action_string(action)
-    case action
-    when :index:   "GET /things"
-    when :show:    "GET /things/12"
-    when :edit:    "GET /things/12/edit"
-    when :update:  "PUT /things/12"
-    when :create:  "POST /things"
-    when :new:     "GET /things/new"
-    when :destroy: "DELETE /things/12"
-    end
-  end
-end
-
-module Spec::Example
-  class IntegrationExampleGroup < Spec::Example::ExampleGroup
-    include ActionController::TestProcess
-    include ActionController::Assertions
-    include RailsMocks
-    
-    # Need this helper, because we made current_objects private
-    def current_objects
-      controller.instance_eval("current_objects")
-    end
-
-    # Need this helper, because we made current_object private
-    def current_object
-      controller.instance_eval("current_object")
-    end
-    
-    ExampleGroupFactory.register(:integration, self)
-  end
-end