MangUpdate 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in MangUpdate.gemspec
+gemspec

data/MangUpdate.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "MangUpdate/version"
+
+Gem::Specification.new do |s|
+  s.name        = "MangUpdate"
+  s.version     = MangUpdate::VERSION
+  s.authors     = ["MOZGIII"]
+  s.email       = ["mike-n@narod.ru"]
+  s.homepage    = ""
+  s.summary     = %q{Use Mupfiles to update your MaNGOS server database.}
+  s.description = %q{This is a small gem that will help you with updating your MaNGOS server. It uses Mupfile to keep all database update logic simple.}
+
+  s.rubyforge_project = "MangUpdate"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "activesupport"
+end

data/README.md

@@ -0,0 +1,27 @@
+MangUpdate
+==========
+
+Installation
+------------
+
+    gem install mangupdate
+
+Usage
+-----
+   
+### WARNING!!!
+**Always check you config with `mangupdate -nl` (dry run and list updates) before using `mangupdate`!**
+
+ - Create `Mupfile` with `mangupdate init`.
+ - Edit and configure `Mupfile` as you need.
+ - Run `mangupdate -nl` to check that lists and jobs are configured.
+ - Check `Mupfile.dump` file and change numbers there to your server's current revisions.
+ - Use `mangupdate` to run the update.
+ 
+Feel free to use `mangupdate -h update` to see all the options available.
+
+
+Mupfile examples
+----------------
+
+Just use `mangupdate init` to get a basic `Mupfile`.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mangupdate

@@ -0,0 +1,4 @@
+require "MangUpdate"
+require "MangUpdate/cli"
+
+MangUpdate::CLI.start

data/lib/MangUpdate/cli.rb

@@ -0,0 +1,66 @@
+require 'thor'
+require 'MangUpdate/version'
+
+module MangUpdate
+
+  class CLI < Thor
+
+    default_task :update
+
+    desc 'update', 'Runs the update'
+    
+    method_option :debug,
+                  :type    => :boolean,
+                  :default => false,
+                  :aliases => '-d',
+                  :banner  => 'Print debug messages'  
+                  
+    method_option :mupfile,
+                  :type    => :string,
+                  :aliases => '-M',
+                  :banner  => 'Specify a Mupfile'
+    
+    method_option :dry_run,
+                  :type    => :boolean,
+                  :default => false,
+                  :aliases => '-n',
+                  :banner  => 'Do not upload SQL files'
+                  
+    method_option :list,
+                  :type    => :boolean,
+                  :default => false,
+                  :aliases => '-l',
+                  :banner  => 'Print SQL filenames'
+                  
+    method_option :nodump,
+                  :type    => :boolean,
+                  :default => false,
+                  :banner  => 'Do not dump update info'
+    
+    def update
+      ::MangUpdate.run(options)
+    end
+
+
+    desc 'version', 'Shows the MangUpdate version'
+    
+    map %w(-v --version) => :version
+    
+    def version
+      ::MangUpdate::UI.info "MangUpdate version #{ MangUpdate::VERSION }"
+    end
+
+    
+    desc 'init', 'Generates a Mupfile at the current working directory'
+    
+    method_option :mupfile,
+              :type    => :string,
+              :aliases => '-M',
+              :banner  => 'Specify a Mupfile path'
+    
+    def init
+      ::MangUpdate.initialize_template(options)
+    end
+
+  end
+end

data/lib/MangUpdate/dsl.rb

@@ -0,0 +1,168 @@
+module MangUpdate
+  class Dsl
+    
+    class << self
+
+      @@options = nil
+      @@configs = nil
+
+      # Evaluate the DSL methods in the `Mupfile`.
+      #
+      def evaluate_mupfile(options = {})
+        raise ArgumentError.new('No option hash passed to evaluate_mupfile!') unless options.is_a?(Hash)
+
+        @@options = options.dup
+        @@configs = {}
+
+        fetch_mupfile_contents
+        instance_eval_mupfile(mupfile_contents)
+        
+        @@configs.each do |key, value|
+          @@options[key] = value unless @@options.key?(key)
+        end
+        @@options
+      end
+
+      def instance_eval_mupfile(contents)
+        new.instance_eval(contents, @@options[:mupfile_path], 1)
+      rescue
+        UI.error "Invalid Mupfile, original error is:\n#{ $! }"
+        raise if @@options[:debug]
+        exit 1
+      end
+      
+      def read_mupfile(mupfile_path)
+        @@options[:mupfile_path]     = mupfile_path
+        @@options[:mupfile_contents] = File.read(mupfile_path)
+      rescue
+        UI.error("Error reading file #{ mupfile_path }")
+        exit 1
+      end
+
+      # Get the content to evaluate and stores it into
+      # the options as `:mupfile_contents`.
+      #
+      def fetch_mupfile_contents
+        if @@options[:mupfile_contents]
+          UI.info 'Using inline Mupfile.'
+          @@options[:mupfile_path] = 'Inline Mupfile'
+
+        elsif @@options[:mupfile]
+          if File.exist?(@@options[:mupfile])
+            read_mupfile(@@options[:mupfile])
+            UI.info "Using Mupfile at #{ @@options[:mupfile] }."
+          else
+            UI.error "No Mupfile exists at #{ @@options[:mupfile] }."
+            exit 1
+          end
+
+        else
+          if File.exist?(mupfile_default_path)
+            read_mupfile(mupfile_default_path)
+          else
+            UI.error 'No Mupfile found, please create one with `mangupdate init`.'
+            exit 1
+          end
+        end
+
+        if mupfile_contents.empty?
+          UI.error "The command file(#{ @@options[:mupfile] }) seems to be empty."
+          exit 1
+        end
+      end
+
+      def mupfile_contents
+        @@options ? @@options[:mupfile_contents] : ''
+      end
+
+      def mupfile_path
+        @@options ? @@options[:mupfile_path] : ''
+      end
+
+      def mupfile_default_path
+        File.join(Dir.pwd, 'Mupfile')
+      end
+
+    end
+    
+    def initialize
+      @tmp = {}
+    end
+    
+    def tmp_block(merge_options = {})
+      return unless block_given?
+      preserve_tmp = @tmp
+      @tmp = {} if @tmp.nil? && merge_options
+      @tmp = @tmp.merge(merge_options) if @tmp.respond_to?(:merge)
+      val = yield
+      @tmp = preserve_tmp
+      val
+    end
+      
+    def list(name)
+      tmp_block({ :type => :list, :paths => [] }) do
+        yield if block_given?
+        MangUpdate.add_list(name, @tmp[:paths])
+      end
+    end
+    
+    def path(path, options = {})
+      raise "path must be called inside of a list block" unless @tmp[:type] == :list
+      @tmp[:paths] << [path, options]
+    end
+    
+    def job(name)
+      # jobs are just for some extra groupping
+      tmp_block({ :type => :job, :applies => [] }) do
+        yield if block_given?
+        MangUpdate.add_job(name, @tmp[:applies])
+      end
+    end
+    
+    def filtered(options = { :clear => false })
+      raise "filtered must be called inside of a job block" unless [:job, :filtered].member?(@tmp[:type])
+      filters_new = []
+      filters_new = @tmp[:filters] if @tmp[:filters] && !options[:clear]      
+      tmp_block({ :type => :filtered, :filters => filters_new, :jobname => @tmp[:jobname] }) do
+        yield if block_given?
+      end
+    end
+    
+    def filter(&block)
+      raise "filter must be called inside of a filtered block" unless @tmp[:type] == :filtered
+      @tmp[:filters] << block
+    end
+    
+    def apply(options = {})
+      raise "apply must be called inside of a job block" unless [:job, :filtered].member?(@tmp[:type])  
+      @tmp[:applies] << [:list, options, @tmp[:filters] || []]
+    end
+    
+    def config(*args)
+      name = args.shift
+      case args.size
+      when 0
+        @@configs[name.downcase.to_sym]
+      when 1
+        @@configs[name.downcase.to_sym] = args[0]
+      else
+        raise ArgumentError, "Wrong number of arguments!"
+      end
+    end
+    
+    def build_lists
+      MangUpdate.build_lists
+    end
+    
+    def upload_file(filename, database, rev = nil)
+      raise "upload_file must be called inside of a job block" unless @tmp[:type] == :job
+      @tmp[:applies] << [:file, filename, database, rev]
+    end
+    
+    def upload_sql_string(sql, database, rev = nil)
+      raise "upload_sql_string must be called inside of a job block" unless @tmp[:type] == :job
+      @tmp[:applies] << [:inline, sql, database, rev]
+    end
+    
+  end
+end

data/lib/MangUpdate/dumpfile.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+
+module MangUpdate
+  class Dumpfile
+  
+    class << self
+      def load(path = "Mupfile.dump")
+        from_hash(YAML.load(File.read(path)))
+      rescue
+        nil
+      end
+      
+      def write(dump, path = "Mupfile.dump")
+        File.open(path, "wb") do |f|
+          f.write dump.to_hash.to_yaml
+        end
+      end
+      
+      def from_hash(hash)
+        dumpfile = self.new
+        dumpfile.revs = hash[:revs]
+        dumpfile
+      end
+    end
+    
+    attr_accessor :revs
+    def initialize(revs = {})
+      @revs = revs
+    end
+    
+    def update_revs(revs_new = {})
+      revs_new.each do |key, value|
+        @revs[key] = value if !@revs.key?(key) || @revs[key] < value
+      end
+    end
+    
+    def to_hash
+      {
+        :revs => revs
+      }
+    end
+    
+  end
+end

data/lib/MangUpdate/job.rb

@@ -0,0 +1,54 @@
+module MangUpdate
+  class Job
+    attr_reader :name, :updates, :latest_revs
+    
+    def initialize(name, applies)
+      @name = name
+      @applies = applies      
+      @updates = nil
+      @latest_revs = {}
+    end
+    
+    def collect_updates
+      @updates = []
+      @applies.each do |apply|
+        type = apply.shift
+        case type
+        when :list
+          options, filters = apply
+          
+          updates = []
+          MangUpdate.lists(options).each do |list|
+            next unless list.built?
+            
+            list.updates.each do |update|
+              selected = filters.all? do |filter|
+                filter.call(update, list)
+              end
+              
+              if selected
+                @latest_revs[list.name] = update.rev  
+                updates << update
+              end
+            end
+            
+          end
+          
+          @updates << updates
+        when :file
+          filename, database, rev = apply
+          model = Model::Common.new(filename, database, rev || 0)
+          @updates << [ model ]
+          
+        when :inline
+          sql, database, rev = apply
+          model = Model::InlineSql.new(nil, database, rev || 0, { :sql => sql })
+          @updates << [ model ]
+          
+        end
+        
+      end
+    end
+    
+  end
+end

data/lib/MangUpdate/list.rb

@@ -0,0 +1 @@
+module MangUpdate
  class List
    
    attr_reader :name, :updates
    attr_accessor :current_rev
    
    def initialize(name, paths)
      @name = name
      @paths = []
      @updates = []
      @built = false
      @current_rev = 0
      add_paths(paths)
    end
    
    def add_paths(paths)
      paths.each do |path|
        _path, options = path
        @paths << Path.new(_path, options) 
      end
    end
    
    def build!
      @built = true
      @paths.each do |path|
        path.scan do |update|
          @updates << update
        end
      end
      sort_list!(@updates)
    rescue
      @built = false
      raise
    end
    
    def built?
      @built
    end    
    
    private
    
    # This sorts the array of updates by it's sort_data field
    def sort_list!(list)
      list.sort! do |a,b|
        a, b = a.sort_data, b.sort_data
        i = 0
        i += 1 while a[i] == b[i] && (a[i+1] || b[i+1])
        if a[i] && b[i]
          a[i] <=> b[i]
        else
          a[i] ? 1 : -1
        end
      end
      list
    end
  
  end

data/lib/MangUpdate/model.rb

@@ -0,0 +1,38 @@
+module MangUpdate
+  module Model
+    
+    autoload :Common,     'MangUpdate/models/common'
+    autoload :InlineSql,  'MangUpdate/models/inline_sql'
+  
+    class Base
+      
+      attr_reader :filename, :database, :rev, :info
+      attr_accessor :applied
+      
+      def self.build(filename, options = {})
+        raise "Do not know how to build #{name}"
+        
+        # Should be overwritten by subclasses with something like self.new ...
+      end
+      
+      def initialize(filename, database, rev, info = {})
+        @filename = filename
+        @database = database
+        @rev = rev
+        @info = info
+      end     
+      
+      def sort_data
+        [rev]
+      end
+      
+      def to_s
+        "Rev#{rev} [#{self.class.name}:#{filename}]"
+      end
+      
+      def upload
+        MangUpdate.upload_file_to_db(filename, database)
+      end
+    end
+  end
+end

data/lib/MangUpdate/models/common.rb

@@ -0,0 +1,14 @@
+module MangUpdate
+  module Model
+
+    class Common < Base
+      
+      def self.build(filename, options = {})
+        data = File.basename(filename, '.sql').split('_')
+        self.new filename, data[1], data[0].gsub(/[^0-9]/, '').to_i
+      end
+      
+    end
+
+  end
+end

data/lib/MangUpdate/models/inline_sql.rb

@@ -0,0 +1,23 @@
+module MangUpdate
+  module Model
+
+    class InlineSql < Base
+      attr_reader :sql
+    
+      def self.build(filename, options = {})
+        raise "#{name} can not be used as a model"
+      end
+      
+      def initialize(filename, database, rev, info = {})
+        super("<Inline SQL>", database, rev, info)
+        @sql = @info[:sql]
+      end
+      
+      def upload
+        MangUpdate.upload_inline_sql(sql, database)
+      end
+      
+    end
+
+  end
+end

data/lib/MangUpdate/models/main_core.rb

@@ -0,0 +1,19 @@
+module MangUpdate
+  module Model
+
+    class MainCore < Base
+      APPLY_PRIORITY = 1
+      
+      def self.build(filename, options = {})
+        data = File.basename(filename, '.sql').split('_')
+        self.new filename, data[2], data[0].to_i, :num => data[1].to_i
+      end
+      
+      def sort_data
+        [rev, APPLY_PRIORITY, info[:num]]
+      end
+      
+    end
+
+  end
+end

data/lib/MangUpdate/models/ytdb_core.rb

@@ -0,0 +1,20 @@
+module MangUpdate
+  module Model
+
+    class YtdbCore < Base
+      APPLY_PRIORITY = 2
+      
+      def self.build(filename, options = {})
+        data = File.basename(filename, '.sql').split('_')
+        return if data[1] == 'corepatch' # skip all corepatches...      
+        self.new filename, data[1], data[3].gsub(/[^0-9]/, '').to_i
+      end
+      
+      def sort_data
+        [rev, APPLY_PRIORITY]
+      end
+      
+    end
+
+  end
+end

data/lib/MangUpdate/path.rb

@@ -0,0 +1 @@
+require 'active_support/inflector'
  class Path
    
    def initialize(path, options = {})
      @path = path
      @options = options
      
      @model_class = get_model_class(options[:model] || :common)
      raise "Unable to load model!" unless @model_class
    end
    
    def scan
      Dir.glob(@path).each do |file|
        model = @model_class.build(file, @options)
        yield(model) if model
      end
    end
    
    private
    
    def get_model_class(name)
      name = name.to_s
      file_name   = name.underscore
      const_name  = name.camelize
      try_require = false
      begin
        require "MangUpdate/models/#{ file_name }" if try_require
        ::MangUpdate::Model.const_get(::MangUpdate::Model.constants.find { |c| c.to_s.downcase == const_name.downcase })
      rescue TypeError
        unless try_require
          try_require = true
          retry
        else
          UI.error "Could not find class MangUpdate::Model::#{ const_name }"
        end
      rescue LoadError => loadError
        UI.error "Could not load 'MangUpdate/models/#{ file_name }' or find class MangUpdate::Model::#{ const_name }"
        UI.error loadError.to_s
      end      
    end
    
  end

data/lib/MangUpdate/templates/Mupfile.erb

@@ -0,0 +1,32 @@
+base_path       = "."
+mangos_path     = base_path + "/mangos"
+scriptdev2_path = base_path + "/scriptdev2"
+
+config :mysql_user, "mangos"
+config :mysql_pass, "mangos"
+
+list("Main Core") do
+  path "#{mangos_path}/sql/updates/*.sql", :model => :main_core
+end
+
+list("Main SD2") do
+  path "#{scriptdev2_path}/sql/updates/r*.sql"
+end
+
+job("Update all") do
+  filtered do
+  
+    # only apply updates that have revision number
+    # greater than currently installed revision
+    filter do |update, list|
+      update.rev > list.current_rev
+    end
+
+    apply
+    
+  end
+end
+
+#job("Custom SQL") do
+#  upload_file "#{base_path}/mangos_custom.sql", "mangos"
+#end

data/lib/MangUpdate/templating.rb

@@ -0,0 +1,23 @@
+require 'erb'
+
+module MangUpdate
+  module Templating
+    class << self
+    
+      def init_template(options = {})
+        b = binding
+        template_filename = File.join(File.dirname(__FILE__), "templates", "Mupfile.erb")
+        
+        template = ERB.new(File.read(template_filename))
+        template.filename = template_filename
+        
+        result = template.result(b)
+        
+        File.open(options[:mupfile], 'wb') do |f|
+          f.puts(result)
+        end
+      end
+      
+    end
+  end
+end

data/lib/MangUpdate/ui.rb

@@ -0,0 +1,182 @@
+module MangUpdate
+  module UI
+    class << self
+
+      color_enabled = nil
+
+      # Show an info message.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def info(message, options = { })
+        unless in_test_mode?
+          reset_line if options[:reset]
+          STDERR.puts color(message) if message != ''
+        end
+      end
+
+      # Show a red error message that is prefixed with ERROR.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def error(message, options = { })
+        unless in_test_mode?
+          reset_line if options[:reset]
+          STDERR.puts color('ERROR: ', :red) + message
+        end
+      end
+
+      # Show a red deprecation message that is prefixed with DEPRECATION.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def deprecation(message, options = { })
+        unless in_test_mode?
+          reset_line if options[:reset]
+          STDERR.puts color('DEPRECATION: ', :red) + message
+        end
+      end
+
+      # Show a debug message that is prefixed with DEBUG and a timestamp.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def debug(message, options = { })
+        unless in_test_mode?
+          reset_line if options[:reset]
+          STDERR.puts color("DEBUG (#{Time.now.strftime('%T')}): ", :yellow) + message if ::MangUpdate.options && ::MangUpdate.options[:debug]
+        end
+      end
+
+      # Reset a line.
+      #
+      def reset_line
+        STDERR.print(color_enabled? ? "\r\e[0m" : "\r\n")
+      end
+
+      # Clear the output.
+      #
+      def clear
+        system('clear;')
+      end
+
+      private
+      
+      def in_test_mode?
+        ENV['MUP_ENV'] == 'test'
+      end
+
+      # Reset a color sequence.
+      #
+      # @deprecated
+      # @param [String] text the text
+      #
+      def reset_color(text)
+        deprecation('UI.reset_color(text) is deprecated, please use color(text, ' ') instead.')
+        color(text, '')
+      end
+
+      # Checks if color output can be enabled.
+      #
+      # @return [Boolean] whether color is enabled or not
+      #
+      def color_enabled?
+        if @color_enabled.nil?
+          if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+            if ENV['ANSICON']
+              @color_enabled = true
+            else
+              @color_enabled = false
+            end
+          else
+            @color_enabled = true
+          end
+        end
+
+        @color_enabled
+      end
+
+      # Colorizes a text message. See the constant in the UI class for possible
+      # color_options parameters. You can pass optionally :bright, a foreground
+      # color and a background color.
+      #
+      # @example
+      #
+      #   color('Hello World', :red, :bright)
+      #
+      # @param [String] the text to colorize
+      # @param [Array] color_options the color options
+      #
+      def color(text, *color_options)
+        color_code = ''
+        color_options.each do |color_option|
+          color_option = color_option.to_s
+          if color_option != ''
+            if !(color_option =~ /\d+/)
+              color_option = const_get("ANSI_ESCAPE_#{ color_option.upcase }")
+            end
+            color_code += ';' + color_option
+          end
+        end
+        color_enabled? ? "\e[0#{ color_code }m#{ text }\e[0m" : text
+      end
+
+    end
+
+    # Brighten the color
+    ANSI_ESCAPE_BRIGHT    = '1'
+
+    # Black foreground color
+    ANSI_ESCAPE_BLACK     = '30'
+
+    # Red foreground color
+    ANSI_ESCAPE_RED       = '31'
+
+    # Green foreground color
+    ANSI_ESCAPE_GREEN     = '32'
+
+    # Yellow foreground color
+    ANSI_ESCAPE_YELLOW    = '33'
+
+    # Blue foreground color
+    ANSI_ESCAPE_BLUE      = '34'
+
+    # Magenta foreground color
+    ANSI_ESCAPE_MAGENTA   = '35'
+
+    # Cyan foreground color
+    ANSI_ESCAPE_CYAN      = '36'
+
+    # White foreground color
+    ANSI_ESCAPE_WHITE     = '37'
+
+    # Black background color
+    ANSI_ESCAPE_BGBLACK   = '40'
+
+    # Red background color
+    ANSI_ESCAPE_BGRED     = '41'
+
+    # Green background color
+    ANSI_ESCAPE_BGGREEN   = '42'
+
+    # Yellow background color
+    ANSI_ESCAPE_BGYELLOW  = '43'
+
+    # Blue background color
+    ANSI_ESCAPE_BGBLUE    = '44'
+
+    # Magenta background color
+    ANSI_ESCAPE_BGMAGENTA = '45'
+
+    # Cyan background color
+    ANSI_ESCAPE_BGCYAN    = '46'
+
+    # White background color
+    ANSI_ESCAPE_BGWHITE   = '47'
+
+  end
+end

data/lib/MangUpdate/version.rb

@@ -0,0 +1,3 @@
+module MangUpdate
+  VERSION = "0.0.1"
+end

data/lib/MangUpdate.rb

@@ -0,0 +1,161 @@
+module MangUpdate
+  
+  autoload :Dsl,        'MangUpdate/dsl'
+  autoload :UI,         'MangUpdate/ui'
+  autoload :Templating, 'MangUpdate/templating'
+  autoload :List,       'MangUpdate/list'
+  autoload :Path,       'MangUpdate/path'
+  autoload :Model,      'MangUpdate/model'
+  autoload :Job,        'MangUpdate/job'
+  autoload :Dumpfile,   'MangUpdate/dumpfile'
+  
+  class << self
+    attr_accessor :options
+    
+    def run(options = {})
+      @lists           = []
+      @jobs            = []
+      @loaded_dumpfile = nil
+      @options         = Dsl.evaluate_mupfile(options)
+      
+      build_lists
+      
+      load_dumpfile
+      
+      unless check_database_auth_info
+        UI.error "Database user and password must be supplied"
+        exit 1
+      end
+      
+      new_dumpfile = Dumpfile.new
+      execute_jobs(new_dumpfile)
+      
+      dump_write(new_dumpfile) unless @options[:nodump]
+    end
+    
+    def initialize_template(options = {})
+      options = { :mupfile => "Mupfile" }.merge(options)
+      if File.exist?(options[:mupfile])
+        UI.error "Mupfile already exists at #{ File.expand_path(options[:mupfile]) }"
+        exit 1
+      end
+      
+      Templating.init_template({ :mupfile => "Mupfile" }.merge(options))
+      UI.info "Mupfile generated, feel free to edit it"
+    end
+    
+    def lists(filter = nil)
+      case filter
+      when Hash
+        if filter[:except]
+          array = filter[:except].kind_of?(Array) ? filter[:except] : [ filter[:except] ]
+          @lists.find_all { |list| !array.member?(list.name) }
+          
+        elsif filter[:only]
+          array = filter[:only].kind_of?(Array) ? filter[:only] : [ filter[:only] ]
+          @lists.find_all { |list| array.member?(list.name) }
+          
+        else
+          @lists
+          
+        end
+      when String, Symbol
+        @lists.find { |list| list.name == filter }
+      when Regexp
+        @lists.find_all { |list| list.name.to_s =~ filter }
+      when Proc
+        @lists.find_all { |list| filter.call(list) }
+      else
+        @lists
+      end
+    end
+    
+    def add_list(name, paths)
+      list = lists(name)
+      if list.nil?
+        list = List.new(name, paths)
+        @lists << list
+      else
+        unless list.built?
+          list.add_paths(paths)
+        else
+          raise "List #{name} was already built, you can't add more paths to it!"
+        end
+      end
+      list
+    end
+    
+    def add_job(name, uploads)
+      job = Job.new(name, uploads)
+      @jobs << job
+    end
+    
+    def build_lists
+      fully_built = lists.inject(true) do |valid, list|
+        list.build!
+        valid &&= list.built?
+      end
+      
+      raise "Some lists are not fully built!" unless fully_built
+    end
+    
+    def execute_jobs(dumpfile)
+      lists.each do |list|
+        dumpfile.update_revs({ list.name => list.current_rev })
+      end
+      
+      @jobs.each do |job|
+        UI.info "Running job: #{job.name}"
+        
+        job.collect_updates
+        
+        dumpfile.update_revs(job.latest_revs)
+        
+        job.updates.flatten.each do |update|
+          UI.info update.filename if @options[:list]
+          update.upload unless @options[:dry_run]
+        end
+        
+      end
+    end
+    
+    def check_database_auth_info
+      [ :mysql_user, :mysql_pass ].all? do |param|
+        @options[param] && !@options[param].empty?
+      end
+    end
+    
+    def upload_file_to_db(path, database)
+      user = @options[:mysql_user]
+      pass = @options[:mysql_pass]
+      command = %Q[mysql -u"#{user}" -p"#{pass}" -D"#{database}" < "#{path}"]
+      UI.debug "SYSTEM: #{command}"
+      system command
+    end
+    
+    def upload_inline_sql(sql, database = nil)
+      user = @options[:mysql_user]
+      pass = @options[:mysql_pass]
+      
+      command = %Q[mysql -u"#{user}" -p"#{pass}" -D"#{database}" -B -s -e "#{sql.gsub('"', '\"')}"]
+      UI.debug "SYSTEM: #{command}"
+      system command
+    end
+    
+    def load_dumpfile
+      @loaded_dumpfile = Dumpfile.load
+      
+      return unless @loaded_dumpfile
+      
+      @loaded_dumpfile.revs.each do |key, value|
+        list = lists(key)
+        list.current_rev = value if list
+      end
+    end
+    
+    def dump_write(dump)
+      Dumpfile.write(dump)
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: MangUpdate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- MOZGIII
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &28246692 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *28246692
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &28245336 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *28245336
+description: This is a small gem that will help you with updating your MaNGOS server.
+  It uses Mupfile to keep all database update logic simple.
+email:
+- mike-n@narod.ru
+executables:
+- mangupdate
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MangUpdate.gemspec
+- README.md
+- Rakefile
+- bin/mangupdate
+- lib/MangUpdate.rb
+- lib/MangUpdate/cli.rb
+- lib/MangUpdate/dsl.rb
+- lib/MangUpdate/dumpfile.rb
+- lib/MangUpdate/job.rb
+- lib/MangUpdate/list.rb
+- lib/MangUpdate/model.rb
+- lib/MangUpdate/models/common.rb
+- lib/MangUpdate/models/inline_sql.rb
+- lib/MangUpdate/models/main_core.rb
+- lib/MangUpdate/models/ytdb_core.rb
+- lib/MangUpdate/path.rb
+- lib/MangUpdate/templates/Mupfile.erb
+- lib/MangUpdate/templating.rb
+- lib/MangUpdate/ui.rb
+- lib/MangUpdate/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: MangUpdate
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Use Mupfiles to update your MaNGOS server database.
+test_files: []