gollum_rails 0.0.2.8 → 0.0.5

data/lib/gollum_rails/adapters/gollum.rb

@@ -0,0 +1,61 @@
+# ~*~ encoding: utf-8 ~*~
+module GollumRails
+  module Adapters
+    # Gollum Wiki connector classes
+    #
+    # TODO:
+    #   * implement
+    #
+    # FIXME:
+    #   currently nothing implemented
+    #
+    module Gollum
+      # connector version
+      VERSION="0.0.0"
+
+      # Gollum connector class, keeping defaults!
+      #
+      class Connector
+        class << self
+          # Sets the page class used by all instances
+          attr_writer :page_class
+
+          # Sets the wiki class used by all instances
+          attr_writer :wiki_class
+
+          # Sets the committer
+          attr_writer :committer_class
+
+          # 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 page_class
+            @page_class || Page
+          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
+          end
+
+          # Gets the current committer or using anon
+          #
+          #
+          def committer_class
+            @committer_class || Committer
+          end
+        end
+      end
+    end
+  end
+end
+
+require File.expand_path '../gollum/error', __FILE__
+require File.expand_path '../gollum/wiki', __FILE__
+require File.expand_path '../gollum/committer', __FILE__
+require File.expand_path '../gollum/page', __FILE__
+

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

@@ -0,0 +1,9 @@
+module GollumRails
+  module Adapters
+    module Gollum
+      # TODO: doc
+      class  Committer < ::Gollum::Committer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module GollumRails
+  module Adapters
+    module Gollum
+
+      # Gollum adapter Error handling class
+      #
+      # provides better errors
+      class Error < ::StandardError
+
+        # does the formatting of the Error message
+        #
+        #
+        def initialize(error_message, urgence)
+          super "#{urgence.upcase} :: #{error_message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+module GollumRails
+  module Adapters
+    module Gollum
+
+      # Main page class for the Gollum connector.
+      #
+      # It provides some awesome features for connecting gollum to gollum_rails such as:
+      #   * new_page
+      #   * find_page
+      #   * delete_page
+      #   * rename_page
+      #   * move_page
+      #   * first_page_commit
+      #   * page_creation time
+      #   * ...
+      #
+      class Page
+
+        Connector.page_class = self
+
+        # Gets / Sets current page
+        attr_accessor :page
+
+          # Gets / Sets the wiki
+        attr_accessor :wiki
+
+        # Initializer
+        def initialize
+          @wiki = Wiki.class_variable_get(:@@wiki)
+        end
+
+
+        # creates a new Page
+        #
+        # name - String
+        # type - Symbol
+        # content - Text
+        # commit - Hash or instance of Committer
+        #
+        # 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
+        #
+        # new - Hash with changed data
+        # commit - Hash or instance of Committer
+        # old - also an instance of self
+        #
+        # 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
+        #
+        # page - instance of self
+        # commit - Hash or instance of Committer
+        #
+        # Returns the commit id
+        def delete_page( commit={}, page = nil )
+          @wiki.delete_page (page||@page), commit
+        end
+        
+        # renames an existing page
+        #
+        # page - instance of myself
+        # newname - new pagename
+        # commit - Hash or instance of Committer
+        #
+        # Returns the commit id
+        def rename_page( page, newname, commit={} )
+
+        end
+
+        # finds all versions of a page
+        #
+        # name - the pagename to search
+        #
+        # Returns the Gollum::Page class
+        def find_page(name)
+          @wiki.page ::Gollum::Page.cname(name)
+        end
+        
+        # moves an existing page
+        #
+        # TODO:
+        #   * implement
+        def move_page()
+        end
+
+        # gets page last edit date
+        #
+        # Returns an instance of Time
+        def page_last_edited_date
+          if @page
+            return @page.versions.first.authored_date
+          else
+            raise Error.new  "page cannot be empty for #{__method__}", :high
+          end
+        end
+
+        # gets the latest commit
+        #
+        # Returns an instance of Grit::Commit
+        def page_last_commit
+          if @page
+            return @page.versions.first
+          else
+            raise Error.new "page cannot be empty for #{__method__}", :high
+          end
+        end
+
+        # gets the creation date of the page
+        #
+        # Returns an instance of Time
+        def page_created
+          if @page
+            return @page.versions.last.authored_date
+          else
+            raise Error.new  "page cannot be empty for #{__method__}", :high
+          end
+
+        end
+        
+        # gets the first page commit
+        #
+        # Returns an instance of Grit::Commit
+        def page_first_commit
+          if @page
+            return @page.versions.last
+          else
+            raise Error.new  "page cannot be empty for #{__method__}", :high
+          end
+        end
+
+        # gets a specific commit version
+        #
+        # Returns an instance of Grit::Commit
+        def page_commit(id)
+          if @page
+            return @page.versions.each{|v| return v if v.id == id}
+          else
+            raise Error.new  "page cannot be empty for #{__method__}", :high
+          end
+        end
+
+        # gets a specific commit time
+        #
+        # Returns an instance of Time
+        def page_commit_date(id)
+          if @page
+            return @page.versions.each{|v| return v.authored_date if v.id == id}
+          else
+            raise Error.new  "page cannot be empty for #{__method__}", :high
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'grit'
+module GollumRails
+  module Adapters
+    module Gollum
+
+      # TODO: doc
+      class  Wiki
+
+        Connector.wiki_class = self
+
+        # Gets / Sets the git path or object
+        attr_accessor :git
+
+        # Static callers
+        class << self
+          # Gets / Sets the wiki instance
+          attr_accessor :wiki
+        end
+
+        # Initializes the class
+        #
+        # location - String or Grit::Repo
+        def initialize(location)
+          gollum = ::Gollum::Wiki
+          @git = location
+          if location.is_a? ::String
+            @@wiki = gollum.new @git
+          else
+            @@wiki = gollum.new @git.path
+          end
+        end
+      
+        # Static call from within any other class
+        #
+        # Returns a new instance of this class
+        def self.wiki(location)
+          Wiki.new(location)
+        end
+
+      end
+    end
+  end
+end

data/lib/gollum_rails/initializer.rb

@@ -0,0 +1,8 @@
+module GollumRails
+  
+
+  # setup
+  def setup(&block)
+  end
+
+end

data/lib/gollum_rails/{hash.rb → modules/hash.rb}

@@ -1,20 +1,33 @@
-# Public: Extend Hash class by a method missing call
-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
-  #         otherwise it will return the value of the key 
-  def method_missing(name)
-    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
+# 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

@@ -1,406 +1,283 @@
-# ~*~ encoding: utf-8 ~*~
-require File.expand_path('../hash', __FILE__)
-require File.expand_path('../versions', __FILE__)
-
-module GollumRails
-  class Page
-    include ActiveModel::Conversion
-    include ActiveModel::Validations
-    extend ActiveModel::Naming
-
-    # Public: Gets/Sets the name of the document
-    attr_accessor :name
-
-    # Public: Gets/Sets the content of the document
-    attr_accessor :content
-
-    # Public: Gets/Sets the format of the document
-    #
-    # Examples
-    #   Page.format = :creole
-    #   #or
-    #   Page.format = :markdown
-    #
-    # Possible formats are
-    #  - :asciidoc
-    #  - :creole
-    #  - :markdown
-    #  - :org
-    #  - :pod
-    #  - :rdoc
-    #  - :rst
-    #  - :tex
-    #  - :wiki
-    attr_accessor :format
-
-    # Public: Gets/Sets the commiters credentials
-    #
-    # commit - The commit Hash details:
-    #   :message - The String commit message.
-    #   :name - The String author full name.
-    #   :email - The String email address.
-    #   :parent - Optional Grit::Commit parent to this update.
-    #   :tree - Optional String SHA of the tree to create the
-    #           index from.
-    #   :committer - Optional Gollum::Committer instance. If provided,
-    #                assume that this operation is part of batch of
-    #                updates and the commit happens later.
-    #
-    # Examples
-    #     commit = {
-    #         message: 'page created',
-    #         name: 'Florian Kasper',
-    #         email: 'nirnanaaa@khnetworks.com'
-    #       }
-    #
-    attr_accessor :commit
-
-    #########
-    # READERs
-    #########
-
-    # Public: Gets the options
-    attr_reader :options
-
-    # Public: Gets the persistance of objects by save(), update(), delete() methods
-    attr_reader :persisted
-
-    # Public: Gets the error messages
-    attr_reader :error
-
-    # Public: Gets the instance of Gollum::Wiki
-    attr_reader :wiki
-
-    # Public: Gets ?!
-    attr_reader :class
-    # Public: Initializes a new Page instance
-    #
-    # attributes - A hash of attributes. See example
-    # options - Will be merged with the configuration
-    #
-    # Examples
-    #
-    #   GollumRails::Page.new({name: '', content: '', format: '', commit: {}})
-    #
-    #
-    # Explanation
-    #
-    #   name must be a string.
-    #   content should be a text/String
-    #   format must be eighter :markdown, :latex, :rdoc, ...
-    #   commit must be a hash for example:
-    #
-    # Raises RuntimeError if the wiki was not initialized
-    # Raises RuntimeError if no configuration was provided
-    #
-    # Returns an instance of this class
-    def initialize(attributes = {}, options = {})
-      wiki = DependencyInjector.wiki
-      config = DependencyInjector.config
-      if wiki && wiki.is_a?(Wiki) && wiki_loaded?(wiki.wiki)
-        @wiki = wiki
-      else
-        #must be hardcoded, cause no options are loaded
-        raise RuntimeError, "No wiki loaded"
-      end
-      if config && config.is_a?(Hash)
-        @options = config
-        options.each{|k,v| @options[k] = v}
-      else
-        raise RuntimeError, "No configuration provided"
-      end
-      if !Validations.is_boolean?(@persisted)
-        @persisted = false
-      end
-      if !@error
-        @error = nil
-      end
-      attributes.each do |name, value|
-        send("#{name}=", value)
-      end
-
-    end
-
-    # Public: Checks if the given Instance is an Instance of the Gollum Wiki
-    #
-    # wiki - An instance of a class
-    #
-    # Examples
-    #   wiki_loaded?(Gollum::Wiki)
-    #   # => true
-    #
-    # Returns if the given instance is an instance of Gollum::Wiki
-    def wiki_loaded?(wiki)
-      wiki.is_a?(Gollum::Wiki)
-    end
-
-    # Public: Gets the @error message
-    #
-    # Examples:
-    #   puts get_error_message
-    #   # => 'An Error Occured'
-    #
-    # Returns an Error message
-    def get_error_message
-      @error
-    end
-
-    # Public: saves this instance
-    def save
-      if valid?
-        begin
-          commit = wiki.wiki.write_page(@name, @format, @content, @commit)
-        rescue Gollum::DuplicatePageError => e
-          @error = e
-          return false
-        end
-      end
-      if commit and commit.is_a? String
-        return commit
-      else
-        return false
-      end
-    end
-
-    # Public: rewrite for save() method with raising exceptions as well
-    def save!
-      saves = save
-      if @error
-        raise RuntimeError, @error
-      else
-        return saves
-      end
-
-    end
-
-    # Public: Updates an existing page
-    # usage:
-    #
-    #
-    # wiki = GollumRails::Wiki.new(PATH)
-    #
-    # page = GollumRails::Page.new
-    # cnt = page.find(PAGENAME)
-    #
-    # commit = {
-    #   :message => "production test update",
-    #   :name => 'Florian Kasper',
-    #   :email => 'nirnanaaa@khnetworks.com'
-    # }
-    # update = page.update("content", commit)
-
-    def update(content, commit, name=nil, format=nil)
-      if !name.nil?
-        @name = name
-      end
-      if !format.nil?
-        @format = format
-      end
-      if commit.nil? || content.nil?
-        @error = @options.messages.commit_not_empty_and_content_not_empty
-        return false
-      end
-      commit = @wiki.wiki.update_page(@page, @name, @format, content, commit)
-      if commit.is_a?(String)
-        @persisted = true
-        return commit
-      else
-        @persisted = false
-        return nil
-      end
-    end
-
-    #Public: alias for update with exceptions
-    def update!(content, commit, name=nil, format=nil)
-      updates = update(content, commit, name=nil, format=nil)
-      if @error
-        raise RuntimeError, @error
-      else
-        return updates
-      end
-    end
-
-    #Public: Deletes page fetched by find()
-    def delete(commit)
-      if commit.nil?
-        @error = @options.messages.commit_must_be_given
-        return false
-      end
-      return @wiki.wiki.delete_page(@page, commit)
-    end
-
-    #Public: alias for delete with exceptions
-    def delete!(commit)
-      deletes = delete(commit)
-      if @error
-        raise RuntimeError, @error
-      else
-        return deletes
-      end
-    end
-
-    #Public: For outputting all pages
-    def all
-
-    end
-
-    # Public: Renders a preview (usable e.g. with ajax)
-    #
-    #
-    # Returns rendered HTML
-    def preview(name = nil, content = nil, format = :markdown)
-      if !name or name == nil
-        name = @name
-      end
-      if !content or content == nil
-        content = @content
-      end
-      return @wiki.wiki.preview_page(name, content, format).formatted_data
-    end
-
-    # Public: Validates class variables
-    #
-    #
-    # Returns either true or false
-    def valid?
-      if !@name || @name.nil?
-        @error = @options.messages.name_not_set_or_nil
-        return false
-      end
-      if !@commit || !@commit.is_a?(Hash)
-        @error = @options.messages.commit_must_be_given
-        return false
-      end
-      if !@format
-        @error = @options.messages.format_not_set
-        return false
-      end
-
-      return true
-    end
-
-    # Public: Gets an instance of Gollum::Page
-    #
-    # name - Search string
-    #
-    # Returns nil if no result was found or no name was given
-    attr_reader :page
-
-    # Public: Finds a page based on given search string
-    #
-    # Be careful: At the moment you must initialize the class by .new
-    #
-    # Examples
-    #   page = Page.new attributes
-    #   page.find('static')
-    #
-    # Returns either nil or an instance of Gollum::Page
-    def find(name = nil)
-      if !name.nil?
-        page = @wiki.wiki.page(name)
-        if page.nil?
-          @error = @options.messages.no_page_found
-          return nil
-        end
-
-        #need a better solution. Thats fu***** bull*****
-        @page = page
-        @name = page.name
-        @format = page.format
-
-        return page
-      else
-        @error = @options.messages.name_not_set_or_nil
-        return nil
-      end
-    end
-
-    # Public: Checks if the object is already persisted
-    #
-    # Examples
-    #   page = Page.new
-    #   page.persisted?
-    #   # => false
-    #   page.save
-    #   page.persisted?
-    #   # => false
-    #
-    #   @commit = {
-    #     :message => "test creation of page",
-    #     :name => 'Florian Kasper',
-    #     :email => 'nirnanaaa@khnetworks.com'
-    #   }
-    #   attributes = {
-    #     name: 'TestPage',
-    #     content: 'content',
-    #     format: :markdown,
-    #     commit: @commit
-    #   }
-    #   page.save
-    #   page.persisted?
-    #   # => true
-    #
-    # Returns a Boolean(false|true)
-    def persisted?
-      @persisted
-    end
-
-    # Public: Magic method ( static )
-    #
-    # name - The functions name
-    # args - Pointer of arguments
-    #
-    # Static into non static converter
-    def self.method_missing(name, *args)
-      klass = self.new
-      return klass.find(args) if name.to_s == 'find'
-    end
-
-    ################################################
-    ######### P A G E # L O A D E D ################
-    ################################################
-
-    # Public: A simple wrapper for Gollum::Page.raw_data
-    #
-    # Page needs to be loaded!
-    #
-    # Returns raw data
-    def raw_data
-      if @page
-        @page.raw_data
-      else
-        @error = @options.messages.no_page_fetched
-        return false
-      end
-    end
-
-    # Public: A simple wrapper for Gollum::Page.formatted_data
-    #
-    # Page needs to be loaded!
-    #
-    # Returns formatted html
-    def formatted_data
-      if @page
-        @page.formatted_data
-      else
-        @error = @options.messages.no_page_fetched
-        return false
-      end
-    end
-
-    # Public: Active Record like
-    #
-    #
-    #
-    # see Active Model documentation
-    def versions
-      if @page && @page.is_a?(Gollum::Page) #&& (persisted? || found?)
-        return GollumRails::Versions.new(@page)
-      else
-        @error = @options.messages.no_page_fetched
-        return false
-      end
-    end
-
-  end
-end
+module GollumRails
+
+  # Main class, used to interact with rails.
+  #
+  # Methods, which are available:
+  #   * find
+  #   * update_attributes
+  #   * find_by_*
+  #   * create
+  #   * new
+  #   * save
+  #   * delete
+  #   * find_or_initialize_by_naname
+  #
+  class Page < Adapters::ActiveModel::Callback
+    include ::ActiveModel::Conversion
+    extend ::ActiveModel::Naming
+    
+
+    # static
+    class << self
+      # Gets / Sets the gollum page
+      #
+      attr_accessor :gollum_page
+
+      # Sets the validator
+      attr_writer :validator
+
+    end
+    # Initializes a new Page
+    #
+    # attrs - Hash of attributes
+    #
+    # commit must be given to perform any page action!
+    def initialize(attrs = {})
+      attrs.each{|k,v| self.instance_variable_set("@#{k}", v)}
+      attrs.each{|k,v| self.class.validator.instance_variable_set("@#{k}", v)}
+    end
+
+    #########
+    # Setters
+    #########
+     
+    # Sets the wiki instance
+    attr_writer :wiki
+
+    # Sets the pages name
+    attr_writer :name
+
+    # Sets the contents content
+    attr_writer :content
+
+    # Sets the commit Hash
+    attr_writer :commit
+
+    # Sets the format
+    attr_writer :format
+
+    # Sets the page
+    attr_writer :page
+    
+    #########
+    # Getters
+    #########
+
+    # Gets the wiki instance
+    def wiki
+      @wiki || Adapters::Gollum::Connector.wiki_class.class_variable_get(:@@wiki)
+    end
+
+    # Gets the pages' name
+    def name
+      @name || @gollum_page.name
+    end
+
+    # Gets the raw content of the current page
+    def content
+      @content || @gollum_page.raw_content
+    end
+
+    # Need to implement the Committer connector (forgot it completely)
+    # Gets the commit Hash from current object
+    def commit
+      @commit
+    end
+
+    # Gets the pages format
+    def format
+      (@format || @gollum_page.format).to_sym
+    end
+
+    # Gets the validator
+    def self.validator
+      @@validator ||= Adapters::ActiveModel::Validation.new
+    end
+
+    # Gets the page class
+    def page
+      @page ||= Adapters::Gollum::Connector.page_class.new
+    end
+    
+    # Statically page getter
+    #
+    # DEPRECATED! Do not use
+    def self.page
+      Adapters::Gollum::Connector.page_class
+    end
+
+    #############
+    # activemodel
+    #############
+
+    # Handles the connection betweet plain activemodel and Gollum
+    # Saves current page in GIT wiki
+    # If another page with the same name is existing, gollum_rails
+    # will detect it and returns that page instead.
+    #
+    # Examples:
+    #   
+    #   obj = GollumRails::Page.new <params>
+    #   @article = obj.save
+    #   # => Gollum::Page
+    #   
+    #   @article.name
+    #   whatever name you have entered OR the name of the previous 
+    #   created page
+    #       
+    #
+    # TODO:
+    #   * overriding for creation(duplicates)
+    #   * do not alias save! on save 
+    # 
+    # Returns an instance of Gollum::Page or false
+    def save
+      begin
+        page.instance_variable_set("@page", page.new_page(name, content, format, commit)) if valid?
+        return page.page||false
+      rescue ::Gollum::DuplicatePageError => e 
+        page.instance_variable_set "@page",page.find_page(name)
+        return page.page 
+      end
+    end
+
+    # aliasing save
+    #
+    # TODO:
+    #   * implement full method!
+    alias_method :save!, :save
+
+    # first creates an instance of itself and executes the save function.
+    #
+    # hash - Hash containing the page data
+    #
+    #
+    # Returns an instance of Gollum::Page or false
+    def self.create(hash)
+      page = Page.new hash
+      page.save
+    end
+
+    # calls `create` on current class. If returned value is nil an exception will be thrown
+    #
+    # hash - Hash containing the page data
+    #
+    # TODO:
+    #   * much testing
+    #
+    # Returns an instance of Gollum::Page
+    def self.create!(hash)
+      action = self.create(hash)
+      if action.nil? or action.is_a? Adapters::ActiveModel::Boolean
+        raise GollumInternalError, "Page is nil"
+      end
+      action
+    end
+
+    # Updates an existing page (or created)
+    #
+    # 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 Gollum::Page 
+    def update_attributes(hash, commit=nil)
+      page.update_page hash, get_right_commit(commit)
+    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)
+      page.delete_page get_right_commit(commit)
+    end
+
+    # Previews the page - Mostly used if you want to see what you do before saving
+    # 
+    # 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
+    #
+    # 
+    # format - Specify the format you want to render with see {self.format_supported?}
+    #          for formats
+    #
+    # Returns a String
+    def preview(format=:markdown)
+      preview = wiki.preview_page @name, @content, format
+      preview.formatted_data
+    end
+
+    # Finds a page based on the name and specified version
+    #
+    # name - the name of the page
+    #
+    # Return an instance of Gollum::Page
+    def self.find(name)
+      page = GollumRails::Adapters::Gollum::Page.new
+      page.find_page name
+    end
+
+    # todo
+    def valid?
+      self.class.validate self,true
+    end
+    
+    # todo
+    def self.validate(context=nil,check=false,&block)
+      if block
+        @@gollum_page = block
+      end
+      if check
+        @@gollum_page.call context.class.validator 
+      end
+    end
+
+    # todo
+    def self.register_validations_for(*args)
+    end
+
+
+    # module templates following:
+
+    # empty
+    #def self.method_missing(name, *args)
+    #  
+    #end
+
+    # empty
+    #def method_missing(name, *args)
+    #end
+    
+    # Finds an existing page or creates it
+    #
+    # Returns self
+    def self.find_or_initialize_by_name(name, commit)
+      result_for_find = self.find(name)
+      self.create({:format => :markdown, :name => name, :content => ".", :commit => commit })
+    end
+
+    def self.format_supported?(format)
+      supported = ['ascii', 'github-markdown','markdown', 'creole', 'org', 'pod', 'rdoc']
+      format.in?(supported)
+    end
+
+    private
+
+    # Get the right commit out of 2 commits
+    #
+    # commit_local - local commit Hash
+    #
+    # Returns local_commit > class_commit
+    def get_right_commit(commit_local)
+      com = commit if commit_local.nil?
+      com = commit_local if !commit_local.nil?
+      return com
+    end
+
+  end
+ end