Shows objects

 @param [String|NilClass] objectish the target object reference (nil == HEAD)
 @param [String|NilClass] path the path of the file to be shown
 @return [String] the object information
195183
def show(objectish=nil, path=nil)
      arr_opts = []

      arr_opts << (path ? "#{objectish}:#{path}" : objectish)

      command('show', arr_opts.compact)
    end
507472
def list(path, params = {}, headers = {})
      params = params.merge(list: true)
      request(:get, path, params, headers)
    end
1083342
def get_object(id)
      return nil unless (blob = find_blob(id)) && (obj = blob.read_object(id))
      deserialize(obj)
    end
1110931
def show_to(*args, &block)
      user = send(Acl9.config[:default_subject_method])
      return if user.nil?

      has_any = false

      if args.last.is_a?(Hash)
        an_obj  = args.pop.values.first
        has_any = args.detect { |role| user.has_role?(role, an_obj) }
      else
        has_any = args.detect { |role| user.has_role?(role) }
      end

      if has_any
        begin
          capture( &block )
        rescue NoMethodError
          yield( :block )
        end
      end

    end
1374448
function(path) {
		var output = {},
			obj = path ? utils.getProp(this.data, path) : this.data;
		if (!obj)
			return null;
		for (var i in obj)
			if (!outputFiler.test(i))
				output[i] = obj[i];
		return output;
	}
539977
def head(path, options = {})
      options = options.merge(:head => true) # No parsing!
      execute('HEAD', path, options)
    end
1297243
def def_method(object, method_name, filename=nil)
      m = object.is_a?(Module) ? :module_eval : :instance_eval
      object.__send__(m, "def #{method_name}; #{@src}; end", filename || @filename || '(erubis)')
    end
624018
function _get(obj, path) {
  var subpathes = path.split('.');
  while (subpathes.length) {
    var subpath = subpathes.shift();
    obj = obj[subpath];
    if (!obj) {
      return obj;
    }
  }
  return obj;
}
221341
def show(record_id = nil, **params)
      if record_id.nil? && !singular_resource?
        raise ArgumentError, "record_id cannot be nil"
      end
      path = nest_path_within_parent(singular_path_for_record(record_id, params), params)
      api_request(:get, path, params: params)
    end
227745
def object_image
      image = object_data[:image] if object_available?

      return image.file.url if image.respond_to?(:file)
      return image if image.present?

      fallback_image
    end
860690
def object_path(self, objhash):
        
        return os.path.join(self._path, self.OBJ_DIR, objhash)
853557
def show(request)
      # force load session because it can be lazy loaded
      request.env[@key].delete(:rack_session_access_force_load_session)

      # session hash object
      session_hash = request.env[@key].to_hash

      case File.extname(request.path)
      when ".raw"
        render do |xml|
          xml.h2 "Raw rack session data"
          xml.pre RackSessionAccess.encode(session_hash)
        end
      else
        render do |xml|
          xml.h2 "Rack session data"
          xml.ul do |ul|
            session_hash.each do |k,v|
              ul.li("#{k.inspect} : #{v.inspect}")
            end
          end
          xml.p do |p|
            p.a("Edit", :href => action_path(:edit))
          end
        end
      end
    end
1320407
def show(self, brief=False):
        
        output = []
        for path in self.options.paths or ["."]:
            if self.options.verbose:
                utils.info("Checking {0} for metadata.".format(path))
            tree = fmf.Tree(path)
            for node in tree.prune(
                    self.options.whole, self.options.keys, self.options.names,
                    self.options.filters):
                if brief:
                    show = node.show(brief=True)
                else:
                    show = node.show(
                        brief=False,
                        formatting=self.options.formatting,
                        values=self.options.values)
                # List source files when in debug mode
                if self.options.debug:
                    for source in node.sources:
                        show += utils.color("{0}\n".format(source), "blue")
                if show is not None:
                    output.append(show)

        # Print output and summary
        if brief or self.options.formatting:
            joined = "".join(output)
        else:
            joined = "\n".join(output)
        try: # pragma: no cover
            print(joined, end="")
        except UnicodeEncodeError: # pragma: no cover
            print(joined.encode('utf-8'), end="")
        if self.options.verbose:
            utils.info("Found {0}.".format(
                utils.listed(len(output), "object")))
        self.output = joined
620307
def file_path(type = nil, suffix = '.dat')
      name = self.case.class.benchmark_name.dup
      name << '#' << short_name
      type and name << '-' << type
      name << suffix
      File.expand_path(name, self.case.class.output_dir)
    end
720478
def list(object_type)
      url = generate_rest_url(:list, object_type)
      result = retrieve(url.path)
      parsed_result = parse_xml(result)
      find_object_in_result(parsed_result, object_type, :list)
    end
348194
def output path, do_file_close = true
      FileUtils.cp @file.path, path
      close if do_file_close
      self
    end
1002736
def get(path,data={},headers=nil)
      data_to_query(data)
      if headers == nil
        response = @http.send_request('GET', path, @defaults[:data])
      else
        response = @http.send_request('GET', path, @defaults[:data], headers)
      end
      response
    end