terrimporter 0.4.0 → 0.5.4

data/lib/configuration.rb

@@ -1,93 +0,0 @@
-require 'etc'
-require 'kwalify'
-require 'config_validator'
-
-module TerrImporter
-  class Application
-    class Configuration < Hash
-
-      CONFIG_DEFAULT_NAME = 'terrimporter.config.yml'
-      SCHEMA_DEFAULT_NAME = 'schema.yml'
-
-      attr_accessor :validations, :config_file
-
-      def initialize(config_file = nil)
-        self.config_file = config_file unless config_file.nil?
-
-      end
-
-      def load_configuration
-        config_file_path = determine_config_file_path
-        validate_and_load_config(config_file_path)
-      end
-
-      def determine_config_file_path
-        unless self.config_file.nil?
-          return self.config_file
-        end
-
-        valid_config_paths.each do |path|
-          file_path = File.join path, CONFIG_DEFAULT_NAME
-          return file_path if File.exists?(file_path)
-        end
-
-        raise ConfigurationError, %Q{config file #{CONFIG_DEFAULT_NAME} not found in search paths. Search paths are:
-        #{valid_config_paths.join "\n"} \n If this is a new project, run with the option --init}
-      end
-
-      def valid_config_paths
-        [
-            Dir.pwd,
-            File.join(Dir.pwd, 'config'),
-            File.join(Dir.pwd, '.config'),
-            Etc.getpwuid.dir
-        ]
-      end
-
-      #todo split!
-      def validate_and_load_config(file)
-        puts "Load configuration "
-
-        schema = Kwalify::Yaml.load_file(schema_file_path)
-        #validator = Kwalify::Validator.new(schema)
-        validator = ConfigValidator.new(schema)
-
-        parser = Kwalify::Yaml::Parser.new(validator)
-        document = parser.parse_file(file)
-        ## show errors if exist
-        errors = parser.errors()
-        ##todo convert to single statement, map for example
-        if errors && !errors.empty?
-          error_message = ""
-          for e in errors
-            error_message << "#{e.linenum}:#{e.column} [#{e.path}] #{e.message}\n"
-          end
-          raise ConfigurationError, error_message
-        end
-
-        self.merge! document
-
-      end
-
-      def schema_file_path
-        File.join(File.dirname(__FILE__), '..', 'config', SCHEMA_DEFAULT_NAME)
-      end
-
-      #todo
-      def validate_schema
-        meta_validator = Kwalify::MetaValidator.instance
-
-        ## validate schema definition
-        parser = Kwalify::Yaml::Parser.new(meta_validator)
-        errors = parser.parse_file(schema_file_path)
-        for e in errors
-          puts "#{e.linenum}:#{e.column} [#{e.path}] #{e.message}"
-        end if errors && !errors.empty?
-      end
-
-      def create_config
-        FileUtils.cp(File.join(File.dirname(__FILE__), "..", "config", CONFIG_DEFAULT_NAME), File.join(Dir.pwd, CONFIG_DEFAULT_NAME))
-      end
-    end
-  end
-end

data/lib/importer.rb

@@ -1,190 +0,0 @@
-require 'fileutils'
-require 'app_logger'
-require 'yaml'
-require 'uri'
-
-
-
-module TerrImporter
-
-  class DefaultError < StandardError
-  end
-
-  class ConfigurationError < StandardError
-  end
-
-  class Importer
-    require 'options'
-    require 'configuration'
-    include Logging
-
-    #todo remove
-    attr_accessor :options, :config
-
-    def initialize(options = {})
-      self.options = options
-      self.config = TerrImporter::Application::Configuration.new options[:config_file]
-
-    end
-
-    def run
-      self.config.load_configuration
-
-      if options[:all] != nil and options[:all] == true
-        import_js
-        import_css
-        import_images
-      else
-
-        options.each do |option, value|
-          if option.to_s =~ /^import_/ and value == true
-            #test this really good!!!
-            self.send option.to_s
-
-          end
-
-
-        end
-      end
-    end
-
-    def import_css
-      unclean_suffix = "_unclean"
-
-      check_and_create_dir config['stylesheets']['dest']
-
-      #create stylesheet array and add base.css
-      styles = config['stylesheets']['styles'].split(" ")
-      styles << "base"
-
-      styles.each do |css|
-        destination_path = File.join(config['stylesheets']['dest'], css + ".css")
-        options = {}
-        options[:suffix] = css if css.include?('ie') #add ie option if in array
-
-        source_url = construct_export_request(:css, options)
-        run_download(source_url, destination_path + unclean_suffix)
-
-        #do line replacement
-        File.open(destination_path, 'w') do |d|
-          File.open(destination_path + unclean_suffix, 'r') do |s|
-            lines = s.readlines
-            lines.each do |line|
-              d.print stylesheet_replace_strings(line)
-            end
-          end
-        end
-        FileUtils.remove destination_path + unclean_suffix
-      end
-    end
-
-    def import_js
-      destination_path = File.join(config['javascripts']['dest'], "base.js")
-      js_source_url = construct_export_request :js
-      puts "Importing base.js from #{js_source_url} to #{destination_path}"
-      run_download(js_source_url, destination_path)
-
-      #start library import
-
-      libraries_destination_path = File.join(config['javascripts']['dest'], config['javascripts']['libraries_dest'])
-
-      check_and_create_dir libraries_destination_path
-
-      js_libraries = config['javascripts']['dynamic_libraries'].split(" ")
-
-      puts "Importing libraries from #{config['libraries_source_path']} to #{libraries_destination_path}"
-
-      js_libraries.each do |lib|
-        run_download(config['libraries_source_path'] + lib + ".js", File.join(libraries_destination_path, lib + ".js"))
-      end
-
-    end
-
-    def import_images
-      config['images'].each do |image|
-        check_and_create_dir image['dest']
-        image_source_path = File.join(config['image_base_path'], image['src'])
-        batch_download_files(image_source_path, image['dest'], image['types'])
-      end
-    end
-
-    private
-
-    def batch_download_files(relative_source_path, relative_dest_path, type_filter = "")
-      source_path = relative_source_path
-
-      puts "Downloading files from #{config['url']}#{source_path} to #{relative_dest_path} #{"allowed extensions: " + type_filter unless type_filter.empty?}"
-
-      files = get_file_list(source_path)
-
-      unless type_filter.empty?
-        puts "Appling type filter: #{type_filter}"
-        files = files.find_all { |file| file =~ Regexp.new(".*" + type_filter.strip.gsub(" ", "|") + "$") }
-      end
-
-      puts "Downloading #{files.size} files..."
-      files.each do |file|
-        destination_path = File.join(relative_dest_path, file)
-        run_download(source_path + file, destination_path, :remove_old => false)
-      end
-    end
-
-    def get_file_list(source_path)
-      output = run_download(source_path)
-      files = []
-
-      output.scan(/<a\shref=\"([^\"]+)\"/) { |res| files << res[0] if not res[0] =~ /^\?/ and res[0].size > 1 }
-      files
-    end
-
-    def construct_export_request(for_what = :js, options={})
-      raise "Specify js or css url" unless for_what == :js or for_what == :css
-      export_settings = config['export_settings'].clone
-
-      export_settings['application'] = config['app_path']
-      export_settings.merge!(options)
-      export_settings['appbaseurl'] = "" if for_what == :css
-
-      #glue everything together
-      export_path = config['export_path']
-      export_path.insert(0, "/") unless export_path.match(/^\//)
-
-      export_path = export_path % [for_what.to_s, config['version']] #replace placeholders
-      export_path << '?' << export_settings.map { |k, v| "#{URI.escape(k.to_s)}=#{URI.escape(v.to_s)}" }.join("&")
-      export_path
-    end
-
-    def check_and_create_dir(dir, create = true)
-      unless File.directory?(dir)
-        puts "Directory #{dir} does not exists... it will #{"not" unless true} be created"
-        FileUtils.mkpath(dir) if create
-      end
-    end
-
-    def stylesheet_replace_strings(line)
-      config['stylesheets']['replace'].each do |replace|
-        what = replace['what']
-        with = replace['with']
-        what = Regexp.new "/#{$1}" if what.match(/^r\//)
-        line.gsub! what, with
-      end
-      line
-    end
-
-    #todo use as central download processing
-    def run_download(remote_path, local = nil, options = {})
-      FileUtils.remove_file(local) if not local.nil? and File.exists?(local) and not File.directory?(local) and not options[:remove_old] == true
-      remote_url = config['url'] + remote_path
-
-      case config['downloader']
-        when 'curl'
-          output = `curl '#{remote_url}' #{"> #{local}" if local != nil}`
-          raise "FATAL: An error orrured downloading from #{remote_url} #{"to #{local}: \n #{output}" if local != nil}" if output.include?('error')
-          return output
-        when 'wget'
-          #todo
-      end
-
-    end
-  end
-end

data/test/unit/test_terrimporter.rb

@@ -1,23 +0,0 @@
-require "helper"
-require "FileUtils"
-
-
-class TerrImporterTest < Test::Unit::TestCase
-
-  def teardown
-    FileUtils.rm_rf File.join(Dir.pwd, TerrImporter::Application::Configuration::CONFIG_DEFAULT_NAME)
-  end
-
-  should 'merge environment and argument options' do
-    ENV['TERRIMPORTER_OPTS'] = '-j -c'
-    merged_options = TerrImporter::Application.build_options([''] + ['-i', '--verbose'])
-    expected_options = {:import_css => true,
-                        :import_js => true,
-                        :import_images => true,
-                        :verbose => true,
-                        :input_file => ''}
-
-    assert_contains merged_options, expected_options
-  end
-
-end