Makes the found root objects available.
 @return [Object]
499256
def method_missing(method, *args, &block)
      name = method.to_s
      if respond_to_missing? name
        @bases[name]
      else
        super(method, *args, &block)
      end
    end
1141548
def load(pattern=nil)
      tests = []

      # Find all tests in the tests directory
      Find.find @@conf.test_root do |path|
        # recurse into all subdirectories
        next if File.directory? path

        # filter tests by pattern if present
        if pattern
          next unless rel_path(path).match(pattern)
        end

        # ignore dotfiles
        next if File.basename(path).match(/^\..*/)

        # ignore files in ignore filter
        next if ignored?(path)

        tests << Test.new(path)
      end

      return tests
    end
1373166
def method_missing(meth, *args)
      if include?(meth.to_s) then
        if args.empty? then
          create_getter meth
        else
          raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
        end
      elsif meth.to_s =~ /^(.+)\?$/ and include?(root_meth = $1) then
        if args.empty? then
          !!create_getter(root_meth) #TODO duplication of logic
        else
          raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
        end
      else
        super
      end
    end
778399
def root(self, parts):
        
        result = None
        name = parts[0]
        log.debug('searching schema for (%s)', name)
        qref = self.qualify(parts[0])
        query = BlindQuery(qref)
        result = query.execute(self.schema)
        if result is None:
            log.error('(%s) not-found', name)
            raise PathResolver.BadPath(name)
        log.debug('found (%s) as (%s)', name, Repr(result))
        return result
863701
def parent_page options={}
      if options[:single_root]
        if parent
          parent
        elsif is_root_page?
          nil
        else
          Humpyard::Page.root_page
        end
      else
        parent
      end
    end
1202068
def each
      root.each do |node, mode, stack|
        if mode == :on_enter
          yield(node.blob_address, node.size)
        end
      end
    end
1119068
def root(force_reload=nil)
      @root = nil if force_reload
      @root ||= transaction do
        reload_boundaries
        base_class.roots.find(:first, :conditions => ["#{nested_set_column(:left)} <= ? AND #{nested_set_column(:right)} >= ?", left, right])
      end
    end
757167
def find_root(self):
        
        cmd = self
        while cmd.parent:
            cmd = cmd.parent
        return cmd
81137
def load(root_file, use_proxy=True, key=None):
    
    if isinstance(root_file, string_types):
        root_file = root_open(root_file)
        own_file = True
    else:
        own_file = False
    obj = Unpickler(root_file, use_proxy).load(key)
    if own_file:
        root_file.Close()
    return obj
1197993
def root(self):
        

        if not self.parent:
            return self

        con = self.parent

        while con.parent:
            con = con.parent

        return con
974385
def instances(descendants = true)
      inst = ObjectSpace.each_object(self).to_a
      descendants ? inst : inst.select { |i| i.class == self }
    end
715722
def keys
      @hash.deep.each_with_object([]) do |(key_path, value), result|
        result << key_path.to_key_path unless value.is_a?(Hash)
      end
    end
1312399
def solr_url
    if defined?(Rails.root)
      ::YAML.load(ERB.new(File.read(File.join(Rails.root,"config","solr.yml"))).result)[Rails.env]['url']
    elsif ENV['RAILS_ENV']
      ::YAML.load(ERB.new(File.read("config/solr.yml")).result)[ENV['RAILS_ENV']]['url']
    else
      ::YAML.load(ERB.new(File.read("config/solr.yml")).result)['development']['url']
    end
  end
37566
def descendants(include_singletons = false)
      return _inherited_by.map { |c| [c, c.descendants] }.flatten.uniq if BBLib.in_opal?
      ObjectSpace.each_object(Class).select do |c|
        (include_singletons || !c.singleton_class?) && c < self
      end
    end
628567
def missing_used_tree(locale)
      used_tree(strict: true).select_keys do |key, _node|
        locale_key_missing?(locale, key)
      end.set_root_key!(locale, type: :missing_used)
    end
959467
def default_root_key(object_class)
      if (serializer = ScopedSerializer.find_serializer_by_class(object_class))
        root_key = serializer.find_scope(:default).options[:root]
      end

      if root_key
        root_key.to_s
      elsif object_class.respond_to?(:model_name)
        object_class.model_name.element
      else
        object_class.name
      end
    end
911459
def parents
      parent = @ancestor
      (@ancestor.instance.path.size...self.instance.path.size).map do |i|
        parent.tap do
          parent = parent[self.instance.path[i]]
        end
      end.reverse
    end