radiant-templates-extension 1.0.0

data/vendor/plugins/make_resourceful/spec/rspec_on_rails/redirect_to.rb

@@ -0,0 +1,81 @@
+require 'action_controller/url_rewriter'
+
+class RedirectTo
+  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}}, "").split("?", 2)[0]
+    path = path.split("/")[1..-1] if ::Rails::VERSION::MINOR < 2
+    ActionController::Routing::Routes.recognize_path path
+  end
+
+  def query_hash(url)
+    query = url.split("?", 2)[1] || ""
+    if defined?(CGIMethods)
+      CGIMethods.parse_query_parameters(query)
+    else
+      ActionController::AbstractRequest.parse_query_parameters(query)
+    end
+  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
+end

data/vendor/plugins/make_resourceful/spec/rspec_on_rails/render_template.rb

@@ -0,0 +1,28 @@
+
+class RenderTemplate
+  
+  def initialize(expected, controller)
+    @controller = controller
+    @expected = expected
+  end
+  
+  def matches?(response)
+    @actual = response.rendered_file
+    full_path(@actual) == full_path(@expected)
+  end
+
+  def failure_message
+    "expected #{@expected.inspect}, got #{@actual.inspect}"
+  end
+  
+  def description
+    "render template #{@expected.inspect}"
+  end
+  
+  private
+  def full_path(path)
+    return nil if path.nil?
+    path.include?('/') ? path : "#{@controller.class.to_s.underscore.gsub('_controller','')}/#{path}"
+  end
+  
+end

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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,279 @@
+$: << File.dirname(__FILE__) + '/../lib'
+require 'rubygems'
+%w[spec action_pack active_record resourceful/maker
+   action_controller action_controller/test_process action_controller/integration
+   spec/rspec_on_rails/redirect_to spec/rspec_on_rails/render_template].each &method(:require)
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+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.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.read_inheritable_attribute(:resourceful_responses)
+  end
+
+  def callbacks
+    @kontroller.read_inheritable_attribute(:resourceful_callbacks)
+  end
+
+  def parents
+    @kontroller.read_inheritable_attribute(: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)
+    RedirectTo.new(request, opts)
+  end
+
+  def render_template(path)
+    RenderTemplate.new(path.to_s, @controller)
+  end
+
+  private
+
+  def init_kontroller(options)
+    @kontroller = Class.new ActionController::Base
+    @kontroller.extend Resourceful::Maker
+
+    @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
+  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
+    def render(options=nil, deprecated_status=nil, &block)
+      unless block_given?
+        @template.metaclass.class_eval do
+          define_method :file_exists? do true end
+          define_method :render_file do |*args|
+            @first_render ||= args[0]
+          end
+        end
+      end
+
+      super(options, deprecated_status, &block)
+    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.should be_success
+      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.should be_success
+      response.content_type.should == 'text/javascript'
+    end
+  end
+
+  def shouldnt_render_xml(action)
+    it "should 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 < Test::Unit::TestCase
+    include ExampleMethods
+    class << self
+      include ExampleGroupMethods
+    end
+
+    def initialize(defined_description, &implementation)
+      super()
+      @_defined_description = defined_description
+      @_implementation = implementation
+    end
+
+    ExampleGroupFactory.register(:integration, self)
+  end
+end