radiant 0.6.6 → 0.6.7

data/spec/lib/radiant/admin_ui_spec.rb

@@ -2,19 +2,75 @@ require File.dirname(__FILE__) + "/../../spec_helper"
 
 describe Radiant::AdminUI do
   before :each do
-    @admin = Radiant::AdminUI.instance
+    @admin = Radiant::AdminUI.new
   end
-  
+
   it "should be a Simpleton" do
     Radiant::AdminUI.included_modules.should include(Simpleton)
     Radiant::AdminUI.should respond_to(:instance)
   end
-  
+
   it "should have a TabSet" do
     @admin.should respond_to(:tabs)
     @admin.tabs.should_not be_nil
     @admin.tabs.should be_instance_of(Radiant::AdminUI::TabSet)
   end
+
+  it "should have collections of Region Sets for every controller" do
+    %w{page snippet layout user}.each do |collection|
+      @admin.should respond_to(collection)
+      @admin.send(collection).should_not be_nil
+      @admin.send(collection).should be_kind_of(OpenStruct)
+    end
+  end
+
+  it "should load the default page regions" do
+    page = @admin.page
+    %w{edit remove children index}.each do |action|
+      page.send(action).should_not be_nil
+      page.send(action).should be_kind_of(Radiant::AdminUI::RegionSet)
+    end
+    page.edit.main.should == %w{edit_header edit_form edit_popups}
+    page.edit.form.should == %w{edit_title edit_extended_metadata
+                                edit_page_parts}
+    page.edit.parts_bottom.should == %w{edit_layout_and_type edit_timestamp}
+    page.edit.form_bottom.should == %w{edit_buttons}
+    page.index.sitemap_head.should == %w{title_column_header
+                                        status_column_header
+                                        modify_column_header}
+    page.index.node.should == %w{title_column status_column add_child_column
+                                  remove_column}
+    page.remove.should === page.index
+    page.children.should === page.index
+    page._part.should === page.edit
+  end
+
+  it "should load the default snippet regions" do
+    snippet = @admin.snippet
+    snippet.edit.should_not be_nil
+    snippet.edit.main.should == %w{edit_header edit_form}
+    snippet.edit.form.should == %w{edit_title edit_content edit_filter
+                                   edit_timestamp}
+    snippet.edit.form_bottom.should == %w{edit_buttons}
+  end
+
+  it "should load the default layout regions" do
+    layout = @admin.layout
+    layout.edit.should_not be_nil
+    layout.edit.main.should == %w{edit_header edit_form}
+    layout.edit.form.should == %w{edit_title edit_extended_metadata
+                                  edit_content edit_timestamp}
+    layout.edit.form_bottom.should == %w{edit_buttons}
+  end
+
+  it "should load the default user regions" do
+    user = @admin.user
+    user.edit.should_not be_nil
+    user.edit.main.should == %w{edit_header edit_form}
+    user.edit.form.should == %w{edit_name edit_email edit_username
+                                edit_password edit_roles edit_notes}
+    user.edit.form_bottom.should == %w{edit_timestamp edit_buttons}
+  end
 end
 
 describe Radiant::AdminUI::TabSet do
@@ -30,7 +86,7 @@ describe Radiant::AdminUI::TabSet do
   it "should be Enumerable" do
     @tabs.class.included_modules.should include(Enumerable)
   end
-  
+
   it "should have its tabs accessible by name using brackets" do
     @tabs.should respond_to(:[])
     @tab_names.each do |name|
@@ -38,27 +94,27 @@ describe Radiant::AdminUI::TabSet do
       @tabs[name].name.should == name
     end
   end
-  
+
   it "should have its tabs accessible by index using brackets" do
     @tab_names.each_with_index do |name, index|
       @tabs[index].should be_instance_of(Radiant::AdminUI::Tab)
       @tabs[index].name.should == name
-    end 
+    end
   end
-  
+
   it "should add new tabs to the end by default" do
     @tabs.size.should == 3
     @tabs.add "Test", "/test"
     @tabs[3].name.should == "Test"
   end
-  
+
   it "should add a new tab before the specified tab" do
     @tabs[1].name.should == "Second"
     @tabs.add "Before", "/before", :before => "Second"
     @tabs[1].name.should == "Before"
     @tabs[2].name.should == "Second"
   end
-  
+
   it "should add a new tab after the specified tab" do
     @tabs[1].name.should == "Second"
     @tabs[2].name.should == "Third"
@@ -67,18 +123,18 @@ describe Radiant::AdminUI::TabSet do
     @tabs[1].name.should == "Second"
     @tabs[3].name.should == "Third"
   end
-  
+
   it "should remove a tab by name" do
     @tabs.size.should == 3
     @tabs.remove "Second"
     @tabs.size.should == 2
     @tabs[1].name.should == "Third"
   end
-  
+
   it "should not allow adding a tab with the same name as an existing tab" do
     lambda { @tabs.add "First", "/first" }.should raise_error(Radiant::AdminUI::DuplicateTabNameError)
   end
-  
+
   it "should remove all tabs when cleared" do
     @tabs.size.should == 3
     @tabs.clear
@@ -99,7 +155,7 @@ describe Radiant::AdminUI::Tab do
       @tab.should be_shown_for(users(user))
     end
   end
-  
+
   it "should be shown only to admin users when visibility is admin" do
     @tab.visibility = [:admin]
     @tab.should be_shown_for(users(:admin))
@@ -107,25 +163,25 @@ describe Radiant::AdminUI::Tab do
       @tab.should_not be_shown_for(users(user))
     end
   end
-  
+
   it "should be shown only to developer users when visibility is developer" do
     @tab.visibility = [:developer]
     @tab.should be_shown_for(users(:developer))
     [:existing, :another, :admin, :non_admin].each do |user|
       @tab.should_not be_shown_for(users(user))
-    end    
+    end
   end
-  
+
   it "should assign visibility from :for option when created" do
     @tab = Radiant::AdminUI::Tab.new "Test", "/test", :for => :developer
     @tab.visibility.should == [:developer]
   end
-  
+
   it "should assign visibility from :visibility option when created" do
     @tab = Radiant::AdminUI::Tab.new "Test", "/test", :visibility => :developer
     @tab.visibility.should == [:developer]
   end
-  
+
   it "should assign visibility from both :for and :visibility options when created" do
     @tab = Radiant::AdminUI::Tab.new "Test", "/test", :for => :developer, :visibility => :admin
     @tab.visibility.should == [:developer, :admin]

data/spec/models/user_spec.rb

@@ -93,26 +93,33 @@ describe User do
     @user.confirm_password = true
     @user.password_confirmation = @user.password = 'test_password'
     @user.save!
-    @user.password.should == User.sha1('test_password')
+    @user.password.should == @user.sha1('test_password')
   end
   
   it 'should save existing but empty password' do
     @user.save!
     @user.password_confirmation = @user.password = ''
     @user.save!
-    @user.password.should == User.sha1('password')
+    @user.password.should == @user.sha1('password')
   end
   
   it 'should save existing but different password' do
     @user.save!
     @user.password_confirmation = @user.password = 'cool beans'
     @user.save!
-    @user.password.should == User.sha1('cool beans')
+    @user.password.should == @user.sha1('cool beans')
   end
   
   it 'should save existing but same password' do
     @user.save! && @user.save!
-    @user.password.should == User.sha1('password')
+    @user.password.should == @user.sha1('password')
+  end
+  
+  it "should create a salt when encrypting the password" do
+    @user.salt.should be_nil
+    @user.send(:encrypt_password)
+    @user.salt.should_not be_nil
+    @user.password.should == @user.sha1('password')
   end
 end
 

data/spec/scenarios/users_scenario.rb

@@ -10,7 +10,7 @@ class UsersScenario < Scenario::Base
   
   helpers do
     def create_user(name, attributes={})
-      create_record :user, name.symbolize, user_attributes(attributes.update(:name => name))
+      create_model :user, name.symbolize, user_attributes(attributes.update(:name => name))
     end
     def user_attributes(attributes={})
       name = attributes[:name] || "John Doe"
@@ -21,7 +21,7 @@ class UsersScenario < Scenario::Base
         :login => symbol.to_s,
         :password => "password"
       }.merge(attributes)
-      attributes[:password] = User.sha1(attributes[:password])
+      attributes[:password_confirmation] = attributes[:password]
       attributes
     end
     def user_params(attributes={})

data/vendor/plugins/haml/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2008 Hampton Catlin
+
+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.

data/vendor/plugins/haml/README.rdoc

@@ -0,0 +1,319 @@
+= Haml and Sass
+
+Haml and Sass are templating engines
+for the two most common types of documents on the web:
+HTML and CSS, respectively.
+They are designed to make it both easier and more pleasant
+to code HTML and CSS documents,
+by eliminating redundancy,
+reflecting the underlying structure that the document represents,
+and providing elegant, easily understandable, and powerful syntax.
+
+== Using
+
+There are several ways to use Haml and Sass.
+They can be used as a plugins for Rails or Merb,
+or embedded on their own in other applications.
+The first step of all of these is to install the Haml gem:
+
+  gem install haml
+
+To install Haml and Sass as a Rails plugin,
+just run <tt>haml --rails path/to/rails/app</tt>
+and both Haml and Sass will be installed.
+Views with the <tt>.haml</tt> (or <tt>.html.haml</tt> for edge)
+extension will automatically use Haml.
+Sass is a little more complicated;
+<tt>.sass</tt> files should be placed in public/stylesheets/sass,
+where they'll be automatically compiled
+to corresponding CSS files in public/stylesheets when needed
+(the Sass template directory is customizable...
+see the Sass module docs for details).
+
+For Merb, <tt>.html.haml</tt> views will work without any further modification.
+To enable Sass, you also need to add it add a dependency.
+To do so, just add
+
+  dependency "haml"
+
+to config/dependencies.rb.
+Then it'll work just like it does in Rails.
+
+To use Haml and Sass programatically,
+check out the RDocs for the Haml and Sass modules.
+
+== Formatting
+
+=== Haml
+
+The most basic element of Haml
+is a shorthand for creating HTML tags:
+
+  %tagname{ :attr1 => 'value1', :attr2 => 'value2' } Contents
+
+No end-tag is needed; Haml handles that automatically.
+Adding <tt>class</tt> and <tt>id</tt> attributes is even easier.
+Haml uses the same syntax as the CSS that styles the document:
+
+  %tagname#id.class
+
+In fact, when you're using the <tt><div></tt> tag,
+it becomes <em>even easier</em>.
+Because <tt><div></tt> is such a common element,
+a tag without a name defaults to a div. So
+
+  #foo Hello!
+
+becomes
+
+  <div id='foo'>Hello!</div>
+
+Haml uses indentation
+to bring the individual elements to represent the HTML structure.
+A tag's children are indented two spaces more than the parent tag.
+Again, a closing tag is automatically added.
+For example:
+
+  %ul
+    %li Salt
+    %li Pepper
+
+becomes:
+
+  <ul>
+    <li>Salt</li>
+    <li>Pepper</li>
+  </ul>
+
+You can also put plain text as a child of an element:
+
+  %p
+    Hello,
+    World!
+
+It's even possible to embed Ruby code into Haml documents.
+An equals sign, <tt>=</tt>, will output the result of the code.
+A hyphen, <tt>-</tt>, will run the code but not output the result.
+You can even use control statements
+like <tt>if</tt> and <tt>while</tt>:
+
+  %p
+    Date/Time:
+    - now = DateTime.now
+    %strong= now
+    - if now > DateTime.parse("December 31, 2006")
+      = "Happy new " + "year!"
+
+Haml provides far more tools than those presented here.
+Check out the reference documentation in the Haml module.
+
+=== Sass
+
+At its most basic,
+Sass is just another way of writing CSS.
+Although it's very much like normal CSS,
+the basic syntax offers a few helpful features:
+tabulation (using *two spaces*)
+indicates the attributes in a rule,
+rather than non-DRY brackets;
+and newlines indicate the end of an attribute,
+rather than a semicolon.
+For example:
+
+  #main
+    :background-color #f00
+    :width 98%
+
+becomes:
+
+  #main {
+    background-color: #f00;
+    width: 98% }
+
+However, Sass provides much more than a way to make CSS look nice.
+In CSS, it's important to have accurate selectors,
+so your styles don't just apply to everything.
+However, in order to do this,
+you need to use nested element selectors.
+These get very ugly very quickly.
+I'm sure everyone's had to write something like
+"#main .sidebar .top p h1 a",
+followed by
+"#main .sidebar .top p h1 a:visited" and
+"#main .sidebar .top p h1 a:hover".
+Well, Sass gets rid of that.
+Like Haml, it uses indentation to indicate the structure of the document.
+So, what was:
+
+  #main {
+    width: 90%;
+  }
+  #main p {
+    border-style: solid;
+    border-width: 1px;
+    border-color: #00f;
+  }
+  #main p a {
+    text-decoration: none;
+    font-weight: bold;
+  }
+  #main p a:hover {
+    text-decoration: underline;
+  }
+
+becomes:
+
+  #main
+    :width 90%
+    p
+      :border-style solid
+      :border-width 1px
+      :border-color #00f
+      a
+        :text-decoration none
+        :font-weight bold
+      a:hover
+        :text-decoration underline
+
+Pretty nice, no? Well, it gets better.
+One of the main complaints against CSS is that it doesn't allow constants.
+What if have a color or a width you re-use all the time?
+In CSS, you just have to re-type it each time,
+which is a nightmare when you decide to change it later.
+Not so for Sass!
+You can use the "!" character to set constants.
+Then, if you put "=" after your attribute name,
+you can set it to a constant.
+For example:
+
+  !note_bg= #55aaff
+
+  #main
+    :width 70%
+    .note
+      :background-color= !note_bg
+    p
+      :width 5em
+      :background-color= !note_bg
+
+becomes:
+
+  #main {
+    width: 70%; }
+    #main .note {
+      background-color: #55aaff; }
+    #main p {
+      width: 5em;
+      background-color: #55aaff; }
+
+You can even do simple arithmetic operations with constants,
+adding numbers and even colors together:
+
+  !main_bg= #46ar12
+  !main_width= 40em
+
+  #main
+    :background-color= !main_bg
+    :width= !main_width
+    .sidebar
+      :background-color= !main_bg + #333333
+      :width= !main_width - 25em
+
+becomes:
+
+  #main {
+    background-color: #46a312;
+    width: 40em; }
+    #main .sidebar {
+      background-color: #79d645;
+      width: 15em; }
+
+Taking the idea of constants a bit further are mixins.
+These let you group whole swathes of CSS attributes into a single
+directive and then include those anywhere you want:
+
+  =blue-border
+    :border
+      :color blue
+      :width 2px
+      :style dotted
+
+  .comment
+    +blue-border
+    :padding 2px
+    :margin 10px 0
+
+  .reply
+    +blue-border
+
+becomes:
+
+  .comment {
+    border-color: blue;
+    border-width: 2px;
+    border-style: dotted;
+    padding: 2px;
+    margin: 10px 0;
+  }
+
+  .reply {
+    border-color: blue;
+    border-width: 2px;
+    border-style: dotted;
+  }
+
+A comprehensive list of features is in
+the documentation for the Sass module.
+
+== Executables
+
+The Haml gem includes several executables that are useful
+for dealing with Haml and Sass from the command line.
+
+=== +haml+
+
+The +haml+ executable transforms a source Haml file into HTML.
+See <tt>haml --help</tt> for further information and options.
+
+=== +sass+
+
+The +sass+ executable transforms a source Sass file into CSS.
+See <tt>sass --help</tt> for further information and options.
+
+=== <tt>html2haml</tt>
+
+The <tt>html2haml</tt> executable attempts to transform HTML,
+optionally with ERB markup, into Haml code.
+Since HTML is so variable, this transformation is not always perfect;
+it's a good idea to have a human check the output of this tool.
+See <tt>html2haml --help</tt> for further information and options.
+
+=== <tt>css2sass</tt>
+
+The <tt>css2sass</tt> executable attempts to transform CSS into Sass code.
+This transformation attempts to use Sass nesting where possible.
+See <tt>css2sass --help</tt> for further information and options.
+
+== Authors
+
+Haml and Sass are designed by Hampton Catlin (hcatlin) and he is the author
+of the original implementation. However, Hampton doesn't even know his way
+around the code anymore and mostly just concentrates on the language issues.
+Hampton lives in Toronto, Ontario (though he's an American by birth) and
+is a partner at Unspace Interactive.
+
+Nathan Weizenbaum is the primary maintainer and architect of the "modern" Ruby
+implementation of Haml. His hard work has kept the project alive by endlessly
+answering forum posts, fixing bugs, refactoring, finding speed improvements,
+writing documentation, implementing new features, and getting Hampton
+coffee (a fitting task for a boy-genius). Nathan lives in Seattle, Washington and
+while not being a student at University of Washington he consults for
+Unspace Interactive and Microsoft.
+
+If you use this software, you must pay Hampton a compliment. And
+buy Nathan some jelly beans. Maybe pet a kitten. Yeah. Pet that kitty.
+
+Some of the work on Haml was supported by Unspace Interactive.
+
+Beyond that, the implementation is licensed under the MIT License.
+Ok, fine, I guess that means compliments aren't *required*.