ktec-subtrac 0.1.43 → 0.1.44

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 43
+:patch: 44

data/lib/subtrac.rb

@@ -38,192 +38,16 @@ require 'subtrac/apache'
 require 'subtrac/svn'
 require 'subtrac/trac'
 require 'subtrac/core_ext'
+require 'subtrac/config'
 
 module Subtrac
 
   SUBTRAC_ROOT = "#{File.dirname(__FILE__)}/" unless defined?(SUBTRAC_ROOT)
   SUBTRAC_ENV = (ENV['SUBTRAC_ENV'] || 'development').dup unless defined?(SUBTRAC_ENV)
-  USER_CONFIG_FILE = 'config/user.yml'
-
-  class << self
-
-    # User configured options
-    def server_name
-      @server_name ||= @APP_CONFIG[:server_name]
-    end
-
-    def server_name=(name)
-      @APP_CONFIG[:server_name] = @server_name = name
-    end
-
-    def server_hostname
-      @server_hostname ||= @APP_CONFIG[:server_hostname]
-    end
-
-    def server_hostname=(name)
-      @APP_CONFIG[:server_hostname] = @server_hostname = name
-    end
-
-    def default_client
-      @default_client ||= @APP_CONFIG[:default_client]
-    end
-
-    def default_client=(name)
-      @APP_CONFIG[:default_client] = @default_client = name
-    end
-
-    def default_project
-      @default_project ||= @APP_CONFIG[:default_project]
-    end
-
-    def default_project=(name)
-      puts "Updating default_project to #{name}"
-      @APP_CONFIG[:default_project] = @default_project = name
-    end
-
-    def default_project_type
-      @default_project_type ||= @APP_CONFIG[:default_project_type]
-    end
-
-    def default_project_type=(name)
-      puts "Updating default_project_type to #{name}"
-      @APP_CONFIG[:default_project_type] = @default_project_type = name
-    end
-    
-
-    # Filesystem directories
-    def root
-      Pathname.new(SUBTRAC_ROOT) if defined?(SUBTRAC_ROOT)
-    end
-
-    def public_path
-      @public_path ||= self.root ? File.join(self.root, "public") : "public"
-    end
-    
-    def public_path=(path)
-      @public_path = path
-    end
-
-    def subtrac_path
-      @subtrac_path ||= self.root ? File.join(self.root, "subtrac") : "subtrac"
-    end
-
-    def install_dir
-      @install_dir ||= File.expand_path(@APP_CONFIG[:installation_dir])
-    end
-
-    def install_dir=(name)
-      puts "Setting new install_dir variable to #{name}"
-      @APP_CONFIG[:installation_dir] = @install_dir = name
-    end
-    
-    def apache_conf_dir
-      @apache_conf_dir ||= @APP_CONFIG[:apache_conf_dir]
-    end
-
-    def apache_conf_dir=(name)
-      @APP_CONFIG[:apache_conf_dir] = @apache_conf_dir = name
-    end
-
-    def docs_dir
-      @docs_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:docs])
-    end
-
-    def svn_dir
-      @svn_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:svn])
-    end
-
-    def trac_dir
-      @trac_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:trac])
-    end
-
-    def temp_dir
-      @temp_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:temp])
-    end
-
-    def log_dir
-      @log_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:log])
-    end
-
-    def locations_dir
-      @locations_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:locations])
-    end
-    
-    # Urls
-    def svn_url
-      @svn_url ||= @APP_CONFIG[:urls][:svn]
-    end
-    
-    def trac_permissions
-      @trac_permissions ||= @APP_CONFIG[:trac][:permissions]
-    end
-    
-    # LDAP
-    def enable_ldap
-      @enable_ldap ||= @APP_CONFIG[:ldap][:enable]
-    end
-
-    def enable_ldap=(value)
-      @APP_CONFIG[:ldap][:enable] = @enable_ldap = value
-    end
-
-    def ldap_bind_dn
-      @ldap_bind_dn ||= @APP_CONFIG[:ldap][:bind_dn]
-    end
-
-    def ldap_bind_dn=(value)
-      @APP_CONFIG[:ldap][:bind_dn] = @ldap_bind_dn = value
-    end
-    
-    def ldap_bind_password
-      @ldap_bind_password ||= @APP_CONFIG[:ldap][:bind_password]
-    end
-
-    def ldap_bind_password=(value)
-      @APP_CONFIG[:ldap][:bind_password] = @ldap_bind_password = value
-    end
-    
-    def ldap_bind_host
-      @ldap_bind_host ||= @APP_CONFIG[:ldap][:bind_host]
-    end
-
-    def ldap_bind_host=(value)
-      @APP_CONFIG[:ldap][:bind_host] = @ldap_bind_password = value
-    end
-    
-  end
-
+  
   # Loads the configuration YML file
   def self.load_config
-    # TODO: We need to refactor this code so it will load the default configuration only if one has not been created
-    puts "\n==== Loading configuration file ===="
-    # load configuration file
-    file_path = File.join(subtrac_path, USER_CONFIG_FILE)
-    file_path = File.join(subtrac_path,"/config/config.yml") if not File.exists?(file_path)
-    puts "Attempting to read config file: #{file_path}"
-    begin
-      yamlFile = YAML.load(File.read(file_path))
-    rescue Exception => e
-      raise StandardError, "Config #{file_path} could not be loaded."
-    end
-    if yamlFile
-      if yamlFile[SUBTRAC_ENV]
-        @APP_CONFIG = yamlFile[SUBTRAC_ENV]
-      else
-        raise StandardError, "config/config.yml exists, but doesn't have a configuration for #{SUBTRAC_ENV}."
-      end
-    else
-      raise StandardError, "config/config.yml does not exist."
-    end
-    say("Configuration loaded successfully...")
-  end
-
-  # Write the changes configuration to disk
-  def self.save_config
-    # save the things that might have changed    
-    file_path = File.join(subtrac_path, USER_CONFIG_FILE)
-    user_config = {SUBTRAC_ENV => @APP_CONFIG}
-    open(file_path, 'w') {|f| YAML.dump(user_config, f)}
+    Config.load()
   end
 
   # Install
@@ -235,7 +59,7 @@ module Subtrac
       confirm_default_client = true
     else
       # check where we are installing
-      confirm_or_replace_value(:install_dir,"install_dir")
+      Config.confirm_or_update(:install_dir,"install_dir")
       
       unless !File.directory?(install_dir) 
         # Ask if the user agrees (yes or no)
@@ -244,24 +68,24 @@ module Subtrac
       end
 
       # confirm server
-      confirm_or_replace_value(:server_name,"server_name")
+      Config.confirm_or_update(:server_name,"server_name")
 
       # ask for hostname
-      confirm_or_replace_value(:server_hostname,"server_hostname")
+      Config.confirm_or_update(:server_hostname,"server_hostname")
 
       # default client/project name
-      confirm_or_replace_value(:default_client,"default_client")
-      confirm_or_replace_value(:default_project,"default_project")
+      Config.confirm_or_update(:default_client,"default_client")
+      Config.confirm_or_update(:default_project,"default_project")
 
     end
     
     say("Ok we're about to install now, these are the options you have chosen:
-    installation directory: #{install_dir}
+    installation directory: #{Config.install_dir}
     overwrite: #{overwrite}
-    server name: #{server_name}
-    server hostname: #{server_hostname}
-    default client: #{default_client}
-    default project: #{default_project}")
+    server name: #{Config.server_name}
+    server hostname: #{Config.server_hostname}
+    default client: #{Config.default_client}
+    default project: #{Config.default_project}")
 
     confirm = agree("Is this ok? [y/n]")  
     
@@ -270,42 +94,44 @@ module Subtrac
     create_environment_directories(overwrite)
 
     #create a new virtual host
-    apache = Apache.new(binding)
+    apache = Apache.new
     apache.create_virtual_host()
     
     # create the trac site
-    trac = Trac.new(trac_dir, binding)
+    trac = Trac.new
     trac.install_common_files()
     
     install_common_files()
     configure_admin_user()
     
     # create default project
-    create_project(default_project,default_client)
+    create_project(Config.default_project,Config.default_client)
 
     # store any user preferences for later use
-    save_config()
+    Config.save()
 
   end
   
   def self.create_project(project,client)
     
     # create default project
-    project = Project.new(project,client,default_project_type)
+    project = Project.new(project,client,Config.default_project_type)
     
     # get these out for binding...we'll tidy up later
-    client = project.client
+    #client = project.client
+    Config.project = project
+    Config.client = project.client
 
     # create the svn repo
-    svn = Svn.new(svn_dir, binding)
+    svn = Svn.new
     svn.create_project(project)
     
     # create the trac site
-    trac = Trac.new(trac_dir, binding)
+    trac = Trac.new
     trac.create_project(project)
     
     # create the apache configuration
-    apache = Apache.new(binding)
+    apache = Apache.new
     apache.create_project(project)
 
     # fix privileges
@@ -317,53 +143,42 @@ module Subtrac
   
   def self.give_apache_privileges
     # make sure apache can operate on these files
-    `sudo chown -R www-data:www-data #{install_dir}`
-  end
-  
-  # confirms the current value with the user or accepts a new value if required
-  def self.confirm_or_replace_value(prop, name)
-    method(prop).call # initialise the property
-    current_value = instance_variable_get("@#{prop}")
-    accept_default = agree("The default value for #{prop} @#{prop} is \"#{current_value}\". Is this ok? [y/n]")
-    if !accept_default then
-      answer = ask("What would you like to change it to?")
-      send("#{prop}=", answer)
-      #instance_variable_set(prop, answer)
-    end
+    `sudo chown -R www-data:www-data #{Config.install_dir}`
   end
   
-  def self.install_common_files
+  def self.install_common_files    
     puts "\n==== Installing common files ===="
     # TODO: implement a mask for .svn folders
     # TODO: refactor /common to the app config
-    FileUtils.cp_r(Dir.glob(File.join(subtrac_path, "common/.")),docs_dir)
+    FileUtils.cp_r(Dir.glob(File.join(Config.subtrac_path, "common/.")),Config.docs_dir)
   end
   
   def self.configure_admin_user
     puts "\n==== Configure admin user ===="
     # create admin user
-    passwd_file = File.join(install_dir, ".passwd")
     admin_user = ask("New admin user:  ") { |q| q.echo = true }
     admin_pass = ask("New password:  ") { |q| q.echo = "*" }
     admin_pass_confirm = ask("Re-type new password:  ") { |q| q.echo = "*" }
     if (admin_pass == admin_pass_confirm) then
+      passwd_file = File.join(Config.install_dir, ".passwd")
       `htpasswd -c -b #{passwd_file} #{admin_user} #{admin_pass}`
-      @APP_CONFIG[:admin_user] = admin_user
-      @APP_CONFIG[:admin_pass] = admin_pass
+      Config.data[:admin_user] = admin_user
+      Config.data[:admin_pass] = admin_pass
       # ensure this guy is added to trac admin group
-      @APP_CONFIG[:trac][:permissions][admin_user] = "admins"
+      Config.data[:trac][:permissions][admin_user] = "admins"
     else
       # call the password chooser again
+      configure_admin_user()
     end
   end
 
   def self.create_environment_directories(overwrite=false)
     puts "\n==== Creating new environment directories ===="
-    FileUtils.rm_rf install_dir if overwrite
-    File.create_if_missing install_dir
+    FileUtils.rm_rf Config.install_dir if overwrite
+    File.create_if_missing Config.install_dir
     # create the environment directories
-    @APP_CONFIG[:dirs].each do |key, value|
-      dir = File.join(install_dir,value)
+    Config.data[:dirs].each do |key, value|
+      dir = File.join(Config.install_dir,value)
       File.create_if_missing dir
     end
   end

data/lib/subtrac/apache.rb

@@ -7,27 +7,26 @@ require 'subtrac/template'
 
 module Subtrac
   class Apache
-    def initialize(binding)
-      @apache_conf_dir = Subtrac::apache_conf_dir
-      @subtrac_path = Subtrac::subtrac_path
-      @server_hostname = Subtrac::server_hostname
-      @locations_dir = Subtrac::locations_dir
-      @binding = binding
+    def initialize
+      
     end
     def create_virtual_host()
       puts "\n==== Creating new virtual host ===="
       # TODO: Place a file in apache2 conf with Include directive which points to our conf folder
-      template = Template.new(File.join(File.dirname(__FILE__), "apache", "vhost.conf.erb"))
-      template.write(File.join(@apache_conf_dir,@server_hostname), @binding)
+      template = get_template("vhost.conf.erb")
+      template.write(File.join(Config.apache_conf_dir,Config.server_hostname))
+      puts("template written")
       enable_site()
+      puts("enabled site")
       force_reload()
+      puts("apache reloaded")
     end
     # creates the files necessary for a new client
     def create_client(client)
-      client_config = File.join(@locations_dir,"#{client.path}.conf")
+      client_config = File.join(Config.locations_dir,"#{Config.client.path}.conf")
       if (!File.exists?(client_config)) then
-        template = Template.new(File.join(File.dirname(__FILE__), "apache", "location.conf.erb"))
-        template.write(client_config,@binding)
+        template = get_template("location.conf.erb")
+        template.write(client_config)
         force_reload()
       end
     end
@@ -37,11 +36,14 @@ module Subtrac
     end
     def enable_site
       # tell apache enable site
-      `a2ensite #{@server_hostname}` if SUBTRAC_ENV != 'test'
+      `a2ensite #{Config.server_hostname}` if SUBTRAC_ENV != 'test'
     end
     def create_project(project)
       # we dont need to do anything for each project, but we do need to ensure a client location exists
       create_client(project.client)
     end
+    def get_template(name)
+      Template.new(File.join(File.dirname(__FILE__), "apache", name))
+    end
   end
 end

data/lib/subtrac/client.rb

@@ -2,6 +2,7 @@ module Subtrac
   class Client
     attr_reader :display_name, :path
     def initialize(name)
+      puts "Client created"
       @display_name = name.gsub(/^[a-z]|\s+[a-z]/) { |a| a.upcase }
       @path = name.downcase
     end

data/lib/subtrac/config.rb

@@ -7,191 +7,271 @@ require 'fileutils'
 
 module Subtrac
   class Config
-    
-    USER_CONFIG_FILE = 'config/user.yml'
+    class << self
 
-    def initialize()
-      
-    end
+      USER_CONFIG_FILE = 'config/user.yml'
+
+      attr_accessor :data
+
+      def initialize()
+        puts "config/initialize"
+      end
+
+      def get_binding
+        binding
+      end
 
-    # Loads the configuration YML file
-    def load_config
-      # TODO: We need to refactor this code so it will load the default configuration only if one has not been created
-      puts "\n==== Loading configuration file ===="
-      # load configuration file
-      file_path = File.join(subtrac_path, USER_CONFIG_FILE)
-      file_path = File.join(subtrac_path,"/config/config.yml") if not File.exists?(file_path)
-      puts "Attempting to read config file: #{file_path}"
-      begin
-        yamlFile = YAML.load(File.read(file_path))
-      rescue Exception => e
-        raise StandardError, "Config #{file_path} could not be loaded."
-      end
-      if yamlFile
-        if yamlFile[SUBTRAC_ENV]
-          @APP_CONFIG = yamlFile[SUBTRAC_ENV]
+      # Loads the configuration YML file
+      def load
+        # TODO: We need to refactor this code so it will load the default configuration only if one has not been created
+        puts "\n==== Loading configuration file ===="
+        # load configuration file
+        file_path = File.join(subtrac_path, USER_CONFIG_FILE)
+        file_path = File.join(subtrac_path,"/config/config.yml") if not File.exists?(file_path)
+        puts "Attempting to read config file: #{file_path}"
+        begin
+          yamlFile = YAML.load(File.read(file_path))
+        rescue Exception => e
+          raise StandardError, "Config #{file_path} could not be loaded."
+        end
+        if yamlFile
+          if yamlFile[SUBTRAC_ENV]
+            @APP_CONFIG = yamlFile[SUBTRAC_ENV]
+            @data = @APP_CONFIG # TODO: Deprecate APP_CONFIG
+          else
+            raise StandardError, "config/config.yml exists, but doesn't have a configuration for #{SUBTRAC_ENV}."
+          end
         else
-          raise StandardError, "config/config.yml exists, but doesn't have a configuration for #{SUBTRAC_ENV}."
+          raise StandardError, "config/config.yml does not exist."
         end
-      else
-        raise StandardError, "config/config.yml does not exist."
+        say("Configuration loaded successfully...")
       end
-      say("Configuration loaded successfully...")
-    end
     
-    # Write the changes configuration to disk
-    def self.save_config
-      # save the things that might have changed    
-      file_path = File.join(subtrac_path, USER_CONFIG_FILE)
-      user_config = {SUBTRAC_ENV => @APP_CONFIG}
-      open(file_path, 'w') {|f| YAML.dump(user_config, f)}
-    end
+      # Write the changes configuration to disk
+      def save
+        # save the things that might have changed    
+        file_path = File.join(subtrac_path, USER_CONFIG_FILE)
+        user_config = {SUBTRAC_ENV => @APP_CONFIG}
+        open(file_path, 'w') {|f| YAML.dump(user_config, f)}
+      end
     
-    # User configured options
-    def server_name
-      @server_name ||= @APP_CONFIG[:server_name]
-    end
+      # confirms the current value with the user or accepts a new value if required
+      def confirm_or_update(prop, name)
+        method(prop).call # initialise the property
+        current_value = instance_variable_get("@#{prop}")
+        accept_default = agree("The default value for #{prop} is \"#{current_value}\". Is this ok? [y/n]")
+        if !accept_default then
+          answer = ask("What would you like to change it to?")
+          send("#{prop}=", answer)
+          #instance_variable_set(prop, answer)
+        end
+      end
+    
+      def project
+        @project
+      end
 
-    def server_name=(name)
-      @APP_CONFIG[:server_name] = @server_name = name
-    end
+      def project=(name)
+        @project = name
+      end
+      
+      def client
+        @client
+      end
+    
+      def client=(name)
+        @client = name
+      end
 
-    def server_hostname
-      @server_hostname ||= @APP_CONFIG[:server_hostname]
-    end
+      # User configured options
+      def server_name
+        @server_name ||= @APP_CONFIG[:server_name]
+      end
 
-    def server_hostname=(name)
-      @APP_CONFIG[:server_hostname] = @server_hostname = name
-    end
+      def server_name=(name)
+        @APP_CONFIG[:server_name] = @server_name = name
+      end
 
-    def default_client
-      @default_client ||= @APP_CONFIG[:default_client]
-    end
+      def server_hostname
+        @server_hostname ||= @APP_CONFIG[:server_hostname]
+      end
 
-    def default_client=(name)
-      @APP_CONFIG[:default_client] = @default_client = name
-    end
+      def server_hostname=(name)
+        @APP_CONFIG[:server_hostname] = @server_hostname = name
+      end
 
-    def default_project
-      @default_project ||= @APP_CONFIG[:default_project]
-    end
+      def default_client
+        @default_client ||= @APP_CONFIG[:default_client]
+      end
 
-    def default_project=(name)
-      puts "Updating default_project to #{name}"
-      @APP_CONFIG[:default_project] = @default_project = name
-    end
+      def default_client=(name)
+        @APP_CONFIG[:default_client] = @default_client = name
+      end
 
-    def default_project_type
-      @default_project_type ||= @APP_CONFIG[:default_project_type]
-    end
+      def default_project
+        @default_project ||= @APP_CONFIG[:default_project]
+      end
 
-    def default_project_type=(name)
-      puts "Updating default_project_type to #{name}"
-      @APP_CONFIG[:default_project_type] = @default_project_type = name
-    end
+      def default_project=(name)
+        puts "Updating default_project to #{name}"
+        @APP_CONFIG[:default_project] = @default_project = name
+      end
+
+      def default_project_type
+        @default_project_type ||= @APP_CONFIG[:default_project_type]
+      end
+
+      def default_project_type=(name)
+        puts "Updating default_project_type to #{name}"
+        @APP_CONFIG[:default_project_type] = @default_project_type = name
+      end
     
 
-    # Filesystem directories
-    def root
-      Pathname.new(SUBTRAC_ROOT) if defined?(SUBTRAC_ROOT)
-    end
+      # Filesystem directories
+      def root
+        Pathname.new(SUBTRAC_ROOT) if defined?(SUBTRAC_ROOT)
+      end
 
-    def public_path
-      @public_path ||= self.root ? File.join(self.root, "public") : "public"
-    end
+      def public_path
+        @public_path ||= self.root ? File.join(self.root, "public") : "public"
+      end
     
-    def public_path=(path)
-      @public_path = path
-    end
+      def public_path=(path)
+        @public_path = path
+      end
 
-    def subtrac_path
-      @subtrac_path ||= self.root ? File.join(self.root, "subtrac") : "subtrac"
-    end
+      def subtrac_path
+        @subtrac_path ||= self.root ? File.join(self.root, "subtrac") : "subtrac"
+      end
 
-    def install_dir
-      @install_dir ||= File.expand_path(@APP_CONFIG[:installation_dir])
-    end
+      def install_dir
+        @install_dir ||= File.expand_path(@APP_CONFIG[:installation_dir])
+      end
 
-    def install_dir=(name)
-      puts "Setting new install_dir variable to #{name}"
-      @APP_CONFIG[:installation_dir] = @install_dir = name
-    end
+      def install_dir=(name)
+        puts "Setting new install_dir variable to #{name}"
+        @APP_CONFIG[:installation_dir] = @install_dir = name
+      end
     
-    def apache_conf_dir
-      @apache_conf_dir ||= @APP_CONFIG[:apache_conf_dir]
-    end
+      def apache_conf_dir
+        @apache_conf_dir ||= @APP_CONFIG[:apache_conf_dir]
+      end
 
-    def apache_conf_dir=(name)
-      @APP_CONFIG[:apache_conf_dir] = @apache_conf_dir = name
-    end
+      def apache_conf_dir=(name)
+        @APP_CONFIG[:apache_conf_dir] = @apache_conf_dir = name
+      end
 
-    def docs_dir
-      @docs_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:docs])
-    end
+      def docs_dir
+        @docs_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:docs])
+      end
 
-    def svn_dir
-      @svn_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:svn])
-    end
+      def svn_dir
+        @svn_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:svn])
+      end
 
-    def trac_dir
-      @trac_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:trac])
-    end
+      def trac_dir
+        @trac_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:trac])
+      end
 
-    def temp_dir
-      @temp_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:temp])
-    end
+      def temp_dir
+        @temp_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:temp])
+      end
 
-    def log_dir
-      @log_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:log])
-    end
+      def log_dir
+        @log_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:log])
+      end
 
-    def locations_dir
-      @locations_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:locations])
-    end
+      def locations_dir
+        @locations_dir ||= File.join(install_dir,@APP_CONFIG[:dirs][:locations])
+      end
     
-    # Urls
-    def svn_url
-      @svn_url ||= @APP_CONFIG[:urls][:svn]
-    end
+      # Urls
+      def svn_url
+        @svn_url ||= @APP_CONFIG[:urls][:svn]
+      end
     
-    def trac_permissions
-      @trac_permissions ||= @APP_CONFIG[:trac][:permissions]
-    end
+      def trac_permissions
+        @trac_permissions ||= @APP_CONFIG[:trac][:permissions]
+      end
     
-    # LDAP
-    def enable_ldap
-      @enable_ldap ||= @APP_CONFIG[:ldap][:enable]
-    end
+      # LDAP
+      def enable_ldap
+        @enable_ldap ||= @APP_CONFIG[:ldap][:enable]
+      end
 
-    def enable_ldap=(value)
-      @APP_CONFIG[:ldap][:enable] = @enable_ldap = value
-    end
+      def enable_ldap=(value)
+        @APP_CONFIG[:ldap][:enable] = @enable_ldap = value
+      end
 
-    def ldap_bind_dn
-      @ldap_bind_dn ||= @APP_CONFIG[:ldap][:bind_dn]
-    end
+      def ldap_host
+        @ldap_host ||= @APP_CONFIG[:ldap][:host]
+      end
 
-    def ldap_bind_dn=(value)
-      @APP_CONFIG[:ldap][:bind_dn] = @ldap_bind_dn = value
-    end
-    
-    def ldap_bind_password
-      @ldap_bind_password ||= @APP_CONFIG[:ldap][:bind_password]
-    end
+      def ldap_host=(value)
+        @APP_CONFIG[:ldap][:host] = @ldap_host = value
+      end
 
-    def ldap_bind_password=(value)
-      @APP_CONFIG[:ldap][:bind_password] = @ldap_bind_password = value
-    end
-    
-    def ldap_bind_host
-      @ldap_bind_host ||= @APP_CONFIG[:ldap][:bind_host]
-    end
+      def ldap_port
+        @ldap_port ||= @APP_CONFIG[:ldap][:port]
+      end
 
-    def ldap_bind_host=(value)
-      @APP_CONFIG[:ldap][:bind_host] = @ldap_bind_password = value
-    end
+      def ldap_port=(value)
+        @APP_CONFIG[:ldap][:port] = @ldap_port = value
+      end
+
+      def ldap_basedn
+        @ldap_basedn ||= @APP_CONFIG[:ldap][:basedn]
+      end
+
+      def ldap_basedn=(value)
+        @APP_CONFIG[:ldap][:basedn] = @ldap_basedn = value
+      end
 
+      def ldap_user_rdn
+        @ldap_user_rdn ||= @APP_CONFIG[:ldap][:user_rdn]
+      end
 
+      def ldap_user_rdn=(value)
+        @APP_CONFIG[:ldap][:user_rdn] = @ldap_user_rdn = value
+      end
+
+      def ldap_group_rdn
+        @ldap_group_rdn ||= @APP_CONFIG[:ldap][:group_rdn]
+      end
+
+      def ldap_group_rdn=(value)
+        @APP_CONFIG[:ldap][:group_rdn] = @ldap_group_rdn = value
+      end
+
+      def ldap_store_bind
+        @ldap_store_bind ||= @APP_CONFIG[:ldap][:store_bind]
+      end
+
+      def ldap_store_bind=(value)
+        @APP_CONFIG[:ldap][:store_bind] = @ldap_store_bind = value
+      end
+
+      def ldap_store_bind
+        @ldap_bind_password ||= @APP_CONFIG[:ldap][:bind_password]
+      end
+
+      def ldap_bind_user
+        @ldap_bind_user ||= @APP_CONFIG[:ldap][:bind_user]
+      end
+
+      def ldap_bind_user=(value)
+        @APP_CONFIG[:ldap][:bind_user] = @ldap_bind_user = value
+      end
+
+      def ldap_bind_passwd
+        @ldap_bind_passwd ||= @APP_CONFIG[:ldap][:bind_passwd]
+      end
+
+      def ldap_bind_passwd=(value)
+        @APP_CONFIG[:ldap][:bind_passwd] = @ldap_bind_passwd = value
+      end
+
+    end
 
   end
 end

data/lib/subtrac/svn.rb

@@ -8,12 +8,8 @@ require 'fileutils'
 module Subtrac
   class Svn
 
-    def initialize(svn_dir, binding)
-      # create svn directory if required
-      @svn_dir = svn_dir
-      File.create_if_missing(@svn_dir)
-      @temp_dir = Subtrac::temp_dir
-      @binding = binding
+    def initialize
+      File.create_if_missing(Config.svn_dir)
     end
 
     # creates a new svn repository for the project
@@ -23,10 +19,10 @@ module Subtrac
       client = project.client
 
       # create the client folder
-      File.create_if_missing(File.join(@svn_dir,client.path))
+      File.create_if_missing(File.join(Config.svn_dir,client.path))
 
       # create the project folder
-      project.svn_dir = File.join(@svn_dir,client.path,project.path)
+      project.svn_dir = File.join(Config.svn_dir,client.path,project.path)
       
       # TODO: Need to handle this exception...
       if (File.directory? project.svn_dir) then
@@ -40,7 +36,7 @@ module Subtrac
       # copy template svn project to a temp folder, then svn import it into the repo
       say("Create temporary project directory and copy template files...")
       svn_template_dir = File.join(project.template,"svn")
-      project_temp_dir = File.join(@temp_dir,project.path)
+      project_temp_dir = File.join(Config.temp_dir,project.path)
       FileUtils.cp_r(svn_template_dir,project_temp_dir)
       
       # import into svn
@@ -54,7 +50,6 @@ module Subtrac
       `sudo chmod 770 #{project.svn_dir}`
       `sudo chmod 755 #{project.svn_dir}/dav/activities`
       `sudo chown www-data:www-data #{project.svn_dir}/dav/activities`
-      
 
     end
 

data/lib/subtrac/template.rb

@@ -1,15 +1,20 @@
+require 'subtrac/config'
 module Subtrac
   class Template
     def initialize(template)
       @template = template
     end
-    def render(binding)
-      ERB.new(IO.read(@template)).result(binding)
+    def render
+      puts "Template rendering #{@template}"
+      b = Config.get_binding
+      ERB.new(IO.read(@template)).result(b)
     end
-    def write(outfile,binding)
+    def write(outfile)
       file = File.open(outfile, 'w+')
       if file
-        file.syswrite(render(binding))
+        file_output = render()
+        #puts file_output
+        file.syswrite(file_output)
       else
         raise "Unable to open file for writing. file #{outfile}"
       end

data/lib/subtrac/trac.rb

@@ -5,31 +5,28 @@
 
 require 'fileutils'
 require 'subtrac/template'
+require 'subtrac/config'
 
 module Subtrac
   class Trac
     
-    def initialize trac_dir, binding
-      @trac_dir = trac_dir
-      @subtrac_path = Subtrac::subtrac_path
-      @trac_permissions = Subtrac::trac_permissions
-      @temp_dir = Subtrac::temp_dir
-      @binding = binding
+    def initialize
+      File.create_if_missing(Config.trac_dir)
     end
     
     # Install the shared trac.ini file
     def install_common_files
-      File.create_if_missing(File.join(@trac_dir, ".shared"))
+      File.create_if_missing(File.join(Config.trac_dir, ".shared"))
       # install trac.ini
       trac_ini_template = Template.new(File.join(File.dirname(__FILE__), "trac", "common.trac.ini.erb"))
-      trac_ini_template.write(File.join(@trac_dir,".shared","trac.ini"),@binding)
+      trac_ini_template.write(File.join(Config.trac_dir,".shared","trac.ini"))
     end
     
     def create_project(project)
       
       client = project.client
       
-      project.trac_dir = File.join(@trac_dir,client.path,project.path)
+      project.trac_dir = File.join(Config.trac_dir,client.path,project.path)
 
       # create new project directories
       say("Create project directories...")
@@ -43,11 +40,11 @@ module Subtrac
       say("Installing trac configuration...")
       # install project trac.ini
       trac_ini_template = Template.new(File.join(File.dirname(__FILE__), "trac", "trac.ini.erb"))
-      trac_ini_template.write(File.join(project.trac_dir,"/conf/trac.ini"),@binding)
+      trac_ini_template.write(File.join(project.trac_dir,"/conf/trac.ini"))
       
       say("Setting up default trac permissions...")
       # set up trac permissions
-      @trac_permissions.each do |key, value|
+      Config.trac_permissions.each do |key, value|
         `sudo trac-admin #{project.trac_dir} permission add #{key} #{value}`
       end
       
@@ -56,9 +53,9 @@ module Subtrac
       Dir.foreach("#{project.template}/trac/wiki/.") do |file|
         # do something with the file here
         unless ['.', '..','.svn'].include? file
-          temp_file = File.join(@temp_dir,file)
+          temp_file = File.join(Config.temp_dir,file)
           template = Template.new(File.join(project.template,"trac/wiki",file))
-          template.write(temp_file,@binding)
+          template.write(temp_file)
           `trac-admin #{project.trac_dir} wiki import #{file} #{temp_file}`
           FileUtils.rm(temp_file)
         end

data/lib/subtrac/trac/trac.ini.erb

@@ -22,16 +22,16 @@ width = -1
 [trac]
 repository_dir = ../../../svn/<%= client.path %>/<%= project.path %>
 
-<% if @APP_CONFIG[:ldap][:enable] then %>
+<% if enable_ldap then %>
 [ldap]
-enable = <%= @APP_CONFIG[:ldap][:enable] %>
-host = <%= @APP_CONFIG[:ldap][:host] %>
-port = <%= @APP_CONFIG[:ldap][:port] %>
-basedn = <%= @APP_CONFIG[:ldap][:basedn] %>
-user_rdn = <%= @APP_CONFIG[:ldap][:user_rdn] %>
-group_rdn = <%= @APP_CONFIG[:ldap][:group_rdn] %>
-store_bind = <%= @APP_CONFIG[:ldap][:store_bind] %>
-group_bind = <%= @APP_CONFIG[:ldap][:group_bind] %>
-bind_user = <%= @APP_CONFIG[:ldap][:bind_user] %>
-bind_passwd = <%= @APP_CONFIG[:ldap][:bind_user] %>
+enable = enable_ldap %>
+host = <%= ldap_host %>
+port = <%= ldap_port %>
+basedn = <%= ldap_basedn %>
+user_rdn = <%= ldap_user_rdn %>
+group_rdn = <%= ldap_group_rdn %>
+store_bind = <%= ldap_store_bind %>
+group_bind = <%= ldap_group_bind %>
+bind_user = <%= ldap_bind_user %>
+bind_passwd = <%= ldap_bind_passwd %>
 <% end %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ktec-subtrac
 version: !ruby/object:Gem::Version 
-  version: 0.1.43
+  version: 0.1.44
 platform: ruby
 authors: 
 - Keith Salisbury
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-02 00:00:00 -07:00
+date: 2009-05-03 00:00:00 -07:00
 default_executable: subtrac
 dependencies: 
 - !ruby/object:Gem::Dependency