parlement 0.1

data/lib/data_import.rb

@@ -0,0 +1,54 @@
+# This is to load initial data
+
+require 'iconv'
+require 'config/environment'
+
+dir = 'db/ROOT'
+
+ICONV = Iconv.new('UTF-8', 'ISO-8859-15')    
+
+def inputDir(directory)
+	Dir.glob(directory+'/*.txt') do |file|
+		dir = directory+'/'+file
+		inputFile File.basename(directory), file
+	end
+
+	Dir.foreach(directory) do |d|
+		if (d != '.' and d != '..')
+		dir = directory+'/'+d
+			if (File.directory?(dir) or File.symlink?(dir))
+				#puts 'dir: '+dir
+				inputDir dir
+			end
+		end
+	end
+end
+
+def inputFile(d, fileName)
+	puts 'Loading: '+fileName
+
+	elt = Elt.find_by_id(File.basename(fileName).gsub(/.txt/, ''))
+
+	file = File.new(fileName)
+
+	if elt == nil
+		elt = Elt.new
+		elt.id = File.basename(fileName).gsub(/.txt/, '')
+		elt.created_on = nil
+	end
+
+	if elt.created_on == nil or elt.created_on < file.mtime
+		elt.parent_id = d
+		elt.created_on = file.mtime
+		puts elt.created_on.class
+		elt.subject = ICONV.iconv(file.gets.strip)
+		elt.body = format(ICONV.iconv(file.gets('\n')))
+		print "subject: "+elt.subject
+		#puts "body: "+elt.body
+		puts " (created_on: "+elt.created_on.to_s+")"
+		elt.save
+	end
+end
+
+inputDir dir
+

data/lib/file_column.rb

@@ -0,0 +1,263 @@
+require 'fileutils'
+require 'tempfile'
+
+module FileColumn # :nodoc:
+    def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+    end
+    
+    # The FileColumn module allows you to easily handle file uploads. You can designate
+    # one or more columns of your model's table as "file columns" like this:
+    #
+    #   class Entry < ActiveRecord::Base
+    #
+    #     file_column :image
+    #   end
+    #
+    # Now, by default, an uploaded file "test.png" for an entry object with primary key 42 will
+    # be stored in in "public/entry/image/42/test.png". The filename "test.png" will be stored
+    # in the record's +image+ column.
+    #
+    # The methods of this module are automatically included into ActiveRecord::Base as class
+    # methods, so that you can use them in your models.
+    #
+    # == Generated Methods
+    #
+    # After calling "<tt>file_column :image</tt>" as in the example above, a number of instance methods
+    # will automatically be generated, all prefixed by "image":
+    #
+    # * <tt>Entry#image=(uploaded_file)</tt>: this will handle a newly uploaded file (see below). Note that
+    #   you can simply call your upload field "entry[image]" in your view (or use the helper).
+    # * <tt>Entry#image</tt>: This will return an absolute path (as a string) to the currently uploaded file
+    #   or nil if no file has been uploaded
+    # * <tt>Entry#image_relative_path</tt>: This will return a path relative to this file column's base 
+    #   directory
+    #   as a string or nil if no file has been uploaded. This would be "42/test.png" in the example.
+    # * <tt>Entry#image_just_uploaded?</tt>: Returns true if a new file has been uploaded to this instance.
+    #   You can use this in <tt>before_validation</tt> to resize images on newly uploaded files, for example.
+    #
+    # You can access the raw value of the "image" column (which will contain the filename) via the
+    # <tt>ActiveRecord::Base#attributes</tt> or <tt>ActiveRecord::Base#[]</tt> methods like this:
+    #
+    #   entry['image']    # e.g."test.png"
+    #
+    # == Storage of uploaded file
+    #
+    # For a model class +Entry+ and a column +image+, all files will be stored under
+    # "public/entry/image". A sub-directory named after the primary key of the object will
+    # be created, so that files can be stored using their real filename. For example, a file
+    # "test.png" stored in an Entry object with id 42 will be stored in
+    #
+    #   public/entry/image/42/test.png
+    #
+    # Files will be moved to this location in an +after_save+ callback. They will be stored in
+    # a temporary location previously as explained in the next section.
+    #
+    # == Handling of form redisplay
+    #
+    # Suppose you have a form for creating a new object where the user can upload an image. The form may
+    # have to be re-displayed because of validation errors. The uploaded file has to be stored somewhere so
+    # that the user does not have to upload it again. FileColumn will store these in a temporary directory
+    # (called "tmp" and located under the column's base directory by default) so that it can be moved to
+    # the final location if the object is successfully created. If the form is never completed, though, you
+    # can easily remove all the images in this "tmp" directory once per day or so.
+    #
+    # So in the example above, the image "test.png" would first be stored in 
+    # "public/entry/image/tmp/<some_random_key>/test.png" and be moved to
+    # "public/entry/image/<primary_key>/test.png".
+    #
+    # This temporary location of newly uploaded files has another advantage when updating objects. If the
+    # update fails for some reasons (e.g. due to validations), the existing image will not be overwritten, so
+    # it has a kind of "transactional behaviour".
+    module ClassMethods
+    
+        DEFAULT_OPTIONS = {
+            "root_path" => File.join(RAILS_ROOT, "public"),
+            "web_root" => ""
+        }.freeze
+        
+        # handle one or more attributes as "file-upload" columns, generating additional methods as explained
+        # above. You should pass the names of the attributes as symbols, like this:
+        #
+        #   file_column :image, :another_image
+        def file_column(*args)
+            options = DEFAULT_OPTIONS.dup
+            options.update(args.pop) if args.last.is_a?(Hash)
+            
+            options["base_path"] ||= File.join(options["root_path"], Inflector.underscore(self.name).to_s)
+            options["base_url"] ||= options["web_root"]+"/"+Inflector.underscore(self.name).to_s+"/"
+            args.each do |attr|
+                store_dir = File.join(options["base_path"], attr.to_s)
+                tmp_base_dir = File.join(store_dir, "tmp")
+                FileUtils.mkpath([store_dir,tmp_base_dir])
+                
+                column_attr = attr.to_s
+                column_read_method = attr.to_sym
+                column_write_method = (attr.to_s+"=").to_sym
+                read_temp_method = "#{attr}_temp".to_sym
+                write_temp_method = "#{attr}_temp=".to_sym
+                column_relative_path_method = (attr.to_s+"_relative_path").to_sym
+                column_options_method = "#{attr}_options".to_sym
+                just_uploaded_method = "#{attr}_just_uploaded?".to_sym
+                
+                # symbols for callback methods
+                column_after_save_method = (attr.to_s+"_after_save").to_sym
+                column_after_destroy_method = (attr.to_s+"_after_destroy").to_sym
+                
+                tmp_dir_attribute = "@#{attr}_temp".to_sym
+                just_uploaded_attribute = "@#{attr}_just_uploaded".to_sym
+                
+                define_method column_read_method do
+                    relative_path = self.send column_relative_path_method
+                    return nil unless relative_path
+                    File.join(store_dir, relative_path)
+                end
+                
+                define_method column_relative_path_method do
+                    filename = read_attribute column_attr
+                    return nil unless filename and !filename.empty?
+                    tmp_dir = instance_variable_get tmp_dir_attribute
+                    if tmp_dir
+                        File.join("tmp",tmp_dir,filename)
+                    else
+                        File.join(self.id.to_s,filename)
+                    end
+
+                end
+                
+                define_method column_write_method do |file|
+                    if file.nil? and read_attribute(column_attr)
+                        if (tmp_dir = instance_variable_get tmp_dir_attribute)
+                            # delete temporary image immediately
+                            FileColumn.remove_file_with_dir(File.join(tmp_base_dir,tmp_dir,
+                                read_attribute(column_attr)))
+                            remove_instance_variable tmp_dir_attribute
+                        end
+                        write_attribute column_attr, nil
+                    end
+                    return nil unless file and file.size > 0
+                    
+                    tmp_dir = FileColumn.generate_temp_name
+                    FileUtils.mkdir(File.join(tmp_base_dir, tmp_dir))
+                    
+                    filename = FileColumn::sanitize_filename(file.original_filename)
+                    local_file_path = File.join(tmp_base_dir,tmp_dir,filename)
+                    
+                    # stored uploaded file into local_file_path
+                    # If it was a Tempfile object, the temporary file will be
+                    # cleaned up automatically, so we do not have to care for this
+                    if file.respond_to?(:local_path) and file.local_path and File.exists?(file.local_path)
+                        FileUtils.copy_file(file.local_path, local_file_path)
+                    elsif file.respond_to?(:read)
+                        File.open(local_file_path, "wb") { |f| f.write(file.read) }
+                    else
+                        raise ArgumentError.new("Do not know how to handle #{file.inspect}")
+                    end
+                    
+                    # if there already was an old temporary file, remove it
+                    if (old_tmp_dir = instance_variable_get tmp_dir_attribute)
+                        FileColumn.remove_file_with_dir(File.join(tmp_base_dir,old_tmp_dir,
+                            read_attribute(column_attr)))
+                    end
+                    
+                    instance_variable_set tmp_dir_attribute, tmp_dir
+                    write_attribute column_attr, filename
+                    instance_variable_set just_uploaded_attribute, true
+                end
+                
+                define_method read_temp_method do
+                    tmp_dir = instance_variable_get tmp_dir_attribute
+                    return nil unless tmp_dir
+                    File.join(tmp_dir, read_attribute(column_attr))
+                end
+                
+                define_method write_temp_method do |temp_path|
+                    return nil if temp_path == ""
+                    raise ArgumentError.new("invalid format of '#{temp_path}'") unless temp_path =~ %r{^((\d+\.)+\d+)/([^/].+)$}
+                    tmp_dir, filename = $1, FileColumn.sanitize_filename($3)
+                    
+                    if instance_variable_get(tmp_dir_attribute).nil?
+                        instance_variable_set tmp_dir_attribute, tmp_dir
+                        write_attribute column_attr, filename
+                    else
+                        # if tmp_dir_attribute is already set we have already uploaded
+                        # a new file via column=, which takes precedence over the old
+                        # temporary image. However, we can clean up the old image right now
+                        FileColumn.remove_file_with_dir(File.join(tmp_base_dir,tmp_dir,filename))
+                    end
+                end
+                
+                define_method column_after_save_method do
+                    if instance_variable_get tmp_dir_attribute
+                        # we have a newly uploaded image, move it to the correct location
+                        
+                        # create a directory named after the primary key, first
+                        dir = File.join(store_dir,self.id.to_s)
+                        FileUtils.mkdir(dir) unless File.exists?(dir)
+                        
+                        # move the temporary file over
+                        local_path = self.send(column_read_method)
+                        FileUtils.mv local_path, dir
+                        
+                        # remove all old files in the directory
+                        # we do this _after_ moving the file to avoid a short period of
+                        # time where none of the two files is available
+                        filename = File.basename(local_path)
+                        FileUtils.rm(
+                            Dir.entries(dir).reject!{ |e| [".",".."].include?(e) or e == filename }.
+                                collect{ |e| File.join(dir,e) }
+                        )
+                        
+                        # cleanup temporary file
+                        Dir.rmdir(File.dirname(local_path))
+                        remove_instance_variable tmp_dir_attribute
+                    elsif read_attribute(column_attr).nil?
+                        # we do not have a file stored anymore, make sure
+                        # to remove it from disk if needed
+                        FileUtils.rm_rf File.join(store_dir, self.id.to_s)
+                    end
+                end
+                after_save column_after_save_method
+                
+                define_method column_after_destroy_method do
+                    local_path = self.send(column_read_method)
+                    FileColumn.remove_file_with_dir(local_path) if local_path
+                end
+                after_destroy column_after_destroy_method
+                
+                define_method just_uploaded_method do
+                    instance_variable_get just_uploaded_attribute
+                end
+                
+                define_method column_options_method do
+                    options
+                end
+                
+                private column_after_save_method, column_after_destroy_method
+            end
+        end
+        
+    end
+    
+    private
+        
+    def self.generate_temp_name
+        now = Time.now
+        "#{now.to_i}.#{now.usec}.#{Process.pid}"
+    end
+    
+    def self.sanitize_filename(filename)
+        filename = File.basename(filename.gsub("\\", "/")) # work-around for IE
+        filename.gsub(/[^a-zA-Z0-9\.\-\+_]/,"_")
+        filename = "_#{filename}" if filename =~ /^\.+$/
+        filename
+    end
+    
+    def self.remove_file_with_dir(path)
+        return unless File.file?(path)
+        FileUtils.rm_f path
+        dir = File.dirname(path)
+        Dir.rmdir(dir) if File.exists?(dir)
+    end
+end

data/lib/file_column_helper.rb

@@ -0,0 +1,45 @@
+# This module contains helper methods for displaying and uploading files
+# for attributes created by +FileColumn+'s +file_column+ method. It will be
+# automatically included into ActionView::Base, thereby making this module's
+# methods available in all your views.
+module FileColumnHelper
+    
+    # Use this helper to create an upload field for a file_column attribute. This will generate
+    # an additional hidden field to keep uploaded files during form-redisplays. For example,
+    # when called with
+    #
+    #   <%= file_column_field("entry", "image") %>
+    #
+    # the following HTML will be generated (assuming the form is redisplayed and something has
+    # already been uploaded):
+    #
+    #   <input type="hidden" name="entry[image_temp]" value="..." />
+    #   <input type="file" name="entry[image]" />
+    #
+    # You can use the +option+ argument to pass additional options to the file-field tag.
+    def file_column_field(object, method, options={})
+        result = ActionView::Helpers::InstanceTag.new(object, method.to_s+"_temp", self).to_input_field_tag("hidden", {})
+        result << ActionView::Helpers::InstanceTag.new(object, method, self).to_input_field_tag("file", options)
+    end
+    
+    # Creates an URL where an uploaded file can be accessed. When called for an Entry object with
+    # id 42 like this
+    #
+    #   <%= url_for_file_column("entry", "image")
+    #
+    # the follwoing URL will be produced, assuming the file "test.png" has been stored in
+    # the "image"-column:
+    #
+    #  /entry/image/42/test.png
+    #
+    # This will produce a valid URL even for temporary uploaded files, e.g. files where the object
+    # they are belonging to has not been saved in the database yet.
+    def url_for_file_column(object_name, method)
+        object = instance_variable_get("@#{object_name.to_s}")
+        url = ""
+        url << @request.relative_url_root.to_s
+        url << object.send("#{method}_options")["base_url"]
+        url << "#{method}/"
+        url << object.send("#{method}_relative_path")
+    end
+end

data/lib/localization.rb

@@ -0,0 +1,88 @@
+require 'iconv'
+
+module Localization
+  
+  LOCALIZED_STRINGS = {}
+
+  def l(symbol, *arguments)
+    language = CONFIG[:default_language]
+
+    symbol = symbol.to_sym if symbol.is_a? String
+
+    # translation of an LString is simply a call to to_s
+    return symbol.to_s if symbol.is_a? LString
+  
+    # translation of an array
+    if symbol.is_a? Array 
+      raise ArgumentError.new("Cannot translate an empty array") if symbol.empty?
+      raise ArgumentError.new("Symbol is an array, arguments must be empty") unless arguments.empty?
+      arguments = symbol
+      symbol = arguments.shift
+    end
+
+    begin
+      translation = (LOCALIZED_STRINGS[language][symbol] or
+                       LOCALIZED_STRINGS['en'][symbol] or
+                       symbol.to_s)
+    rescue
+      translation = symbol.to_s
+    end
+
+    begin
+      return translation % arguments
+    rescue => e
+      raise ArgumentError.new("Translation value #{translation.inspect} " + 
+          "with arguments #{arguments.inspect} caused error '#{e.message}'")
+    end
+  end
+
+  def valid_language?(language)
+    LOCALIZED_STRINGS.has_key? language
+  end
+
+  def self.load_localized_strings
+    # Load language files
+    Dir[RAILS_ROOT + '/lang/*.yaml'].each do |filename|
+      filename =~ /(([a-z]+_?)+)\.yaml$/
+      hash = YAML::load(File.read(filename))
+      file_charset = hash['file_charset'] || 'ascii'
+      lang = $1
+
+      # convert string keys to symbols
+      symbol_hash = Hash.new
+      Iconv.open(CONFIG[:web_charset], file_charset) do |i|
+        hash.each do |key, value|
+          symbol_hash[key.to_sym] = i.iconv(value)
+          if key =~ /^active_record_errors_(.*)/
+            ActiveRecord::Errors.default_error_messages[$1.to_sym] =
+              symbol_hash[key.to_sym]
+          end
+        end
+      end
+
+      LOCALIZED_STRINGS[lang] = symbol_hash
+    end
+  end
+
+  class LString
+  
+    include Localization
+    
+    def initialize(symbol, arguments)
+      @symbol, @arguments = symbol, arguments
+    end
+
+    def to_s
+      l(@symbol, @arguments)
+    end
+  end
+
+  # redefinition of ActionMail::Base#render_message, that adds locale suffix to
+  # the template name
+  ActionMailer::Base.module_eval <<-EOL
+  private
+  def render_message(method_name, body)
+    initialize_template_class(body).render_file(method_name + "_#{CONFIG[:default_language]}")
+  end
+  EOL
+end

data/lib/localizer.rb

@@ -0,0 +1,88 @@
+require 'iconv'
+
+module Localizer
+  
+  LOCALIZED_STRINGS = {}
+
+  def l(symbol, *arguments)
+    language = CONFIG[:default_language]
+
+    symbol = symbol.to_sym if symbol.is_a? String
+
+    # translation of an LString is simply a call to to_s
+    return symbol.to_s if symbol.is_a? LString
+  
+    # translation of an array
+    if symbol.is_a? Array 
+      raise ArgumentError.new("Cannot translate an empty array") if symbol.empty?
+      raise ArgumentError.new("Symbol is an array, arguments must be empty") unless arguments.empty?
+      arguments = symbol
+      symbol = arguments.shift
+    end
+
+    begin
+      translation = (LOCALIZED_STRINGS[language][symbol] or
+                       LOCALIZED_STRINGS['en'][symbol] or
+                       symbol.to_s)
+    rescue
+      translation = symbol.to_s
+    end
+
+    begin
+      return translation % arguments
+    rescue => e
+      raise ArgumentError.new("Translation value #{translation.inspect} " + 
+          "with arguments #{arguments.inspect} caused error '#{e.message}'")
+    end
+  end
+
+  def valid_language?(language)
+    LOCALIZED_STRINGS.has_key? language
+  end
+
+  def self.load_localized_strings
+    # Load language files
+    Dir[RAILS_ROOT + '/lang/*.yaml'].each do |filename|
+      filename =~ /(([a-z]+_?)+)\.yaml$/
+      hash = YAML::load(File.read(filename))
+      file_charset = hash['file_charset'] || 'ascii'
+      lang = $1
+
+      # convert string keys to symbols
+      symbol_hash = Hash.new
+      Iconv.open(CONFIG[:web_charset], file_charset) do |i|
+        hash.each do |key, value|
+          symbol_hash[key.to_sym] = i.iconv(value)
+          if key =~ /^active_record_errors_(.*)/
+            ActiveRecord::Errors.default_error_messages[$1.to_sym] =
+              symbol_hash[key.to_sym]
+          end
+        end
+      end
+
+      LOCALIZED_STRINGS[lang] = symbol_hash
+    end
+  end
+
+  class LString
+  
+    include Localizer
+    
+    def initialize(symbol, arguments)
+      @symbol, @arguments = symbol, arguments
+    end
+
+    def to_s
+      l(@symbol, @arguments)
+    end
+  end
+
+  # redefinition of ActionMail::Base#render_message, that adds locale suffix to
+  # the template name
+  ActionMailer::Base.module_eval <<-EOL
+  private
+  def render_message(method_name, body)
+    initialize_template_class(body).render_file(method_name + "_#{CONFIG[:default_language]}")
+  end
+  EOL
+end

data/lib/login_system.rb

@@ -0,0 +1,87 @@
+require_dependency "user"
+
+module LoginSystem 
+  
+  protected
+  
+  # overwrite this if you want to restrict access to only a few actions
+  # or if you want to check if the user has the correct rights  
+  # example:
+  #
+  #  # only allow nonbobs
+  #  def authorize?(user)
+  #    user.login != "bob"
+  #  end
+  def authorize?(user)
+     true
+  end
+  
+  # overwrite this method if you only want to protect certain actions of the controller
+  # example:
+  # 
+  #  # don't protect the login and the about method
+  #  def protect?(action)
+  #    if ['action', 'about'].include?(action)
+  #       return false
+  #    else
+  #       return true
+  #    end
+  #  end
+  def protect?(action)
+    true
+  end
+   
+  # login_required filter. add 
+  #
+  #   before_filter :login_required
+  #
+  # if the controller should be under any rights management. 
+  # for finer access control you can overwrite
+  #   
+  #   def authorize?(user)
+  # 
+  def login_required
+    
+    if not protect?(action_name)
+      return true  
+    end
+
+    if @session[:user] and authorize?(@session[:user])
+      return true
+    end
+
+    # store current location so that we can 
+    # come back after the user logged in
+    store_location
+  
+    # call overwriteable reaction to unauthorized access
+    access_denied
+    return false 
+  end
+
+  # overwrite if you want to have special behavior in case the user is not authorized
+  # to access the current operation. 
+  # the default action is to redirect to the login screen
+  # example use :
+  # a popup window might just close itself for instance
+  def access_denied
+    redirect_to :controller=>"/account", :action =>"login"
+  end  
+  
+  # store current uri in  the session.
+  # we can return to this location by calling return_location
+  def store_location
+    @session[:return_to] = @request.request_uri
+  end
+
+  # move to the last store_location call or to the passed default one
+  def redirect_back_or_default(default)
+    if @session[:return_to].nil?
+      redirect_to default
+    else
+      redirect_to_url @session[:return_to]
+      @session[:return_to] = nil
+    end
+  end
+
+end

data/lib/rails_file_column.rb

@@ -0,0 +1,19 @@
+# require this file from your "config/environment.rb" (after rails has been loaded)
+# to integrate the file_column extension into rails.
+
+require 'file_column'
+require 'file_column_helper'
+
+
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+    # make file_column method available in all active record decendants
+    include FileColumn
+  end
+end
+
+module ActionView # :nodoc:
+  class Base # :nodoc:
+    include FileColumnHelper
+  end
+end