ruhoh 0.0.2 → 0.0.3

data/spec/parsers/layouts_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Layouts
+  
+  describe Ruhoh::Parsers::Layouts do
+    
+    before(:each) do
+      Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+      Ruhoh.setup(SampleSitePath)
+    end
+    
+    describe "#generate" do
+      let(:layouts){
+        Ruhoh::Parsers::Layouts.generate
+      }
+      
+      it 'should extract the correct layouts from a theme.' do
+        layouts.keys.sort.should == ['default', 'page', 'post']
+      end
+      
+      it 'should return a hash for each layout containing the keys "data" and "content"' do
+        layouts.each_value { |value|
+          value.should have_key("data")
+          value.should have_key("content")
+        }
+      end
+
+    end
+    
+  end
+  
+end

data/spec/parsers/pages_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module Pages
+  
+  describe Ruhoh::Parsers::Pages do
+    
+    describe "#generate" do
+      
+      before(:each) do
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+        Ruhoh.setup(SampleSitePath)
+      end
+      
+      let(:pages){
+        Ruhoh::Parsers::Pages.generate
+      }
+      
+      it 'should extract valid pages from source directory.' do
+        pages.keys.sort.should ==  ['about.md', 'archive.html', 'categories.html', 'index.md', 'pages.md', 'tags.html']
+      end
+      
+      it 'should return a properly formatted hash for each page' do
+        pages.each_value { |value|
+          value.should have_key("layout")
+          value.should have_key("id")
+          value.should have_key("url")
+          value.should have_key("title")
+        }
+      end
+
+    end
+    
+    describe "#is_valid_page?" do
+      
+      context "No user specified exclusions in config." do
+        
+        before(:each) do
+          Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+          Ruhoh.setup(SampleSitePath)
+        end
+        
+        it "should return true for a valid page filepath" do
+          filepath = 'about.md'
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == true
+        end
+      
+        it "should return false for a filepath beginning with _" do
+          filepath = '_blah/about.md'
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == false
+        end
+      
+        it "should return false for a filepath beginning with ." do
+          filepath = '.vim'
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == false
+        end
+
+      end
+      
+      context "Exclude array is passed into config." do
+        
+        it "should return false for a filepath matching a string in exclude array" do
+          filepath = 'about.md'
+          Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({
+            'theme' => "twitter",
+            'exclude' => filepath
+          })
+          Ruhoh.setup(SampleSitePath)
+          
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath).should == false
+        end
+        
+        it "should return false for a filepath matching a regular expression in exclude array" do
+          filepath1 = 'test/about.md'
+          filepath2 = 'test/yay.md'
+          filepath3 = 'vest/yay.md'
+          Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({
+            'theme' => "twitter",
+            'exclude' => /^test/
+          })
+          Ruhoh.setup(SampleSitePath)
+          
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath1).should == false
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath2).should == false
+          Ruhoh::Parsers::Pages.is_valid_page?(filepath3).should == true
+        end
+        
+      end
+      
+    end
+    
+    
+    pending "#titleize"
+    pending "#permalink"
+    
+  end
+  
+end

data/spec/parsers/posts_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+module Posts
+  
+  describe Ruhoh::Parsers::Posts do
+    
+    before(:each) do
+      Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+      Ruhoh.setup(SampleSitePath)
+    end
+    
+    describe "#generate" do
+      
+      it 'should return a valid data structures for core API' do
+        posts = Ruhoh::Parsers::Posts.generate
+        
+        posts['dictionary'].should be_a_kind_of(Hash)
+        posts['chronological'].should be_a_kind_of(Array)
+        posts['collated'].should be_a_kind_of(Array)
+        posts['tags'].should be_a_kind_of(Hash)
+        posts['categories'].should be_a_kind_of(Hash)
+      end
+      
+    end
+  
+    describe "#process" do
+      
+      context "A valid post" do
+        pending 'should extract valid posts from source directory.' do
+          Ruhoh::Parsers::Posts.process
+          dictionary.keys.sort.should ==  ['_posts/2012-01-01-hello-world.md']
+        end
+        
+        it 'should return a properly formatted hash for each post' do
+          dictionary = Ruhoh::Parsers::Posts.process
+
+          dictionary.each_value { |value|
+            value.should have_key("layout")
+            value.should have_key("id")
+            value.should have_key("url")
+            value.should have_key("title")
+          }
+        end
+      end
+      
+      context "A post with an invalid filename format" do
+        it "should omit the post file and record it as invalid post" do
+          post_path = 'test/hello-world.md'
+          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
+          Ruhoh::Utils.stub(:parse_file).and_return({"data" => {"date" => "2012-01-01"}})
+          
+          dictionary = Ruhoh::Parsers::Posts.process
+          
+          dictionary.should_not include(post_path)
+        end
+      end
+      
+      context "A post with an invalid date in the filename" do
+        it "should omit the post file and record it as invalid post" do
+          post_path = 'test/2012-51-01-hello-world.md'
+          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
+          Ruhoh::Utils.stub(:parse_file).and_return({"data" => {"title" => "meep"}})
+          
+          dictionary = Ruhoh::Parsers::Posts.process
+          
+          dictionary.should_not include(post_path)
+        end
+      end
+      
+      context "A post with an invalid date in the YAML Front Matter" do
+        it "should omit the post file and record it as invalid post" do
+          post_path = 'test/2012-01-01-hello-world.md'
+          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
+          Ruhoh::Utils.stub(:parse_file).and_return({"data" => {"date" => "2012-51-01"}})
+          
+          dictionary = Ruhoh::Parsers::Posts.process
+          
+          dictionary.should_not include(post_path)
+        end
+      end
+      
+      context "A post with no YAML Front Matter" do
+        it "should omit the post file and record it as invalid post" do
+          post_path = 'test/2012-01-01-hello-world.md'
+          Ruhoh::Parsers::Posts.should_receive(:files).and_return([post_path])
+          Ruhoh::Utils.stub(:parse_file).and_return({})
+          
+          dictionary = Ruhoh::Parsers::Posts.process
+          
+          dictionary.should_not include(post_path)
+        end
+      end
+      
+    end
+    
+    describe "#parse_filename" do
+      it "should parse a post filename into corresponding metadata" do
+        filename = '_posts/2011-10-10-my-post-title.md'
+        data = Ruhoh::Parsers::Posts.parse_filename(filename)
+
+        data['path'].should == "_posts/"
+        data['date'].should == "2011-10-10"
+        data['slug'].should == "my-post-title"
+        data['extension'].should == ".md"
+      end
+      
+      it "should return a blank hash if the filename format is invalid" do
+        filename = '_posts/my-post-title.md'
+        data = Ruhoh::Parsers::Posts.parse_filename(filename)
+        data.should == {}
+      end
+    end
+    
+    describe "#permalink" do
+      it "should return the default permalink style (/:categories/:year/:month/:day/:title.html)" do
+        post = {"date" => "2012-01-02", "title" => "My Blog Post"}
+        #post = {"date" => "2012-01-02", "title" => "My Blog Post", 'permalink' => :date }
+        permalink = Ruhoh::Parsers::Posts.permalink(post)
+        permalink.should == '/2012/01/02/my-blog-post.html'
+      end
+      
+      it "should return the post specific permalink style" do
+        post = {"date" => "2012-01-02", "title" => "My Blog Post", 'permalink' => '/:categories/:title' }
+        permalink = Ruhoh::Parsers::Posts.permalink(post)
+        permalink.should == '/my-blog-post'
+      end
+      
+      context "A post with one category" do
+        it "should include the category path in the permalink." do
+          post = {"date" => "2012-01-02", "title" => "My Blog Post", 'categories'=> 'ruby/lessons/beginner', 'permalink' => '/:categories/:title' }
+          permalink = Ruhoh::Parsers::Posts.permalink(post)
+          permalink.should == '/ruby/lessons/beginner/my-blog-post'
+        end
+      end
+      
+      context "A post belonging in two separate categories" do  
+        it "should include the first category path in the permalink." do
+          post = {"date" => "2012-01-02", "title" => "My Blog Post", 'categories'=> ['web', 'ruby/lessons/beginner'], 'permalink' => '/:categories/:title' }
+          permalink = Ruhoh::Parsers::Posts.permalink(post)
+          permalink.should == '/web/my-blog-post'
+        end
+      end
+      
+      context "A post having special characters in the title" do  
+        it "should escape those characters." do
+          post = {"date" => "2012-01-02", "title" => "=) My Blog Post!", 'permalink' => '/:title' }
+          permalink = Ruhoh::Parsers::Posts.permalink(post)
+          permalink.should_not == '/=)-my-blog-post-!'
+          permalink.should == '/%3D%29-my-blog-post%21'
+        end
+      end
+    end
+    
+    describe "#titleize" do
+      it "should prettify a filename slug for use as a title/header" do
+        file_slug = 'my-post-title'
+        title = Ruhoh::Parsers::Posts.titleize(file_slug)
+        title.should == "My Post Title"
+      end
+    end
+    
+    describe "helpers" do
+      let(:dictionary_stub) {
+        {
+          "a" => {"date"=>"2011-01-01", "id" => "a"},
+          "b" => {"date"=>"2011-02-01", "id" => "b"},
+          "c" => {"date"=>"2012-01-01", "id" => "c"},
+          "d" => {"date"=>"2010-08-01", "id" => "d"},
+        }
+      }
+      let(:ordered_posts_stub) {
+        [
+          {"date"=>"2012-01-01", "id" => "c"},
+          {"date"=>"2011-02-01", "id" => "b"},
+          {"date"=>"2011-01-01", "id" => "a"},
+          {"date"=>"2010-08-01", "id" => "d"},
+        ]
+      }
+      let(:collated_stub) {
+        [
+          {"year"=>"2012", "months"=>[{"month"=>"January", "posts"=>["c"]}]},
+          {"year"=>"2011", "months"=>[{"month"=>"February", "posts"=>["b"]}, {"month"=>"January", "posts"=>["a"]}]},
+          {"year"=>"2010", "months"=>[{"month"=>"August", "posts"=>["d"]}]}
+        ]
+      }
+      
+      describe "#ordered_posts" do
+        it "should order a dictionary hash by date descending and return an Array" do
+          ordered_posts = Ruhoh::Parsers::Posts.ordered_posts(dictionary_stub)
+
+          ordered_posts.should be_a_kind_of(Array)
+          ordered_posts.should == ordered_posts_stub
+        end
+      end
+
+      describe "#build_chronology" do
+        it 'should return an array of ids ordered by date descending' do
+          chrono = Ruhoh::Parsers::Posts.build_chronology(ordered_posts_stub)
+          chrono.should == ['c', 'b', 'a', 'd']
+        end
+      end
+      
+      describe "#collate" do
+        it 'should return an array of years with nested months and nested, ordered post ids for each month.' do
+          collated = Ruhoh::Parsers::Posts.collate(ordered_posts_stub)
+          collated.should == collated_stub
+        end
+      end
+      
+    end
+    
+    describe "#parse_tags" do
+      let(:ordered_posts_stub) {
+        [
+          {"id" => "c", "tags" => ['apple', 'orange']},
+          {"id" => "b", "tags" => ['apple', 'pear']},
+          {"id" => "a", "tags" => ['banana']},
+          {"id" => "d", "tags" => 'kiwi' },
+        ]
+      }
+      let(:tags){
+        Ruhoh::Parsers::Posts.parse_tags(ordered_posts_stub)
+      }
+      
+      it 'should return a dictionary of all tags on posts' do
+        tags.keys.sort.should == ['apple', 'banana', 'kiwi', 'orange', 'pear']
+      end
+      
+      it 'should return a dictionary containing tag objects having name, count and posts' do
+        tags.each_value { |tag|
+          tag.should have_key("name")
+          tag.should have_key("count")
+          tag.should have_key("posts")
+        }
+      end
+      
+      it 'should return a dictionary with tag objects having correct post id references.' do
+        tags['apple']['posts'].should == ['c', 'b']
+        tags['banana']['posts'].should == ['a']
+        tags['kiwi']['posts'].should == ['d']
+        tags['orange']['posts'].should == ['c']
+        tags['pear']['posts'].should == ['b']
+      end
+      
+      it 'should return a dictionary containing correct tag counts' do
+        tags['apple']['count'].should == 2
+        tags['banana']['count'].should == 1
+        tags['kiwi']['count'].should == 1
+        tags['orange']['count'].should == 1
+        tags['pear']['count'].should == 1
+      end
+      
+    end
+    
+    describe "#parse_categories" do
+      let(:ordered_posts_stub) {
+        [
+          {"id" => "c", "categories" => ['web', ['ruby', 'tutorials']] },
+          {"id" => "b", "categories" => ['web', ['ruby']] },
+          {"id" => "a", "categories" => ['web', 'python'] },
+          {"id" => "d", "categories" => 'erlang' },
+        ]
+      }
+
+      let(:categories) {
+        categories = Ruhoh::Parsers::Posts.parse_categories(ordered_posts_stub)
+      }
+
+      it 'should return a dictionary of all post categories' do
+        categories.keys.sort.should == ['erlang', 'python', 'ruby', 'ruby/tutorials', 'web']
+      end
+      
+      it 'should return a dictionary containing category objects having name, count and posts' do
+        categories.each_value { |cat|
+          cat.should have_key("name")
+          cat.should have_key("count")
+          cat.should have_key("posts")
+        }
+      end
+      
+      it 'should return a dictionary with category objects having correct post id references.' do
+        categories['erlang']['posts'].should == ['d']
+        categories['python']['posts'].should == ['a']
+        categories['ruby']['posts'].should == ['b']
+        categories['ruby/tutorials']['posts'].should == ['c']
+        categories['web']['posts'].should == ['c','b','a']
+      end
+      
+      it 'should return a dictionary containing correct tag counts' do
+        categories['erlang']['count'].should == 1
+        categories['python']['count'].should == 1
+        categories['ruby']['count'].should == 1
+        categories['ruby/tutorials']['count'].should == 1
+        categories['web']['count'].should == 3
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/parsers/routes_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Routes
+  
+  describe Ruhoh::Parsers::Routes do
+    
+    describe "#generate" do
+
+      before(:each) do
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+        Ruhoh.setup(SampleSitePath)
+      end
+      
+      let(:pages){
+        {
+          "blah.md" => {'url' => '/blah.html', "id" => "blah.md"},
+          "yes.md" => {'url' => '/yes.html', "id" => "yes.md"},
+          "no.md" => {'url' => '/no.html', "id" => "no.md"},
+        }
+      }
+      let(:posts){
+        { 
+          "dictionary" => {
+            "post1.md" => {'url' => '/post1.html', "id" => "post1.md"},
+            "post2.md" => {'url' => '/post2.html', "id" => "post2.md"},
+            "post3.md" => {'url' => '/post3.html', "id" => "post3.md"},
+          }
+        }
+      }
+      
+      it 'should return a dictionary/hash with urls as keys that map to post/draft/page ids as values' do
+        Ruhoh::DB.should_receive(:pages).and_return(pages)
+        Ruhoh::DB.should_receive(:posts).and_return(posts)
+        
+        routes = Ruhoh::Parsers::Routes.generate
+        
+        routes.should be_a_kind_of(Hash)
+        routes.keys.sort.should == ['/blah.html', '/no.html', '/post1.html', '/post2.html', '/post3.html', '/yes.html']
+        routes.values.sort.should == ['blah.md',  'no.md', 'post1.md', 'post2.md', 'post3.md', 'yes.md']
+      end
+
+    end
+  end
+  
+end

data/spec/parsers/site_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Site
+  
+  describe Ruhoh::Parsers::Site do
+    
+    describe "#generate" do
+
+      before(:each) do
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({'theme' => "twitter"})
+        Ruhoh.setup(SampleSitePath)
+      end
+      
+      it 'should parse the config and site yaml files' do
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).with(Ruhoh.paths.site_source, Ruhoh.files.site).and_return({})
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).with(Ruhoh.paths.site_source, Ruhoh.files.config).and_return({})
+
+        Ruhoh::Parsers::Site.generate
+      end
+      
+      it 'should return a site hash with config set as value to key "config" ' do
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).with(Ruhoh.paths.site_source, Ruhoh.files.site).and_return({"nav" => [1,2,3]})
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).with(Ruhoh.paths.site_source, Ruhoh.files.config).and_return({"theme" => "orange"})
+        
+        site = Ruhoh::Parsers::Site.generate
+        site.should == { "nav" => [1,2,3], "config" => {"theme" => "orange"} }
+      end
+      
+    end
+  end
+  
+end

data/spec/setup_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Setup
+  
+  describe "Setup" do
+    
+    describe "#setup" do
+      
+      it 'should setup config, paths, and filters' do
+        Ruhoh.should_receive(:setup_config)
+        Ruhoh.should_receive(:setup_paths)
+        Ruhoh.should_receive(:setup_filters)
+        Ruhoh.setup
+      end
+      
+    end
+    
+    describe "#setup_config" do
+
+      context "Invalid _config.yml file" do
+
+        it 'should raise an exception if theme is not specified.' do
+          Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({})
+          lambda { Ruhoh.setup_config }.should raise_error
+        end
+
+      end
+      
+      context "Valid _config.yml file" do
+        
+        it 'should setup the config struct based on configuration input.' do
+          custom_permalink = '/my/custom/link'
+          custom_theme = 'table'
+          custom_exclude = ['.secret']
+          Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({
+            "permalink" => custom_permalink, 
+            "theme" => custom_theme,
+            'exclude' => custom_exclude
+          })
+
+          Ruhoh.setup_config
+        
+          Ruhoh.config.permalink.should == custom_permalink
+          Ruhoh.config.theme.should == custom_theme
+          Ruhoh.config.theme_path.should == "/_templates/themes/#{custom_theme}"
+          Ruhoh.config.exclude.should == custom_exclude
+        end
+      
+      end
+      
+    end
+    
+    describe "#setup_filters" do
+      
+      it 'should add custom exclude filters to the filters variable' do
+        custom_exclude = ['.secret', /^test/]
+        Ruhoh::Utils.should_receive(:parse_file_as_yaml).and_return({
+          'theme' => "twitter",
+          'exclude' => custom_exclude
+        })
+        Ruhoh.setup_config
+        Ruhoh.setup_filters
+        
+        Ruhoh.filters.pages['names'].should include('.secret')
+        Ruhoh.filters.pages['regexes'].should include(/^test/)
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler/setup'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ruhoh'
+
+RSpec.configure do |config|
+  config.after(:each) do 
+    # Reset all configuration variables after each test.
+    Ruhoh.reset
+  end
+end
+
+SampleSitePath = File.expand_path(File.join(File.dirname(__FILE__), '../scaffolds/blog'))
+

data/system_partials/analytics/getclicky

@@ -0,0 +1,12 @@
+<script type="text/javascript">
+var clicky_site_ids = clicky_site_ids || [];
+clicky_site_ids.push({{ site.config.analytics.getclicky.site_id }});
+(function() {
+  var s = document.createElement('script');
+  s.type = 'text/javascript';
+  s.async = true;
+  s.src = '//static.getclicky.com/js';
+  ( document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0] ).appendChild( s );
+})();
+</script>
+<noscript><p><img alt="Clicky" width="1" height="1" src="//in.getclicky.com/{{ site.config.analytics.getclicky.site_id }}ns.gif" /></p></noscript>

data/system_partials/analytics/google

@@ -0,0 +1,11 @@
+<script type="text/javascript">
+  var _gaq = _gaq || [];
+  _gaq.push(['_setAccount', '{{ site.config.analytics.google.tracking_id }}']);
+  _gaq.push(['_trackPageview']);
+
+  (function() {
+    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+  })();
+</script>

data/system_partials/comments/disqus

@@ -0,0 +1,13 @@
+<div id="disqus_thread"></div>
+<script type="text/javascript">
+    {{^site.production }}var disqus_developer = 1;{{/site.production}}
+    var disqus_shortname = '{{ site.config.comments.disqus.short_name }}'; // required: replace example with your forum shortname
+    /* * * DON'T EDIT BELOW THIS LINE * * */
+    (function() {
+        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
+        dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
+        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
+    })();
+</script>
+<noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
+<a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a>

data/system_partials/comments/facebook

@@ -0,0 +1,9 @@
+<div id="fb-root"></div>
+<script>(function(d, s, id) {
+  var js, fjs = d.getElementsByTagName(s)[0];
+  if (d.getElementById(id)) return;
+  js = d.createElement(s); js.id = id;
+  js.src = "//connect.facebook.net/en_US/all.js#xfbml=1&appId={{ site.config.comments.facebook.appid }}";
+  fjs.parentNode.insertBefore(js, fjs);
+}(document, 'script', 'facebook-jssdk'));</script>
+<div class="fb-comments" data-href="{{ site.production_url }}" data-num-posts="{{ site.config.comments.facebook.num_posts }}" data-width="{{ site.config.comments.facebook.width }}" data-colorscheme="{{ site.config.comments.facebook.colorscheme }}"></div>

data/system_partials/comments/intensedebate

@@ -0,0 +1,6 @@
+<script>
+var idcomments_acct = '{{ site.config.comments.intensedebate.account }}';
+var idcomments_post_id;
+var idcomments_post_url;
+</script>
+<script type="text/javascript" src="http://www.intensedebate.com/js/genericLinkWrapperV2.js"></script>

data/system_partials/comments/livefyre

@@ -0,0 +1,6 @@
+<script type='text/javascript' src='http://zor.livefyre.com/wjs/v1.0/javascripts/livefyre_init.js'></script>
+<script type='text/javascript'>
+    var fyre = LF({
+        site_id: {{ site.config.comments.livefyre.site_id }}
+    });
+</script>