Module: WikiFlatFileStore

Included in:
Wiki
Defined in:
lib/soks-storage.rb

Constant Summary collapse

CONTENT_EXTENSION = 
'.textile'
REVISIONS_EXTENSION = 
'.yaml'
DEFAULT_AUTHOR = 
'the import script'

Instance Method Summary collapse

Instance Method Details

#check_disk_for_updated_page(pagename, force = false) ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/soks-storage.rb', line 77

def check_disk_for_updated_page( pagename, force = false )
  return unless force || self.check_files_every # We don't care about file changes 
  filename = filename_for_content( pagename )
  return :file_does_not_exist unless File.exists?( filename ) # File doesn't exist on disk
  return load_page( filename ) unless page_named( pagename )# File is new on the disk, but not yet in memory 
  return load_page( filename ) if content_newer_than_revisions?( page_named(pagename) ) # File is newer on disk
  return nil
end

#content_newer_than_revisions?(page) ⇒ Boolean

Returns:

  • (Boolean) 


132
133
134
135
 
# File 'lib/soks-storage.rb', line 132

def content_newer_than_revisions?( page )
  return true if page.empty?
  File.ctime(filename_for_content( page.name )) > File.ctime(filename_for_revisions(page.name))
end

#delete_files_for_page(page_name) ⇒ Object 



68
69
70
 
# File 'lib/soks-storage.rb', line 68

def delete_files_for_page( page_name )
  File.delete( filename_for_content( page_name ), filename_for_revisions( page_name ) )
end

#filename_for_content(pagename) ⇒ Object 



179
180
181
 
# File 'lib/soks-storage.rb', line 179

def filename_for_content( pagename )
  File.join( @folder, "#{pagename.url_encode}#{CONTENT_EXTENSION}" )
end

#filename_for_revisions(pagename) ⇒ Object 



183
184
185
 
# File 'lib/soks-storage.rb', line 183

def filename_for_revisions( pagename )
  File.join( @folder, "#{pagename.url_encode}#{REVISIONS_EXTENSION}" )
end

#load_all_pages ⇒ Object 



52
53
54
55
56
57
58
59
60
61
 
# File 'lib/soks-storage.rb', line 52

def load_all_pages
  move_files_if_names_are_not_url_encoded
  pages_on_disk = Dir[ File.join( @folder, "*#{CONTENT_EXTENSION}" ) ].map { |filename| page_name_for( filename )}
  pages_in_memory = @pages.values.map { |page| page && page.name }
  ( pages_in_memory.compact | pages_on_disk ).each do |pagename| 
    if check_disk_for_updated_page( pagename, true ) == :file_does_not_exist
      revise( pagename, $MESSAGES[:page_deleted], DEFAULT_AUTHOR )
    end
   end
end

#load_content(page) ⇒ Object 



110
111
112
 
# File 'lib/soks-storage.rb', line 110

def load_content( page )
  IO.readlines( filename_for_content( page.name ) ).join
end

#load_page(filename) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/soks-storage.rb', line 86

def load_page( filename )
  mutate( page_name_for( filename ) ) do |page|
    disk_content = load_content( page )
    return nil if disk_content == page.content # No change, disk is the same as memory

    # We now know that the content on disk is different from that in memory
    
    page.revisions = load_revisions( page ) if page.revisions.empty? # Load revisions from disk if none known 
    # assumes disk revisions are ALWAYS up to date with memory?
    
    # We now know what the page content and the page revisions should be. But not if the revisions are up to date 
    if content_newer_than_revisions?( page ) # The textile file has been modified, but the array file has not been updated to match
      page.content = reconstruct_content_from_revisions( page.revisions )
      page.revise( disk_content, DEFAULT_AUTHOR )
      save_last_revision( page )
    else # The textile file and the array file are in sync.
      page.content = disk_content
    end
  
    add_page_to_index( page )
    [ page.revisions.last, :dont_save ]
  end
end

#load_revisions(page) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/soks-storage.rb', line 114

def load_revisions( page )
  return [] unless File.exists?( filename_for_revisions( page.name ) )
  revisions = []
  begin
    File.open( filename_for_revisions( page.name ) ) { |file| 
      YAML.each_document( file ) { |array|
        next unless array.is_a? Array 
        next unless array.size == 4
        next unless array[0].is_a? Integer 
        revisions[ array[0] ] = Revision.new( page, *array ) } 
    }
  rescue
    $LOG.error "Error loading revisions with #{$!.to_s} in file #{page.name}"
  end
  revisions.each_with_index { |r,i| $LOG.error "#{page.name} missing revision #{i}" unless r }
  revisions
end

#move_files_for_page(old_page_name, new_page_name) ⇒ Object 



72
73
74
75
 
# File 'lib/soks-storage.rb', line 72

def move_files_for_page( old_page_name, new_page_name )
  File.rename( filename_for_content( old_page_name ), filename_for_content( new_page_name ) )
  File.rename( filename_for_revisions( old_page_name ), filename_for_revisions( new_page_name ) )
end

#move_files_if_names_are_not_url_encoded ⇒ Object 



143
144
145
146
147
148
149
150
 
# File 'lib/soks-storage.rb', line 143

def move_files_if_names_are_not_url_encoded
  Dir[ File.join( @folder, "*#{CONTENT_EXTENSION}" ) ].each do |filename|
    basename = File.basename( filename, '.*')
    next if basename.url_decode.url_encode == basename # All ok, so no worry
    new_name = File.join( File.dirname(filename), File.unique_filename( File.dirname(filename), basename.url_decode.url_encode +  File.extname( filename) ) )
    File.rename(filename, new_name )
  end
end

#page_name_for(filename) ⇒ Object 



175
176
177
 
# File 'lib/soks-storage.rb', line 175

def page_name_for( filename )
  File.basename( filename, '.*').url_decode  
end

#reconstruct_content_from_revisions(revisions) ⇒ Object 



137
138
139
140
141
 
# File 'lib/soks-storage.rb', line 137

def reconstruct_content_from_revisions( revisions )
  content = []
  revisions.each { |revision| content = Diff::LCS.patch( content, revision.changes, :patch ) }
  content.join("\n")
end

#save(page) ⇒ Object 



63
64
65
66
 
# File 'lib/soks-storage.rb', line 63

def save( page )
  save_content( page )
  save_last_revision( page )
end

#save_all_revisions(page) ⇒ Object 



165
166
167
168
169
170
171
172
173
 
# File 'lib/soks-storage.rb', line 165

def save_all_revisions( page )
  $LOG.warn "Saving all revisions for #{page.name}"
  File.open(filename_for_revisions( page.name ), 'w' ) do |file|
    page.revisions.each do |revision| 
      YAML.dump( revision.to_a, file )
      file.puts # Needed to ensure that documents are separated
    end
  end
end

#save_content(page) ⇒ Object 



152
153
154
 
# File 'lib/soks-storage.rb', line 152

def save_content( page )
  File.open(filename_for_content( page.name ), 'w' ) { |file| file.puts page.content }
end

#save_last_revision(page) ⇒ Object

Appends the last revision onto the yaml file



157
158
159
160
161
162
163
 
# File 'lib/soks-storage.rb', line 157

def save_last_revision( page )
  $LOG.info "Saving revisions for #{page.name}"
  File.open(filename_for_revisions( page.name ), 'a' ) do |file| 
    YAML.dump( page.revisions.last.to_a, file )
    file.puts # Needed to ensure that documents are separated
  end
end