gollum_rails 1.0.4 → 1.0.5

data/lib/gollum_rails.rb

@@ -6,9 +6,6 @@ require 'rubygems'
 # external
 require 'gollum-lib'
 
-# patches
-require 'grit/git-ruby/internal/pack'
-require 'core_ext/string'
 
 # GollumRails is a RubyGem for extending Rails and the Gollum wiki powered by github
 # It has the ability to combine the benefits from a git powered wiki with Rails.
@@ -23,7 +20,7 @@ module GollumRails
   autoload :Setup,    'gollum_rails/setup'
 
   # GollumRails version string
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 
   # Simplified error
   class Error < StandardError; end
@@ -31,13 +28,9 @@ module GollumRails
   # All Gollum internal exceptions will be redirected to this
   class GollumInternalError < Error
 
-    # The classes name, that raised the exception
-    attr_accessor :name
 
-    # The messsage, brought by the class
+    attr_accessor :name
     attr_accessor :message
-
-    # The target, the class wanted to interact with
     attr_accessor :target
 
     # modifies content for throwing an exception

data/lib/gollum_rails/adapters/gollum.rb

@@ -20,7 +20,11 @@ module GollumRails
           attr_writer :page_class
 
           # Sets the wiki class used by all instances
-          attr_writer :wiki_class
+          attr_writer :wiki_path
+          
+          # Sets the wiki options
+          attr_writer :wiki_options
+          
 
           # Sets the applications status
           attr_writer :enabled
@@ -38,13 +42,18 @@ module GollumRails
           def page_class
             @page_class || Page
           end
+          
+          # Gets the wiki options
+          def wiki_options
+            @wiki_options || {}
+          end
 
           # Gets the Globally used Page class or use a new one if not defined
           #
           #
           # Returns the internal page class or a fresh ::Gollum::Page
-          def wiki_class
-            @wiki_class || Wiki
+          def wiki_path
+            @wiki_path || ""
           end
 
         end

data/lib/gollum_rails/adapters/gollum/page.rb

@@ -18,63 +18,99 @@ module GollumRails
 
         Connector.page_class = self
 
-        # Gets / Sets current page
-        attr_accessor :page
-
-          # Gets / Sets the wiki
-        attr_accessor :wiki
-
-        # Initializer
-        def initialize
-          @wiki = Connector.wiki_class
+        class << self
+
+          # == Parses a given filepath e.g. '/test/page'
+          # Name is page
+          # path is /test
+          #
+          # Returns a Hash
+          def parse_path(name)
+            path = '/'
+            name = name.to_s
+            if name.include?('/')
+              name = name[1..-1] if name[0] == "/"
+              content = name.split('/')
+              name = content.pop
+              path = '/'+content.join('/')
+            end
+            { path: path, name: name }
+          end
+          
+          # finds all versions of a page
+          #
+          # name - the pagename to search
+          # wiki - instance of Gollum::Wiki
+          # version - optional - The pages version
+          #
+          # Returns the Gollum::Page class
+          def find_page(name, wiki, version=nil)
+            wiki.clear_cache
+            path_data = parse_path(name)
+            wiki.paged(path_data[:name], path_data[:path], exact = true, version)
+          end
         end
 
-
-        # creates a new Page
+        # == Creates a new page
         #
-        # name - String
-        # type - Symbol
-        # content - Text
-        # commit - Hash or instance of Committer
+        # name - The name of the page
+        # content - The content of the page
+        # wiki - An instance of Gollum::Wiki
+        # type - A filetype as symbol (optional)
+        # commit - Commit Hash
         #
-        # Returns the commit id
-        def new_page( name, content,type=:markdown, commit={} )
-          @wiki.write_page name.to_s, type, content, commit if name
-          @page = @wiki.page name
-          @page
+        # Returns the page
+        def new_page( name, content, wiki, type=:markdown, commit={} )
+          path_data = self.class.parse_path(name)
+          wiki.write_page( path_data[:name], type, content, commit, path_data[:path].gsub!(/^\//, "").gsub!(/(\/)+$/,'') || "" )
+          wiki.clear_cache
+          self.class.find_page( name, wiki )
         end
 
-        # updates an existing page
+        # == Updates an existing page
+        #
+        # page - An instance of Gollum::Page
+        # wiki - An instance of Gollum::Wiki
+        # content - New content
+        # commit - Commit Hash
+        # name - A new String (optional)
+        # format - A filetype as symbol (optional)
+        #
+        # Returns the page
+        def update_page( page, wiki, content=nil, commit={}, name=nil, format=nil)
+          wiki.clear_cache
+          return page if page.nil?
+          name ||= page.name
+          format = (format || page.format).to_sym
+          content ||= page.raw_data
+          
+          wiki.update_page(page,name,format,content.to_s,commit) unless ((!content||page.raw_data == content) && page.format == format)
+          
+          self.class.find_page( mixin(page.url_path, name), wiki )
+        end
+        
+        # == Preview page
         #
-        # new - Hash with changed data
-        # commit - Hash or instance of Committer
-        # old - also an instance of self
+        # wiki - An instance of Gollum::Wiki
+        # content - New content
+        # name - A String
+        # format - A filetype as symbol (optional)
         #
-        # Returns the commit id
-        def update_page( new, commit={}, old=nil)
-          if new.is_a?(Hash)
-            commit_id = @wiki.update_page (old||@page), 
-                                          new[:name]||@page.name, 
-                                          new[:format]||@page.format, 
-                                          new[:content]||@page.raw_data, 
-                                          commit 
-          else
-            raise Error.new  "commit must be a Hash. #{new.class} given", :crit
-          end
-
-          # this is very ugly. Shouldn't gollum return the new page?
-          @page = @page.find(new[:name]||@page.name, commit_id)
-          @page
+        def preview_page(wiki, name, content, format=:markdown)
+          page = wiki.preview_page(name,content,format)
+          page.formatted_data
         end
 
-        # deletes an existing page
+        # == Deletes an existing page
         #
-        # page - instance of self
-        # commit - Hash or instance of Committer
+        # page - Gollum::Page
+        # wiki - Gollum::Wiki
+        # commit - Commit Hash
         #
         # Returns the commit id
-        def delete_page( commit={}, page = nil )
-          @wiki.delete_page (page||@page), commit
+        def delete_page( page,wiki,commit={} )
+          wiki.clear_cache
+          wiki.delete_page(page, commit)
         end
         
         # renames an existing page
@@ -94,7 +130,8 @@ module GollumRails
         #
         # Returns the Gollum::Page class
         def find_page(name)
-          @wiki.page ::Gollum::Page.cname(name)
+          
+          self.class.find_page(name)
         end
         
         # moves an existing page
@@ -170,6 +207,16 @@ module GollumRails
             raise Error.new  "page cannot be empty for #{__method__}", :high
           end
         end
+        
+        private
+        
+        # replaces old filename with new
+        def mixin(old_url, new_name)
+          url = old_url.split("/")
+          url.pop
+          url << new_name
+          url.join("/")
+        end
 
       end
     end

data/lib/gollum_rails/adapters/gollum/wiki.rb

@@ -6,27 +6,28 @@ module GollumRails
       # TODO: doc
       class  Wiki
 
-        # Gets / Sets the git path or object
-        attr_accessor :git
-
         # Initializes the class
         #
         # location - String or Grit::Repo
-        def initialize(location)
-          @git = location
-          if location.is_a? ::String
-            con = ::Gollum::Wiki.new @git
+        def initialize(location, options={})
+          
+          Connector.wiki_options = options
+          
+          if location.is_a?(::String)
+            con = location
           else
-            con= ::Gollum::Wiki.new @git.path
+            con = location.path
           end
-          Connector.wiki_class = con
+          
+          Connector.wiki_path = con
+          
         end
       
         # Static call from within any other class
         #
         # Returns a new instance of this class
-        def self.wiki(location)
-          Wiki.new(location)
+        def self.wiki(location, options={})
+          Wiki.new(location, options)
         end
 
         # Forwards unknown methods to Gollum::Wiki

data/lib/gollum_rails/page.rb

@@ -12,14 +12,12 @@ module GollumRails
   #   * new
   #   * save
   #   * delete
-  #   * find_or_initialize_by_naname
+  #   * find_or_initialize_by_name
   #
   class Page
-    extend ::ActiveModel::Callbacks
-    include ::ActiveModel::Validations
-    include ::ActiveModel::Conversion
-    extend ::ActiveModel::Naming
-
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
 
     # Callback for save
     define_model_callbacks :save
@@ -29,25 +27,32 @@ module GollumRails
 
     # Callback for delete
     define_model_callbacks :delete
-
+    
+    # Callback for initialize
+    define_model_callbacks :initialize
+    
+    # Callback for create
+    define_model_callbacks :create
+
+    # Callback for commit
+    define_model_callbacks :commit
+    
     # static
     class << self
-      # Gets / Sets the gollum page
-      #
-      attr_accessor :gollum_page
-
-      # Sets the validator
-      attr_writer :validator
-
+      
       # Finds an existing page or creates it
       #
       # name - The name
       # commit - Hash
       #
       # Returns self
-      def find_or_initialize_by_name(name, commit)
-        result_for_find = self.find(name)
-        self.create({:format => :markdown, :name => name, :content => ".", :commit => commit })
+      def find_or_initialize_by_name(name, commit={})
+        result_for_find = find(name)
+        unless result_for_find.nil?
+          result_for_find
+        else
+          new(:format => :markdown, :name => name, :content => ".", :commit => commit)
+        end
       end
 
       # Checks if the fileformat is supported
@@ -56,67 +61,88 @@ module GollumRails
       #
       # Returns true or false
       def format_supported?(format)
-        supported = ['ascii', 'github-markdown','markdown', 'creole', 'org', 'pod', 'rdoc']
-        format.in?(supported)
+        Gollum::Markup.formats.include?(format.to_sym)
       end
 
       # first creates an instance of itself and executes the save function.
       #
-      # hash - Hash containing the page data
+      # data - Hash containing the page data
       #
       #
       # Returns an instance of Gollum::Page or false
-      def create(hash)
-        page = Page.new hash
+      def create(data)
+        page = Page.new(data)
         page.save
       end
 
 
       # calls `create` on current class. If returned value is nil an exception will be thrown
       #
-      # hash - Hash containing the page data
+      # data - Hash of Data containing all necessary stuff
+      # TODO write this stuff
       #
       #
       # Returns an instance of Gollum::Page
-      def create!(hash)
-        action = self.create(hash)
-        action
+      def create!(data)
+        page = Page.new(data)
+        page.save!
       end
 
       # Finds a page based on the name and specified version
       #
       # name - the name of the page
+      # version - optional - The pages version
       #
       # Return an instance of Gollum::Page
-      def find(name)
-        page = GollumRails::Adapters::Gollum::Page.new
-        page.find_page name
+      def find(name, version=nil)
+        page = Adapters::Gollum::Page.find_page(name, wiki, version)
+        
+        return new( :gollum_page => page ) unless page.nil?
+        return nil
+        
       end
 
       # Gets all pages in the wiki
       def all
-        self.wiki.pages
+        wiki.pages
       end
+      
       alias_method :find_all, :all
 
       # Gets the wiki instance
       def wiki
-        @wiki || Adapters::Gollum::Connector.wiki_class
+        @wiki ||= ::Gollum::Wiki.new(Adapters::Gollum::Connector.wiki_path, Adapters::Gollum::Connector.wiki_options)
+      end
+      
+      # TODO: implement more of this (format, etc)
+      #
+      def method_missing(name, *args)
+        if name =~ /^find_by_(name)$/
+          self.find(args.first)
+        else
+          raise NoMethodError, "Method #{name} was not found"
+        end
       end
 
     end
 
-
+    # Gets / Sets the gollum page
+    #
+    attr_accessor :gollum_page
+    
     # Initializes a new Page
     #
     # attrs - Hash of attributes
     #
     # commit must be given to perform any page action!
     def initialize(attrs = {})
-      if Adapters::Gollum::Connector.enabled
-        attrs.each{|k,v| self.public_send("#{k}=",v)} if attrs
-      else
-        raise GollumInternalError, 'gollum_rails is not enabled!'
+      run_callbacks :initialize do
+        if Adapters::Gollum::Connector.enabled
+          attrs.each{|k,v| self.public_send("#{k}=",v)} if attrs
+          update_attrs if attrs[:gollum_page]
+        else
+          raise GollumInternalError, 'gollum_rails is not enabled!'
+        end
       end
     end
 
@@ -126,10 +152,10 @@ module GollumRails
 
 
     # Gets / Sets the pages name
-    attr_accessor :name
+    attr_writer :name
 
     # Gets / Sets the contents content
-    attr_accessor :content
+    attr_writer :content
 
     # Gets / Sets the commit Hash
     attr_accessor :commit
@@ -145,14 +171,24 @@ module GollumRails
 
     # Gets the pages format
     def format
-      @format.to_sym
+      (@format || @gollum_page.format).to_sym
     end
 
+    def name
+      @name ||= @gollum_page.name
+    end
+    
+    def content
+      @content ||= @gollum_page.content
+    end
 
     # Gets the page class
     def page
-      @page ||= Adapters::Gollum::Connector.page_class.new
+      Adapters::Gollum::Page.new
     end
+    
+    # Gollum Page
+    attr_accessor :gollum_page
 
     #############
     # activemodel
@@ -181,58 +217,77 @@ module GollumRails
     # Returns an instance of Gollum::Page or false
     def save
       run_callbacks :save do
-        return false unless valid?
+        return nil unless valid?
         begin
-          page.new_page(name,content,format,commit)
+          @gollum_page = page.new_page(name,content,wiki,format,commit) 
         rescue ::Gollum::DuplicatePageError => e
-          page.page = page.find_page(name)
+          @gollum_page = Adapters::Gollum::Page.find_page(name, wiki)
         end
-        return page.page
+        return self
       end
     end
 
-    # aliasing save
+    # == Save without exception handling
+    # raises errors everytime something is wrong 
     #
-    # TODO:
-    #   * implement full method!
-    alias_method :save!, :save
+    def save!
+      run_callbacks :save do
+        raise StandardError, "record is not valid" unless valid?
+        raise StandardError, "commit could not be empty" if commit == {}
+        @gollum_page = page.new_page(name,content,wiki,format,commit)
+        return self
+      end
+    end
 
-    # Updates an existing page (or created)
+    # == Updates an existing page (or created)
     #
-    # hash - Hash containing the attributes, you want to update
+    # content - optional. If given the content of the gollum_page will be updated
+    # name - optional. If given the name of gollum_page will be updated
+    # format - optional. Updates the format. Uses markdown as default
     # commit - optional. If given this commit will be used instead of that one, used
     #          to initialize the instance
     #
     #
-    # Returns an instance of Gollum::Page
-    def update_attributes(hash, commit=nil)
+    # Returns an instance of GollumRails::Page
+    def update_attributes(content=nil,name=nil,format=:markdown, commit=nil)
       run_callbacks :update do
-        page.update_page hash, get_right_commit(commit)
+        @gollum_page = page.update_page(gollum_page, wiki, content, get_right_commit(commit), name, format)
       end
     end
-
-    # Deletes current page (also available static. See below)
+    
+    # == Deletes current page (also available static. See below)
     #
     # commit - optional. If given this commit will be used instead of that one, used
     #          to initialize the instance
     #
     # Returns the commit id of the current action as String
-    def delete(commit=nil)
+    def destroy(commit=nil)
       run_callbacks :delete do
-        page.delete_page get_right_commit(commit)
+        page.delete_page(gollum_page, wiki, get_right_commit(commit))
       end
     end
 
+    # == Deletes current page (also available static. See below)
+    #
+    # commit - optional. If given this commit will be used instead of that one, used
+    #          to initialize the instance
+    #
+    # Returns the commit id of the current action as String
+    def delete(commit=nil)
+      destroy(commit)
+    end
+
     # checks if entry already has been saved
     #
     #
     def persisted?
-      return true if page.page.instance_of?(::Gollum::Page)
+      return true if gollum_page
       return false
     end
-    # Previews the page - Mostly used if you want to see what you do before saving
+    
+    # == Previews the page - Mostly used if you want to see what you do before saving
     #
-    # This is an extremely performant method!
+    # This is an extremely fast method!
     # 1 rendering attempt take depending on the content about 0.001 (simple markdown)
     # upto 0.004 (1000 chars markdown) seconds, which is quite good
     #
@@ -242,16 +297,91 @@ module GollumRails
     #
     # Returns a String
     def preview(format=:markdown)
-      preview = self.class.wiki.preview_page @name, @content, format
-      preview.formatted_data
+      page.preview_page( wiki, name, content, format )
     end
 
-
+    # == Gets the url for current page from Gollum::Page
+    #
+    # Returns a String
+    def url
+      gollum_page.url_path
+    end
+    
+    # == Gets the title for current Gollum::Page
+    #
+    # Returns a String
+    def title
+      gollum_page.title
+    end
+    
+    # == Gets formatted_data for current Gollum::Page
+    #
+    # Returns a String
+    def html_data
+      gollum_page.formatted_data
+    end
+    
+    
+    # == Gets raw_data for current Gollum::Page
+    #
+    # Returns a String
+    def raw_data
+      gollum_page.raw_data
+    end
+    
+    # == Gets the history of current gollum_page
+    #
+    # Returns an Array
+    def history
+      return nil unless persisted?
+      gollum_page.versions
+    end
+    
+    # == Gets the last modified by Gollum::Committer
+    #
+    # Returns a String
+    def last_changed_by
+      "%s <%s>" % [history.last.author.name, history.last.author.email]
+    end
+    
+    # == Compare 2 Commits.
+    #
+    # sha1 - SHA1
+    # sha2 - SHA1
+    def compare_commits(sha1,sha2=nil)
+      Page.wiki.full_reverse_diff_for(@gollum_page,sha1,sha2)
+    end
+    
+    # == The pages filename, based on the name and the format
+    # 
+    # Returns a String
+    def filename
+      Page.wiki.page_file_name(@name, @format)
+    end
+      
+    # == Checks if current page is a subpage
+    def sub_page?
+      return nil unless persisted?
+      @gollum_page.sub_page
+    end
+    
+    # == Gets the version of current commit
+    #
+    def current_version(long=false)
+      return nil unless persisted?
+      unless long
+        @gollum_page.version_short 
+      else
+        @gollum_page.version.to_s
+      end
+      
+    end
+    
     #######
     private
     #######
 
-    # Get the right commit out of 2 commits
+    # == Gets the right commit out of 2 commits
     #
     # commit_local - local commit Hash
     #
@@ -261,6 +391,19 @@ module GollumRails
       com = commit_local if !commit_local.nil?
       return com
     end
-
+    
+    # == Updates local attributes from gollum_page class
+    #
+    def update_attrs
+      @name = gollum_page.name
+      @content= gollum_page.raw_data
+      @format = gollum_page.format      
+    end
+    
+    # == To static
+    def wiki
+      self.class.wiki
+    end
+    
   end
  end