Perform importing in parallel.

      result = aggregate(parsed_files)

      @relations = filter_classes(result)

      InheritDoc.new(@relations).resolve_all

      Importer.import(@opts.imports, @relations)

      Importer.import(@opts.imports, @relations, @parallel)

      Lint.new(@relations).run

      # Initialize guides, videos, examples, ...

    module_function

    # Loads in exported docs and generates @since and @new tags based on that data.

    def import(imports, relations)

    def import(imports, relations, parallel)

      if imports.length > 0

        generate_since_tags(read_all(imports), relations)

        generate_since_tags(read_all(imports, parallel), relations)

      end

    end

    # Reads in data for all versions, returning array of

    # version/class-data pairs.  We don't use a hash to preserve the

    # order of versions (from oldest to newest).

    def read_all(imports)

    def read_all(imports, parallel)

      imports.map do |ver|

        {

          :version => ver[:version],

          :classes => ver[:path] ? read(ver) : current_version,

          :classes => ver[:path] ? read(ver, parallel) : current_version,

        }

      end

    end

    end

    # Reads in data from all .json files in directory

    def read(ver)

      classes = {}

      Dir[ver[:path] + "/*.json"].each do |filename|

    def read(ver, parallel)

      # Map list of files into pairs of (classname, members-hash)

      pairs = parallel.map(Dir[ver[:path] + "/*.json"]) do |filename|

        JsDuck::Logger.instance.log("Importing #{ver[:version]}", filename)

        json = JsonDuck.read(filename)

        classes[json["name"]] = members_id_index(json)

        [json["name"],  members_id_index(json)]

      end

      classes

      # Turn key-value pairs array into hash

      return Hash[ pairs ]

    end

    # creates index of all class members