ribit 0.3.0

data/lib/ribit/contentstore.rb

@@ -0,0 +1,406 @@
+#--
+#    Copyright (C) 2004-2005 Tero Vuorela   
+#
+#    This program is free   This program is free software; you can redistribute it and/or modify it
+#    under the terms of the GNU General Public License as published by the Free
+#    Software Foundation; either version 2 of the License, or (at your option)
+#    any later version.
+#
+#    This program is distributed in the hope that it will be useful, but WITHOUT
+#    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+#    more details.
+#
+#    You should have received a copy of the GNU General Public License along with
+#    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+#    Place - Suite 330, Boston, MA 02111-1307, USA.
+#++
+
+require 'fileutils'
+require 'common/cvs'
+require 'ribit/ribitlogger'
+require 'ribit/ribitdata'
+require 'ribit/constants'
+
+module Ribit
+  
+  module Repository
+    CVS_PROJECT_NAME = 'content'
+    
+    #
+    def init( ribitConfig )
+      raise RuntimeError, 'init() not implemented', caller
+    end
+    
+    #
+    def add_to_repository( directory, fileName, msg )
+      raise RuntimeError, 'add_to_repository() not implemented', caller
+    end
+    
+    #
+    def commit_to_repository( fileName )
+      raise RuntimeError, 'commit_to_repository() not implemented', caller
+    end
+    
+  end
+  
+  ##
+  #
+  class CVSRepository
+    include Repository
+  
+    #
+    def initialize
+      @logger = RibitLogger.new( CVSRepository )
+    end
+    
+    #
+    def init( ribitConfig, dataPath )
+      @ribitConfig = ribitConfig
+      @dataPath = dataPath
+      
+      # if no CVSROOT defined then we don't store to CVS    
+      if ( ribitConfig[RibitConfig::CVSROOT] == nil )
+        @cvsroot = nil
+        @logger.info( "No CVSROOT defined" )
+      else
+        # Yes, CVSROOT is defined 
+	    @cvsroot = resolve_absolute_cvsroot_path( ribitConfig[RibitConfig::CVSROOT] )
+	    @logger.info( "Using CVS repository in #{@cvsroot}" )
+	    
+	    prepare_cvs
+      end
+    end
+
+    #
+    def add_to_repository( directory, fileName, msg )
+      @cvs.add( directory, fileName, msg )
+    end
+    
+    #
+    def commit_to_repository( fileName )
+      # construct proper path
+      #  => find where 'content' is and take rest
+      @logger.debug( "Storing the file: #{fileName}" )
+      
+      parts = []
+      contentFound = false
+      fileName.split( Constants::PATH_SEPARATOR ).each do |part|
+        if ( contentFound )
+          parts.push( part )
+        elsif ( part == CVS_PROJECT_NAME )
+          contentFound = true
+        end
+      end
+      
+      commitPath = parts.join( Constants::PATH_SEPARATOR )      
+      @logger.debug( "The commit path is: #{commitPath}" )
+
+      @cvs.commit( @dataPath, commitPath, '' )
+    end
+        
+private
+    #
+    def prepare_cvs
+	  @cvs = CVS::CVS.new( { 'cvsroot' => @cvsroot } )
+      
+      # now if repository doesn't exist then create it    
+      if ( !File.exist?( @cvsroot ) )
+        @cvs.init
+      end
+      
+	  # then does CVS contain proper project
+	  projectInCVS = File.join( @cvsroot, CVS_PROJECT_NAME )
+      if ( !File.exist?( projectInCVS ) )  
+      
+        # insert current data files to CVS
+        @cvs.import( 
+          'initial import during startup', 
+          CVS_PROJECT_NAME, 
+          @dataPath, 
+          'ribit' )
+        
+        # move the initial directory to different name
+        FileUtils.rm_rf( @dataPath )
+        # checkout the project
+        @cvs.checkout( CVS_PROJECT_NAME, File.dirname( @dataPath ) )
+      else
+        # the repository exists => make sure everything is committed    
+        status = @cvs.query_update( @dataPath )
+      
+        status.modified.each do |f|
+          @cvs.commit( @dataPath, f, '' )
+        end
+        status.added.each do |f|
+          @cvs.commit( @dataPath, f, '' )
+        end
+        status.new.each do |f|
+          @cvs.add( @dataPath, f, '' )
+          @cvs.commit( @dataPath, f, '' )
+        end      
+      
+      end
+    end
+         
+    #
+    def resolve_absolute_cvsroot_path( path )
+      # the path could be relative, so we need absolute path
+      oldPath = FileUtils.pwd
+      # this throws exception if path doesn't exit
+      FileUtils.cd( File.dirname( path ) )
+      absPath = FileUtils.pwd
+      FileUtils.cd( oldPath )
+      
+      return File.join( absPath, File.basename( path ) )
+    end
+    
+  end
+  
+  ##
+  #
+  class ContentStore
+    # implements IDataStorage
+    include IDataStorage
+    
+    #
+    def initialize( ribitConfig, repository )
+      @logger = RibitLogger.new( ContentStore )
+      @ribitConfig = ribitConfig
+      @dataPath = File.join( ribitConfig[RibitConfig::DATA_PATH], Repository::CVS_PROJECT_NAME )
+      
+      @repository = repository
+      @repository.init( ribitConfig, @dataPath )
+    end
+    
+    #
+    def get_ribit_data
+      contentDir = get_content_dir
+      @logger.info( "Reading data from #{contentDir}" )
+      
+      categoryParser = RibitData::CategoryParser.new( contentDir )
+      categories = categoryParser.parse_categories
+      
+      # RibitData will later use self object for saving
+      ribitData = RibitData::RibitData.new( self )
+      pageParser = RibitData::PageParser.new( contentDir )
+      parse_categories( pageParser, ribitData, categories )
+      
+      return ribitData
+    end
+    
+    #
+    def parse_categories( pageParser, ribitData, categories )
+      categories.each do |category|
+        # adds pages to category
+        pageParser.parse_pages( category )
+        ribitData.add_category( category )
+        
+        # process child categories
+        parse_categories( pageParser, ribitData, category.get_child_categories )
+      end
+    end
+    
+    # 
+    def save_page( page )
+      contentDir = get_content_dir
+      categoryDir = File.join( contentDir, page.category.id )
+      fileName = File.join( categoryDir, page.id + '.xml' )
+            
+      # is the file new ? (we need this information later)
+      newFile = !File.exist?( fileName )
+      
+      writer = FileWriter.new( fileName )
+      writer.write( page )
+
+      # is the file in CVS ?
+      if ( newFile )
+        # no => add it before commit
+        @logger.debug( "Adding page file to repository: #{fileName}" )
+        @repository.add_to_repository( categoryDir, File.basename( fileName ), 'new page created' )
+      end
+      
+      @repository.commit_to_repository( fileName )
+      
+      # do data reloading if configured   
+      if ( @ribitConfig[RibitConfig::DATA_RELOAD] == 'true' )
+        @logger.info( "Reloading is true => reload saved page #{page.full_id}" )
+        
+        # reloading happends first by deleting old page and then adding it again to category
+        pageParser = RibitData::PageParser.new( contentDir )
+        
+        category = page.category
+        category.remove_page( page.id )
+        
+        pageParser.parse_page( category, fileName )
+      end
+      
+    end
+    
+    #
+    def get_content_dir
+      return File.join( @ribitConfig[RibitConfig::DATA_PATH], Repository::CVS_PROJECT_NAME )
+    end
+    
+    #
+    def save_categories_hierarchy( ribitData )
+      contentDir = get_content_dir
+      categories = RibitData::CategoriesWriter.new( ribitData )
+      
+      fileName = File.join( contentDir, RibitData::CategoryParser::CATEGORIES_XML_FILE )
+      
+      writer = FileWriter.new( fileName )
+      writer.write( categories )
+      
+      # assuming that categories.xml already exists in CVS
+      @repository.commit_to_repository( fileName )
+      
+      # NOTE: reloading is actually same as validating => we load categories
+      #       and compare structure to existing 
+      if ( @ribitConfig[RibitConfig::DATA_RELOAD] == 'true' )
+        @logger.info( "Reloading is true => validate category hierarchies" )
+        
+        categoryParser = RibitData::CategoryParser.new( contentDir )
+        # TODO: BUG: parse_categories returns only root categories
+        categories = categoryParser.parse_categories
+        
+        # build a map to make comparison easier
+        categoriesMap = {}
+        categories.each do |cat|
+          categoriesMap[cat.id.to_s] = cat
+          categoriesMap.merge!( get_child_categories( cat ) )
+          print "ON DISK=#{cat.id}\n"
+        end
+
+        # 'categories' contains now all possible categories
+        #  => get same kind of list from the current RibitData and compare
+        existingCategories = ribitData.get_all_categories
+        
+        existingCategories.each do |cat|
+            #print "################ MEMORY=#{cat.id}\n"
+
+            reloadCategory = categoriesMap.delete( cat.id.to_s )
+            if ( reloadCategory == nil )
+              raise RibitException, "On the disk there is no category ID=#{cat.id} that is in memory", caller
+            end
+            
+            # check parent
+            if ( cat.get_parent_category == nil and reloadCategory.get_parent_category == nil )
+              # OK
+            elsif ( cat.get_parent_category.id == reloadCategory.get_parent_category.id )
+              # OK
+            else
+              raise RibitException, "Hierarchy structure on the disk and in memory doesn not match: categoryID=#{cat.id}", caller
+            end
+        end
+
+        # if everything matched then categoriesMap should be empty now
+        if ( not categoriesMap.empty? )
+          raise RibitException, "There are more categories on the disk than in memory", caller
+        end
+        
+      end 
+    end
+    
+    #
+    def save_category( category )
+      contentDir = get_content_dir
+      categoryDir = File.join( contentDir, category.id )
+      categoryFileName = File.join( categoryDir, RibitData::CategoryParser::CATEGORY_XML_FILE )
+      
+      # if this category is new then we need to create directory
+      if ( not File.exist?( categoryDir ) )
+        FileUtils.mkdir( categoryDir )
+        @repository.add_to_repository( contentDir, category.id, '' )
+      end
+      
+      fileExists = File.exist?( categoryFileName )
+      writer = FileWriter.new( categoryFileName )
+      writer.write( category )
+      
+      if ( not fileExists )
+        @logger.debug( "Adding category file to repository: #{categoryFileName}" )
+        @repository.add_to_repository( categoryDir, File.basename( categoryFileName ), 'new category created' )
+      end
+      
+      @repository.commit_to_repository( categoryFileName )  
+      
+      # do data reloading if configured   
+      if ( @ribitConfig[RibitConfig::DATA_RELOAD] == 'true' )
+        @logger.info( "Reloading is true => reload saved category ID=#{category.id}" )
+        
+        # category hierarchies has not been changed, only contents of category.xml
+
+        categoryParser = RibitData::CategoryParser.new( contentDir )
+        reloadedCategory = categoryParser.parse_category( category.id )
+        
+        category.name = reloadedCategory.name
+        category.set_main_page_id( reloadedCategory.get_main_page_id )
+      end
+      
+    end
+    
+  private
+    #
+    def get_child_categories( category )
+      children = {}
+      category.get_child_categories.each do |child|
+        children[child.id.to_s] = child
+        children.merge!( get_child_categories( child ) )
+      end
+      
+      return children
+    end
+    
+  end # end of class
+
+  ##
+  # Class for writing data to XML format.
+  class Writer
+
+    #
+    def initialize
+      @logger = RibitLogger.new( Writer )
+    end
+  
+    # Returns data in XML format. Expects data object to implement to_document()
+    def write( data )
+      doc = data.to_document
+      outputStr = ''
+      doc.write( outputStr, 0 )
+      return outputStr  
+    end
+
+  end
+
+  ##
+  # Writer that writes to a file
+  class FileWriter < Writer
+
+    #
+    def initialize( fileName )
+      super()
+      @fileName = fileName
+    end
+  
+    #
+    def write( data )
+      # get data to variable. This problems in writing XML doesn't
+      # corrupt our file
+      data = super( data )
+      stream = File.new( @fileName, 'w' )
+      begin 
+        stream << data
+        stream.flush
+      rescue Exception => exception
+        @logger.error( 'Writing failed: ' + exception.to_s )
+        raise exception
+            
+      ensure
+        @stream.close unless @stream.nil?
+      end
+    
+    end
+  
+  end
+  
+end # end of module

data/lib/ribit/localization.rb

@@ -0,0 +1,76 @@
+#--
+#    Copyright (C) 2004-2005 Tero Vuorela
+#
+#    This program is free software; you can redistribute it and/or modify it
+#    under the terms of the GNU General Public License as published by the Free
+#    Software Foundation; either version 2 of the License, or (at your option)
+#    any later version.
+#
+#    This program is distributed in the hope that it will be useful, but WITHOUT
+#    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+#    more details.
+#
+#    You should have received a copy of the GNU General Public License along with
+#    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+#    Place - Suite 330, Boston, MA 02111-1307, USA.
+#++
+
+require 'ribit/common'
+
+##
+#
+module Localization
+	# insert localization keys here as constants
+	ACTION_SAVE_OK = 'action.saving_ok'
+	ACTION_SAVE_CATEGORY_OK = 'action.saving_category_ok'
+	ACTION_NEW_PAGE_OK = 'action.create_new_page_ok'
+	ACTION_EDIT_CANCELED = 'action.edit_canceled'
+	ACTION_CATEGORY_CREATION_NOTICE = 'action.category_creation_notice'
+	ACTION_DEFAULT_PAGE_FAILED = 'action.default_page_failed'
+	
+	TITLE_NEW_PAGE = 'title.new_page'
+	TITLE_NEW_CATEGORY = 'title.new_category'
+	TITLE_CATEGORIES_PAGE = 'title.categories_page'
+	
+	NO_PARENT_OPTION = 'option.no_parent'
+	
+	#
+    def get_localized( name, params={} )
+      if ( not ribitData_defined? )
+        raise RibitException, "No @ribitData defined for the class", caller
+      end
+
+	  str = @ribitData.get_localization().get( name )	
+      
+      if ( str == nil )
+        return '(text not found)'
+      end
+      
+	  str.gsub!( /\#\{[a-zA-Z_0-9]+\}/ ) do |matchStr|
+        # extract var name
+        varMatch = /\{([a-zA-Z_0-9]+)\}/.match( matchStr )
+        varName = varMatch[1]
+        value = params[varName]
+        if ( value == nil )
+          value = '(nil)'
+        end
+        
+        value
+      end
+      
+      str
+	end
+    
+	#
+    def ribitData_defined?
+      begin
+        instance_variable_get( :@ribitData )
+        return true
+      rescue NameError => error
+        return false
+      end
+   end
+   
+end
+