rad_kit 0.0.1

data/lib/kit/spec.rb

@@ -0,0 +1,77 @@
+require 'rad'
+
+require 'rad/spec'
+
+require 'mongoid_misc'
+require 'mongoid_misc/spec'
+require 'carrierwave_ext/spec'
+
+
+# 
+# SaaS
+#
+unless ENV['saas'] == 'false'
+  begin
+    require 'saas/spec' 
+  rescue LoadError
+  end
+end
+
+
+# 
+# User
+# 
+rad.register :user
+rspec do
+  def login_as user
+    rad.user = user
+  end
+  
+  def self.login_as name, options = {}
+    before do
+      @user = Factory.create name, options
+      login_as @user
+    end
+  end
+end
+
+
+# 
+# CarrierWave
+# 
+module Rad::CarrierWaveSpecHelper  
+  def with_files
+    before do
+      rad.config.fs_path       = CarrierWaveExtSpecHelper::TEST_PATH
+      rad.config.fs_cache_path = CarrierWaveExtSpecHelper::TEST_CACHE_PATH
+      
+      Models::FileUploader.storage :file
+    end
+    
+    super            
+  end
+end
+rspec.extend Rad::CarrierWaveSpecHelper
+
+
+# 
+# Micelaneous
+# 
+rspec do
+  alias_method :call, :wcall
+  alias_method :pcall, :post_wcall  
+  alias_method :set_call, :set_wcall
+  
+  class << self    
+    def with_models
+      with_mongoid            
+      rad.extension :with_models, self
+    end
+    
+    def with_controllers
+      with_models
+    end
+  end
+end
+
+require 'kit/spec/items_controller_crud'

data/lib/kit/spec/items_controller_crud.rb

@@ -0,0 +1,64 @@
+shared_examples_for "Items Controller CRUD" do
+  before do
+    @controller_class.should be_present
+    @model_class ||= @controller_class.model_class
+    @model_name ||= @model_class.alias.underscore
+  end
+  
+  %w{html json}.each do |format|
+    it "show :#{format}" do
+      @item = Factory.create @model_name    
+      call :show, id: @item.to_param, format: format
+      response.should be_ok
+      response.body.should include(@item.name)
+    end
+    
+    it "all :#{format}" do
+      @item = Factory.create @model_name
+      call :all, format: format
+      response.should be_ok
+      response.body.should include(@item.name)
+    end
+  end
+  
+  it "edit :js" do
+    item = Factory.create @model_name
+    call :edit, id: item.to_param, format: 'js'
+    response.should be_ok
+  end
+  
+  %w{js json}.each do |format|
+    it "new :#{format}" do    
+      call :new, format: format
+      response.should be_ok
+    end
+    
+    it "create :#{format}" do
+      item_attributes = Factory.attributes_for @model_name
+      pcall :create, model: item_attributes, format: format
+
+      (format == 'js') ? response.body.should(include('window.location')) : response.should(be_ok)
+      @model_class.count.should == 1
+      item = @model_class.first
+      item.name.should == item_attributes[:name]
+    end
+    
+    it "update :#{format}" do
+      item = Factory.create @model_name
+      pcall :update, id: item.to_param, model: {name: 'new_name'}, format: format
+
+      response.should be_ok
+      response.body.should =~ /new_name|reload/ if format == 'js'
+
+      item.reload
+      item.name.should == 'new_name'
+    end
+
+    it "destroy :#{format}" do
+      item = Factory.create @model_name
+      pcall :destroy, id: item.to_param, format: format
+      response.should be_ok
+      @model_class.count.should == 0
+    end
+  end            
+end

data/lib/kit/support.rb

@@ -0,0 +1,14 @@
+require 'kit/gems'
+require 'stringex'
+
+# SaaS
+unless ENV['saas'] == 'false'
+  begin
+    require 'saas_extensions'
+  rescue LoadError
+  end  
+end
+
+%w(
+  string
+).each{|f| require "kit/support/#{f}"}

data/lib/kit/support/string.rb

@@ -0,0 +1,6 @@
+class String
+  def to_url_with_escape
+    to_url_without_escape.gsub /[^a-z0-9_-]/, ''
+  end
+  alias_method_chain :to_url, :escape
+end

data/lib/kit/tasks.rb

@@ -0,0 +1,18 @@
+require 'rake_ext'
+
+require 'rad_ext/tasks'
+require 'rad/assets/tasks'
+require 'mongo_migration/tasks'
+
+namespace :db do
+  desc "Internal task to prepare migration environment"
+  task migration_evnironment: :environment do
+    require 'mongo_migration'
+    require 'mongo_migration/adapters/mongoid'
+    
+    adapter = Mongo::Migration::Mongoid.new
+    Mongo.migration = Mongo::Migration.new adapter
+    
+    Dir["#{rad.runtime_path}/db/**/*.rb"].each{|f| require f.sub(/\.rb$/, '')}
+  end
+end

data/lib/kit/text_utils.rb

@@ -0,0 +1,43 @@
+require 'digest/md5'
+
+require 'nokogiri'
+require 'bluecloth'
+require 'sanitize'
+
+module Rad::TextUtils; end
+
+%w(
+  processor
+
+  github_flavoured_markdown
+  image_box
+  custom_markdown
+  urls
+  tag_shortcuts
+  html_sanitizer
+  ensure_utf
+  truncate
+  code_highlighter
+  truncator
+  
+  markup
+).each{|f| require "kit/text_utils/#{f}"}
+
+module Rad::TextUtils
+  class << self
+    def markup text
+      Rad::TextUtils::Markup.new.process text, {}
+    end
+  
+    def random_string length = 3
+      @digits ||= ('a'..'z').to_a + (0..9).to_a
+      (0..(length-1)).map{@digits[rand(@digits.size)]}.join
+    end
+  
+    def truncate str_or_html, length  
+      Rad::TextUtils::Truncator.new(nil, length).process str_or_html, {}      
+      # str_or_html = HtmlSanitizer.new.process str_or_html, {}
+      # Truncator.new(length).process str_or_html
+    end
+  end
+end

data/lib/kit/text_utils/code_highlighter.rb

@@ -0,0 +1,58 @@
+class Rad::TextUtils::CodeHighlighter < Rad::TextUtils::Processor
+  
+  # highlights code inside of <code lang/language='java'> ... code ... </code>
+  def process html, env
+    require 'coderay'
+    require 'nokogiri'
+
+    snippets, unique_id = {}, 0    
+
+    # Highlighting
+    html = html.gsub /(<code.*?>)(.+?)(<\/code\s*>)/im do
+      begin
+        node = Nokogiri::HTML($1 + $3).css('code').first
+        language = node.attributes['lang'].try(:value) || node.attributes['language'].try(:value)
+        code = $2
+        
+        if language.present? and code.present?
+          attributes = []
+          node.attributes.each do |name, value|
+            attributes << %(#{name}="#{value.value}")
+          end
+
+          code = CodeRay.scan(code, language.downcase.to_sym).div :css => :class          
+          
+          snippet = "<code #{attributes.join(' ')}>\n#{code}\n</code>"
+        
+          # adding prefix 'hl_' to all CodeRay classes
+          node = Nokogiri::HTML(snippet).css('code').first          
+          node.css("*").each do |e|
+            classes = e.attribute 'class'
+            if classes.present? and classes.value.present?
+              classes = classes.value.strip.split(/\s+/).collect{|c| "hl_#{c}"}.join(' ')
+              e['class'] = classes
+            end
+          end
+          snippet = node.to_s
+        end        
+      # rescue StandardError => e
+      #   rad.logger.warn "CodeHighlighter: #{e.message}"
+      end
+      
+      # temporarilly removing all highlighted code from html to prevent it's beed damaged by next processors
+      unique_id += 1
+      id = "CODE#{unique_id}CODE"
+      snippets[id] = snippet
+      id
+    end
+    
+    html = call_next html, env
+    
+    # inserting highlighted code back to html
+    html = html.gsub /(CODE[0-9]+CODE)/ do |id|
+      snippets[id]
+    end
+
+    html
+  end
+end

data/lib/kit/text_utils/custom_markdown.rb

@@ -0,0 +1,90 @@
+class Rad::TextUtils::CustomMarkdown < Rad::TextUtils::Processor
+  def process markdown, env
+    markdown = github_flavoured_markdown markdown
+    markdown = image_box markdown
+    text = custom_markdown markdown
+    
+    call_next text, env
+  end
+  
+  protected
+    def custom_markdown markdown
+      # BlueCloth doesn't apply inside of HTML tags, so we temporarilly replacing it
+      markdown = markdown.gsub('<', 'HTML_BEGIN').gsub('>', 'HTML_END')
+
+      markdown = markdown.gsub(" \n", "<br/>\n")
+
+      text = BlueCloth.new(markdown).to_html
+
+      text = text.gsub(/\A<.+?>/){"#{$&} "}.gsub(/<\/.+?>\Z/){" #{$&}"}
+
+      text = text.gsub('HTML_BEGIN', '<').gsub('HTML_END', '>')
+
+      text.gsub(/[\n]+/, "\n")
+    end
+  
+    def github_flavoured_markdown markdown
+      # Extract pre blocks
+      extractions = {}
+      markdown.gsub!(%r{<pre>.*?</pre>}m) do |match|
+        md5 = Digest::MD5.hexdigest(match)
+        extractions[md5] = match
+        "{gfm-extraction-#{md5}}"
+      end
+
+      # prevent foo_bar_baz from ending up with an italic word in the middle
+      markdown.gsub!(/(^(?! {4}|\t)\w+_\w+_\w[\w_]*)/) do |x|
+        x.gsub('_', '\_') if x.split('').sort.to_s[0..1] == '__'
+      end
+
+      # in very clear cases, let newlines become <br /> tags
+      markdown.gsub!(/^[\w\<\!][^\n]*\n+/) do |x|
+        if x =~ /\>[\n\r]*/
+          x
+        else
+          x =~ /\n{2}/ ? x : (x.strip!; x << " \n")
+        end
+      end
+
+      # Insert pre block extractions
+      markdown.gsub!(/\{gfm-extraction-([0-9a-f]{32})\}/) do
+        "\n\n" + extractions[$1]
+      end
+
+      markdown
+    end
+    
+    # !![img] => [![img_thumb]][img]
+    def image_box markdown
+      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
+
+      markdown
+    end
+end

data/lib/kit/text_utils/ensure_utf.rb

@@ -0,0 +1,8 @@
+class Rad::TextUtils::EnsureUtf < Rad::TextUtils::Processor
+  def process data, env
+    data = call_next data, env
+    
+    # Escape all non-word unicode symbols, otherwise it will raise error when converting to BSON
+    Iconv.conv('UTF-8//IGNORE//TRANSLIT', 'UTF-8', data)        
+  end
+end

data/lib/kit/text_utils/github_flavoured_markdown.rb

@@ -0,0 +1,32 @@
+class Rad::TextUtils::GithubFlavouredMarkdown < Rad::TextUtils::Processor
+  def process markdown, env
+    # Extract pre blocks
+    extractions = {}
+    markdown.gsub!(%r{<pre>.*?</pre>}m) do |match|
+      md5 = Digest::MD5.hexdigest(match)
+      extractions[md5] = match
+      "{gfm-extraction-#{md5}}"
+    end
+
+    # prevent foo_bar_baz from ending up with an italic word in the middle
+    markdown.gsub!(/(^(?! {4}|\t)\w+_\w+_\w[\w_]*)/) do |x|
+      x.gsub('_', '\_') if x.split('').sort.to_s[0..1] == '__'
+    end
+
+    # in very clear cases, let newlines become <br /> tags
+    markdown.gsub!(/^[\w\<\!][^\n]*\n+/) do |x|
+      if x =~ /\>[\n\r]*/
+        x
+      else
+        x =~ /\n{2}/ ? x : (x.strip!; x << " \n")
+      end
+    end
+
+    # Insert pre block extractions
+    markdown.gsub!(/\{gfm-extraction-([0-9a-f]{32})\}/) do
+      "\n\n" + extractions[$1]
+    end
+
+    call_next markdown, env
+  end
+end

data/lib/kit/text_utils/html_sanitizer.rb

@@ -0,0 +1,89 @@
+class Rad::TextUtils::HtmlSanitizer < Rad::TextUtils::Processor
+  RELAXED = {
+    elements: [
+      'a', 'b', 'blockquote', 'br', 'caption', 'cite', 'code', 'col',
+      'colgroup', 'dd', 'dl', 'dt', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+      'i', 'img', 'li', 'ol', 'p', 'pre', 'q', 'small', 'strike', 'strong',
+      'sub', 'sup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'u',
+      'ul', 'div', 'font', 'span'],
+
+    attributes: {
+      :all         => ['class', 'style'],
+      'a'          => ['href', 'title', 'rel'],
+      'blockquote' => ['cite'],
+      'col'        => ['span', 'width'],
+      'colgroup'   => ['span', 'width'],
+      'img'        => ['align', 'alt', 'height', 'src', 'title', 'width'],
+      'ol'         => ['start', 'type'],
+      'q'          => ['cite'],
+      'table'      => ['summary', 'width'],
+      'td'         => ['abbr', 'axis', 'colspan', 'rowspan', 'width'],
+      'th'         => ['abbr', 'axis', 'colspan', 'rowspan', 'scope', 'width'],
+      'ul'         => ['type'],
+      'code'       => ['lang', 'language']
+    },
+
+    protocols: {
+      'a'          => {'href' => ['ftp', 'http', 'https', 'mailto', :relative]},
+      'blockquote' => {'cite' => ['http', 'https', :relative]},
+      'img'        => {'src'  => ['http', 'https', :relative]},
+      'q'          => {'cite' => ['http', 'https', :relative]}
+    }
+  }
+  
+  VIDEO_URLS = [
+    /^http:\/\/(?:www\.)?youtube\.com\/v\//,
+  ]
+
+  EMBEDDED_VIDEO = lambda do |env|
+    node      = env[:node]
+    node_name = node.name.to_s.downcase
+    parent    = node.parent
+  
+    # Since the transformer receives the deepest nodes first, we look for a
+    # <param> element or an <embed> element whose parent is an <object>.
+    return nil unless (node_name == 'param' || node_name == 'embed') && parent.name.to_s.downcase == 'object'
+  
+    if node_name == 'param'
+      # Quick XPath search to find the <param> node that contains the video URL.
+      return nil unless movie_node = parent.search('param[@name="movie"]')[0]
+      url = movie_node['value']
+    else
+      # Since this is an <embed>, the video URL is in the "src" attribute. No
+      # extra work needed.
+      url = node['src']
+    end
+  
+    # # Verify that the video URL is actually a valid YouTube video URL.
+    return nil unless VIDEO_URLS.any?{|t| url =~ t}
+  
+    # # We're now certain that this is a YouTube embed, but we still need to run
+    # # it through a special Sanitize step to ensure that no unwanted elements or
+    # # attributes that don't belong in a YouTube embed can sneak in.
+    Sanitize.clean_node!(parent, {
+      :elements   => ['embed', 'object', 'param'],
+      attributes: {
+        'embed'  => ['allowfullscreen', 'allowscriptaccess', 'height', 'src', 'type', 'width'],
+        'object' => ['height', 'width'],
+        'param'  => ['name', 'value']
+      }
+    })
+
+    # Now that we're sure that this is a valid YouTube embed and that there are
+    # no unwanted elements or attributes hidden inside it, we can tell Sanitize
+    # to whitelist the current node (<param> or <embed>) and its parent
+    # (<object>).
+    {:whitelist_nodes => [node, parent]}
+  end
+  
+  def process html, env
+    html = call_next html, env
+    
+    Sanitize.clean(html, RELAXED.merge(
+      transformers: [EMBEDDED_VIDEO],
+      :add_attributes => {
+        all: [:class]
+      }
+    ))         
+  end
+end