A Blacklight index field helper_method
 @param [Hash] options from blacklight helper_method invocation. Maps license URIs to links with labels.
 @return [ActiveSupport::SafeBuffer] license links, html_safe
165149
def license_links(options)
      service = Hyrax.config.license_service_class.new
      to_sentence(options[:value].map { |right| link_to service.label(right), right })
    end
821095
def options_for_render(options = {})
      style = options_for_style(options[:style] || DEFAULT_OPTIONS[:style])
      DEFAULT_OPTIONS.merge(style).merge(options)
    end
1351113
def format(options = {})
      options = options.dup
      o = {}
      o[k = :color] = (v = options.delete(k)).nil?? true : v
      raise ArgumentError, "Unknown option(s): #{options.inspect}" if not options.empty?

      require_valid

      Colorize.colorize *[
        (own?? [[:list_method, :own_marker], OWN_MARKER[0]] : [[:list_method, :not_own_marker], OWN_MARKER[1]]),
        [[:list_method, :obj_module_name], obj_module_name],
        ([[:list_method, :owner_name], "(#{owner_name})"] if not own?),
        [[:list_method, :access], access],
        [[:list_method, :name], method_name],
        ([[:list_method, :visibility], " [#{visibility}]"] if not public?),
        [[:reset]],
      ].compact.flatten(1).reject {|v| v.is_a? Array and not o[:color]}
    end
545479
def partnership_by_uri(uri, options={})
      raise 'Error: Param uri is nil!' if uri.nil?

      url = url_for_uri(uri)
      url = append_query_params(url, options)
      client.get(url, options) do |response|
        a_hash = parse(response)
        Resource::Partnership.from_coach a_hash
      end
    end
1070069
def URI(url) # rubocop:disable Naming/MethodName
      if url.respond_to?(:host)
        url
      elsif url.respond_to?(:to_str)
        default_uri_parser.call(url)
      else
        raise ArgumentError, 'bad argument (expected URI object or URI string)'
      end
    end
978433
function (options) {
        // return early if options is empty or invalid
        if (!_.isObject(options)) {
            return;
        }

        _.mergeDefined(this, /** @lends Certificate.prototype */ {
            /**
             * Unique identifier
             * @type {String}
             */
            id: options.id,

            /**
             * Name for user reference
             * @type {String}
             */
            name: options.name,

            /**
             * List of match pattern
             * @type {UrlMatchPatternList}
             */
            matches: options.matches && new UrlMatchPatternList({}, options.matches),

            /**
             * Private Key
             * @type {{ src: (string) }}
             */
            key: _.isObject(options.key) ? options.key : { src: options.key },

            /**
             * Certificate
             * @type {{ src: (string) }}
             */
            cert: _.isObject(options.cert) ? options.cert : { src: options.cert },

            /**
             * PFX or PKCS12 Certificate
             * @type {{ src: (string) }}
             */
            pfx: _.isObject(options.pfx) ? options.pfx : { src: options.pfx },

            /**
             * passphrase
             * @type {Object}
             */
            passphrase: options.passphrase
        });
    }
818851
def ilabel(object_name, method, content_or_options = nil, options = nil, &block)
      options ||= {}

      content_is_options = content_or_options.is_a?(Hash)
      if content_is_options || block_given?
        options.merge!(content_or_options) if content_is_options
        text = nil
      else
        text = content_or_options
      end

      ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_ilabel_tag(text, options, &block)
    end
972717
def render_crumbs(options = {})
      raise ArgumentError, "Renderer and block given" if options.has_key?(:renderer) && block_given?
      return yield(crumbs, options) if block_given?
      
      @_renderer ||= if options.has_key?(:renderer)
        options.delete(:renderer)
      else
        require 'crummy/standard_renderer'
        Crummy::StandardRenderer.new
      end

      @_renderer.render_crumbs(crumbs, options)
    end
451087
def options=(options)
      fail ArgumentError, 'options must be a Hash. ' \
                          "#{ options.inspect } given." unless options.is_a?(Hash)

      @options.merge! options

      build_query
    end
523112
def url
      sch = @options[:ssl] ? "https" : "http"
      hosts = Array(@options[:host])
      @url ||= if hosts.first.include?(":")
                 URI("#{sch}://[#{hosts.first}]:#{port}").to_s
               else
                 URI("#{sch}://#{hosts.first}:#{port}").to_s
               end
    end
1073245
def options
      VALID_OPTION_KEYS.inject({}) do |option, key|
        option.merge!(key => send(key))
      end
    end
1024231
def options
      VALID_OPTIONS_KEYS.reduce({}) do |options, key|
        options.merge(key => send(key))
      end
    end
437217
def extract_options!(options, html_options: nil)
      options.symbolize_keys!
      html_options.symbolize_keys! if html_options

      # effective_bootstrap specific options
      layout = options.delete(:layout) # Symbol
      wrapper = options.delete(:wrapper) # Hash
      input_group = { append: options.delete(:append), prepend: options.delete(:prepend), input_group: options.delete(:input_group) }.compact

      feedback = options.delete(:feedback) # Hash
      label = options.delete(:label) # String or Hash
      hint = options.delete(:hint) # String or Hash

      input_html = options.delete(:input_html) || {} # Hash
      input_js = options.delete(:input_js) || {} # Hash

      # Every other option goes to input
      @options = input = (html_options || options)

      # Merge all the default objects, and intialize everything
      wrapper = merge_defaults!(wrapper, wrapper_options)
      input_group = merge_defaults!(input_group, input_group_options)
      feedback = merge_defaults!(feedback, feedback_options)

      label = merge_defaults!(label, label_options)
      hint = merge_defaults!(hint, hint_options)

      merge_defaults!(input.merge!(input_html), input_html_options)
      merge_defaults!(input_js, input_js_options)

      if input_js.present?
        merge_defaults!(input_js, input_js_options_method_name)
        input['data-input-js-options'] = JSON.generate(input_js)
      end

      { layout: layout, wrapper: wrapper, input_group: input_group, label: label, hint: hint, input: input, feedback: feedback }
    end
801497
def subscription_by_uri(uri, options={})
      raise 'Error: Param uri is nil!' if uri.nil?

      url = url_for_uri(uri)
      url = append_query_params(url, options)
      client.get(url, options) do |response|
        a_hash = parse(response)
        Resource::Subscription.from_coach a_hash
      end
    end
803641
def uri_join(*paths)
      return nil if paths.length == 0
      leadingslash = paths[0][0] == '/' ? '/' : ''
      trailingslash = paths[-1][-1] == '/' ? '/' : ''
      paths.map! { |path| path.sub(/^\/+/, '').sub(/\/+$/, '') }
      leadingslash + paths.join('/') + trailingslash
    end
858266
def options
      VALID_OPTIONS.inject({}) do |option, key|
        option.merge!(key => send(key))
      end
    end
433926
def docomo_utn_link_to(str, options = {})
      url = options
      if options.is_a?(Hash)
        options = options.symbolize_keys
        options[:only_path] = false
        url = url_for(options)
      end
      %(<a href="#{url}" utn>#{str}</a>).html_safe
    end