gollum_rails 1.0.6 → 1.4.0.rc1

data/lib/gollum_rails/adapters/gollum.rb

@@ -20,11 +20,7 @@ module GollumRails
           attr_writer :page_class
 
           # Sets the wiki class used by all instances
-          attr_writer :wiki_path
-          
-          # Sets the wiki options
-          attr_writer :wiki_options
-          
+          attr_writer :wiki_class
 
           # Sets the applications status
           attr_writer :enabled
@@ -42,18 +38,13 @@ 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_path
-            @wiki_path || ""
+          def wiki_class
+            @wiki_class || Wiki
           end
 
         end

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

@@ -18,99 +18,63 @@ module GollumRails
 
         Connector.page_class = self
 
-        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
+        # Gets / Sets current page
+        attr_accessor :page
+
+          # Gets / Sets the wiki
+        attr_accessor :wiki
+
+        # Initializer
+        def initialize
+          @wiki = Connector.wiki_class
         end
 
-        # == Creates a new page
+
+        # creates a new Page
         #
-        # 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
+        # name - String
+        # type - Symbol
+        # content - Text
+        # commit - Hash or instance of Committer
         #
-        # 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 )
+        # 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
         end
 
-        # == 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
+        # updates an existing page
         #
-        # wiki - An instance of Gollum::Wiki
-        # content - New content
-        # name - A String
-        # format - A filetype as symbol (optional)
+        # new - Hash with changed data
+        # commit - Hash or instance of Committer
+        # old - also an instance of self
         #
-        def preview_page(wiki, name, content, format=:markdown)
-          page = wiki.preview_page(name,content,format)
-          page.formatted_data
+        # 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
         end
 
-        # == Deletes an existing page
+        # deletes an existing page
         #
-        # page - Gollum::Page
-        # wiki - Gollum::Wiki
-        # commit - Commit Hash
+        # page - instance of self
+        # commit - Hash or instance of Committer
         #
         # Returns the commit id
-        def delete_page( page,wiki,commit={} )
-          wiki.clear_cache
-          wiki.delete_page(page, commit)
+        def delete_page( commit={}, page = nil )
+          @wiki.delete_page (page||@page), commit
         end
         
         # renames an existing page
@@ -130,8 +94,7 @@ module GollumRails
         #
         # Returns the Gollum::Page class
         def find_page(name)
-          
-          self.class.find_page(name)
+          @wiki.page ::Gollum::Page.cname(name)
         end
         
         # moves an existing page
@@ -207,16 +170,6 @@ 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,28 +6,27 @@ 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, options={})
-          
-          Connector.wiki_options = options
-          
-          if location.is_a?(::String)
-            con = location
+        def initialize(location)
+          @git = location
+          if location.is_a? ::String
+            con = ::Gollum::Wiki.new @git
           else
-            con = location.path
+            con= ::Gollum::Wiki.new @git.path
           end
-          
-          Connector.wiki_path = con
-          
+          Connector.wiki_class = con
         end
       
         # Static call from within any other class
         #
         # Returns a new instance of this class
-        def self.wiki(location, options={})
-          Wiki.new(location, options)
+        def self.wiki(location)
+          Wiki.new(location)
         end
 
         # Forwards unknown methods to Gollum::Wiki

data/lib/gollum_rails/modules/hash.rb

@@ -0,0 +1,33 @@
+# See http://ruby-doc.org/core-2.0/Hash.html for further information
+#
+# Extended methods:
+#   * object support
+#   * setter
+#   * hash setter
+#   * isset
+#
+#
+# TODO
+#   * implement is? method
+#   * improve testing
+#
+class ::Hash
+
+
+  # Public: Converts a method . into an Hash element
+  #
+  # Examples
+  #   hash = {a: "b", b: "c", c: "d"}   
+  #   hash.a
+  #   # => "b"
+  #   #   hash.b
+  #   # => "c"
+  #
+  # Returns an instance of Hash if the name is the key of a new hash
+  def method_missing(name, *args)
+    return self[name] if key? name
+    self.each { |k,v| return v if k.to_s.to_sym == name }
+    super.method_missing name
+  end
+
+end

data/lib/gollum_rails/modules/loader.rb

@@ -0,0 +1,5 @@
+module GollumRails
+  ::Dir.glob(::File.expand_path(::File.dirname(__FILE__)) + '/*.rb') do |file|
+    require file if file != __FILE__
+  end
+end

data/lib/gollum_rails/page.rb

@@ -12,34 +12,42 @@ module GollumRails
   #   * new
   #   * save
   #   * delete
-  #   * find_or_initialize_by_name
+  #   * find_or_initialize_by_naname
   #
   class Page
-    extend ActiveModel::Naming
-    extend ActiveModel::Callbacks
-    
-    include ActiveModel::Conversion
-    include ActiveModel::Validations
+    extend ::ActiveModel::Callbacks
+    include ::ActiveModel::Validations
+    include ::ActiveModel::Conversion
+    extend ::ActiveModel::Naming
 
-    define_model_callbacks :save, :update, :delete, :initialize, :create, :commit
 
-    
+    # Callback for save
+    define_model_callbacks :save
+
+    # Callback for update
+    define_model_callbacks :update
+
+    # Callback for delete
+    define_model_callbacks :delete
+
     # 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 = find(name)
-        unless result_for_find.nil?
-          result_for_find
-        else
-          new(:format => :markdown, :name => name, :content => ".", :commit => commit)
-        end
+      def find_or_initialize_by_name(name, commit)
+        result_for_find = self.find(name)
+        self.create({:format => :markdown, :name => name, :content => ".", :commit => commit })
       end
 
       # Checks if the fileformat is supported
@@ -48,88 +56,67 @@ module GollumRails
       #
       # Returns true or false
       def format_supported?(format)
-        Gollum::Markup.formats.include?(format.to_sym)
+        supported = ['ascii', 'github-markdown','markdown', 'creole', 'org', 'pod', 'rdoc']
+        format.in?(supported)
       end
 
       # first creates an instance of itself and executes the save function.
       #
-      # data - Hash containing the page data
+      # hash - Hash containing the page data
       #
       #
       # Returns an instance of Gollum::Page or false
-      def create(data)
-        page = Page.new(data)
+      def create(hash)
+        page = Page.new hash
         page.save
       end
 
 
       # calls `create` on current class. If returned value is nil an exception will be thrown
       #
-      # data - Hash of Data containing all necessary stuff
-      # TODO write this stuff
+      # hash - Hash containing the page data
       #
       #
       # Returns an instance of Gollum::Page
-      def create!(data)
-        page = Page.new(data)
-        page.save!
+      def create!(hash)
+        action = self.create(hash)
+        action
       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, version=nil)
-        page = Adapters::Gollum::Page.find_page(name, wiki, version)
-        
-        return new( :gollum_page => page ) unless page.nil?
-        return nil
-        
+      def find(name)
+        page = GollumRails::Adapters::Gollum::Page.new
+        page.find_page name
       end
 
       # Gets all pages in the wiki
       def all
-        wiki.pages
+        self.wiki.pages
       end
-      
       alias_method :find_all, :all
 
       # Gets the wiki instance
       def wiki
-        @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, "undefined method `#{name}` for #{self}:#{self.class}"
-        end
+        @wiki || Adapters::Gollum::Connector.wiki_class
       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 = {})
-      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
+      if Adapters::Gollum::Connector.enabled
+        attrs.each{|k,v| self.public_send("#{k}=",v)} if attrs
+      else
+        raise GollumInternalError, 'gollum_rails is not enabled!'
       end
     end
 
@@ -139,10 +126,10 @@ module GollumRails
 
 
     # Gets / Sets the pages name
-    attr_writer :name
+    attr_accessor :name
 
     # Gets / Sets the contents content
-    attr_writer :content
+    attr_accessor :content
 
     # Gets / Sets the commit Hash
     attr_accessor :commit
@@ -158,24 +145,14 @@ module GollumRails
 
     # Gets the pages format
     def format
-      (@format || @gollum_page.format).to_sym
+      @format.to_sym
     end
 
-    def name
-      @name ||= @gollum_page.name
-    end
-    
-    def content
-      @content ||= @gollum_page.content
-    end
 
     # Gets the page class
     def page
-      Adapters::Gollum::Page.new
+      @page ||= Adapters::Gollum::Connector.page_class.new
     end
-    
-    # Gollum Page
-    attr_accessor :gollum_page
 
     #############
     # activemodel
@@ -204,77 +181,58 @@ module GollumRails
     # Returns an instance of Gollum::Page or false
     def save
       run_callbacks :save do
-        return nil unless valid?
+        return false unless valid?
         begin
-          @gollum_page = page.new_page(name,content,wiki,format,commit) 
+          page.new_page(name,content,format,commit)
         rescue ::Gollum::DuplicatePageError => e
-          @gollum_page = Adapters::Gollum::Page.find_page(name, wiki)
+          page.page = page.find_page(name)
         end
-        return self
+        return page.page
       end
     end
 
-    # == Save without exception handling
-    # raises errors everytime something is wrong 
+    # aliasing 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
+    # TODO:
+    #   * implement full method!
+    alias_method :save!, :save
 
-    # == Updates an existing page (or created)
+    # Updates an existing page (or created)
     #
-    # 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
+    # hash - Hash containing the attributes, you want to update
     # commit - optional. If given this commit will be used instead of that one, used
     #          to initialize the instance
     #
     #
-    # Returns an instance of GollumRails::Page
-    def update_attributes(content=nil,name=nil,format=:markdown, commit=nil)
+    # Returns an instance of Gollum::Page
+    def update_attributes(hash, commit=nil)
       run_callbacks :update do
-        @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)
-    #
-    # 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 destroy(commit=nil)
-      run_callbacks :delete do
-        page.delete_page(gollum_page, wiki, get_right_commit(commit))
+        page.update_page hash, get_right_commit(commit)
       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)
-      destroy(commit)
+      run_callbacks :delete do
+        page.delete_page get_right_commit(commit)
+      end
     end
 
     # checks if entry already has been saved
     #
     #
     def persisted?
-      return true if gollum_page
+      return true if page.page.instance_of?(::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 fast method!
+    # This is an extremely performant 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
     #
@@ -284,91 +242,16 @@ module GollumRails
     #
     # Returns a String
     def preview(format=:markdown)
-      page.preview_page( wiki, name, content, format )
+      preview = self.class.wiki.preview_page @name, @content, format
+      preview.formatted_data
     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
     #######
 
-    # == Gets the right commit out of 2 commits
+    # Get the right commit out of 2 commits
     #
     # commit_local - local commit Hash
     #
@@ -378,19 +261,6 @@ 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