gollum_rails 1.0.4 → 1.0.5

data/lib/gollum_rails/setup.rb

@@ -27,6 +27,9 @@ module GollumRails
       # Gets / Sets the repository
       attr_accessor :repository
 
+      # Gets / Sets the init options
+      attr_accessor :options
+      
       # Startup action for building wiki components
       #
       # Returns true or throws an exception if the path is invalid
@@ -39,7 +42,11 @@ module GollumRails
             initialize_wiki @repository
           end
         end
-
+      end
+      
+      # Wiki startup options
+      def options=(options)
+        @options = options
       end
       
       # defines block builder for Rails initializer.
@@ -68,7 +75,7 @@ module GollumRails
       def initialize_wiki(path)
         if path_valid? path
           repository = Grit::Repo.new path.to_s
-          GollumRails::Adapters::Gollum::Wiki.new repository
+          GollumRails::Adapters::Gollum::Wiki.new(repository, options || {})
           true
         else
           raise GollumInternalError, 'no repository path specified'

data/spec/gollum_rails/adapters/gollum/connector_spec.rb

@@ -5,9 +5,15 @@ describe GollumRails::Adapters::Gollum::Connector do
     @class = GollumRails::Adapters::Gollum::Connector 
   end
 
-  it "should test the Wiki class connector" do
-    @class.wiki_class.should == GollumRails::Adapters::Gollum::Wiki
+  it "should test the Wiki path connector" do
+    @class.wiki_path.should be_a String
   end
+  it "should test the Wiki options connector" do
+    @class.wiki_options.should be_a Hash
+  end  
+  it "should test the Wiki options content" do
+    @class.wiki_options.should == {}
+  end  
   it "should test the Page class connector" do
     @class.page_class.should == GollumRails::Adapters::Gollum::Page
   end

data/spec/gollum_rails/adapters/gollum/page_spec.rb

@@ -6,84 +6,24 @@ describe GollumRails::Adapters::Gollum::Page do
       :name => 'The Mosny',
       :email => 'mosny@zyg.li'
     }
-
-    @location = "#{File.dirname(__FILE__)}/../../../utils/wiki.git"
-    @repo = Grit::Repo.init_bare @location
-    @wiki = GollumRails::Adapters::Gollum::Wiki.new @repo
-    @page = GollumRails::Adapters::Gollum::Page.new 
   end
-  it "should initialize the correct wiki" do
-    location = "#{File.dirname(__FILE__)}/../../../utils/wiki.git"
-    repo = Grit::Repo.init_bare location
-    wiki = GollumRails::Adapters::Gollum::Wiki.new repo
-    page = GollumRails::Adapters::Gollum::Page.new 
-    page.wiki.should be_instance_of Gollum::Wiki
-  end
-  it "should create a new page" do
-    location = "#{File.dirname(__FILE__)}/../../../utils/wiki.git"
-    repo = Grit::Repo.init_bare location
-    wiki = GollumRails::Adapters::Gollum::Wiki.new repo
-    page = GollumRails::Adapters::Gollum::Page.new 
-    page.new_page("testpage", "content",:markdown, @commit ).should be_instance_of Gollum::Page
-    page.delete_page(@commit)
-  end
-
-  it "should delete an existing page" do
-    page = @page.new_page 'testpage', 'content', :markdown, @commit
-    @page.delete_page(@commit,page).should be_instance_of String
-    
-    @page.new_page 'testpage', 'content', :markdown, @commit
-    @page.delete_page(@commit).should be_instance_of String
-  end
-  it "should update an existing page" do 
-    @page.new_page 'testpage', 'content', :markdown, @commit
-    page = {}
-    page[:name] = 'test'
-    page[:format] = :markdown
-    page[:content] = "content"
-    @page.update_page(page, @commit)
-
-    page = []
-    expect{@page.update_page(page, @commit)}.to raise_error GollumRails::Adapters::Gollum::Error
-
-    page = {}
-    page[:content] = "test"
-    @page.update_page(page, @commit).raw_data.should == page[:content]
-
-    page = {}
-    page[:name] = "test"
-    @page.update_page(page, @commit).name.should == page[:name]
-
-    page = {}
-    page[:format] = :wiki
-    @page.update_page(page, @commit).format.should == :mediawiki
-
-
-
-    @page.delete_page(@commit)
-  end
-  it "should find a page" do
-    @page.new_page 'content_page', 'content', :markdown, @commit
-
-    @page.find_page("content_page")
-    @page.delete_page(@commit)
-  end
-  it "should test the commit methods" do
-    @page.new_page 'content_page', 'content', :markdown, @commit
-    @page.page_last_edited_date.should be_instance_of Time
-    @page.page_created.should be_instance_of Time
-    @page.page_last_commit.should be_instance_of Grit::Commit
-    @page.page_commit(@page.page.versions.first.id).should be_instance_of Grit::Commit
-    @page.page_commit_date(@page.page.versions.first.id).should be_instance_of Time
-    @page.page_first_commit.should be_instance_of Grit::Commit
-    @page.delete_page(@commit)
-  end
-  it "should test the error throwing" do
-    expect{@page.page_last_commit}.to raise_error GollumRails::Adapters::Gollum::Error
-    expect{@page.page_first_commit}.to raise_error GollumRails::Adapters::Gollum::Error
-    expect{@page.page_last_edited_date}.to raise_error GollumRails::Adapters::Gollum::Error
-    expect{@page.page_created}.to raise_error GollumRails::Adapters::Gollum::Error
-    expect{@page.page_commit(1)}.to raise_error GollumRails::Adapters::Gollum::Error
-    expect{@page.page_commit_date(1)}.to raise_error GollumRails::Adapters::Gollum::Error
+  describe "Connector stuff" do
+    it "should have updated the page_class on initialize" do
+      adapter = GollumRails::Adapters::Gollum::Page.new
+      GollumRails::Adapters::Gollum::Connector.page_class.should == GollumRails::Adapters::Gollum::Page
+    end
+  end
+  describe "statically methods" do
+    it "is a hash" do
+      GollumRails::Adapters::Gollum::Page.parse_path('google/de').should be_a Hash
+    end
+    it "should equal" do
+      path1 = GollumRails::Adapters::Gollum::Page.parse_path('google/de')
+      path2 = GollumRails::Adapters::Gollum::Page.parse_path('/google/de')
+      path1.should == path2
+    end
+    it "adds a leading slash" do
+      GollumRails::Adapters::Gollum::Page.parse_path('google/de')[:path][0].should == '/'
+    end
   end
 end

data/spec/gollum_rails/page_spec.rb

@@ -2,79 +2,173 @@ require 'spec_helper'
 
 describe "Gollum Page" do
   before(:each) do
+    GollumRails::Setup.build do |config|
+      config.repository = File.join(File.dirname(__FILE__),'..','utils','wiki.git')
+      config.options={}
+      config.startup = true
+    end
+    
       @commit = {
-        :name => "flo",
-        :message => "commit",
-        :email => "mosny@zyg.li"
+        name: "flo",
+        message: "commit",
+        email: "mosny@zyg.li"
       }
       @call = {
-        :name => "Goole",
-        :content => "content data",
-        :commit => @commit,
-        :format => :markdown
+        name: "Goole",
+        content: "content data",
+        commit: @commit,
+        format: :markdown
       }
     end
+    
   describe GollumRails::Page do
-    class RailsModel < GollumRails::Page
+    class RailsModel < GollumRails::Page; end
 
+    describe "the creation of a page" do
+      
+      before :each do 
+        @rr = RailsModel.new(@call)
+      end
+      
+      it "saves via .save" do
+        @rr.save.should be_a GollumRails::Page
+      end
+      
 
-    end
+      it "saves via .create" do
+        RailsModel.create(@call).should be_a GollumRails::Page
+      end
+      
+
+      it "fails if invalid arguments are supplied via the ! create" do
+        args = {
+          name: "Gaming",
+          content: "content data",
+          commit: {},
+          format: :markdown
+        }
+        expect{RailsModel.create!(args)}.to raise_error  StandardError #change this
+      end
+      it "has a history now" do
+        @rr.save
+        @rr.history.should be_a Array
+      end
+      it "outputs the raw_data" do
+        @rr.save
+        @rr.raw_data.should == @call[:content]
+      end
+      it "has the formatted data" do
+        @rr.save
+        @rr.html_data.should == 'content data'
+      end
+      it "was last changed by me" do
+        @rr.save
+        @rr.last_changed_by.should == 'flo <mosny@zyg.li>'
+      end
+      it "has a title" do
+        @rr.save
+        @rr.title.should == "Goole"
+      end
+      it "has a url" do
+        @rr.save
+        @rr.url.should =="Goole"
+      end
 
-    it "should test the creation of a page" do
-      rr = RailsModel.new(@call)
-      rr.save.should be_instance_of Gollum::Page
-      rr.save!.should be_instance_of Gollum::Page
-      RailsModel.create(@call)
     end
 
-    it "should test the update of a page" do
-      rr = RailsModel.new @call
-      cc = rr.save.should be_instance_of Gollum::Page
-      rr.update_attributes({:name => "google", :format => :wiki}).should be_instance_of Gollum::Page
+    describe "the update of a page" do
+      before :each do 
+        @rr = RailsModel.new(@call)
+        @rr.save
+      end
+      
+      it { @rr.update_attributes({:name => "google", :format => :wiki}).should be_a Gollum::Page }
+      
     end
-
-    it "should test the deletion of a page" do
-      rr = RailsModel.new @call
-      cc = rr.save.should be_instance_of Gollum::Page
-      rr.delete.should be_instance_of String
+    describe "method missings" do
+      
+      it "should perform a normal find" do
+        RailsModel.find_by_name('Goole').should be_a GollumRails::Page
+          
+        
+      end
+      
     end
 
-    it "should test the finding of a page" do
-      RailsModel.find('google').should be_instance_of Gollum::Page
-
-      #invalid input
-      RailsModel.find('<script type="text/javascript">alert(123);</script>').should be_nil
-    end
-    it "should test the preview" do
-      rr = RailsModel.new :content => "# content", :name => "somepage"
-      100.times do
-        rr.preview.should include("<h1>content<a class=\"anchor\" id=\"content\" href=\"#content\"></a></h1>")
+    describe "should test the deletion of a page" do
+      before :each do 
+        @rr = RailsModel.new @call
+        @cc = @rr.save
+      end
+      
+      it "should return a string" do
+        delete = @rr.delete
+        delete.should be_a String
+      end
+      
+      it "should return a SHA1 hash" do
+        delete = @rr.delete
+        delete.length.should == 40
+      end
+      
+      it "should also work was result from save" do
+        delete = @cc.delete
+        delete.should be_a String
+      end
+      
+      it "should test the recreation" do
+        delete = @rr.delete
+        @rr.save.should be_a GollumRails::Page
+        @rr.delete.should be_a String
+        
       end
     end
 
+   
     it "should test exception methods" do
-      create = RailsModel.create! @call
+      RailsModel.create @call
+      expect{RailsModel.create! @call}.to raise_error Gollum::DuplicatePageError
     end
 
-    it "should test the supported formats" do
-      RailsModel.format_supported?('ascii').should be_true
-      RailsModel.format_supported?('markdown').should be_true
-      RailsModel.format_supported?('github-markdown').should be_true
-      RailsModel.format_supported?('rdoc').should be_true
-      RailsModel.format_supported?('org').should be_true
-      RailsModel.format_supported?('pod').should be_true
+    describe "supported formats" do
+      ['markdown', 'rdoc', 'org', 'pod'].each do |format|
+        it "should support #{format}" do
+          RailsModel.format_supported?(format).should be_true
+        end
+      end
+      
     end
-
-    it "should test getters" do
-      rr = RailsModel.new @call
-      rr.name.should == "Goole"
-      rr.content.should == "content data"
-      rr.commit.should be_instance_of Hash
-      rr.commit.should == @commit
-      rr.format.should == :markdown
-      rr.save
-      rr.page.should be_instance_of GollumRails::Adapters::Gollum::Page
+    
+    describe "accessors" do
+      let(:rr){RailsModel.new @call}
+      
+      it "should have a name" do
+        expect(rr.name).to match(/^Goole$/)
+      end
+      
+      it "should have a content" do
+        expect(rr.content).to match(/^content\ data$/)
+      end
+      
+      it "should have a commit which is a Hash" do
+        expect(rr.commit).to be_a Hash
+      end
+      
+      it "should be @commit" do
+        expect(rr.commit).to be(@commit)
+      end
+      
+      it "should have a format" do
+        expect(rr.format.to_s).to match('markdown')
+      end
+      
+      it "should be a Gollum::Page after save" do
+        rr.save
+        expect(rr.gollum_page).to be_a Gollum::Page
+      end
+      
     end
+    
     it "should test setters" do
       rr = RailsModel.new
       rr.name=("google").should == "google"
@@ -82,12 +176,34 @@ describe "Gollum Page" do
       rr.content=("content").should == "content"
       rr.format=(:markdown).should == :markdown
     end
-
-
-    it "should test find or initialize" do
-      rr = RailsModel.new @call
-      rr.save
-      RailsModel.find_or_initialize_by_name(@call[:name], @commit).should  be_instance_of Gollum::Page
+    
+    it "tests the find method to return nil if no page was found" do
+      expect(RailsModel.find('whoooohoo')).to be_nil
+    end
+    
+    it "tests the find method to return a gollum_rails:page if a page was found" do
+      expect(RailsModel.find('Goole')).to be_a GollumRails::Page
+    end
+    
+    it 'should not be persisted on initialization or finding' do
+      init = RailsModel.find_or_initialize_by_name('totallybad', @commit)
+      expect(init.persisted?).to be_false
+    end
+    
+    it "should find the page without a commit if it exists" do
+      expect(RailsModel.find_or_initialize_by_name("Goole").persisted?).to be_true
+    end
+    
+    it "should find the page with a commit if it exists" do
+      expect(RailsModel.find_or_initialize_by_name("Goole", @commit).persisted?).to be_true
+    end
+    
+    it "should be valid on initialization or finding" do
+      init = RailsModel.find_or_initialize_by_name('whoooohooo', @commit)
+      expect(init.valid?).to be_true
+      
+      #RailsModel.find_or_initialize_by_name(@call[:name], @commit).should  be_a GollumRails::Page
+      
     end
   end
   describe "callbacks" do
@@ -136,16 +252,15 @@ describe "Gollum Page" do
       test = CallbackTest.new @call
       test.persisted?.should be_false
       test.save
-      test.delete @commit
-      test.save
-      test.update_attributes @call
-      test.persisted?.should be_true
     end
   end
   describe "rails extension" do
+    
     it "should test fetch_all" do
-      GollumRails::Page.all.length.should == 2
-      GollumRails::Page.find_all.length.should == 2
+      GollumRails::Page.all.length.should == 1
+    end
+    it "should test all" do 
+      GollumRails::Page.find_all.length.should == 1
     end
 
   end
@@ -157,29 +272,35 @@ describe "Gollum Page" do
      class Callbackt < GollumRails::Page
       validates_presence_of :name
      end
+     
      cla = Callbackt.new @call
      cla.valid?.should be_true
    end
+   
    class SugarBaby < GollumRails::Page
      validates_presence_of :name
      validates_length_of :name, :minimum => 20
      validates_length_of :format, :maximum => 14
    end
+   
    it "should test string validation" do
      @call[:name] = "das ist zu lang"*10
      cla = SugarBaby.new @call
      cla.valid?.should be_true
    end
+   
    it "should test the presence validator" do
      @call[:name] = [ ]
      bla = SugarBaby.new @call
      bla.valid?.should be_false
    end
+   
    it "should test the length validator for name" do
      @call[:name] = "das"
      res = SugarBaby.new @call
      res.valid?.should be_false
    end
+   
    it "should test the length validator for format" do
      @call[:format] = :toolongformatstringforvalidator
      res = SugarBaby.new @call
@@ -187,21 +308,131 @@ describe "Gollum Page" do
    end
 
   end
- describe "the thread safety" do
-   class ThreadModel < GollumRails::Page
-
-   end
-   it "should save " do
-     100.times do |time|
-       Thread.new do
-         ThreadModel.new(@call)
-         ThreadModel.save.should be_instance_of(Gollum::Page)
-         ThreadModel.delete(@commit).length.should == 40
-       end
-     end
-
-   end
-
+  
+  describe "diffing commits" do
+    class CommitDiff < GollumRails::Page
+    end
+    
+    it "should display the diff commit" do
+      commit = {
+        name: "flo",
+        message: "commit",
+        email: "mosny@zyg.li"
+      }
+      call = {
+        name: "a Page",
+        content: "my content",
+        commit: commit,
+        format: :markdown
+      }
+      
+      res = CommitDiff.new call
+      res.save
+      res.update_attributes("content",nil,:markdown, @commit)
+      diff = res.compare_commits(res.history.first)
+      expect(diff).to be_a String
+      expect(diff).to match(/---/)
+      res.delete
+    end
+    
+  end
+  
+  describe "Filename" do
+    class Fns < GollumRails::Page
+    end
+    it "should assemble a filename" do
+      res = CommitDiff.new @call
+      expect(res.filename).to match(/^Goole\.md$/)
+    end
+  end
+  
+  describe "Sub Page" do
+    class Fns < GollumRails::Page
+    end
+    
+    it "should return nil if not persisted" do
+      res = CommitDiff.new @call
+      expect(res.sub_page?).to be_nil
+    end
+    it "should be true" do
+      res = CommitDiff.new @call.merge(name: '_aPage')
+      res.save
+      expect(res.sub_page?).to be_true
+      res.delete
+    end
+    
+    it "should be false" do
+      res = CommitDiff.new @call
+      res.save
+      expect(res.sub_page?).to be_false
+      res.delete
+    end
+  end  
+  
+  describe "Current version" do
+    class Fns < GollumRails::Page
+    end
+    
+    it "current version should have 7 digest" do
+      res = CommitDiff.new @call
+      res.save
+      expect(res.current_version.length).to be(7)
+      res.delete
+    end
+    
+    it "should be nil if page has not been set" do
+      res = CommitDiff.new @call
+      expect(res.current_version).to be_nil
+    end
 
-end
+    it "should be the latest version of the page but shortened" do
+      res = CommitDiff.new @call
+      res.save
+      expect(res.gollum_page.version.to_s).to match(res.current_version)
+      res.delete
+    end
+    it "should display the long version" do
+      res = CommitDiff.new @call
+      res.save
+      expect(res.gollum_page.version.to_s).to match(/^#{res.current_version(true)}$/)
+      res.delete
+    end
+    
+  end
+  
+  describe 'History' do
+    class Fns < GollumRails::Page
+    end
+    
+    it "history should return nil if no gollum_page was saved" do
+      res = Fns.new @call
+      expect(res.history).to be_nil
+    end
+    
+    it "history should return the pages versions if there are changes" do
+      res = Fns.new @call
+      res.save
+      expect(res.history).to be_a Array
+      res.delete
+    end
+    
+  end
+  
+ # describe "the thread safety" do
+#    class ThreadModel < GollumRails::Page
+# 
+#    end
+#    it "should save " do
+#      100.times do |time|
+#        Thread.new do
+#          ThreadModel.new(@call)
+#          ThreadModel.save.should be_a(GollumRails::Page)
+#          ThreadModel.delete(@commit).length.should == 40
+#        end
+#      end
+# 
+#    end
+
+
+#end
 end