rad_kit 0.0.1

data/lib/kit/text_utils/image_box.rb

@@ -0,0 +1,35 @@
+class Rad::TextUtils::ImageBox < Rad::TextUtils::Processor
+  # !![img] => [![img_thumb]][img]
+  def process markdown, env
+    img_urls = {}
+    markdown = markdown.gsub(/!!\[(.+?)\]/) do
+      img_key = $1 || ''
+      if url = markdown.scan(/\[#{img_key}\]:\s*([^\s]+)$/).first.try(:first)
+        unless url =~ /\.[^\.]+\.[^\.]+$/ # image.png
+          thumb_img_key = "#{img_key}_thumb"
+      
+          # building url with thumb (foo.png => foo.thumb.png)
+          img_urls[thumb_img_key] = url.sub(/\.([^\.]+)$/){".thumb.#{$1}"}
+
+          "[![][#{thumb_img_key}]][#{img_key}]"
+        else # image.(icon|thumb|...).png
+          img_key_full = "#{img_key}_full"
+      
+          # building url with thumb (foo.png => foo.thumb.png)
+          img_urls[img_key_full] = url.sub(/\.([^\.]+)\.([^\.]+)$/){".#{$2}"}
+      
+          "[![][#{img_key}]][#{img_key_full}]"
+        end
+      else
+        $& || ''
+      end
+    end
+  
+    unless img_urls.blank?
+      markdown << "\n"
+      markdown << img_urls.to_a.collect{|k, v| "[#{k}]: #{v}"}.join("\n")
+    end
+    
+    call_next markdown, env
+  end    
+end

data/lib/kit/text_utils/markup.rb

@@ -0,0 +1,43 @@
+class Rad::TextUtils::Markup < Rad::TextUtils::Processor
+
+  def initialize processor = nil
+    super
+            
+    @markup = build_from(
+      Rad::TextUtils::EnsureUtf,
+      Rad::TextUtils::HtmlSanitizer,
+    
+      Rad::TextUtils::CodeHighlighter,
+      
+      Rad::TextUtils::CustomMarkdown,
+      
+      Rad::TextUtils::Urls,
+      Rad::TextUtils::TagShortcuts                    
+    )
+    
+    @html = build_from(
+      Rad::TextUtils::EnsureUtf,
+      Rad::TextUtils::HtmlSanitizer,
+      Rad::TextUtils::CodeHighlighter
+    )
+  end
+
+  def process text, env
+    return text if text.blank?
+    
+    if text =~ /\A\[html\]/i
+      text = text.sub(/\A\[html\][\s\n\r]*/i, '')
+      chain = @html
+    else
+      chain = @markup
+    end
+
+    text = chain.process text, env
+
+    unless text.encoding == Encoding::UTF_8
+      raise "something wrong happens, invalid encoding (#{text.encoding} instead of utf-8)!"
+    end
+
+    call_next text, env
+  end
+end

data/lib/kit/text_utils/processor.rb

@@ -0,0 +1,25 @@
+class Rad::TextUtils::Processor
+  def initialize next_processor = nil
+    @next_processor = next_processor
+  end
+  
+  protected
+    def call_next data, env
+      if @next_processor 
+        @next_processor.process data, env 
+      else
+        data
+      end
+    end
+  
+    def build_from *processors
+      processors.reverse.inject nil do |next_processor, meta|
+        klass, args = if meta.is_a? Array
+          [meta[0], meta[1..-1]]
+        else
+          [meta, []]
+        end
+        klass.new next_processor, *args
+      end
+    end
+end

data/lib/kit/text_utils/tag_shortcuts.rb

@@ -0,0 +1,14 @@
+class Rad::TextUtils::TagShortcuts < Rad::TextUtils::Processor
+  TAGS = {
+    /\[clear\]/ => lambda{|match| "<div class='clear'></div>"},
+    /\[space\]/ => lambda{|match| "<div class='space'></div>"}
+  }
+
+  def process markdown, env
+    TAGS.each do |k, v|
+      markdown.gsub!(k, &v)
+    end
+    
+    call_next markdown, env
+  end
+end

data/lib/kit/text_utils/truncate.rb

@@ -0,0 +1,29 @@
+class Rad::TextUtils::Truncate < Rad::TextUtils::Processor
+  def initialize processor, length
+    super(processor)
+    @length = length
+  end
+  
+  def process str_or_html, env
+    str_or_html ||= ""
+  
+    # Strip from HTML tags
+    str_or_html = str_or_html.gsub("<br", " <br").gsub("<p", " <p") # to preserve space in place of <> html elements
+    doc = Nokogiri::XML("<div class='root'>#{str_or_html}</div>")
+    str = doc.css('.root').first.content
+
+    str = str.gsub(/\s+/, ' ')
+
+    # Truncate with no broken words
+    str = if str.length >= @length
+      shortened = str[0, @length]
+      splitted = shortened.split(/\s/)
+      words = splitted.length
+      splitted[0, words-1].join(" ") + ' ...'
+    else
+      str
+    end
+    
+    call_next str, env
+  end
+end

data/lib/kit/text_utils/truncator.rb

@@ -0,0 +1,15 @@
+class Rad::TextUtils::Truncator < Rad::TextUtils::Processor  
+  def initialize processor, length
+    super(processor)
+    
+    @chain = build_from(
+      Rad::TextUtils::EnsureUtf,
+      [Rad::TextUtils::Truncate, length]      
+    )
+  end
+  
+  def process text_or_html, env
+    text_or_html = @chain.process text_or_html, env
+    call_next text_or_html, env
+  end
+end

data/lib/kit/text_utils/urls.rb

@@ -0,0 +1,13 @@
+class Rad::TextUtils::Urls < Rad::TextUtils::Processor
+  # Creates <a> tags for all urls.
+  # IMPORTANT: make sure you've used #urls_to_images method first
+  # if you wanted all images urls to become <img> tags.
+  def process html, env
+    # becouse it finds only one url in such string "http://some_domain.com http://some_domain.com" we need to aply it twice
+    regexp, sub = /(\s|^|\A|\n|\t|\r)(http:\/\/.*?)([,.])?(\s|$|\n|\Z|\t|\r|<)/, '\1<a href="\2">\2</a>\3\4'
+    html = html.gsub regexp, sub
+    html.gsub regexp, sub
+    
+    call_next html, env
+  end
+end

data/readme.md

@@ -0,0 +1,10 @@
+# Rapid Application Development Kit for Rad Framework
+
+[add docs]
+
+# Low
+
+- WYSIWYG from WordPress/GitHub
+- remove unused locale tokens
+
+# TODO

data/spec/controller/authorization_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe "Authorizations" do    
+  with_controllers
+  
+  isolate :config
+    
+  before :all do     
+    @permissions = {
+      'call_controller_level' => [],
+      'call_business_logic_level' => [],
+      'call_with_owner' => []
+    }
+    
+    class ::AuthorizationController
+      inherit Rad::Controller::Http
+      
+      inherit Rad::Controller::Http::Authorized
+    
+      require_permission :call_controller_level, only: :controller_level
+    
+      def unprotected
+        render_ok
+      end
+    
+      def controller_level
+        render_ok
+      end
+          
+      def business_logic_level
+        require_permission :call_business_logic_level
+        render_ok
+      end
+      
+      def with_owner
+        require_permission :call_with_owner, owned_object
+        render_ok
+      end
+      
+      def with_owner_controller_level
+        render_ok
+      end
+      require_permission :call_with_owner, only: :with_owner_controller_level do
+        owned_object
+      end
+      
+      protected 
+        def owned_object
+          @@owned_object
+        end
+        
+        def self.owned_object= o
+          @@owned_object = o
+        end
+    end
+    
+    rad.router.configure do |c|
+      c.resource :authorization_controllers, class_name: 'AuthorizationController'     
+    end
+    
+    I18n.locale = :en
+  end  
+  
+  after :all do
+    remove_constants %w(AuthorizationController)
+  end
+  
+  before do
+    AuthorizationController.owned_object = nil
+    
+    rad.config.permissions = @permissions
+    
+    @user = Models::User.new
+    rad.user = @user
+  end
+  
+  def raise_authorization_error
+    raise_error(UserError, /Access Denied/)
+  end
+  
+  it "should allow to call unprotected methods" do
+    call('/authorization_controllers/unprotected')
+    response.body.should == "ok"
+  end
+  
+  it "should allow declarative authorization at controller level" do    
+    @user.stub!(:can?).and_return(false)
+    lambda{
+      call '/authorization_controllers/controller_level'
+    }.should raise_authorization_error
+    # response.should be_redirect
+  
+    @user.stub!(:can?).and_return(true)
+    call '/authorization_controllers/controller_level'
+    response.body.should == "ok"
+  end
+  
+  it "should allow declarative authorization at business logic level" do    
+    @user.stub!(:can?).and_return(false)
+    lambda{
+      call '/authorization_controllers/business_logic_level'
+    }.should raise_authorization_error
+    # response.should be_redirect
+      
+    @user.stub!(:can?).and_return(true)
+    call '/authorization_controllers/business_logic_level'
+    response.body.should == "ok"
+  end
+  
+  it "should use owner if provided" do
+    @user.stub!(:can?){false}
+    lambda{
+      call '/authorization_controllers/with_owner'
+    }.should raise_authorization_error
+    # response.should be_redirect
+  
+    
+    o = Object.new
+    o.stub!(:owner_name){@user.name}
+    AuthorizationController.owned_object = o 
+    
+    @user.stub!(:can?) do |operation, object|       
+      object and object.owner_name == @user.name
+    end
+    
+    call '/authorization_controllers/with_owner'
+    response.body.should == "ok"
+  end
+  
+  it "should use owner if provided (action level)" do    
+    @user.stub!(:can?){false}
+    lambda{
+      call '/authorization_controllers/with_owner_controller_level'
+    }.should raise_authorization_error
+    # response.should be_redirect
+    
+    
+    o = Object.new
+    o.stub!(:owner_name){@user.name}
+    AuthorizationController.owned_object = o
+  
+    @user.stub!(:can?) do |operation, object|       
+      object and object.owner_name == @user.name
+    end
+    
+    call '/authorization_controllers/with_owner_controller_level'
+    response.body.should == "ok"
+  end
+end

data/spec/controller/comments_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe "Comments" do
+  with_controllers
+  set_controller Controllers::Comments
+  login_as :user
+    
+  before do
+    @item = Factory.create :item
+  end
+  
+  def create_comment original_text = 'text'
+    Factory.create :comment, item: @item, owner: @user
+  end
+  
+  it "should display new dialog" do
+    call :new, format: 'js', item_id: @item.to_param
+    response.should be_ok
+  end
+  
+  it "should create Comment" do
+    comment_attributes = Factory.attributes_for :comment
+    pcall :create, format: 'js', item_id: @item.to_param, model: comment_attributes
+    response.should be_ok
+    
+    Models::Comment.count.should == 1
+    comment = Models::Comment.first
+    comment.original_text.should == comment_attributes[:original_text]
+    comment.owner.should == @user
+    comment.item.should == @item
+  end
+  
+  it "should display edit dialog" do
+    comment = create_comment
+    call :edit, format: 'js', id: comment.to_param
+    response.should be_ok
+  end
+  
+  it "should update Comment" do
+    comment = create_comment
+    new_attributes = {original_text: 'new text'}
+    pcall :update, format: 'js', id: comment.to_param, model: new_attributes
+    response.should be_ok
+    
+    comment.reload
+    comment.original_text.should == 'new text'
+  end
+  
+  it "should delete Comment" do
+    comment = create_comment
+    pcall :destroy, format: 'js', id: comment.to_param
+    Models::Comment.count.should == 0
+  end
+end

data/spec/controller/items_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "Items" do
+  with_controllers
+  login_as :manager, name: 'auser'
+  
+  describe "Basic" do
+    set_controller Controllers::Items
+    
+    it "should update layout" do      
+      @item = Factory.create :item
+      @item.layout.should == nil
+    
+      pcall :layout, id: @item.to_param, value: 'home', format: 'js'      
+      response.should be_ok
+    
+      @item.reload
+      @item.layout.should == 'home'
+    end
+  
+    it 'viewers, add_roles' do
+      @item = Factory.create :item
+      @item.viewers.should == %w{manager user:auser}
+      @item.owner_name.should == @user.name
+    
+      pcall :viewers, id: @item.to_param, add_roles: 'user', format: 'js'
+      response.should be_ok      
+    
+      @item.reload
+      @item.viewers.should == %w{manager member user user:auser}
+    end
+    
+    it "should redirect to /items if no default_url specified" do
+      call :redirect
+      response.should redirect_to(rad.router.default_url)
+    end
+    
+    it "should display :all"
+    # do
+    #   call :all
+    #   response.should be_ok
+    # end
+
+  end
+end