query
stringlengths 7
9.55k
| document
stringlengths 10
363k
| metadata
dict | negatives
listlengths 0
101
| negative_scores
listlengths 0
101
| document_score
stringlengths 3
10
| document_rank
stringclasses 102
values |
|---|---|---|---|---|---|---|
Only allow a list of trusted parameters through.
|
def question_option_selection_params
params.require(:question_option_selection).permit(:question_answer_id, :question_option_id)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def allow_params_authentication!; end",
"def whitelisted_args\n args.select &:allowed\n end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def filtered_parameters; end",
"def sanitize_params_for user, params, allowed_params\n params.each do |key, val|\n #if allowed_params.include?(key)\n #sanitize!(user, params, key) if key =~ /_attributes|_ids$/\n #else\n #params.delete(key)\n #end\n params.delete(key) unless allowed_params.include?(key.to_sym)\n end\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def expected_permitted_parameter_names; end",
"def sanitize_parameters!(sanitizer, params)\n # replace :readwrite with :onlyif\n if params.has_key?(:readwrite)\n warn \":readwrite is deprecated. Replacing with :onlyif\"\n params[:onlyif] = params.delete(:readwrite)\n end\n\n # add default parameters\n bindata_default_parameters.each do |k,v|\n params[k] = v unless params.has_key?(k)\n end\n\n # ensure mandatory parameters exist\n bindata_mandatory_parameters.each do |prm|\n if not params.has_key?(prm)\n raise ArgumentError, \"parameter ':#{prm}' must be specified \" +\n \"in #{self}\"\n end\n end\n\n # ensure mutual exclusion\n bindata_mutually_exclusive_parameters.each do |param1, param2|\n if params.has_key?(param1) and params.has_key?(param2)\n raise ArgumentError, \"params #{param1} and #{param2} \" +\n \"are mutually exclusive\"\n end\n end\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def check_params; true; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def allowed?(*_)\n true\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def allowed_params(parameters)\n parameters.select do |name, values|\n values.location != \"path\"\n end\n end",
"def secure_params\n return @secure_params if @secure_params\n\n defn = implementation_class.definition\n field_list = [:master_id] + defn.field_list_array\n\n res = params.require(controller_name.singularize.to_sym).permit(field_list)\n res[implementation_class.external_id_attribute.to_sym] = nil if implementation_class.allow_to_generate_ids?\n @secure_params = res\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permit( params, whitelist, name = nil )\n raise 'Parametrization not yet configured' unless @configured\n whitelist ||= []\n px = params.respond_to?( :permit ) ? params : ActionController::Parameters.new( params )\n px = dig(px, name)\n px.permit( *whitelist )\n end",
"def valid_params?; end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def url_allowlist=(_arg0); end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def list_params\n params.permit(:list_name)\n end",
"def valid_params_request?; end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def param_list(param_type, name, type, required, description = nil, allowed_values = [], hash = {})\n hash.merge!({allowable_values: {value_type: \"LIST\", values: allowed_values}})\n param(param_type, name, type, required, description, hash)\n end",
"def safelists; end",
"def authorize_own_lists\n authorize_lists current_user.lists\n end",
"def listed_params\n params.permit(:listed, :list_id, :listable_id, :listable_type, :campsite_id)\n end",
"def lists_params\n params.require(:list).permit(:name)\n\n end",
"def list_params\n params.require(:list).permit(:name, :user_id)\n end",
"def list_params\n params.require(:list).permit(:name, :description, :type, :privacy, :allow_edit, :rating, :votes_count, :user_id)\n end",
"def check_params\n true\n end",
"def authorize_own_or_shared_lists\n authorize_lists current_user.all_lists\n end",
"def user_pref_list_params\n\t\tparams.require(:user).permit(:preference_list)\n\tend",
"def may_contain!(*keys)\n self.allow_only_permitted = true\n self.permitted_keys = [*permitted_keys, *keys].uniq\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def whitelist; end",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.permit(:name)\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :list, :references)\n end",
"def cancan_parameter_sanitizer\n resource = controller_name.singularize.to_sym\n method = \"#{resource}_params\"\n params[resource] &&= send(method) if respond_to?(method, true)\n end",
"def list_params\n params.require(:list).permit(:name).merge(user_id: current_user.id)\n end",
"def whitelist_place_params\n params.require(:place).permit(:place_name, :unlock, :auth, :is_deep_checked, :parent_ADM4, :parent_ADM3, :parent_ADM2, :parent_ADM1, :parent_country, feature_code: [], same_as: [], related_authority: [], altlabel: [], note: []) # Note - arrays need to go at the end or an error occurs!\n end",
"def list_params\n params.fetch(:list, {}).permit(:user_id, :name, :active)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def secure_params(require_param, permit_keys)\n params.require(require_param).permit(*permit_keys)\n end",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def permitted_params\n []\n end",
"def price_list_params\n params.fetch(:price_list, {}).permit(:name, :valid_from, :valid_to, :active,\n :all_warehouses, :all_users, :all_contact_groups,\n warehouse_ids: [], price_lists_user_ids: [], contact_group_ids: [])\n end",
"def params(list)\n @declared_params = list\n end",
"def admin_review_params\n params.fetch(:review, {}).permit(whitelisted_params)\n end",
"def saved_list_params\n params.require(:saved_list).permit(:user_id)\n end",
"def allow(ids); end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def filter_params(param_set, **kwargs)\r\n begin\r\n key = kwargs[:key]\r\n params.require(key).permit(*param_set)\r\n rescue Exception\r\n params.permit(*param_set)\r\n end\r\n end",
"def valid_parameters\n sort_symbols(@interface.allowed_parameters)\n end",
"def validate_paramified_params\n self.class.paramify_methods.each do |method|\n params = send(method)\n transfer_errors_from(params, TermMapper.scope(params.group)) if !params.valid?\n end\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def secure_params\n return @secure_params if @secure_params\n\n @implementation_class = implementation_class\n resname = @implementation_class.name.ns_underscore.gsub('__', '_').singularize.to_sym\n @secure_params = params.require(resname).permit(*permitted_params)\n end",
"def refine_permitted_params(param_list)\n res = param_list.dup\n\n ms_keys = res.select { |a| columns_hash[a.to_s]&.array }\n ms_keys.each do |k|\n res.delete(k)\n res << { k => [] }\n end\n\n res\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :description, recipient_id_array: [])\n end",
"def safelist; end",
"def sponsor_params\n params.require(:sponsor).permit(WHITE_LIST)\n end",
"def valid_for_params_auth?; end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def shopping_list_params\n params.require(:shopping_list).permit!\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def permitters\n @_parametrizr_permitters || {}\n end",
"def allow_params(action, keys: nil, except: nil, &blk)\n keys &&= Array.wrap(keys)\n keys ||= User.field_names\n except &&= Array.wrap(except)\n except ||= %i[id email]\n devise_parameter_sanitizer.permit(action, keys: keys, except: except, &blk)\n end",
"def list_params\n if current_user && current_user.role == 'admin'\n params.require(:list).permit(:name, :url, :description, :user_id,\n ideas_attributes: [:id, :list_id, :body, :due_date, :completion_status, :_destroy])\n else\n params.require(:list).permit(:name, :description,\n ideas_attributes: [:body, :due_date, :completion_status]) \n end\n end",
"def whitelist(params)\n send_request_of_type(GlobalConstant::PrivateOpsApi.private_ops_api_type, 'post', '/token-sale/whitelist', params)\n end",
"def valid_access_params\n params.require(:valid_access).permit(:wish_list_id, :user_id)\n end",
"def url_allowlist; end",
"def ensure_redirected_params_are_safe!(passed_params)\n unless passed_params.is_a?(ActionController::Parameters) && passed_params.permitted?\n error_message = if passed_params.is_a?(ActionController::Parameters)\n unsafe_parameters = passed_params.send(:unpermitted_keys, params)\n \"[Rails::Prg] Error - Must use permitted strong parameters. Unsafe: #{unsafe_parameters.join(', ')}\"\n else\n \"[Rails::Prg] Error - Must pass strong parameters.\"\n end\n raise error_message\n end\n end",
"def data_collection_params\n allow = [:name,:description,:institution,:collection_name,:country_id,:province_id,:city_id]\n params.require(:data_collection).permit(allow)\n end",
"def quote_params\n params.permit!\n end"
] |
[
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.6326454",
"0.63140553",
"0.6299814",
"0.62642586",
"0.626006",
"0.62578833",
"0.6236823",
"0.6227561",
"0.6221758",
"0.62200165",
"0.620879",
"0.61983657",
"0.6195055",
"0.6172993",
"0.6156856",
"0.61558664",
"0.61521494",
"0.6135789",
"0.6121145",
"0.61118174",
"0.60736513",
"0.6071645",
"0.60632104",
"0.60549796",
"0.6043906",
"0.6034662",
"0.60207325",
"0.6018568",
"0.6016575",
"0.60103434",
"0.60084206",
"0.600763",
"0.6007443",
"0.6003619",
"0.6003619",
"0.5995791",
"0.5993301",
"0.5993231",
"0.5984926",
"0.597122",
"0.5968121",
"0.5965808",
"0.59640145",
"0.59632224",
"0.59602356",
"0.59332967",
"0.5927556",
"0.5922805",
"0.5909745",
"0.5905083",
"0.5904304",
"0.5893434",
"0.58888215",
"0.58823985",
"0.58823985",
"0.58823985",
"0.5873434",
"0.58619875",
"0.58533794",
"0.5845531",
"0.58426666",
"0.58360124",
"0.583218",
"0.5828041",
"0.5827927",
"0.5816121",
"0.5814705",
"0.5812719",
"0.581121",
"0.5803423",
"0.5803423",
"0.57995003",
"0.5794207",
"0.5784923",
"0.5781365",
"0.5776385",
"0.5774859",
"0.57671493",
"0.5766998",
"0.57618684",
"0.5758038"
] |
0.0
|
-1
|
Single traces larger than +max_size+ will be discarded.
|
def initialize(encoder, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
@encoder = encoder
@max_size = max_size
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def pop\n traces = @traces.pop(VERY_LARGE_INTEGER)\n\n measure_pop(traces)\n\n traces\n end",
"def push(trace)\n return if @closed\n len = @traces.length\n if len < @max_size || @max_size <= 0\n @traces << trace\n else\n # we should replace a random trace with the new one\n replace_index = rand(len)\n replaced_trace = @traces.delete_at(replace_index)\n @traces << trace\n\n # Check if we deleted the element right when the buffer\n # was popped. In that case we didn't actually delete anything,\n # we just inserted into a newly cleared buffer instead.\n measure_drop(replaced_trace) if replaced_trace\n end\n\n measure_accept(trace)\n end",
"def on_size_exceeded\n tracer.trace('operation.parent') do\n # Fill the trace over the capacity of the context\n max_size.times do |i|\n tracer.trace('operation.sibling') do |span|\n yield(span) if i + 1 == max_size\n end\n end\n end\n end",
"def truncate_samples\n @samples.sort!{|a,b| a.duration <=> b.duration}\n @samples.slice!(0..-(max_capacity + 1))\n end",
"def push(trace)\n @mutex.synchronize do\n return if @closed\n len = @traces.length\n if len < @max_size || @max_size <= 0\n @traces << trace\n else\n # we should replace a random trace with the new one\n replace_index = rand(len)\n replaced_trace = @traces[replace_index]\n @traces[replace_index] = trace\n measure_drop(replaced_trace)\n end\n\n measure_accept(trace)\n end\n end",
"def max_size\n 1\n end",
"def reduce_max_size\n @max_size /= 2\n end",
"def summarizable?\n size < MAX_SIZE\n end",
"def valid_batch_size?(max)\n spec[batch_key].size < max\n end",
"def default_max_size\n [Setting[:histsize], self.size].min\n end",
"def clean_unsaturated\n if !max.empty? && max.text_value.to_i > 0\n builder.if_ \"#{accumulator_var}.size < #{max.text_value}\" do\n builder << '@terminal_failures.pop' # Ignore the last failure.\n end\n end\n end",
"def trim_logs!(threshold = 1000)\n m = [last_analyzed_log_entry, last_broadcasted_log_entry].min\n l = last_trimmed_log_entry\n entries = []\n\n if m - last_trimmed_log_entry >= threshold\n entries = redis.zrangebyscore(log_key, l, m, :with_scores => true)\n redis.zremrangebyscore(log_key, l, m)\n redis.hset(ident, 'last_trimmed_log_entry', m)\n end\n\n entries\n end",
"def check_max_samples_exceeded\n # loop over each stripwell and sum the num samples in each to find total num samples\n num_samples = 0\n operations.map { |op| op.input(\"PCR\").collection }.uniq.each do |stripwell|\n num_samples = num_samples + stripwell.num_samples\n end\n if num_samples > 96\n operations.store io: \"input\", interactive: false\n raise \"The fragment analyzer can only hold 96 samples at once. This job has #{num_samples} total samples\"\n end\n num_samples\n end",
"def skip_profiling?(queue_size, impl)\n impl.klass == DHeap::Benchmarks::PushAndResort && 10_000 < queue_size\n end",
"def test_skips_all_elements_count_gt_size\n stream = FromArray.new([1, 2, 3])\n collected = stream.skip(4).collect\n assert(\n collected == [],\n 'Expected ' + [].to_s + ' but got ' + collected.to_s\n )\n end",
"def specific_max_size(number); end",
"def inspect_limit\n @inspect_limit || 500\n end",
"def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end",
"def pop\n @mutex.synchronize do\n traces = @traces\n @traces = []\n\n measure_pop(traces)\n\n return traces\n end\n end",
"def skip_profiling?(queue_size, impl)\n impl.klass == DHeap::Benchmarks::Sorting && 10_000 < queue_size\n end",
"def size_exhausted?\n @size >= (MAX_BYTES - Defaults::Metric::MAX_BYTES)\n end",
"def remove_useless_traces_data(params)\n convert_list_of_json_traces_to_objects(params[0])\n create_new_traces\n @traces_json_string = '[' + @traces_json_string[0...-1] + ']'\n puts @traces_json_string\n end",
"def delete_max\n loc = delete_max_locator\n loc and loc.value\n end",
"def max_size; end",
"def remove_small_components(max_size: 1)\n roots = self.addresses.to_set.dup\n leaves = Set.new\n each_record do |r|\n refs = r['references']\n if refs.empty?\n leaves << r['address']\n else\n roots.subtract(r['references'])\n end\n end\n\n to_remove = Set.new\n roots.each do |root_address|\n component = Set[]\n queue = Set[root_address]\n while !queue.empty? && (component.size <= max_size)\n address = queue.first\n queue.delete(address)\n next if component.include?(address)\n component << address\n queue.merge(address_to_record[address]['references'])\n end\n\n if component.size <= max_size\n to_remove.merge(component)\n end\n end\n\n without(find_all { |r| to_remove.include?(r['address']) })\n end",
"def over_limit?\n count > max_calls\n end",
"def maximum_queued_data_size\n super\n end",
"def limited_samples\n results = positive_samples\n limit = results.map{|x| x[:value]}.max * LIMIT\n results.select{|x| x[:value] > limit}\n end",
"def specific_max_size(number)\n [self.size, number].min\n end",
"def delete_max\n return -1 if @count == 0\n data = @array[0]\n @array[0] = @array.pop\n @count = @array.size\n percolate_down(0)\n data\n end",
"def cashed_events_limit_not_reached?(max)\n max ? self.cashed_events_count < max : true\n end",
"def length\n @traces.length\n end",
"def max_size=(_arg0); end",
"def initialize(max_size)\n @head = nil\n @max_size = max_size\n @current_size = 0\n end",
"def large\n filter << 'Size:Large'\n self\n end",
"def trim_buffer\n trim_size = @buffer.size - @max_items\n trim_size = 0 if trim_size < 0\n @buffer.shift(trim_size)\n end",
"def empty?\n @mutex.synchronize do\n return @traces.empty?\n end\n end",
"def unsafe_forget_past!\n slices.values.map(&:history).each{|h| h.recent(memory_size)}\n\n if multi_slices?\n to_delete = slices.values.reject{|s| keep_slice?(s)}\n to_delete.map(&:rack_id).map do |rack_id| \n slices.delete(rack_id)\n end\n end\n end",
"def delete_max_locator\n return nil if empty?\n use_max\n loc = mode_call(:find_max_loc)\n @heapsize = mode_call(:delete_loc, loc)\n loc\n end",
"def stifle_history(max)\r\n max = 0 if (max < 0)\r\n\r\n if (@history_length > max)\r\n @the_history.slice!(0,(@history_length - max))\r\n @history_length = max\r\n end\r\n\r\n @history_stifled = true\r\n @max_input_history = @history_max_entries = max\r\n end",
"def empty?\n @traces.empty?\n end",
"def unlimited\n cached_dataset(:_unlimited_ds){clone(:limit=>nil, :offset=>nil)}\n end",
"def span_events_queue_size\n NewRelic::Agent.config[:'span_events.queue_size']\n end",
"def max_history= length\n @agent.history.max_size = length\n end",
"def remove_size(size)\n @size.delete(size)\n end",
"def size\n @max_entries\n end",
"def unlimited?\n return @unlimited\n end",
"def max_websocket_frame_size=(size)\n @j_del.setMaxWebSocketFrameSize(size)\n end",
"def max_websocket_frame_size=(size)\n @j_del.setMaxWebSocketFrameSize(size)\n end",
"def large\n @chart_size = 'large'\n self\n end",
"def max_bad_records= new_max_bad_records\n frozen_check!\n @gapi.max_bad_records = new_max_bad_records\n end",
"def valid_in_payload too_large # :nodoc:\n load_limit = @drb_config[:load_limit]\n\n size = nil\n valid = []\n\n loop do\n size, too_large = too_large.unpack 'Na*'\n\n break if load_limit < size\n\n valid << Marshal.load(too_large.slice!(0, size)).inspect\n end\n\n return valid, size, too_large\n end",
"def trim_scc_array\n if @scc_size.size > 0\n @scc_size.sort!\n if @scc_size.size < 5\n if @scc_size.first > @last_scc_size\n @scc_size.push(@last_scc_size)\n else\n @scc_size.unshift(@last_scc_size)\n end\n else\n if @last_scc_size > @scc_size.first\n @scc_size[0] = @last_scc_size\n end\n end\n else\n @scc_size.push(@last_scc_size)\n end\n end",
"def reject!\n n = size\n delete_if { |o| yield(o) }\n size == n ? nil : self\n end",
"def enforce_max_records_scan; end",
"def sample_length_with_overflow(tick_sample_length)\n @tracks.keys.collect {|track_name| @tracks[track_name].sample_length_with_overflow(tick_sample_length) }.max || 0\n end",
"def max_buffer_size; end",
"def prune_samples(at)\n cutoff = at - @interval\n while @samples.size > 1 && (@samples.first.first < cutoff)\n @samples.shift\n end\n end",
"def max\n if size == 0\n 0/0.0\n else\n self.size - 1\n end\n end",
"def display_drb_too_large packet # :nodoc:\n return if @quiet\n\n rest = packet.payload\n\n source, destination = resolve_addresses packet\n\n valid, size, rest = valid_in_payload rest\n\n puts '%s %s to %s packet too large, valid: [%s] too big (%d bytes): %s' % [\n packet.timestamp.strftime(TIMESTAMP_FORMAT),\n source, destination,\n valid.join(', '), size, rest.dump\n ]\n end",
"def remove_max\n return nil if heap.empty?\n deleted = @heap.delete_at 0\n last_one = @heap.pop\n if last_one #ei ole false tai nil\n @heap.insert 0, last_one\n heapify_down 0\n end\n deleted\n end",
"def exceeds_limit?(limit_value)\n !!(limit_value && sliced_nodes.limit(limit_value + 1).count > limit_value)\n end",
"def small_enough(arr, limit)\n arr.max <= limit\nend",
"def trimmed_audits\n grouped_audits.map { |_, audits| audits.first }\n end",
"def max_history\n @agent.history.max_size\n end",
"def on_finish(span) # rubocop:disable Metrics/AbcSize\n return unless span.context.trace_flags.sampled?\n\n lock do\n n = spans.size + 1 - max_queue_size\n spans.shift(n) if n.positive?\n spans << span\n @condition.signal if spans.size > max_queue_size / 2\n end\n end",
"def max_size\n @group.max_size\n end",
"def size_exhausted?\n @json_size >= (MAX_BYTES - Defaults::Message::MAX_BYTES)\n end",
"def file_max_byte_size_variant(max_byte_size)\n return nil unless file.attached? && file.analyzed?\n\n return file if file.blob.byte_size <= max_byte_size\n\n # original\n width = file.blob.metadata['width']\n height = file.blob.metadata['height']\n wh_ratio = width / height.to_f\n\n # target\n w = Math.sqrt( (max_byte_size * wh_ratio) / (WEIGHT_SIZE_RATIO * 3) ).floor\n\n if w >= width\n file\n else\n file.variant(resize_to_limit: [w, w / wh_ratio])\n end\n end",
"def avail_out= size\n\t\tsize.times do \n\t\t\tif size > avail_out\n\t\t\t\t@output_buffer.push nil\n\t\t\telse\n\t\t\t\t@output_buffer.pop\n\t\t\tend\n\t\tend\n\tend",
"def inspect\n \"#<#{self.class} size=#{size}/#{@max_size}>\"\n end",
"def clean(backtrace, kind = :silent)\n filtered = filter_backtrace(backtrace)\n\n case kind\n when :silent\n silence(filtered)\n when :noise\n noise(filtered)\n else\n filtered\n end\n end",
"def qcks_max_sink\n Quicksands[terrain_tag][:max_sink]\n end",
"def max_bad_records\n @gapi.max_bad_records\n end",
"def post_sample_size\n 300\n end",
"def remove_excess_entry\n TransportPassengerImport.first.destroy if TransportPassengerImport.count > 15\n end",
"def lift\r\n show_blank(size)\r\n @contents.pop\r\n end",
"def clean(backtrace, kind = :silent)\n filtered = filter(backtrace)\n\n case kind\n when :silent\n silence(filtered)\n when :noise\n noise(filtered)\n else\n filtered\n end\n end",
"def max_snapshots_per_group; end",
"def avail_out= size\n\t\t\tsize.times do\n\t\t\t\tif size > avail_out\n\t\t\t\t\t@output_buffer.push nil\n\t\t\t\telse\n\t\t\t\t\t@output_buffer.pop\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def with_no_logs_expected(max_severity, msg = nil, &block)\n logs = capture_logs(&block)\n failures = logs.map do |log|\n severity_str = log[:severity]\n next unless Logger::Severity.const_get(severity_str) >= max_severity\n\n # give a handful of stack frames (no way to know how many are useful)\n bt = log[:caller][0..2].map{|s| \" at #{s}\"}\n if bt.length < log[:caller].length\n bt << \" (...)\"\n end\n\n \" #{severity_str}: #{log[:msg]}\\n\" + bt.join(\"\\n\")\n end.compact\n\n unless failures.empty?\n msg ||= 'Unexpected log messages'\n flunk( ([msg+':'] + failures).join(\"\\n\\n\") )\n end\n end",
"def max_file_buffer; end",
"def max_file_buffer; end",
"def size\n @max\n end",
"def max_snapshot_groups; end",
"def immediately_clear_tag_cloud?\n Annotation.count < (Seek::Config.max_visible_tags * 2)\n end",
"def immediately_clear_tag_cloud?\n Annotation.count < (Seek::Config.max_visible_tags * 2)\n end",
"def limit; end",
"def limit; end",
"def limit; end",
"def collect_every(size)\n collect = []\n\n index = 0\n while true\n slice = self.slice(index, size)\n break if slice.nil? || slice.empty?\n\n collect.concat(yield slice)\n index += size\n end\n\n collect\n end",
"def set_maximum_queued_data_size(opts)\n opts = check_params(opts,[:sizes])\n super(opts)\n end",
"def enforce_max_records_scan=(_arg0); end",
"def default_max_size; end",
"def plot_summary_size?\n make_plot = false\n @groups.each do |g|\n if g.has_overall_sample_size?\n make_plot = true\n break\n end\n end\n return make_plot\n end",
"def callback_traces\n return true if @trace_buffer.empty?\n\n begin\n traces = @trace_buffer.pop\n traces = Pipeline.process!(traces)\n @trace_task.call(traces, @transport) unless @trace_task.nil?\n rescue StandardError => e\n # ensures that the thread will not die because of an exception.\n # TODO[manu]: findout the reason and reschedule the send if it's not\n # a fatal exception\n Datadog::Tracer.log.error(\n \"Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}\"\n )\n end\n end",
"def big_files(max_size=10.megabytes)\n return @big_files if @big_files\n @big_files = (memsize_per_file_hash || {}).select do |key, size|\n size >= max_size\n end\n end",
"def maximum_size\n @ids.size\n end",
"def max_history=(length); end",
"def max_history=(length); end",
"def reject!(&block)\n block or return enum_for(__method__) { size }\n n = size\n delete_if(&block)\n self if size != n\n end"
] |
[
"0.61693555",
"0.57163584",
"0.57105595",
"0.54114175",
"0.53919816",
"0.52930886",
"0.528617",
"0.5285338",
"0.5233599",
"0.5205406",
"0.51650554",
"0.51444846",
"0.514387",
"0.51410484",
"0.51288825",
"0.5065652",
"0.50645363",
"0.5055123",
"0.5051021",
"0.5035188",
"0.503353",
"0.5004294",
"0.4970562",
"0.4939507",
"0.49065313",
"0.4830716",
"0.48144272",
"0.4806698",
"0.48030668",
"0.4731009",
"0.472701",
"0.47190413",
"0.47189346",
"0.4715306",
"0.46908605",
"0.46819732",
"0.4670196",
"0.4654297",
"0.46537852",
"0.4643553",
"0.462457",
"0.46221668",
"0.46182653",
"0.4612573",
"0.46098438",
"0.46044388",
"0.45996138",
"0.45946452",
"0.45946452",
"0.45881927",
"0.4586997",
"0.45826086",
"0.45773935",
"0.45740554",
"0.45571998",
"0.4556266",
"0.45538354",
"0.4552414",
"0.45459616",
"0.45429677",
"0.4541239",
"0.454081",
"0.4538023",
"0.45333916",
"0.45319727",
"0.45307133",
"0.452864",
"0.4519647",
"0.45173556",
"0.44980136",
"0.44803694",
"0.44765672",
"0.44759357",
"0.44653898",
"0.44616553",
"0.44519535",
"0.44488016",
"0.44399485",
"0.4431322",
"0.4427078",
"0.44198948",
"0.44124627",
"0.44124627",
"0.43996114",
"0.43928692",
"0.4388741",
"0.4388741",
"0.4388314",
"0.4388314",
"0.4388314",
"0.43826562",
"0.4382655",
"0.43764246",
"0.43749237",
"0.43747577",
"0.4373117",
"0.43664283",
"0.43616974",
"0.43608496",
"0.43608496",
"0.43593687"
] |
0.0
|
-1
|
Encodes a list of traces in chunks. Before serializing, all traces are normalized. Trace nesting is not changed.
|
def encode_in_chunks(traces)
encoded_traces = if traces.respond_to?(:filter_map)
# DEV Supported since Ruby 2.7, saves an intermediate object creation
traces.filter_map { |t| encode_one(t) }
else
traces.map { |t| encode_one(t) }.reject(&:nil?)
end
Datadog::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|
[encoder.join(chunk), chunk.size]
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def encode_traces(traces)\n to_send = []\n traces.each do |trace|\n to_send << trace.map(&:to_hash)\n end\n encode(to_send)\n end",
"def batch(requests)\n data = requests.map { |request| Request.new(*request).data }\n RPC.log \"CLIENT ENCODE BATCH #{data.inspect}\"\n data.to_json\n end",
"def encode_chunk(chunk); end",
"def create_new_traces\n @traces.each do |trace|\n trace_stack = trace.stack_to_render[0]\n unless(trace_stack.func_name.include? '<init>')\n trace_stack_ordered_variable_names = trace_stack.ordered_varnames\n trace_stack_encoded_locals = trace_stack.encoded_locals\n trace_heap = trace.heap\n trace_code = @code[trace.line]\n filtered_trace = filter_trace([\n trace_stack_ordered_variable_names,\n trace_stack_encoded_locals,\n trace_heap,\n trace_code,\n trace.line\n ])\n @new_traces << filtered_trace\n trace_string = Yajl::Encoder.encode(filtered_trace)\n @traces_json_array << trace_string\n @traces_json_string += trace_string + ','\n end\n end\n end",
"def marshal_dump\r\n [@depth, @map_id, @event_id, @list, @index + 1, @branch]\r\n end",
"def send_spans(traces, transport)\n return true if traces.empty?\n\n # Send traces and get responses\n responses = transport.send_traces(traces)\n\n # Tally up successful flushes\n responses.reject { |x| x.internal_error? || x.server_error? }.each do |response|\n @traces_flushed += response.trace_count\n end\n\n events.after_send.publish(self, responses)\n\n # Return if server error occurred.\n !responses.find(&:server_error?)\n end",
"def do_encode # :nodoc:\n case\n when encoded_to_s.length <= 78\n encoded_to_s\n when encoded_to_s.length > 78\n @folded_line = []\n @unfolded_line = encoded_to_s\n wspp = @unfolded_line =~ /[ \\t]/\n fold\n @folded_line.join(\"\\r\\n\\t\")\n end\n end",
"def serialize_tracks(tracks)\n json = \"{[\"\n # Add each track to the JSON.\n tracks.each do |track|\n json += serialize_track(track)\n # Add a comma if there are more tracks.\n json += \",\" unless track == tracks.last\n end\n # Close out the JSON and return.\n json += \"]}\"\n end",
"def serialize trace_context\n [\n 0, # version\n 0, # field 0\n trace_context.trace_id,\n 1, # field 1\n trace_context.span_id,\n 2, # field 2\n trace_context.trace_options\n ].pack(BINARY_FORMAT)\n end",
"def map_to_chunks(frames)\n frames.each_cons(1 + BONUS_LOOKAHEADS.max).to_a\n end",
"def convert_list_of_json_traces_to_objects(list_of_traces)\n list_of_traces.each do |trace|\n @traces << convert_json_trace_to_object(trace)\n end\n end",
"def encode_modified(list)\n pack(list).map { |i| i.length > 1 ? [i.length,i.first] : i.first }\nend",
"def encode_list(value)\n encode_string(value.map { |s| encode_string(s) }.join)\n end",
"def send_spans(traces, transport)\n return true if traces.empty?\n\n # Inject hostname if configured to do so\n inject_hostname!(traces) if Datadog.configuration.report_hostname\n\n # Send traces an get a response.\n response = transport.send_traces(traces)\n\n unless response.internal_error?\n @traces_flushed += traces.length unless response.server_error?\n\n # Update priority sampler\n unless priority_sampler.nil? || response.service_rates.nil?\n priority_sampler.update(response.service_rates)\n end\n end\n\n # Return if server error occurred.\n !response.server_error?\n end",
"def put_raw(metric_lines)\n @buffer.push(metric_lines)\n if @buffer.size >= @config[:flush_size]\n flush\n end\n end",
"def list_orders_tosend_multiple_artworks\n doc = Hpricot::XML(request.raw_post)\n doc = doc.to_s.gsub(\"&\",\"&\")\n doc = Hpricot::XML(doc)\n @orders = Artwork::ArtworkCrud.list_orders_tosend_multiple_artworks(doc)\n # render :xml=>@orders[0].xmlcol\n render :xml=>'<encoded>'+Base64.encode64(Zlib::Deflate.deflate(@orders[0].xmlcol))+'</encoded>'\n end",
"def encode(list)\n pack(list).map { |i| [i.length,i.first] }\nend",
"def encode_body(buffer)\n buffer << prior_action_ids.to_msgpack\n end",
"def encode(serialized_actions = [])\n serialized_actions.join(\"\\n\")\n end",
"def serialize_list_array(list_uri, uris)\n uris.each_index { |index|\n next_uri = nil\n next_uri = uris[index + 1] if index + 1 < uris.length\n serialize_list(uris, index, uris[index], next_uri, list_uri)\n }\n end",
"def encode(tokens)\n return nil if tokens.nil?\n tokens = [tokens] unless tokens.is_a?(Array)\n\n # TODO: tokens need to be unique (duplicates need to remain at the end), remember\n # the order from left to right is oldest to newest - any duplicates should always be newest\n # (i.e. if we 'track' a user using the same token on the same day 2x - the second visit's position\n # should be meaningful) -- i.e. order of tracking => A, F, B, F, C should encode as A|B|F|C, NOT A|F|B|C\n tokens.map{|t| encode_token(t) }.join(config.separator)\n end",
"def encode_stream(stream)\n sz = stream.inject(0) do |acc, ele|\n acc + (ele.kind_of?(Array) ? ele.size : 1)\n end\n\n @max_stack_depth = 0\n @stack_depth = 0\n @iseq = InstructionSequence.new(sz)\n @offset = 0\n\n begin\n stream.each do |inst|\n encode inst\n end\n rescue Exception => e\n STDERR.puts \"Unable to encode stream:\"\n STDERR.puts stream.inspect\n raise e\n end\n\n @iseq.stack_depth = @max_stack_depth\n\n return @iseq\n end",
"def _encode(list, c = 1, acc = [])\n\n h, hh, *t = list\n if list.empty? then acc\n elsif hh.nil? then acc.push([h, c])\n elsif h == hh then _encode([hh] + t, c + 1, acc)\n else _encode([hh] + t, 1, acc.push([h, c]))\n end\nend",
"def to_payload\n to_array.map { |line| MultiJson.encode(line) }.join(\"\\n\") + \"\\n\"\n end",
"def serialize_events( events )\n\t\treturn events.map( &SERIALIZE_PIPELINE )\n\tend",
"def serialize_events( events )\n\t\treturn events.map( &SERIALIZE_PIPELINE )\n\tend",
"def serialize_list(values, index, value_uri, next_value_uri, list_uri)\n if index == 0 then\n create_triple(list_uri, @base.has_first_part, value_uri)\n elsif index + 1 == values.length then\n create_triple(list_uri, @base.has_last_part, value_uri)\n else\n create_triple(list_uri, @base.has_ordered_part, value_uri)\n end\n if index + 1 < values.length then\n create_triple(value_uri, @base.is_before, next_value_uri)\n end\n end",
"def encode(data)\n MultiJson.encode(data)\n end",
"def encode(codes)\n encode_list(codes, @weeks)\n codes << encoding_token\n end",
"def serialize_in_batches(collection, serializer)\n collection.find_in_batches(batch_size: 50).each_with_object([]) do |batch, arr|\n arr << batch.map { |resource| serializer.new(resource).serialize.compact }\n end.flatten\n end",
"def callback_traces\n return true if @trace_buffer.empty?\n\n begin\n traces = @trace_buffer.pop\n traces = Pipeline.process!(traces)\n @trace_task.call(traces, @transport) unless @trace_task.nil?\n rescue StandardError => e\n # ensures that the thread will not die because of an exception.\n # TODO[manu]: findout the reason and reschedule the send if it's not\n # a fatal exception\n Datadog::Tracer.log.error(\n \"Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}\"\n )\n end\n end",
"def _test_recursive_list\n assert_raise BEncode::EncodeError do\n list = []\n list << list\n list.bencode\n end\n\n assert_raise BEncode::EncodeError do\n list = [[]]\n list.first << list\n list.bencode\n end\n end",
"def json()\n @trace_arr.map{|trace| \n tile = trace.json \n @tiles[trace.id] = trace\n trace.id\n }\n end",
"def batchify\n nodes = pop(Time.now)\n batches = []\n\n nodes.in_groups_of(50, false) do |group|\n batches << SuperNode::Facebook::Batch.new({\n :access_token => access_token,\n :queue_id => queue_id,\n :batch => group,\n })\n end\n\n batches\n end",
"def convert_binary_traceroutes(data, print=false)\n offset=0\n traceroutes=[]\n while not offset>=data.length\n header=data[offset,16].unpack(\"L4\")\n offset += 16\n if header.nil? or header.include?(nil) \n raise TruncatedTraceFileException.new(traceroutes), \"Error reading header\", caller\n end\n client_id=header.at(0)\n uid=header.at(1)\n num_tr=header.at(2)\n record_length=header.at(3)\n (0...num_tr).each{|traceroute_index|\n tr_header=data[offset,8].unpack(\"NL\")\n offset += 8\n if tr_header.nil? or tr_header.include?(nil)\n raise TruncatedTraceFileException.new(traceroutes), \"Error reading TR header\", caller\n end\n dst=Inet::ntoa(tr_header.at(0))\n numhops=tr_header.at(1)\n hops = []\n rtts = []\n ttls = []\n last_nonzero=-1\n (0...numhops).each{|j|\n hop_info=data[offset,12].unpack(\"NfL\")\n offset += 12\n if hop_info.nil? or hop_info.include?(nil)\n raise TruncatedTraceFileException.new(traceroutes), \"Error reading hop\", caller\n end\n ip = Inet::ntoa(hop_info.at(0))\n rtt = hop_info.at(1)\n ttl = hop_info.at(2)\n if (ttl > 512)\n raise TruncatedTraceFileException.new(traceroutes), \"TTL>512, may be corrupted\", caller\n end\n if ip!=\"0.0.0.0\"\n last_nonzero=j\n end\n hops << ip\n rtts << rtt\n ttls << ttl\n\n }\n if last_nonzero>-1\n traceroutes << [dst,hops,rtts,ttls]\n if print\n tr_s=\"#{dst} #{last_nonzero+1} #{hops[0..last_nonzero].join(\" \")}\"\n if block_given?\n yield(tr_s)\n else \n $stdout.puts \"tr_s\"\n end \n #puts \"#{ARGV[1..-1].join(\" \")} #{dst} #{last_nonzero+1} #{hops[0..last_nonzero].join(\" \")}\"\n end\n end\n\n }\n end\n return traceroutes\nend",
"def encode(object)\n ::MultiJson.encode(object)\n end",
"def callback_traces\n return if @trace_buffer.empty?\n\n begin\n traces = @trace_buffer.pop()\n @trace_task.call(traces, @transport)\n rescue StandardError => e\n # ensures that the thread will not die because of an exception.\n # TODO[manu]: findout the reason and reschedule the send if it's not\n # a fatal exception\n Datadog::Tracer.log.error(\"Error during traces flush: dropped #{items.length} items. Cause: #{e}\")\n end\n end",
"def encode(codes)\n encode_list(codes, @days)\n codes << encoding_token\n end",
"def add_multi_block(block)\n\t\t\t@encoded << block\n\tend",
"def trace_list\n my_list = []\n (0...@list_of_events.length).each do |x|\n temp = @list_of_events[x]\n my_list << temp.trace\n end\n my_list\n end",
"def send_batch msgs\n @ws.send encode_batch(msgs)\n end",
"def write( x )\n Array( x ).each {|e| @head[-1] << e }\n end",
"def record(span)\n span.service ||= default_service\n\n spans = []\n @mutex.synchronize do\n @spans << span\n parent = span.parent\n # Bubble up until we find a non-finished parent. This is necessary for\n # the case when the parent finished after its parent.\n parent = parent.parent while !parent.nil? && parent.finished?\n @buffer.set(parent)\n\n return unless parent.nil?\n\n # In general, all spans within the buffer belong to the same trace.\n # But in heavily multithreaded contexts and/or when using lots of callbacks\n # hooks and other non-linear programming style, one can technically\n # end up in different situations. So we only extract the spans which\n # are associated to the root span that just finished, and save the\n # others for later.\n trace_spans = []\n alien_spans = []\n @spans.each do |s|\n if s.trace_id == span.trace_id\n trace_spans << s\n else\n alien_spans << s\n end\n end\n spans = trace_spans\n @spans = alien_spans\n end\n\n return if spans.empty? || !span.sampled\n write(spans)\n end",
"def write_many(writer, items, options = nil)\n writer.push_array\n items.each do |item|\n write_one(writer, item, options)\n end\n writer.pop\n end",
"def encode\n return [Zlib::Deflate.deflate(Marshal.dump(self))].pack('m')\n end",
"def export spans\n each { |delegate| delegate.export spans }\n nil\n end",
"def encode_block(state, buf)\n\t\tbuf\n\tend",
"def blocks\n object.blocks.map{ |x|\n ShallowBlockSerializer.new(x)\n }\n end",
"def to_tags\n arr = split_tags.map(&:add_at)\n if block_given?\n yield arr\n else\n arr\n end\n end",
"def write( chunk )\n begin\n $log.debug \"Size of chunk is: #{chunk.size}\"\n requests = self.build_add_events_body( chunk )\n $log.debug \"Chunk split into #{requests.size} request(s).\"\n\n requests.each_with_index { |request, index|\n $log.debug \"Request #{index + 1}/#{requests.size}: #{request[:body].bytesize} bytes\"\n begin\n response = self.post_request( @add_events_uri, request[:body] )\n self.handle_response( response )\n rescue OpenSSL::SSL::SSLError => e\n if e.message.include? \"certificate verify failed\"\n $log.warn \"SSL certificate verification failed. Please make sure your certificate bundle is configured correctly and points to a valid file. You can configure this with the ssl_ca_bundle_path configuration option. The current value of ssl_ca_bundle_path is '#{@ssl_ca_bundle_path}'\"\n end\n $log.warn e.message\n $log.warn \"Discarding buffer chunk without retrying or logging to <secondary>\"\n rescue Scalyr::Client4xxError => e\n $log.warn \"4XX status code received for request #{index + 1}/#{requests.size}. Discarding buffer without retrying or logging.\\n\\t#{response.code} - #{e.message}\\n\\tChunk Size: #{chunk.size}\\n\\tLog messages this request: #{request[:record_count]}\\n\\tJSON payload size: #{request[:body].bytesize}\\n\\tSample: #{request[:body][0,1024]}...\"\n\n end\n }\n\n rescue JSON::GeneratorError\n $log.warn \"Unable to format message due to JSON::GeneratorError.\"\n raise\n end\n end",
"def chunk_records(records, batch_size)\n Enumerator.new do |enum|\n chunked_records = []\n\n records.each do |record|\n if chunked_records.size == batch_size\n enum.yield(chunked_records)\n chunked_records = []\n end\n\n transformed_record = block_given? ? yield(record) : record\n chunked_records.push(transformed_record)\n end\n\n # Yield the remaining records if any\n enum.yield(chunked_records) unless chunked_records.empty?\n end\nend",
"def report_spans(spans)\n return unless @state == :announced\n\n path = \"com.instana.plugin.ruby/traces.#{@process[:report_pid]}\"\n uri = URI.parse(\"http://#{@host}:#{@port}/#{path}\")\n req = Net::HTTP::Post.new(uri)\n\n req.body = spans.to_json\n response = make_host_agent_request(req)\n\n if response\n last_trace_response = response.code.to_i\n\n #::Instana.logger.debug \"traces response #{last_trace_response}: #{spans.to_json}\"\n\n if [200, 204].include?(last_trace_response)\n return true\n end\n end\n false\n rescue => e\n Instana.logger.debug \"#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}\"\n Instana.logger.debug e.backtrace.join(\"\\r\\n\")\n end",
"def encode\n h = {\n :batch => @batch_hash,\n :job_id => @job_id\n }\n h.to_json.to_s\n end",
"def handle_extent_array\n bytecounts, byteoffsets, startblocks, fileoffsets, partitions = [], [], [], [], []\n @extentinfo[:extent].each do |f|\n bytecounts << f[:bytecount]\n byteoffsets << f[:byteoffset]\n startblocks << f[:startblock]\n fileoffsets << f[:fileoffset]\n partitions << f[:partition]\n end\n @bytecount = bytecounts.join(',')\n @byteoffset = byteoffsets.join(',')\n @startblock = startblocks.join(',')\n @fileoffset = fileoffsets.join(',')\n @partition = partitions.join(',')\n end",
"def on_start(span, _parent_context)\n context = span.context\n trace_id = context.trace_id\n\n lock do\n if all_spans_count(traces_spans_count) >= max_queue_size\n # instead of just dropping all new spans, dd-trace-rb drops a random trace\n # https://github.com/DataDog/dd-trace-rb/blob/c6fbf2410a60495f1b2d8912bf7ea7dc63422141/lib/ddtrace/buffer.rb#L34-L36\n # It allows for a more fair usage of the queue when under stress load,\n # and will create proportional representation of code paths being instrumented at stress time.\n unfinished_trace_id = fetch_unfinished_trace_id\n\n # if there are no unfinished traces able to be dropped, don't add more spans, and return early\n if unfinished_trace_id.nil?\n OpenTelemetry.logger.warn('Max spans for all traces, spans will be dropped')\n @_spans_dropped = true\n return\n end\n\n drop_unfinished_trace(unfinished_trace_id)\n OpenTelemetry.logger.warn('Max spans for all traces, traces will be dropped')\n end\n\n if traces[trace_id].nil?\n traces[trace_id] = [span]\n traces_spans_count[trace_id] = 1\n else\n if traces[trace_id].size >= max_trace_size\n OpenTelemetry.logger.warn('Max spans for trace, spans will be dropped')\n @_spans_dropped = true\n return\n end\n\n traces[trace_id] << span\n traces_spans_count[trace_id] += 1\n end\n end\n end",
"def aggregate_by_chunks\n forward = []\n reverse = []\n chunks.each do |chunk|\n reads=get :chunks, chunk\n forward << (get :side, :left)\n reverse << (get :side, :right)\n end\n [forward,reverse]\n end",
"def encode(object)\n if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)\n MultiJson.dump object\n else\n MultiJson.encode object\n end\n end",
"def encode_items\n self.items =\n ActiveSupport::JSON.encode(self.items) rescue self.items.to_json\n end",
"def __group_entries(entries)\n entry_groups = {}\n entries.map do |entry|\n # group streams by their base paths (ignore ~decim endings)\n group_name = entry[:chunks].pop.gsub(UpdateStream.decimation_tag, '')\n __add_to_group(entry_groups, group_name, entry)\n end\n entry_groups\n end",
"def enqueue_trace(trace)\n @trace_buffer.push(trace)\n end",
"def enqueue_trace(trace)\n @trace_buffer.push(trace)\n end",
"def to_s\n '#<Twilio.FlexApi.V1.InsightsSegmentsList>'\n end",
"def chunk(*chunks)\n @queue += chunks\n schedule_dequeue\n end",
"def encode_array(arr)\n arr.join ','\n end",
"def batch(items)\n if items.is_a?(String)\n @file.write(\" #{items}\")\n else\n items.each { |item| @file.write(\" #{item}\") }\n end\n end",
"def batch\n yield self.class.new(batch = Transport::Queue.new)\n\n batch.inject(Hash.new { |h,k| h[k]=[] }) do |stats, stat|\n # [ \"foo.bar:10|c\", \"foo.bar:101|ms\" ]\n key, value = stat.split(':', 2)\n stats[key] << value\n stats\n end.sort.each do |pairs|\n # [ \"foo.bar\", [ \"10|c\", \"101|ms\" ] ]\n @transport.write(pairs.flatten.join(\":\"))\n end\n self\n end",
"def encode_body(buffer)\n # Encode the message count.\n buffer << {\n :count => messages.length\n }.to_msgpack\n \n # Encode all the messages.\n messages.each do |message|\n message.encode(buffer)\n end\n end",
"def serialize(*args)\n MultiJson.dump(*args)\n end",
"def encode(headers)\n buffer = Buffer.new\n commands = []\n\n # Literal header names MUST be translated to lowercase before\n # encoding and transmission.\n headers.map! {|(hk,hv)| [hk.downcase, hv] }\n\n # Generate remove commands for missing headers\n @cc.refset.each do |idx, (wk,wv)|\n if headers.find {|(hk,hv)| hk == wk && hv == wv }.nil?\n commands.push @cc.removecmd idx\n end\n end\n\n # Generate add commands for new headers\n headers.each do |(hk,hv)|\n if @cc.refset.find {|i,(wk,wv)| hk == wk && hv == wv}.nil?\n commands.push @cc.addcmd [hk, hv]\n end\n end\n\n commands.each do |cmd|\n @cc.process cmd.dup\n buffer << header(cmd)\n end\n\n buffer\n end",
"def marshal_into_items(objects)\n objects.map { |object| marshal_into_item(object) }\n end",
"def dump(records, dump = '')\n # each is faster than inject\n records.each do |record|\n record[1] = @serializer.dump(record.last)\n dump << @format.dump(record)\n end\n dump\n end",
"def stanzas(data)\n @buf << data\n raise \"Stanzas must be less than #{@max_buffer_size} bytes\" if (@buf.length > @max_buffer_size)\n data.each_char do |ch|\n @state = @state.handle(@context, ch)\n @pos += 1\n end\n @stanzas.slice!(0, @stanzas.length)\n end",
"def encode_to_array\n components = []\n components << [self.class.id, @channel, @payload.bytesize].pack(PACK_CHAR_UINT16_UINT32)\n components << self.class.encoded_payload(@payload)\n components << FINAL_OCTET\n components\n end",
"def send_chunks\n\t\t\tsend_headers unless @sent_headers\n\t\t\twhile chunk = @chunks.shift\n\t\t\t\traise \"last chunk already sent\" if @last_chunk_sent\n\t\t\t\ttext = chunk.is_a?(Hash) ? chunk[:text] : chunk.to_s\n\t\t\t\tsend_data \"#{format(\"%x\", text.length).upcase}\\r\\n#{text}\\r\\n\"\n\t\t\t\t@last_chunk_sent = true if text.length == 0\n\t\t\tend\n\t\tend",
"def chunk_to_lines chunk, layout, start, depth\n prefix = \" \" * INDENT_SPACES * depth\n\n if chunk.inlineable?\n lines = layout.wrapped ? wrap_lines(chunk.lines) : chunk.lines\n lines.map { |line| [[chunk.color, \"#{prefix}#{line}\"]] }\n elsif chunk.expandable?\n case layout.state\n when :closed\n [[[chunk.patina_color, \"#{prefix}+ #{chunk.patina_text}\"]]]\n when :open\n lines = layout.wrapped ? wrap_lines(chunk.lines) : chunk.lines\n [[[chunk.patina_color, \"#{prefix}- #{chunk.patina_text}\"]]] + lines.map { |line| [[chunk.color, \"#{prefix}#{line}\"]] }\n end\n else\n [[[chunk.patina_color, \"#{prefix}x #{chunk.patina_text}\"]]]\n end\n end",
"def serialize\n data = MultiJson::dump(self)\n header = [data.length].pack('Q')\n data.prepend(header)\n end",
"def encode(headers)\n buffer = Buffer.new\n pseudo_headers, regular_headers = headers.partition { |f, _| f.start_with? ':' }\n headers = [*pseudo_headers, *regular_headers]\n commands = @cc.encode(headers)\n commands.each do |cmd|\n buffer << header(cmd)\n end\n\n buffer\n end",
"def events_jsonify(events)\n\t\t\tevents.collect do |event|\n\t\t\t\t{ id: event.id,\n\t\t\t\t\tname: event.name,\n\t\t\t\t\tsummary: event.summary,\n\t\t\t\t\tstart_era: event.start_era,\n\t\t\t\t\tstart_date: \"#{event.start_date or 0}/#{event.start_month or 0}/#{event.start_year}\",\n\t\t\t\t\tend_date: \"#{event.end_date or 0}/#{event.end_month or 0}/#{event.end_year or event.start_year}\",\n\t\t\t\t\tarcs: event.arcs,\n\t\t\t\t\tentities: event.entities }\n\t\t\tend.to_json\n\t\tend",
"def write_varint_array(array, &block)\n if array.nil?\n write_varint(-1)\n else\n write_varint(array.size)\n array.each(&block)\n end\n end",
"def encode(headers)\n commands = []\n @cc.update_sets\n\n # Remove missing headers from the working set\n @cc.workset.each do |idx, (wk,wv)|\n if headers.find {|(hk,hv)| hk == wk && hv == wv }.nil?\n commands.push @cc.removecmd idx\n end\n end\n\n # Add missing headers to the working set\n headers.each do |(hk,hv)|\n if @cc.workset.find {|i,(wk,wv)| hk == wk && hv == wv}.nil?\n commands.push @cc.addcmd [hk, hv]\n end\n end\n\n commands.map do |cmd|\n @cc.process cmd.dup\n header cmd\n end.join\n end",
"def to_s\n @segments.collect { |s| s if s.to_s.length > 0 }.join( \"\\n\" ).encode(encoding)\n end",
"def serialize_batch(batch)\n batch.to_json\n end",
"def to_stack; end",
"def chunk(*chunks)\n @body.chunk(*chunks)\n end",
"def flush\n send_batch( Traject::Util.drain_queue(@batched_queue) )\n end",
"def marshal_dump\n [@tokens, @count, @index, @pairs]\n end",
"def write(trace, services = nil)\n unless services.nil?\n Datadog::Patcher.do_once('Writer#write') do\n Datadog::Tracer.log.warn(%(\n write: Writing services has been deprecated and no longer need to be provided.\n write(traces, services) can be updted to write(traces)\n ))\n end\n end\n\n # In multiprocess environments, the main process initializes the +Writer+ instance and if\n # the process forks (i.e. a web server like Unicorn or Puma with multiple workers) the new\n # processes will share the same +Writer+ until the first write (COW). Because of that,\n # each process owns a different copy of the +@buffer+ after each write and so the\n # +AsyncTransport+ will not send data to the trace agent.\n #\n # This check ensures that if a process doesn't own the current +Writer+, async workers\n # will be initialized again (but only once for each process).\n pid = Process.pid\n if pid != @pid # avoid using Mutex when pids are equal\n @mutex_after_fork.synchronize do\n # we should start threads because the worker doesn't own this\n start if pid != @pid\n end\n end\n\n # Associate root span with runtime metrics\n runtime_metrics.associate_with_span(trace.first) unless trace.empty?\n\n @worker.enqueue_trace(trace)\n end",
"def add_to_buffer(records)\n @records_buffer.push(*records)\n end",
"def expand(*regions)\n regions = normalize_territories(regions.flatten)\n expanded_set(regions).to_a\n end",
"def write(chunk)\n generate_tokens_list()\n return unless @tokens.is_a? Hash\n\n chunk.msgpack_each do |tag, record|\n next unless record.is_a? Hash\n next unless @use_json or record.has_key? \"message\"\n\n token = get_token(tag, record)\n next if token.nil?\n\n # Clean up the string to avoid blank line in logentries\n message = @use_json ? record.to_json : record[\"message\"].rstrip()\n send_logentries(token, message)\n end\n end",
"def encode\n s = \"#{punpack_string(@ts)}#{punpack_string(@ls)}\"\n [@type, @length, @value].pack(\"#{s}a*\")\n end",
"def encode\n Logger.debug \"encoding #{self.inspect}\"\n class_mapper = RocketAMF::ClassMapper.new\n ser = RocketAMF::Serializer.new class_mapper\n\n if amf3?\n ser.stream << \"\\x00\"\n end\n\n ser.serialize 0, command\n ser.serialize 0, transaction_id\n\n if amf3?\n ser.stream << \"\\x05\"\n ser.stream << \"\\x11\"\n ser.serialize 3, values.first\n else\n values.each do |value|\n ser.serialize 0, value\n end\n end\n\n ser.stream\n end",
"def rail_encode(s,rail_count)\n phrase = s.dup\n rail_indexes = Array(0..(rail_count-1))\n rails = create_rails(rail_indexes)\n lines = build_lines(phrase,rails,rail_indexes)\n lines.values.reduce(:+)\nend",
"def to_tracks(raw_tracks)\n result = []\n raw_tracks.each do |raw_track|\n \tresult << to_track(raw_track)\n end\n\n return result\n end",
"def send_splits(event)\n # Parse message parameters\n msg = event.content\n ep = parse_highscoreable(msg, mappack: true)\n ep = ep.episode if ep.is_a?(Levelish)\n raise OutteError.new \"Sorry, columns can't be analyzed yet.\" if ep.is_a?(Storyish)\n mappack = ep.is_a?(MappackHighscoreable)\n board = parse_board(msg, 'hs')\n raise OutteError.new \"Sorry, speedrun mode isn't available for Metanet levels yet.\" if !mappack && board == 'sr'\n raise OutteError.new \"Sorry, episode splits are only available for either highscore or speedrun mode\" if !['hs', 'sr'].include?(board)\n scores = ep.leaderboard(board, pluck: false)\n rank = parse_range(msg)[0].clamp(0, scores.size - 1)\n ntrace = board == 'hs' # Requires ntrace\n\n # Calculate episode splits\n if board == 'sr'\n valid = [true] * 5\n ep_scores = Demo.decode(scores[rank].demo.demo, true).map(&:size)\n ep_splits = splits_from_scores(ep_scores, start: 0, factor: 1, offset: 0)\n elsif FEATURE_NTRACE\n file = nil\n valid = valid = [false] * 5\n ep_splits = []\n ep_scores = []\n\n # Execute ntrace in mutex\n wait_msg = event.send_message(\"Queued...\") if $mutex[:ntrace].locked?\n $mutex[:ntrace].synchronize do\n wait_msg.delete if !wait_msg.nil?\n\n # Export input files\n File.binwrite('inputs_episode', scores[rank].demo.demo)\n ep.levels.each_with_index{ |l, i|\n map = !l.is_a?(Map) ? MappackLevel.find(l.id) : l\n File.binwrite(\"map_data_#{i}\", map.dump_level)\n }\n shell(\"python3 #{PATH_NTRACE}\")\n\n # Read output files\n file = File.binread('output.txt') rescue nil\n if !file.nil?\n valid = file.scan(/True|False/).map{ |b| b == 'True' }\n ep_splits = file.split(/True|False/)[1..-1].map{ |d|\n round_score(d.strip.to_i.to_f / 60.0)\n }\n ep_scores = scores_from_splits(ep_splits, offset: 90.0)\n FileUtils.rm(['output.txt'])\n end\n\n # Cleanup\n FileUtils.rm(['inputs_episode', *Dir.glob('map_data_*')])\n end\n end\n\n # Calculate IL splits\n lvl_splits = ep.splits(rank, board: board)\n if lvl_splits.nil?\n event << \"Sorry, that rank doesn't seem to exist for at least some of the levels.\"\n return\n end\n scoref = !mappack ? 'score' : \"score_#{board}\"\n factor = mappack && board == 'hs' ? 60.0 : 1\n lvl_scores = ep.levels.map{ |l| l.leaderboard(board)[rank][scoref] / factor }\n\n # Calculate differences\n full = (!ntrace || FEATURE_NTRACE) && !file.nil?\n\n event << \"ntrace failed.\" if file.nil?\n\n if full\n errors = valid.count(false)\n if errors > 0\n wrong = valid.each_with_index.map{ |v, i| !v ? i.to_s : nil }.compact.to_sentence\n event << \"Warning: Couldn't calculate episode splits (error in #{'level'.pluralize(errors)} #{wrong}).\"\n full = false\n end\n\n cum_diffs = lvl_splits.each_with_index.map{ |ls, i|\n mappack && board == 'sr' ? ep_splits[i] - ls : ls - ep_splits[i]\n }\n diffs = cum_diffs.each_with_index.map{ |d, i|\n round_score(i == 0 ? d : d - cum_diffs[i - 1])\n }\n end\n\n # Format response\n rows = []\n rows << ['', '00', '01', '02', '03', '04']\n rows << :sep\n rows << ['Ep splits', *ep_splits] if full\n rows << ['Lvl splits', *lvl_splits]\n rows << ['Total diff', *cum_diffs] if full\n rows << :sep if full\n rows << ['Ep scores', *ep_scores] if full\n rows << ['Lvl scores', *lvl_scores]\n rows << ['Ind diffs', *diffs] if full\n\n event << \"#{rank.ordinalize} #{format_board(board)} splits for episode #{ep.name}:\"\n event << \"(Episode splits aren't available because ntrace is disabled).\" if ntrace && !FEATURE_NTRACE\n event << format_block(make_table(rows))\nrescue => e\n lex(e, \"Error calculating splits.\", event: event)\nend",
"def encode_headers(headers)\n result = StringIO.new\n headers.each do |key, value|\n next if value == nil\n if value.kind_of?(Array)\n value.each do |subvalue|\n result << (\"%s: %s\\r\\n\" % [key, subvalue])\n end\n else\n result << (\"%s: %s\\r\\n\" % [key, value])\n end\n end\n return result.string\n end",
"def encode_end(real_payload, reqs, encoded)\n encoded\n end",
"def write(chunk)\n log.trace \"write:\", chunk\n\n @redis.multi \n chunk.each do |time, record|\n log.debug \"write sync redis push \", chunk.metadata.tag, time, record, @listname\n @redis.lpush(@listname,redisFormat(chunk.metadata.tag,time,record))\n end\n @redis.exec\n end",
"def serialize\n {\n tiles: @tiles\n }\n end",
"def chunks\n (0...chunk_count).map do |chunk|\n offset_start = chunk_size * chunk\n offset_end = [offset_start + chunk_size, body.length].min - 1\n body[offset_start..offset_end]\n end\n end"
] |
[
"0.6498665",
"0.5217285",
"0.4876195",
"0.48170498",
"0.47569302",
"0.47521403",
"0.46824327",
"0.4678066",
"0.46687075",
"0.46402425",
"0.46326843",
"0.460194",
"0.4559601",
"0.4554241",
"0.45117408",
"0.44863996",
"0.44578606",
"0.44557407",
"0.44481462",
"0.44431496",
"0.44292575",
"0.44212392",
"0.43939477",
"0.4390259",
"0.43844318",
"0.43844318",
"0.43678728",
"0.43636712",
"0.436031",
"0.43593958",
"0.4352564",
"0.43502328",
"0.42891464",
"0.42705047",
"0.4263661",
"0.4260558",
"0.42495018",
"0.42395425",
"0.42041188",
"0.41964144",
"0.41779903",
"0.41671032",
"0.4149977",
"0.41466284",
"0.41394368",
"0.4131001",
"0.41252774",
"0.41209888",
"0.41135943",
"0.4102194",
"0.40799358",
"0.40738145",
"0.4062583",
"0.40623623",
"0.40607527",
"0.40551504",
"0.4055053",
"0.40531075",
"0.40512452",
"0.40317044",
"0.40317044",
"0.4025892",
"0.40256315",
"0.40222862",
"0.40214384",
"0.40083885",
"0.40024415",
"0.39957044",
"0.398678",
"0.39806986",
"0.39726064",
"0.39686152",
"0.39663398",
"0.39579943",
"0.39517626",
"0.3950415",
"0.39481363",
"0.39383957",
"0.39348382",
"0.39249066",
"0.39232966",
"0.39137998",
"0.39099175",
"0.3908122",
"0.39050907",
"0.3904681",
"0.39005345",
"0.38889116",
"0.3874166",
"0.3872823",
"0.38694236",
"0.38626352",
"0.38606265",
"0.3859038",
"0.3855794",
"0.3853788",
"0.384592",
"0.3841375",
"0.38398468",
"0.38339248"
] |
0.7816375
|
0
|
The alphabet is a series of characters used to create the bijection E.g: "wrdcuyjpbiflaqzesgmhvtknxo" The booster is used to avoid generating sequences that are too short E.g: If booster is zero then encoding an id close to zero will produce only one character. If you want a minimum of three then you should set your booster to ~1000 (depending on your alphabet)
|
def initialize(alphabet, booster = 0)
raise ArgumentError, "You must provide an alphabet" if alphabet.blank?
@alphabet = alphabet
@booster = booster
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def encode(number)\n i = number + @booster\n return @alphabet[0] if i == 0\n s = StringIO.new\n base = @alphabet.length\n while i > 0\n s << @alphabet[i.modulo(base)]\n i /= base\n end\n s.string.reverse\n end",
"def bijective_encode\n \t# from http://refactormycode.com/codes/124-base-62-encoding\n \t# with only minor modification\n \t# return ALPHABET[0] if i == 0\n \t# s = ''\n \t# base = ALPHABET.length\n \t# while i > 0\n \t# \ts << ALPHABET[i.modulo(base)]\n \t# \ti /= base\n \t# end\n \t# s.reverse + SecureRandom.hex(5 - s.length)\n \tSecureRandom.hex(4)\n end",
"def alphabet\n alphabet = ['1111110001111111000110001']\n alphabet << '1111110001111111000111111'\n alphabet << '1111110000100001000011111'\n alphabet << '1110010010100011001011100'\n alphabet << '1111110000111111000011111'\n alphabet << '1111110000111111000010000'\n alphabet << '1111110000100001000111111'\n alphabet << '1000110001111111000110001'\n alphabet << '1111100100001000010011111'\n alphabet << '1111100100001000010011100'\n alphabet <<\t'1000110010111001001010001'\n alphabet <<\t'1000010000100001000011111'\n alphabet <<\t'1000111011101011000110001'\n alphabet <<\t'1000111001101011001110001'\n alphabet <<\t'1111110001100011000111111'\n alphabet <<\t'1111110001111111000010000'\n alphabet <<\t'1111110001101011001111111'\n alphabet <<\t'1111110001111111001010001'\n alphabet <<\t'1111110000111110000111111'\n alphabet <<\t'1111100100001000010000100'\n alphabet <<\t'1000110001100011000111111'\n alphabet <<\t'1000110001010100101000100'\n alphabet <<\t'1010110101101011010111111'\n alphabet <<\t'1000101010001000101010001'\n alphabet <<\t'1000110001010100010000100'\n alphabet <<\t'1111100010001000100011111'\n end",
"def alphabet\n 'abcdefghijklmnopqrstuvwxyz'\n end",
"def bijective_encode(i)\n # from http://refactormycode.com/codes/125-base-62-encoding\n # with only minor modification\n return ALPHABET[0] if i == 0\n s = ''\n base = ALPHABET.length\n while i > 0\n s << ALPHABET[i.modulo(base)]\n i /= base\n end\n s.reverse\nend",
"def caesar_guesser(encrypted_string, alphabet)\nend",
"def caesar_guesser(encrypted_string, alphabet)\r\n\r\nend",
"def vigenere_cipher(string, key_sequence, alphabet)\r\n\r\nend",
"def best_letter string\n alphabet = ('a'..'z').to_a\n frequency_hash = Hash['a' => 1]\n alphabet.each do |x|\n frequency_hash[x] = alphabet_frequency(string, x)\n end\n #puts frequency_hash\n number_alphabet [(alphabet_number(frequency_hash.min_by{|k,v| v}.first.split(\"\")).first + 1) % 26]\nend",
"def bijective_encode(i)\n # from http://refactormycode.com/codes/125-base-62-encoding\n # with only minor modification\n return ALPHABET[0] if i == 0\n s = ''\n base = ALPHABET.length\n while i > 0\n s << ALPHABET[i.modulo(base)]\n i /= base\n end\n s.reverse\n end",
"def decode(sentence)\n i = 0\n base = @alphabet.length\n sentence.each_char { |c| i = i * base + @alphabet.index(c) }\n i - @booster\n end",
"def dealphabetize(\n alphabet = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"\n )\n str = to_s\n alphabet = alphabet.to_s\n len = alphabet.length\n str.chars.inject(0) do |num, char|\n i = alphabet.index(char)\n raise(\"Character not in alphabet: '#{char}'\") if i.nil?\n\n num * len + i\n end\n end",
"def bijective_encode(id)\n code = ''\n\n while id > 0\n code << CHARS[id.modulo(BASE)]\n id /= BASE\n end\n\n code.reverse\n end",
"def alphabet\n ('A'..'Z').to_a\n end",
"def alphabet\n ('A'..'Z').to_a\n end",
"def alphabet\n ('a'..'z').to_a\n end",
"def draw_letters\n compact_bag = {\n \"A\" => 9,\n \"B\" => 2, \n \"C\" => 2, \n \"D\" => 4, \n \"E\" => 12, \n \"F\" => 2, \n \"G\" => 3, \n \"H\" => 2, \n \"I\" => 9,\n \"J\" => 1, \n \"K\" => 1, \n \"L\" => 4,\n \"M\" => 2,\n \"N\" => 6,\n \"O\" => 8,\n \"P\" => 2, \n \"Q\" => 1, \n \"R\" => 6,\n \"S\" => 4, \n \"T\" => 6,\n \"U\" => 4,\n \"V\" => 2,\n \"W\" => 2,\n \"X\" => 1, \n \"Y\" => 2, \n \"Z\" => 1\n }\n expanded_bag = []\n compact_bag.each do |letters, number|\n number.times do \n expanded_bag << letters\n end\n end \n\n random = []\n\n 10.times do \n x = rand expanded_bag.length\n while random.include? x\n x = rand expanded_bag.length\n end\n random << x\n end\n\n hand = random.map {|number| expanded_bag[number]}\nend",
"def calculate_alphabet(str)\nend",
"def generate_code\n charset = Array('A'..'Z') + Array('a'..'z')\n Array.new(8) { charset.sample }.join\nend",
"def add_letters_to_bag()\n\n bag = [\"Z\", \"X\", \"J\", \"K\", \"Q\"] # Letters which only appear once\n \n 2.times do # Letters which appear twice\n bag << \"V\"\n bag << \"W\"\n bag << \"B\"\n bag << \"C\"\n bag << \"F\"\n bag << \"H\"\n bag << \"M\"\n bag << \"Y\"\n bag << Blank.new\n bag << \"P\"\n end\n\n 3.times do bag << \"G\" end\n\n 4.times do\n bag << \"D\"\n bag << \"L\"\n bag << \"S\"\n bag << \"U\"\n end\n\n 6.times do\n bag << \"N\"\n bag << \"R\"\n bag << \"T\"\n end\n \n 8.times do bag << \"O\" end \n\n 9.times do\n bag << \"A\"\n bag << \"I\"\n end\n\n 12.times do bag << \"E\" end\n\n return bag\n end",
"def jumble_sort(str, alphabet = (\"a\"..\"z\"))\n char_count = Hash.new(0)\n str.each_char { |c| char_count[c] += 1 }\n jumbled_str = \"\"\n alphabet.each do |c|\n (0...char_count[c]).each { |n| jumbled_str << c }\n end\n jumbled_str\nend",
"def danToAlphabet(int)\n return (int+96).chr\n end",
"def depunctuate(a_string)\n alphabet = [*\"A\"..\"Z\"] + [*\"a\"..\"z\"]\n result = \"\"\n a_string.length.times do |i|\n if alphabet.include?(a_string[i])\n result << a_string[i]\n end\n end\n result\nend",
"def jumble_sort(str, alphabet = nil)\n\nend",
"def jumble_sort(str, alphabet = nil)\n\nend",
"def jumble_sort(str, alphabet = nil)\n\nend",
"def generate\n @letters = alphabet\n include_letters\n exclude_letters\n shuffle_alphabet_maybe\n reverse_alphabet_maybe\n @letters.split('').join(' ')\n end",
"def vigenere_cipher(string, key_sequence)\n result = \"\"\n alphabet = (\"a\"..\"z\").to_a\n string.each_char.with_index do |ch, idx|\n key_idx = idx % key_sequence.length\n char_idx = (alphabet.index(ch) + key_sequence[key_idx]) % alphabet.length\n result << alphabet[char_idx]\n end\n result\nend",
"def vigenereCipher(string, key, alphabet)\n aryStr = string.split(\"\")\n nStr = Array.new\n i = 0\n while i < aryStr.length\n j = 0\n while j < key.length\n nStr << (alphabet[(alphabet.index(aryStr[i]) + key[j])])\n j += 1\n i += 1\n end\n end\n return nStr.join('')\nend",
"def alphabet\n Set.new(to_a.flatten!.uniq!)\n end",
"def vigenere_cipher(string, key_sequence, alphabet)\n #\n # your code goes here\n #\nend",
"def alphabet\n read_attr :alphabet\n end",
"def encode\n @word.chars.map do |letter|\n index = @abc.index(letter) \n @abc_reverse[index]\n end.join\n \n end",
"def generate_alphabet\n (\"a\"..\"z\").to_a\nend",
"def alphabet\n alpha = []\n @transitions.each { |k,v| alpha += v.keys }\n Set.new(expand_symbols(alpha))\n end",
"def letterbank\n {\n vowels: [\"a\",\"e\",\"i\",\"o\",\"u\"],\n cap_vowels: [\"A\",\"E\",\"I\",\"O\",\"U\"],\n consonants: [\"b\",\"c\",\"d\",\"f\",\"g\",\"h\",\"j\",\"k\",\"l\",\"m\",\n \"n\",\"p\",\"q\",\"r\",\"s\",\"t\",\"v\",\"w\",\"x\",\"y\",\"z\"],\n cap_consonants: [\"B\",\"C\",\"D\",\"F\",\"G\",\"H\",\"J\",\"K\",\"L\",\"M\",\n \"N\",\"P\",\"Q\",\"R\",\"S\",\"T\",\"V\",\"W\",\"X\",\"Y\",\"Z\"],\n catch_all: [\" \", \"@\", \".\", \"-\"]\n }\nend",
"def ceasars_ciper(str)\n alphabet = Array(a..z)\n alphabet.zip(alphabet.rotate(1)).to_h\n end",
"def vigenere_cipher(str, arr)\n alpha = (\"a\"..\"z\").to_a\n new_str = \"\"\n str.each_char.with_index do |char, i|\n pos = alpha.index(char)\n key = arr[i % arr.length]\n new_pos = (pos + key) % alpha.length\n new_str += alpha[new_pos]\n end\n new_str\nend",
"def jumble_sort(str, alphabet = nil)\n alphabet ||= ('a'..'z').to_a\n sorted = \"\"\n alphabet.each do |c1|\n str.chars.each do |c2|\n sorted << c2 if c2 == c1\n end\n end\n sorted\nend",
"def jumble_sort(str, alphabet = nil)\n alphabet ||= ('a'..'z').to_a\n final_str = \"\"\n \n alphabet.each do |alpha_char|\n if str.include?(alpha_char)\n str.count(alpha_char).times do\n final_str += alpha_char\n end\n end\n end\n \n final_str\nend",
"def max_beauty(string)\n chars = Hash.new { |h,k| h[k] = 0 }\n\n string.chars.each do |char|\n chars[char] += 1\n end\n\n next_value = 26\n beauty = 0\n chars.sort_by { |key, value| -value }.each do |_, count|\n beauty += count * next_value\n next_value -= 1\n end\n\n beauty\nend",
"def caesar_encode(string, offset)\n string.split(\"\").map do |character| #.map goes through array and creates a new array \n if $array_abc_low.include?(character) #checks if a letter is in the first/second array\n new_character = $array_abc_low[($array_abc_low.index(character)+offset)%26]\n # character_index = ($array_abc_low.index(character)+offset)%26 #adds in the offset number so the letter will change\n # new_character=$array_abc_low[character_index] #returns element in the new index\n elsif $array_abc_up.include?(character) #checks if a letter is in the first/second array\n new_character = $array_abc_up[($array_abc_up.index(character)+offset)%26]\n # character_index = ($array_abc_up.index(character)+offset)%26 #adds in the offset number so the letter will change\n # new_character=$array_abc_up[character_index]\n else character #this is for symbols/number and returns 'nil'\n end\n end.join(\"\")\nend",
"def random_poly(string)\n\t\talphabet = ('a'..'z').to_a\n\t\tkey = alphabet.shuffle.join\n\t\ta = string.tr(alphabet.join,key)\n\t\t# test :\n\t\t# p a.tr(key,alphabet.join)\n\t\t# a\n\tend",
"def jumble_sort(str, alphabet = nil)\n return str.chars.sort.join(\"\") if alphabet.nil?\n new_string = \"\"\n alphabet.each do |letter|\n (str.count(letter)).times do\n new_string += letter\n end\n end\n new_string\nend",
"def encode(letters, char, offset)\n\t\t((((char - letters.min) + offset) % 26) + letters.min).chr\n\t\t# binding.pry\n\tend",
"def decipher\n if @input\n main_arr = @input.split('0').map do |item|\n number = item[0].to_i\n item_length = item.length\n letter_length = @letters[number].length\n if item_length > 0 and /^(\\d)\\1*$/.match(item)\n position = item_length % letter_length\n @letters[number][position - 1]\n end\n end\n end\n main_arr.join\n end",
"def keygens; end",
"def generate_code(number)\n charset = Array('A'..'Z') + Array('a'..'z')\n Array.new(number) { charset.sample }.join\nend",
"def jumble_sort(str, alphabet = (\"a\"..\"z\").to_a)\n str_arr = []\n temp = []\n str.chars.each do |char1|\n if str_arr.empty?\n str_arr << char1\n temp << char1\n else\n temp.each_index do |i|\n if alphabet.index(str_arr[i]) < alphabet.index(char1)\n str_arr << char1\n else\n str_arr.insert(i,char1)\n end\n end\n end\n end\n str_arr.join(\"\")\nend",
"def guessable_letters(animal)\n alphabet = *('a'..'z')\n letter_array = animal.name.downcase.split('')\n\n while letter_array.length < 12\n letter_array.push(alphabet.sample)\n end\n return letter_array.shuffle\n end",
"def create_key_a\n @key_chars[0..1].join.to_i\n end",
"def encode\n @word.chars.map { |letter|\n index = @abc.index(letter)\n cipher_character = @abc_reverse[index]\n }.join\n end",
"def obfuscate_id_default_spin\n alphabet = Array(\"a\"..\"z\")\n number = name.split(\"\").collect do |char|\n alphabet.index(char)\n end\n\n number.shift(12).join.to_i\n end",
"def get_alpha\n@alphabet\nend",
"def genStr strLen\nsortedAlphabet = @alphabet.sort\nresultStrs = [ ]\ntestStrings = [ ]\ntestStrings[0] = []\ntestStrings[0].push \"\"\n1.upto(strLen.to_i) { |x|\ntestStrings[x] = []\ntestStrings[x-1].each { |s|\nsortedAlphabet.each { |c|\ntestStrings[x].push s+c\n}\n}\n}\ntestStrings.flatten.each { |s|\nresultStrs.push s if accept? s, @start\n}\nresult = \"\"\nresultStrs.each { |x| result.concat '\"'+x+'\" ' }\nresult\nend",
"def scramble_words(chars = WordChars)\n\t\tgsub(/(#{chars})(#{chars}+)(?=#{chars})/) { $1 + $2.randomize }\n\tend",
"def vigenere_cipher(msg, arr)\n alphabet = (\"a\"..\"z\").to_a\n new_msg = \"\"\n msg.each_char.with_index do |char, i|\n pos= alphabet.index(char)\n key = arr[i % arr.length]\n new_pos = (pos + key) % alphabet.length\n new_msg += alphabet[new_pos]\n end\n new_msg\nend",
"def translate_to_cipher(sentence)\n # this creates an array where each char represents one element and calls it alphabet\n alphabet = ('a'..'z').to_a\n # Takes the alphabet array, uses the zip array to assign merge element to sa key position in a hash, then maps those keys \n # to a new alphabet array that rotates each element by the element 4 positions later than it. \n cipher = Hash[alphabet.zip(alphabet.rotate(4))]\n # define spaces as an array of special char\n spaces = [\"@\", \"#\", \"$\", \"%\", \"^\", \"&\", \"*\"]\n \n #defines original_sentence as input converted to all lowercase letters\n original_sentence = sentence.downcase\n #creates array called encoded_sentence\n encoded_sentence = []\n\n # for each character in the string do\n original_sentence.each_char do |element|\n # if the cipher has the element, push the value of the element into the new array\n if cipher.include?(element)\n encoded_sentence << cipher[element]\n # if cipher has a space, select randomly from the 7 special chars, push sp char to new array\n elsif element == ' '\n encoded_sentence << spaces.sample\n # otherwise, push the element as is to the new arrray\n else \n encoded_sentence << element\n end\n end\n #output the encoded sentence array as a string\n return encoded_sentence.join\nend",
"def jumble_sort(str, alphabet = nil)\n return str.chars.sort.join if alphabet == nil\n\n arr = []\n cur_len = 0\n alphabet.each do |c|\n break if cur_len >= str.length\n\n if str.include?(c)\n num = str.count(c)\n arr.push(c * num)\n cur_len += num\n end\n end\n\n arr.join\nend",
"def morse_encode(str)\n hash={}\n \n hash[\"a\"]=\"._ \"\n hash[\"b\"]=\"_... \"\n hash[\"c\"]=\"_._. \"\n hash[\"d\"]=\"_.. \"\n hash[\"e\"]=\". \"\n hash[\"f\"]=\".._. \"\n hash[\"g\"]=\"__. \"\n hash[\"h\"]=\".... \"\n hash[\"i\"]=\".. \"\n hash[\"j\"]=\".___ \"\n hash[\"k\"]=\"_._ \"\n hash[\"l\"]=\"._.. \"\n hash[\"m\"]=\"__ \"\n hash[\"n\"]=\"_. \"\n hash[\"o\"]=\"___ \"\n hash[\"p\"]=\".__. \"\n hash[\"q\"]=\"__._ \"\n hash[\"r\"]=\"._. \"\n hash[\"s\"]=\"... \"\n hash[\"t\"]=\"_ \"\n hash[\"u\"]=\".._ \"\n hash[\"v\"]=\"..._ \"\n hash[\"w\"]=\".__ \"\n hash[\"x\"]=\"_.._ \"\n hash[\"y\"]=\"_.__ \"\n hash[\"z\"]=\"__.. \"\n \n hash[\" \"]=\" \"\n \n hash[\"A\"]=\"._ \"\n hash[\"B\"]=\"_... \"\n hash[\"C\"]=\"_._. \"\n hash[\"D\"]=\"_.. \"\n hash[\"E\"]=\". \"\n hash[\"F\"]=\".._. \"\n hash[\"G\"]=\"__. \"\n hash[\"H\"]=\".... \"\n hash[\"I\"]=\".. \"\n hash[\"J\"]=\".___ \"\n hash[\"K\"]=\"_._ \"\n hash[\"L\"]=\"._.. \"\n hash[\"M\"]=\"__ \"\n hash[\"N\"]=\"_. \"\n hash[\"O\"]=\"___ \"\n hash[\"P\"]=\".__. \"\n hash[\"Q\"]=\"__._ \"\n hash[\"R\"]=\"._. \"\n hash[\"S\"]=\"... \"\n hash[\"T\"]=\"_ \"\n hash[\"U\"]=\".._ \"\n hash[\"V\"]=\"..._ \"\n hash[\"W\"]=\".__ \"\n hash[\"X\"]=\"_.._ \"\n hash[\"Y\"]=\"_.__ \"\n hash[\"Z\"]=\"__.. \"\n \n output=\"\"\n f=0\n while f<str.length\n output+=hash[str[f]]\n f+=1\n end\n \n \n return output\n \n \nend",
"def bears(num, str)\n i = 0\n answer = []\n arr = str.split('')\n while i < arr.length - 1\n if (arr[i] == 'B' && arr[i + 1] == '8') ||\n (arr[i] == '8' && arr[i + 1] == 'B')\n \n answer << arr[i] << arr[i + 1]\n i += 2\n else\n i += 1\n end\n\n end\n [answer.join, answer.length / 2 >= num]\nend",
"def output_letter\r\n a = @deck.first\r\n a = 53 if a.instance_of? String\r\n output = @deck[a]\r\n if output.instance_of? String\r\n nil\r\n else\r\n output -= 26 if output > 26\r\n (output + 64).chr\r\n end\r\n end",
"def random_key\n (0...10).map { ('a'..'z').to_a[rand(26)] }.join\n end",
"def vigenere_cipher(str,keys)\n alpha = (\"a\"..\"z\").to_a\n new_str = \"\"\n\n str.each_char.with_index do |char,idx|\n old_pos = alpha.index(char)\n new_pos = old_pos + keys[idx % keys.length]\n new_str += alpha[new_pos % alpha.length]\n end\n\n new_str\n\nend",
"def high(x)\n\n x = ('abcdefghijklmnopqrstuvwxyz')\n\n letterScore = {\n 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6, 'g' => 7, 'h' => 8,\n 'i' => 9, 'j' => 10, 'k' => 11, 'l' => 12, 'm' => 13, 'n' => 14, 'o' => 15, 'p' => 16,\n 'q' => 17, 'r' => 18, 's' => 19, 't' => 20, 'u' => 21, 'v' => 22, 'w' => 23, 'x' => 24,\n 'y' => 25, 'z' => 26\n\n }\n\n end",
"def folding_cipher(string)\n alphabet = (\"a\"..\"z\").to_a\n hash = {}\n\n alphabet.each_with_index do |letter, idx|\n hash[letter] = alphabet[25 - idx]\n end\n\n string.chars.map! do |char|\n hash[char]\n end.join(\"\")\nend",
"def number_encoder( input )\n output = \"\"\n \n # build letter to number hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator[ letters[i] ] = i+1 }\n\n \n # seperates into chunks\n input.each(' ') do |chunk|\n chunk.each_char() { |char| output << translator[char].to_s + ' ' }\n end\n output.rstrip!\n output \nend",
"def morse_encode\n morse_dict = {\n \"a\" => \".-\",\n \"b\" => \"-...\",\n \"c\" => \"-.-.\",\n \"d\" => \"-..\",\n \"e\" => \".\",\n \"f\" => \"..-.\",\n \"g\" => \"--.\",\n \"h\" => \"....\",\n \"i\" => \"..\",\n \"j\" => \".---\",\n \"k\" => \"-.-\",\n \"l\" => \".-..\",\n \"m\" => \"--\",\n \"n\" => \"-.\",\n \"o\" => \"---\",\n \"p\" => \".--.\",\n \"q\" => \"--.-\",\n \"r\" => \".-.\",\n \"s\" => \"...\",\n \"t\" => \"-\",\n \"u\" => \"..-\",\n \"v\" => \"...-\",\n \"w\" => \".--\",\n \"x\" => \"-..-\",\n \"y\" => \"-.--\",\n \"z\" => \"--..\",\n \" \" => \" \", }\n\n end",
"def nato_phonetic_alphabet # rubocop:disable Metrics/MethodLength\n {\n 'a' => 'Alfa',\n 'b' => 'Bravo',\n 'c' => 'Charlie',\n 'd' => 'Delta',\n 'e' => 'Echo',\n 'f' => 'Foxtrot',\n 'g' => 'Golf',\n 'h' => 'Hotel',\n 'i' => 'India',\n 'j' => 'Juliett',\n 'k' => 'Kilo',\n 'l' => 'Lima',\n 'm' => 'Mike',\n 'n' => 'November',\n 'o' => 'Oscar',\n 'p' => 'Papa',\n 'q' => 'Quebec',\n 'r' => 'Romeo',\n 's' => 'Sierra',\n 't' => 'Tango',\n 'u' => 'Uniform',\n 'v' => 'Victor',\n 'w' => 'Whiskey',\n 'x' => 'X-ray',\n 'y' => 'Yankee',\n 'z' => 'Zulu'\n }\nend",
"def get_cipherbet key\n alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\".split(\"\")\n# start the cipherbet empty, we'll add letters one by one\n cipherbet = []\n pos = key\n # get letters from key to the end\n while pos < alphabet.length\n cipherbet.push alphabet[pos]\n pos = pos + 1\n end\n # add the letters from the beginning of the alphabet o the key\n pos = 0\nwhile pos < key\n cipherbet.push alphabet[pos]\n pos = pos + 1\nend\n\nreturn cipherbet\nend",
"def v_decode message, key\n message_array = alphabet_number(message.split(\"\"))\n key_array = alphabet_number(make_key_repeat(key.split(\"\"), message_array.length)).take(message_array.length)\n number_alphabet(message_array.map.with_index{ |m,i| (m.to_i - key_array[i].to_i + 1) % 26}).take(message_array.length).join(\"\")\nend",
"def vigenere_cipher(message, keys)\n alphabet = ('a'..'z').to_a\n array = []\n\n i = 0\n\n message.each_char do |char|\n idx = alphabet.index(char)\n array << alphabet[(idx + keys[i]) % 26]\n if i < keys.length - 1\n i += 1\n else\n i = 0\n end\n end\n array.join('')\n \nend",
"def alphabet_soup(str)\n str.split('').sort.join\nend",
"def obfuscatable_default_spin\n alphabet = Array(\"a\"..\"z\")\n number = name.split(\"\").collect do |char|\n alphabet.index(char)\n end\n number.shift(12).join.to_i\n end",
"def abba(str)\n str.chars.each_cons(4)\n .select{|word| word == word.reverse and word[0] != word[1]}\n .map(&:join)\n end",
"def prep_bombs\n 10.times { @bombs << \"X\" }\n 71.times { @bombs << \"O\" }\n @bombs = @bombs.shuffle\n end",
"def restrict(convolution, m)\n alphabet = []\n freq = convolution.each_with_object({}) { |itm, hsh| hsh[itm] = hsh[itm].to_i + 1 if convolution.include?(itm) }\n eligible = freq.select {|k, v| 57 <= k && k <= 200}\n sorted = eligible.sort_by {|k,v| v}.reverse\n sorted.each do |am, f|\n if alphabet.size < m\n alphabet << am \n # let's ensure we include any ties\n elsif alphabet.size == m\n alphabet << am if alphabet[m-1] == am\n end\n break if alphabet[m-1] > am unless alphabet[m-1].nil?\n end\n alphabet\nend",
"def draw_letters\n # Letters A B C D E F G H I J K L M N O P Q R S T U V W X Y Z\n letter_dist = [9, 2, 2, 4, 12, 2, 3, 2, 9, 1, 1, 4, 2, 6, 8, 2, 1, 6, 4, 6, 4, 2, 2, 1, 2, 1]\n hand_size = 10\n # ASCII table number for a\n letter_a_offset = 65\n \n letter_pool = letter_dist.map.with_index { |dist, index| (index + letter_a_offset).chr * dist }\n return letter_pool.join('').split('').sample(hand_size)\nend",
"def alphabetToDan(s)\n if RUBY_VERSION >= \"1.9.1\"\n # String.bytes is incompatible:\n # - Ruby 1.9.3 String.bytes returns Enumerator\n # - Ruby 2.1.0 String.bytes returns [Integer]\n return s.each_byte.next-96\n else\n return s[0]-96\n end\n end",
"def generate_code(number)\n charset = Array('A'..'Z') + Array('a'..'z')\n Array.new(number) { charset.sample }.join\n end",
"def alphabet_array\n ('A'..'Z').to_a\n end",
"def gencode(instr)\n memoizer = Hash.new { |h,morse|\n retval = []\n get_letters(morse) { |c,rest|\n h[rest].each {|s| retval << (c+s)}\n }\n h[morse] = retval\n }\n memoizer[''] = ['']\n memoizer[instr]\nend",
"def anagrams(string, array)\nend",
"def number_decoder( input )\n output = \"\"\n \n # build number to letter hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator [(i+1).to_s] = letters[i] }\n \n input.each(' ') do |nibble|\n\n \n num = nibble.strip.to_i\n if (num == 0 or num.nil?) then output << \" \"\n else\n case (num-1)/26\n when 0 then output << translator[num.to_s]# + ' '\n when 1 then output << translator[(num - 26).to_s]\n end\n end\n end\n \n output\nend",
"def brutus_cipher(string)\n\tresult = \"\"\n\tis_letter = /[a-zA-Z]/\n\tfor x in 0...string.length do\n\t\tputs \"For loop iterating...\"\n\t\tif is_letter.match(string[x])\n\t\t\tif string[x].ord.between?(88, 91) || string[x].ord > 119\n\t\t\t\tresult += (string[x].ord - 23).chr\n\t\t\telse\n\t\t\t\tresult += (string[x].ord + 3).chr\n\t\t\tend\n\t\telse\n\t\t\tresult += string[x]\n\t\tend\n\tend\n\treturn result\nend",
"def play_pass(str, n)\n alphabet = (\"A\"..\"Z\").to_a\n shifted_alphabet = alphabet.rotate(n)\n ary = str.chars\n \n ary.each_with_index do |item, index|\n if item == item.to_i.to_s\n ary[index] = (9 - item.to_i).to_s\n elsif alphabet.include?(item)\n ind = alphabet.index(item)\n ary[index] = shifted_alphabet[ind]\n end\n end\n ary.map!.with_index { |item, index| index.odd? ? ary[index].downcase : ary[index].upcase }\n \n ary.join('').reverse\nend",
"def broad_sword\n # use regexp since .. is used for wildcard\n Regexp.new s_to_h(<<-S)\n B1 96 B1 D3 ED AE 5F 92 F4 65 03 01 .. FF FF FF\n FF .. .. .. .. 23 19 01 0B 00 00 00 00 08 00 00\n 00 2A 00 00 00 00 00 00 00 02 00 00 00 00 00 00\n 00 02 00 00 00 02 00 00 00 99 32 C5 C4 CC 57 6D\n 43 87 6B 03 01 FF FF FF FF 99 32 C5 C4 CC 57 6D\n 43 27 9E 00 01 FF FF FF FF 01 00 00 00 99 32 C5\n C4 CC 57 6D 43 27 9E 00 01 FF FF FF FF 13 00 00\n 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n 00 00 00 00 00 00 00 00 00 06 00 00 00 00 00 00\n 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00\n 00\n S\nend",
"def encode_to_braille(input)\n result = []\n input.split('').each_slice(40) do |one_sixty_dots|\n result << check_input_vs_alphabet(one_sixty_dots)\n end\n result.join\n end",
"def genbank\n chars = 60\n lines = (length / chars.to_f).ceil\n width = length.to_s.length\n\n s = ''\n (1..lines).each do |i|\n s << \"%#{width}d\" % (chars * (i - 1) + 1)\n s << ' '\n s << to_s[chars * (i - 1), chars].scan(/\\w{1,10}/).join(' ')\n s << \"\\n\"\n end\n s\n end",
"def mixgenes( mgenes, sgenes ) ## returns babygenes\n ## note: reverse genes strings (in kai) so index 0 is the first number\n ## index 1 is the second number etc.\n mgenes = mgenes.reverse\n sgenes = sgenes.reverse\n\n babygenes = \"?\"*48 ## string with 48 question marks (?)\n\n # PARENT GENE SWAPPING\n 12.times do |i| # loop from 0 to 11 # for(i = 0; i < 12; i++)\n puts \"parent gene swapping i: #{i}\"\n index = 4*i # index = 4 * i\n 3.downto(1) do |j| ## loop from 3 to 1 # for (j = 3; j > 0; j--)\n puts \" j: #{j}\"\n if rand(100) < 25 # if random() < 0.25:\n mgenes[index+j-1], mgenes[index+j] = # swap(mGenes, index+j, index+j-1)\n mgenes[index+j], mgenes[index+j-1]\n end\n if rand(100) < 25 # if random() < 0.25:\n sgenes[index+j-1], sgenes[index+j] = # swap(sGenes, index+j, index+j-1)\n sgenes[index+j], sgenes[index+j-1]\n end\n end\n end\n\n # BABY GENES\n 48.times do |i| # loop from 0 to 47 # for (i = 0; i < 48; i++):\n puts \"baby genes i: #{i}\"\n mutation = nil # mutation = 0\n # # CHECK MUTATION\n if i % 4 == 0 # if i % 4 == 0:\n gene1 = Kai::NUMBER[ mgenes[i] ] # gene1 = mGene[i]\n gene2 = Kai::NUMBER[ sgenes[i] ] # gene2 = sGene[i]\n if gene1 > gene2 # if gene1 > gene2:\n gene1, gene2 = gene2, gene1 # gene1, gene2 = gene2, gene1\n end\n if (gene2 - gene1) == 1 && gene1.even? # if (gene2 - gene1) == 1 and iseven(gene1):\n probability = 25 # probability = 0.25\n if gene1 > 23 # if gene1 > 23:\n probability /= 2 # probability /= 2\n end\n if rand(100) < probability # if random() < probability:\n mutation = Kai::ALPHABET[ (gene1/2)+16 ] # mutation = (gene1 / 2) + 16\n end\n end\n end\n # GIVE BABY GENES\n if mutation # if mutation:\n babygenes[i]=mutation # baby[i] = mutation\n else # else:\n if rand(100) < 50 # if random() < 0.5:\n babygenes[i] = mgenes[i] # babyGenes[i] = mGene[i]\n else # else:\n babygenes[i] = sgenes[i] # babyGenes[i] = sGene[i]\n end\n end\n end\n\n babygenes.reverse # return bagygenes (reversed back)\nend",
"def vigenere_cipher(string, key_sequence)\n alphabet = (\"a\"..\"z\").to_a\n alphabet.concat(alphabet) # double it to deal with wrapping\n \n chars = string.split('')\n count = 0\n \n for i in 0...chars.length\n # lookup the index of chars[i] in alphabet, then add to it using key sequence\n # and modulo to keep track of which step in the sequence you're at\n chars[i] = alphabet[alphabet.index(chars[i]) + key_sequence[count % key_sequence.length]]\n count += 1\n end\n chars.join('')\nend",
"def vigenere_cipher(word,arr)\n\n new_arr = []\n alp = (\"a\"..\"z\").to_a\n word.split(\"\").each.with_index do |char,i|\n old_index = alp.index(char)\n new_index = (alp.index(char)+ arr[i % arr.length]) % 26\n new_arr << alp[new_index]\n end\n new_arr.join(\"\")\n\nend",
"def get_starting_letter\t\n\t\trandom_number = @random_number_generator.rand(0.0..1.0)\n\n @pair_probability_table.frequencies.select {|k, v| k[0] == ' ' &&\n k[1] != ' ' &&\n v >= random_number}.keys.sort.first[1]\n\tend",
"def distinct_subseq_ii(s)\n alphabets = ('a'..'z').to_a\n dict = Array.new(27, 0)\n mod = 10 ** 9 + 7\n total = 1\n s.chars.each do |char|\n index = alphabets.index(char) + 1\n combo = total * 2 - dict[index]\n dict[index] = total # if 'c' ever appears again, it will clash with the current combos.\n total = combo < 0 ? 0 + mod : combo % mod\n end\n total - 1 # subtract empty string\nend",
"def use_bigram(str,i)\n\t\tmax=@han[str[i]][0]\n\t\tif i==0\n\t\t\t@han[str[i]].each{|h|\n\t\t\t\tif ref(\"$\"+h)>ref(\"$\"+max)\n\t\t\t\t\tmax=h\n\t\t\t\tend\n\n\t\t\t}\n\t\telse\n\t\t\t\t@han[str[i]].each{|h|\n\t\t\t\tif ref(str[i-1]+h)>ref(str[i-1]+max)\n\t\t\t\t\tmax=h\n\t\t\t\tend\n\n\t\t\t}\n\t\tend\n\t\treturn max\n\n\tend",
"def DNA_strand(dna)\n n = dna.split(\"\")\n mapping = {'T' => 'A', 'A' => 'T', 'C' => 'G', 'G' => 'C'}\n # n = n.map {|e| mapping[e] || e}\n n.map! {|e| mapping[e] || e}\n n = n.join(\"\")\n return n\nend",
"def caesar(string, key, flag)\n string_to_code = string.upcase.split(//).map.to_a\n cipher_key = LETTERS.rotate(key)\n string_to_code.each_with_index do |character,position|\n next if character == \" \"\n string_to_code[position] = cipher_key[LETTERS.index(character)] if flag == \"encode\"\n string_to_code[position] = LETTERS[cipher_key.index(character)] if flag == \"decode\"\n end\n string_to_code.join\nend",
"def vigenere_cipher(string, keys)\n alpha = ('a'..'z').to_a\n new_word = \"\"\n\n string.each_char.with_index do |char, idx|\n old_idx = alpha.index(char)\n new_idx = old_idx + keys[idx % keys.length]\n new_char = alpha[new_idx % alpha.length]\n new_word += new_char\n end\n\n new_word\nend",
"def vigenere_cipher(str, k)\n alpha = (\"a\"..\"z\").to_a\n\n msg = (0...str.length).map do |i|\n old_pos = alpha.index(str[i])\n new_pos = (old_pos + k[i%k.length]) % alpha.length\n alpha[new_pos]\n end\n\n msg.join()\nend",
"def decode(numbers)\n\ttext=\"\"\n\t#Process each number in the array.\n\tnumber.each do |numebr|\n\t\t#Get the letterr that corresponds to this number.\n\t\tletter=KEY[number]\n\t\t#Add it onto the string.\n\t\ttext = letter\n\tend\n\t#return the decoded string.\n\treturn text\nend"
] |
[
"0.6529132",
"0.6510735",
"0.6432002",
"0.6418563",
"0.6315762",
"0.63018644",
"0.6275429",
"0.6214931",
"0.6181105",
"0.6165188",
"0.608075",
"0.60632944",
"0.6007543",
"0.5968244",
"0.5968244",
"0.5946893",
"0.5932772",
"0.59119284",
"0.5905748",
"0.58660555",
"0.58632106",
"0.58614063",
"0.5841817",
"0.58265126",
"0.58265126",
"0.58265126",
"0.57896996",
"0.57765937",
"0.5775102",
"0.5741563",
"0.5729813",
"0.57148474",
"0.57091844",
"0.57057834",
"0.5704773",
"0.5680684",
"0.567948",
"0.5664485",
"0.5653103",
"0.56466824",
"0.5627807",
"0.5615115",
"0.5612125",
"0.5607837",
"0.5598098",
"0.55963564",
"0.55942094",
"0.5586979",
"0.5582804",
"0.5576375",
"0.5574548",
"0.5562555",
"0.5562228",
"0.5560608",
"0.555157",
"0.5551318",
"0.554432",
"0.5541828",
"0.55402786",
"0.55316055",
"0.5495367",
"0.5492418",
"0.54912347",
"0.54879534",
"0.5477561",
"0.5473391",
"0.5472412",
"0.5472128",
"0.54683393",
"0.5462511",
"0.5451853",
"0.54504293",
"0.5447268",
"0.54470605",
"0.5446388",
"0.5441159",
"0.54386425",
"0.5437996",
"0.54378647",
"0.54372907",
"0.54358673",
"0.54330087",
"0.5425772",
"0.54235756",
"0.54116327",
"0.5411201",
"0.5406671",
"0.5399602",
"0.53961134",
"0.53940713",
"0.53940356",
"0.5391109",
"0.5390202",
"0.53895324",
"0.53813547",
"0.5379597",
"0.53785604",
"0.5377975",
"0.53769565",
"0.53737485"
] |
0.6587932
|
0
|
Transform an integer into a unique string using the engine alphabet and booster
|
def encode(number)
i = number + @booster
return @alphabet[0] if i == 0
s = StringIO.new
base = @alphabet.length
while i > 0
s << @alphabet[i.modulo(base)]
i /= base
end
s.string.reverse
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def obfuscate_id_default_spin\n alphabet = Array(\"a\"..\"z\")\n number = name.split(\"\").collect do |char|\n alphabet.index(char)\n end\n\n number.shift(12).join.to_i\n end",
"def id_to_code(id)\n (id.to_i * factor + pad).to_s(26).tr('0-9a-p', 'a-z')\n end",
"def bijective_encode(id)\n code = ''\n\n while id > 0\n code << CHARS[id.modulo(BASE)]\n id /= BASE\n end\n\n code.reverse\n end",
"def con10to62(id)\n\tnew_id = \"0000\"\n\tfor i in 0..3\n\t\tdiv = id / 62**(3 - i)\n\t\tif div > -1 && div < 10\n\t\t\t#0-9\n\t\t\tnew_id.setbyte(i, (div + 48))\n\t\telsif div > 9 && div < 36\n\t\t\t#A-Z\n\t\t\tnew_id.setbyte(i, (div + 55))\n\t\telsif div > 35 && div < 62\n\t\t\t#a-z\n\t\t\tnew_id.setbyte(i, (div + 36))\n\t\telse\n\t\t\t#error\n\t\t\treturn -1\n\t\tend\n\t\tid = id % 62**(3 - i)\n\tend\n\treturn new_id\nend",
"def generate_code(number)\n charset = Array('A'..'Z') + Array(0..9)\n Array.new(number) { charset.sample }.join\n end",
"def generate_code(number)\n charset = Array('A'..'Z') + Array('a'..'z')\n Array.new(number) { charset.sample }.join\nend",
"def generate_code(number)\n charset = Array('A'..'Z') + Array('a'..'z')\n Array.new(number) { charset.sample }.join\n end",
"def short_code\n id.to_s 36\n end",
"def boom(number)\n return number.to_s\nend",
"def int_to_key(num)\n #10s digit = num/26\n d1 = num/26 + 97\n\n #1s digit = num%26\n d2 = num%26 + 97\n result = d1.chr + d2.chr\n\n return result\nend",
"def integer_to_string(number)\n hash_of_integers = { 0 => '0', 1 => '1', 2 => '2', 3 => '3', 4 => '4', 5 => '5', 6 => '6', 7 => '7', 8 => '8', 9 => '9'}\n \n string =''\n loop do\n\n number, digit = number.divmod(10)\n \n string.prepend(hash_of_integers[digit])\n break if number == 0\n end\n string\nend",
"def number_encoder( input )\n output = \"\"\n \n # build letter to number hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator[ letters[i] ] = i+1 }\n\n \n # seperates into chunks\n input.each(' ') do |chunk|\n chunk.each_char() { |char| output << translator[char].to_s + ' ' }\n end\n output.rstrip!\n output \nend",
"def unique_transaction_number\n chars = [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten\n string = (0...10).map{ chars[rand(chars.length)] }.join + Time.now.to_i.to_s\n end",
"def number_decoder( input )\n output = \"\"\n \n # build number to letter hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator [(i+1).to_s] = letters[i] }\n \n input.each(' ') do |nibble|\n\n \n num = nibble.strip.to_i\n if (num == 0 or num.nil?) then output << \" \"\n else\n case (num-1)/26\n when 0 then output << translator[num.to_s]# + ' '\n when 1 then output << translator[(num - 26).to_s]\n end\n end\n end\n \n output\nend",
"def number_to_letter\n\t\t(self + 64).chr\n\tend",
"def fake_bin(s)\n s.tr('1-9', '00001')\nend",
"def unique_id\n generator = Sass::Script::Functions.random_number_generator\n Thread.current[:sass_last_unique_id] ||= generator.rand(36**8)\n # avoid the temptation of trying to guess the next unique value.\n value = (Thread.current[:sass_last_unique_id] += (generator.rand(10) + 1))\n # the u makes this a legal identifier if it would otherwise start with a number.\n identifier(\"u\" + value.to_s(36).rjust(8, '0'))\n end",
"def change a\n a = a.downcase\n end_string = ''\n ('a'..'z').each { |let| a.include?(let) ? end_string << '1' : end_string << '0' }\n end_string\nend",
"def stringy(int)\n new_string = \"\"\n (int / 2).times { new_string << \"10\" }\n new_string << \"1\" if int.odd? \n new_string\nend",
"def integer_to_string(integer)\n\n counter = 0\n loop do\n counter += 1\n remainder = 10 ** counter\n mod = integer.divmod(remainder)\n break if mod[0] == 0\n end\n\n arr = []\n loop do\n counter -= 1\n denominator = 10 ** counter\n key = (integer / denominator) % 10\n arr << CHAR_SET[key]\n break if counter == 0\n end\n\n arr.join\nend",
"def get_normalized_number(identifier, group_id, base = NORMALIZER)\n MurmurHash3::V32.str_hash(\"#{group_id}:#{identifier}\") % base + 1\n end",
"def crunch(string)\n string.gsub(/([a-z0-9])\\1+/, \"\\\\1\")\nend",
"def to_s22\n \tinteger=self.to_i\n \trval=''\n 22.times do\n c=(integer & 0x3F)\n rval+=@@chars64[c]\n integer =integer >> 6\n end\n return rval.reverse\n end",
"def generate_unique_key\n # not doing uppercase as url is case insensitive\n charset = ::Shortener.key_chars\n (0...::Shortener.unique_key_length).map{ charset[rand(charset.size)] }.join\n end",
"def stringy number, count = 1\n binary_string = ''\n\n if count == 1\n (number / 2).times {binary_string << '10'}\n binary_string << '1' if number % 2 == 1\n elsif count == 0\n (number / 2).times {binary_string << '01'}\n binary_string << '0' if number % 2 == 1\n end\n\n binary_string\n end",
"def generate_id(str); end",
"def get_alpha(num)\n alpha26 = ('A'...'AA').to_a\n return \"\" if num < 1\n string = \"\"\n loop do\n num, r = (num-1).divmod(26)\n string.prepend(alpha26[r])\n break if num.zero?\n end\n string\n end",
"def basic_generate_id(str); end",
"def replaceNumberToChar(number)\n case number\n when 10\n then\n number = 'T'\n when 11\n then\n number = 'J'\n when 12\n then\n number = 'Q'\n when 13\n then\n number = 'K'\n when 14\n then\n number = 'A'\n end\n number.to_s\nend",
"def generate_slug\n rand(36**@@string_length).to_s(36)\n end",
"def integer_to_string(num)\n\tlookup_table = {0 => '0', 1 => '1', 2 => '2', 3 => '3', 4 => '4', \n\t\t\t\t\t5 => '5', 6 =>'6', 7 => '7', 8 => '8', 9 => '9'}\n \n result = ''\n\n if num.is_a? Integer\n num.digits.reverse.each do |number|\n result += lookup_table[number]\n end\n result\n else\n puts \"Invalid entry!\"\n end\nend",
"def stringy(num)\n str = ''\n 1.upto(num) do |index|\n if index.odd?\n str << '1'\n else\n str << '0'\n end\n end\n str\nend",
"def uuid\n char = (0..9).collect { |n| n.to_s }\n char += ('a'..'f').to_a\n blocks = [8,4,4,4,12]\n \n uuid = ''\n blocks.each do |num|\n while num >= 0\n uuid << char.sample\n num -= 1\n end\n uuid += '-' \n end\n uuid.chop\nend",
"def encode_number(param)\n CGI.escape(SimpleScramble.scramble_number(param))\n end",
"def generate_free_insurance_id\n return 'AiShanXing' + DateTime.current.in_time_zone('Beijing').to_s(:number) + ('0'..'9').to_a.shuffle[0..3].join\n end",
"def bijective_encode(i)\n # from http://refactormycode.com/codes/125-base-62-encoding\n # with only minor modification\n return ALPHABET[0] if i == 0\n s = ''\n base = ALPHABET.length\n while i > 0\n s << ALPHABET[i.modulo(base)]\n i /= base\n end\n s.reverse\nend",
"def bijective_encode\n \t# from http://refactormycode.com/codes/124-base-62-encoding\n \t# with only minor modification\n \t# return ALPHABET[0] if i == 0\n \t# s = ''\n \t# base = ALPHABET.length\n \t# while i > 0\n \t# \ts << ALPHABET[i.modulo(base)]\n \t# \ti /= base\n \t# end\n \t# s.reverse + SecureRandom.hex(5 - s.length)\n \tSecureRandom.hex(4)\n end",
"def assign_uid\n chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a\n uid = ''\n 1.upto(8) {\n i = rand(62)\n uid += chars[i]\n }\n self.uid = uid\n end",
"def full_id9\n self.id.blank? ? '000000000' : self.id.to_s.rjust(9,'0')\n end",
"def secret_number\n\tnumber = '8'\nend",
"def number_to_action(number)\n code = number.to_i.to_s(26).tr('0-9a-q', 'a-z')\n \"action_#{code}\"\nend",
"def randstr\n\trand(36 ** 8).to_s(36)\nend",
"def num_to_s(num, base)\n raise \"Please give a base greater than 1 and less than 16\" if base <= 1 || base > 16\n\n number_string_hash = {0 =>\"0\", 1 =>\"1\", 2 =>\"2\", 3 =>\"3\", 4 =>\"4\", 5 =>\"5\", 6 =>\"6\",\n 7 =>\"7\", 8 =>\"8\", 9 =>\"9\" }\n \n if base > 10\n num = num.to_i(base)\n base = 10\n end\n \n num_string = \"\"\n num_place = 0\n while num > 0\n current_digit = (num / base**num_place) % base\n num = num - (current_digit * (base**num_place))\n num_string.prepend(number_string_hash[current_digit])\n num_place += 1\n end\n num_string\nend",
"def generate_code(number)\n Array.new(number) { CHARSET.sample }.join\n end",
"def get_random_string\r\n length=30\r\n source=(\"a\"..\"z\").to_a + (\"A\"..\"Z\").to_a + (0..9).to_a + [\"_\",\"-\"]\r\n key=\"\"\r\n length.times{ key += source[rand(source.size)].to_s }\r\n return key\r\nend",
"def get_uuid\n characters = ('0'..'9').to_a + ('a'..'f').to_a\n dash_positions = [8, 13, 18, 23]\n uuid = []\n\n 32.times do\n uuid.push(characters.sample)\n end\n uuid.each_with_index{ |char, ind| uuid.insert(ind, '-') if dash_positions.include?(ind) }\n uuid.join\nend",
"def encode i\n return @sequence[0,1] if i == 0\n s = ''\n while i > 0\n s << @sequence[i.modulo(@base)]\n i /= @base\n end\n s.reverse\n end",
"def code_to_id(code)\n (code.to_s.tr('a-z', '0-9a-p').to_i(26) - pad) / factor\n end",
"def ran_str_maker\r\n length = 10\r\n ran_str = rand(36**length).to_s(36)\r\n return ran_str\r\nend",
"def num_into_string(number)\n puts number.ordinalize\nend",
"def generate_name_with_digit (digit)\n char_array = ('a'..'z').to_a + ('0'..'9').to_a + ['_'] # char_array.length is 37\n\n quotient = digit\n queue = []\n while true do\n queue.push quotient % N_CHAR\n quotient = (quotient / N_CHAR).round - 1\n if quotient <= -1\n break\n end\n end\n\n name = ''\n while queue.any? do\n name = name + char_array[queue.pop]\n end\n name\n end",
"def mutate_ugcid(_)\n (ALPHABET.sample(6) + DIGITS.sample(4)).join\n end",
"def idTo18(id)\n\tid = id.strip\n\treturn id if(id.length != 15)\n\n\tmap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ012345'\n\textra = ''\n\n\tid.scan(/.{5}/).each do |chunk|\n\t\tbits = []\n\t\t\n\t\tchunk.scan(/.{1}/).each do |char|\n\t\t\tbits.unshift( (char.to_i == 0 && char != 0 && char.downcase != char) ? 1 : 0)\n\t\tend\n\t\t\n\t\tind = bits.inject(0) do |ind, bit|\n\t\t\tind + ind + bit\n\t\tend\n\n\t\textra += map[ind..ind]\n\tend\n\n\treturn id + extra\nend",
"def stringy(int)\n str = ''\n int.times { |i| str += ((i + 1) % 2).to_s }\n str\nend",
"def stringy(number)\n result = ''\n 1.upto(number) do |num|\n answer = num.odd? ? '1' : '0'\n result << answer\n end\n\n result\nend",
"def alphanumeric(placeholder = nil)\n generate(placeholder, ALPHANUMERIC_CHARACTERS)\n end",
"def swedish_organisation_number\n # Valid leading digit: 1, 2, 3, 5, 6, 7, 8, 9\n # Valid third digit: >= 2\n # Last digit is a control digit\n base = [sample([1, 2, 3, 5, 6, 7, 8, 9]), sample((0..9).to_a), sample((2..9).to_a), format('%06d', rand(10**6))].join\n base + luhn_algorithm(base).to_s\n end",
"def encode_number(num)\r\n encode_string = \"\"\r\n while num >= 0x20\r\n next_value = (0x20 | (num & 0x1f)) + 63\r\n encode_string << next_value.chr\r\n num >>= 5\r\n end\r\n final_value = num + 63\r\n encode_string << final_value.chr\r\n return encode_string\r\n end",
"def integer_to_string(number)\n result = ''\n loop do\n number, remainder = number.divmod(10)\n # binding.pry\n result.prepend(DIGITS[remainder])\n break if number == 0\n end\n result\nend",
"def stringy(num)\n str = ''\n char = '1'\n\n loop do\n str += char\n\n char = char == '1' ? '0' : '1'\n break if str.size == num\n end\n\n str\nend",
"def autogenerate_code\n self.code = String.random_alphanumeric if self.code.length == 0\n end",
"def random_name(number)\n charset = Array('a'..'z')\n Array.new(number) { charset.sample }.join\n end",
"def generate_random_id\n len = 8\n chars = (\"a\"..\"z\").to_a + (\"A\"..\"Z\").to_a + (\"0\"..\"9\").to_a\n newpass = \"\"\n 1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }\n return newpass\n end",
"def shortened\n id.to_s(Radix)\n end",
"def change(str)\n if str.class == String\n array = str.split(//)\n binary = Array.new(26, 0)\n array.uniq.sort!\n base = \"a\".ord\n base_upcase = \"A\".ord\n array.each do |x|\n if (65..90).include?(x.ord)\n binary[x.ord - base_upcase] = 1\n elsif (97..122).include?(x.ord)\n binary[x.ord - base] = 1\n end\n end\n end\n binary.join('')\nend",
"def uuid_generator\n character_set = %w(a b c d e f 0 1 2 3 4 5 6 7 8 9)\n\n uuid = ''\n\n [8, 4, 4, 4, 12].each do |num|\n num.times { uuid << character_set.sample }\n uuid << '-' if num != 12\n end\n\n uuid\nend",
"def gen_alphanumeric(length = 10)\n positive_int! length\n gen_string_from_letters length, ALPHANUMERIC\n end",
"def bijective_encode(i)\n # from http://refactormycode.com/codes/125-base-62-encoding\n # with only minor modification\n return ALPHABET[0] if i == 0\n s = ''\n base = ALPHABET.length\n while i > 0\n s << ALPHABET[i.modulo(base)]\n i /= base\n end\n s.reverse\n end",
"def number_encoding(str)\n result = ''\n str.downcase.each_char do |char|\n if char =~ /[a-z]/\n result << (char.ord - 96).to_s\n else\n result << char\n end\n end\n result\nend",
"def encode_digit(d)\n d + 22 + 75 * (d < 26 ? 1 : 0)\n # 0..25 map to ASCII a..z or A..Z \n # 26..35 map to ASCII 0..9\n end",
"def uuid()\n 8.times.map { [*'0'..'9', *'a'..'f'].sample }.join + \"-\" + \\\n 4.times.map { [*'0'..'9', *'a'..'f'].sample }.join + \"-\" + \\\n 4.times.map { [*'0'..'9', *'a'..'f'].sample }.join + \"-\" + \\\n 4.times.map { [*'0'..'9', *'a'..'f'].sample }.join + \"-\" + \\\n 12.times.map { [*'0'..'9', *'a'..'f'].sample }.join\nend",
"def obfuscatable_default_spin\n alphabet = Array(\"a\"..\"z\")\n number = name.split(\"\").collect do |char|\n alphabet.index(char)\n end\n number.shift(12).join.to_i\n end",
"def randHashtag()\n (0...10).map{ ('a'..'z').to_a[rand(26)] }.join\nend",
"def integer_to_string(number)\n\n\tconversion = {0 => '0', 1 => '1', 2 => '2', 3 => '3', 4 => '4', 5 => '5',\n\t\t\t\t 6 => '6', 7 => '7', 8 => '8', 9 => '9' }\n\n\tnumber.digits.reverse.map do |num|\n\t\tconversion[num]\n\tend.join\n\nend",
"def stringy(integer)\n i = 1\n output = ''\n while i <= integer\n output += '1' if i.odd?\n output += '0' if i.even?\n i += 1\n end\n output\nend",
"def convert_to_title(n)\n result = []\n while n > 0\n n = n - 1\n div, mod = n.divmod(26)\n result.unshift((mod + 'A'.ord).chr)\n n = div\n end\n\n return result.join(\"\")\nend",
"def numToChar(number)\n return (number+65).chr\nend",
"def con62to10(id)\n\tnew_id = 0\n\tfor i in 0..3\n\t\tc = id.getbyte(i)\n\t\tif c > 47 && c < 58\n\t\t\t#0-9\n\t\t\tnum = c - 48\n\t\telsif c > 64 && c < 91\n\t\t\t#A-Z\n\t\t\tnum = c - 55\n\t\telsif c > 96 && c < 123\n\t\t\t#a-z\n\t\t\tnum = c - 36\n\t\telse\n\t\t\t#error\n\t\t\treturn -1\n\t\tend\n\t\tnew_id += num * 62**(3 - i)\n\tend\n\treturn Integer(new_id)\nend",
"def random_alphanumeric\n (1..10).collect { ALPHANUMERIC[rand(ALPHANUMERIC.size)] }.join\n end",
"def integer_to_string(int)\n string_chars = {\n 0 => '0', 1 => '1', 2 => '2', 3 => '3', 4 => '4', 5 => '5',\n 6 => '6', 7 => '7', 8 => '8', 9 => '9'\n }\n\n string = ''\n int.digits.reverse.each {|digit| string << string_chars[digit]}\n string\nend",
"def enbase(int, min_length = nil)\n min_length ||= @min_length\n result = self.inner_enbase(int)\n\n if min_length > result.length\n return (@alphabet[0] * (min_length - result.length)) + result\n else\n return result\n end\n end",
"def generate_string\n (0...6).map{(65+rand(26)).chr}.join\n end",
"def no_to_use_as_reference\n self.id.to_s.rjust(11, '0')\n end",
"def stringy(num)\n binary = ''\n loop do\n binary << '1'\n break if binary.length == num\n binary << '0'\n break if binary.length == num\n end\n binary\nend",
"def int_to_uuid(num)\n '00000000-0000-0000-0000-%012d' % num.to_i\n end",
"def generate_short_url\n # encode base 10 id as base 62 string as seen here https://gist.github.com/zumbojo/1073996\n i = id\n return Constants::ALPHABET[0] if i.zero?\n s = ''\n base = Constants::ALPHABET.length\n while i > 0\n s << Constants::ALPHABET[i.modulo(base)]\n i /= base\n end\n update_attributes(short_url: s.reverse)\n end",
"def generate_production_number\n start_digits = rand(10000..99999)\n end_digits = rand(10000..99999)\n alphabet = (\"A\"..\"Z\").to_a\n middle_digits = \"2017\"\n 5.times { middle_digits << alphabet.sample}\n \"#{start_digits}-#{middle_digits}-#{end_digits}\"\n end",
"def generate_production_number\n start_digits = rand(10000..99999)\n end_digits = rand(10000..99999)\n alphabet = (\"A\"..\"Z\").to_a\n middle_digits = \"2017\"\n 5.times { middle_digits << alphabet.sample}\n \"#{start_digits}-#{middle_digits}-#{end_digits}\"\n end",
"def get_short_url_from_id n\n # Map to store 62 possible characters \n map = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\"; \n \tshorturl = \"\"\n\n # Convert given integer id to a base 62 number \n while n!=0 do\n # use above map to store actual character in short url \n shorturl += map[n%62]; \n n = n/62; \n \t\tend\n # Reverse shortURL to complete base conversion \n shorturl.reverse!\n end",
"def uplus\n sprintf('U+%04X', @int)\n end",
"def generate_uuid\n characters = []\n ('a'..'z').each { |letter| characters << letter}\n (0..9).each { |integer| characters << integer}\n sections = [8, 4, 4, 4, 12]\n uuid = []\n sections.each do |digit_quantity|\n uuid << characters.flatten.sample(digit_quantity).join\n end\n uuid.join('-')\nend",
"def generate_random_characters(num)\n valid_characters = ('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a\n slug_array = []\n num.times do\n slug_array << valid_characters[rand(62)]\n end\n slug_array\n end",
"def code\n id ? id.to_s(36) : nil\n end",
"def convertUpToBase36(inStr, inBase, outBase)\n inStr.to_i(inBase.to_i).to_s(outBase.to_i).upcase\nend",
"def hashIDtoTag(number, poll)\n \tif poll\n \t\tnumber = number + POLLSSTARTID\n \tend\n \tnewnumber = (number / 4).to_i\n \tif (number % 4 == 0)\n \t\tnewnumber = MAX/4 - newnumber\n \telsif (number % 4 == 1)\n \t\tnewnumber = 3*MAX/4 - newnumber\n \telsif (number % 4 == 2)\n \t\tnewnumber = MAX/2 - newnumber\n \telse\n \t\tnewnumber = MAX - newnumber\n \tend\n \tresult = \"\"\n \tputs newnumber\n \tfor i in 1..5\n \t\tresult += CODESTRING[newnumber % 20]\n \t\tnewnumber /= 20\n \tend\n\n \t\treturn (result[2]+result[0]+result[4]+result[3]+result[1]).upcase\n end",
"def hex_for_non_alphanumeric_code(input)\n if input < LOW_HEX_CODE_LIMIT\n HEX_CODES[input]\n else\n input.to_s(HEX_BASE)\n end\n end",
"def danToAlphabet(int)\n return (int+96).chr\n end",
"def encode_digit(d)\n d + 22 + 75 * (d < 26 ? 1 : 0)\n # 0..25 map to ASCII a..z\n # 26..35 map to ASCII 0..9\n end",
"def uuid\n id = ''\n id << %w(0 1 2 3 4 5 6 7 8 9 a b c d e f).sample until id.size >= 32\n 4.times { |i| id.insert(8+i*5, '-') }\n id\nend",
"def default_abbreviation\n \"%03d\" % (id % 1000) if id\n end"
] |
[
"0.6958512",
"0.6827479",
"0.67895436",
"0.6759214",
"0.6696846",
"0.6667088",
"0.66527086",
"0.66306525",
"0.6624921",
"0.66217595",
"0.6428974",
"0.6424408",
"0.6417241",
"0.6383967",
"0.6349206",
"0.6348904",
"0.6312951",
"0.630796",
"0.63047916",
"0.6278765",
"0.62694585",
"0.6254059",
"0.6252657",
"0.624712",
"0.6242192",
"0.6235554",
"0.6218821",
"0.62162197",
"0.6208228",
"0.6206338",
"0.6175384",
"0.61683774",
"0.61653984",
"0.61637205",
"0.6163264",
"0.6155586",
"0.6151545",
"0.61460894",
"0.6139621",
"0.61361355",
"0.6133263",
"0.61320233",
"0.6121941",
"0.61199045",
"0.6112828",
"0.61110294",
"0.6110355",
"0.61039424",
"0.60966986",
"0.60959405",
"0.6095494",
"0.6093065",
"0.60866696",
"0.60851145",
"0.6082736",
"0.6081741",
"0.6081408",
"0.60778654",
"0.60753536",
"0.60649943",
"0.60629565",
"0.605894",
"0.60532016",
"0.60529184",
"0.6051983",
"0.6050619",
"0.60440725",
"0.6042541",
"0.6041606",
"0.6039628",
"0.6035946",
"0.60331887",
"0.6027175",
"0.6027076",
"0.60250515",
"0.60193115",
"0.6014939",
"0.6011303",
"0.6005858",
"0.6003891",
"0.60004944",
"0.59923697",
"0.59892595",
"0.5985763",
"0.59854746",
"0.598262",
"0.5977692",
"0.5977692",
"0.597673",
"0.5973765",
"0.59673566",
"0.59639716",
"0.5962014",
"0.595703",
"0.59506315",
"0.59496635",
"0.5947994",
"0.59378517",
"0.59355766",
"0.59323597"
] |
0.7293493
|
0
|
Transform a string into a number using the engine alphabet and booster
|
def decode(sentence)
i = 0
base = @alphabet.length
sentence.each_char { |c| i = i * base + @alphabet.index(c) }
i - @booster
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def translate_string_to_number(input)\n\n #take the input\n #break it up into individual letters\n #map the letters to a dictionary (a = 1) or\n #map the input to a placement in an array\n\nend",
"def numberfy(string)\n message = string.downcase.split(//)\n message.each do |char|\n (ALPHA.include? char) ? number = ALPHA_HASH[char] : number = char\n @numeric_message << number\n end\n end",
"def number_encoding(str)\n result = ''\n str.downcase.each_char do |char|\n if char =~ /[a-z]/\n result << (char.ord - 96).to_s\n else\n result << char\n end\n end\n result\nend",
"def replaceCharToNumber(char)\n case char\n when 'T'\n then\n char = 10\n when 'J'\n then\n char = 11\n when 'Q'\n then\n char = 12\n when 'K'\n then\n char = 13\n when 'A'\n then\n char = 14\n end\n char.to_i\nend",
"def convert_string_to_number(str); end",
"def number_encoder( input )\n output = \"\"\n \n # build letter to number hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator[ letters[i] ] = i+1 }\n\n \n # seperates into chunks\n input.each(' ') do |chunk|\n chunk.each_char() { |char| output << translator[char].to_s + ' ' }\n end\n output.rstrip!\n output \nend",
"def word_to_digit(number_string)\n NUMBER_HASH.each do |string, value|\n number_string.gsub!(/\\b#{string}\\b/, NUMBER_HASH[string])\n end\n number_string\nend",
"def word_to_digit(string)\n words_to_numbers = {\n 'zero' => 0,'one' => 1, 'two' => 2,'three' => 3,'four' => 4,\n 'five' => 5,'six' => 6,'seven' => 7,'eight' => 8,'nine' => 9,\n }\n words_to_numbers.keys.each do |word|\n string.gsub!(word,words_to_numbers[word].to_s)\n end\n string\nend",
"def number_decoder( input )\n output = \"\"\n \n # build number to letter hash\n translator = Hash.new\n letters = ('A'..'Z').to_a\n letters.each_index{|i| translator [(i+1).to_s] = letters[i] }\n \n input.each(' ') do |nibble|\n\n \n num = nibble.strip.to_i\n if (num == 0 or num.nil?) then output << \" \"\n else\n case (num-1)/26\n when 0 then output << translator[num.to_s]# + ' '\n when 1 then output << translator[(num - 26).to_s]\n end\n end\n end\n \n output\nend",
"def title_to_number(s)\n i = - 1\n s.chars.reverse.inject(0) { |agg, c|\n i += 1\n agg + 26 ** i * (c.ord - 'A'.ord + 1)\n } \nend",
"def word_to_digit(string)\n string.split.each do |word|\n word_only = word.downcase.delete(\"^a-z\")\n if NUMBERS.keys.include?(word_only)\n string.gsub!(/#{word_only}/i, NUMBERS[word_only])\n end\n end\n string\nend",
"def word_to_digit(str)\n num_hash = {\n 'one'=> 1, 'two'=> 2, 'three'=> 3, 'four'=> 4, 'five'=> 5, 'six'=> 6, 'seven'=> 7, 'eight'=> 8, 'nine'=> 9, 'zero'=> 0\n }\n \n num_hash.keys.each {|key|\n str.gsub!(key,num_hash[key].to_s)\n }\n \n str\nend",
"def to_num(string)\n string.gsub!(' ', '')\n string.each_char.map { |char| \"#{convert[char]} \" }.join.chop\n end",
"def word_to_digit(string)\n words = string.split\n words.map! do |word|\n clean_word = word.delete(\"^a-zA-Z\")\n if CONVERT.has_key?(clean_word)\n CONVERT[clean_word] + word.delete(\"a-zA-Z\")\n else\n word\n end\n end\n words.join(' ')\nend",
"def dealphabetize(\n alphabet = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"\n )\n str = to_s\n alphabet = alphabet.to_s\n len = alphabet.length\n str.chars.inject(0) do |num, char|\n i = alphabet.index(char)\n raise(\"Character not in alphabet: '#{char}'\") if i.nil?\n\n num * len + i\n end\n end",
"def numbers_to_letters(string)\n convertion_table = ('A'..'Z').to_a\n words = string.split('+')\n words.map do |word|\n word.scan(/\\d+/).map{|letter| convertion_table[letter.to_i - 1]}.join\n end.join(' ')\nend",
"def vowels_to_numbers(word)\n word.tr('aeiou','43106')\n end",
"def letter_to_number(letter)\n letter.ord - 64\nend",
"def title_to_number(s)\n s.split(\"\").map {|ch| ch.ord - 'A'.ord + 1}.reduce(:+)\nend",
"def word_to_digit(string)\n numbers = %w(zero one two three four five six seven eight nine)\n numbers.each_with_index do |num, idx|\n string.gsub!(/\\b#{num}\\b/, idx.to_s)\n end\n string\nend",
"def convert_to_int num_string\n num_hash = {\n '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,\n '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9 \n }\n\n num_array = num_string.chars.map do |char|\n num_hash[char]\n end\n\n final_number = 0\n count = num_array.length - 1\n\n num_array.each do |num| \n final_number += num * (10 ** count)\n count -=1\n end\n\n p final_number\nend",
"def string_to_integer(string)\n digits = string.chars.map { |digit| MATCH[digit] }\n\n value = 0\n digits.each { |digit| value = 10 * value + digit }\n value\nend",
"def to_letters(num_string)\n num_string.split.map { |num| convert.key(num) }.join\n .scan(/...../).join(' ')\n end",
"def string_to_integer(str)\n num_hsh = {'1'=>1,'2'=>2,'3'=>3,'4'=>4,'5'=>5,'6'=>6,'7'=>7,'8'=>8,'9'=>9,'0'=>0,}\n arr = str.chars.reverse\n total = 0\n new_arr = []\n arr.each do |str|\n new_arr << num_hsh[str]\n end\n new_arr.each_with_index do |num, i|\n total += num * 10**i\n end\n total\nend",
"def word_to_digit(str) # I'm hoping thats not the point\n list = str.split(\" \") # cuz I'm doing it the hard way\n insertions = []\n list.each_index do |i| \n if list[i].include?(\".\") # could also be /[!?.@,]/ etc.\n list[i] = list[i].split(\".\").slice(0,list[i].length-1).join\n insertions.push(i) # collecter\n end\n end\n list.each_index do |i|\n case list[i].downcase\n when \"zero\"; list[i] = \"0\"\n when \"one\"; list[i] = \"1\"\n when \"two\"; list[i] = \"2\"\n when \"three\"; list[i] = \"3\"\n when \"four\"; list[i] = \"4\"\n when \"five\"; list[i] = \"5\"\n when \"six\"; list[i] = \"6\"\n when \"seven\"; list[i] = \"7\"\n when \"eight\"; list[i] = \"8\"\n when \"nine\"; list[i] = \"9\"\n end\n end\n insertions.each{|i| list[i] = list[i]+\".\"}\n list.join(\" \")\nend",
"def convertCodeGolf(inStr, inBase, outBase)\n number = inStr.chars.reverse.map.with_index{ |c,i|\n inBase**i*$digits.index(c) }.reduce &:+\n intToStr(number, outBase)\nend",
"def string_to_number(s)\n s.to_i\nend",
"def string_to_number(s)\n s.to_i\nend",
"def word_to_digit(string)\n numbers = %w(zero one two three four five six seven eight nine)\n numbers.each_with_index do |word, digit|\n string.gsub!(/\\b#{word}\\b/i, digit.to_s)\n end\n string.gsub!(/(?<=\\s)(\\d)\\s(?=\\d\\s|\\d[[:punct:]])/, '\\1')\n string.gsub(/(\\d{3})(\\d{3})(\\d{4})/, '(\\1) \\2-\\3')\nend",
"def letter_to_number(letters)\n letters.upcase.each_codepoint.reduce(0) do |result, codepoint|\n 26 * result + codepoint - CODEPOINT_OFFSET\n end\n end",
"def word_to_digit(words)\n # words\n DIGIT_HASH.keys.each do |word|\n words.gsub!(/#{word}\\b ?/, DIGIT_HASH[word])\n end\n words\nend",
"def decode(str)\n num = 0\n str.each_char {|c| num = num * BASE + ALPHANUM.index(c) }\n return num;\n end",
"def str_to_num(string)\n int_list = []\n final_num = 0\n string_list = string.split(\"\")\n for char in string_list\n if 48 <= char.ord && char.ord <= 57\n int_list.push(char.ord - 48)\n else\n return false\n end\n end\n for i in 0...int_list.length\n value = int_list[-i-1]\n place = 10**i\n final_num += value*place\n end\n final_num\nend",
"def locNumToInt(str)\n\tnum = 0\n\tstr.split('').each {|c|\n\t\tnum += 2**(c.ord - 97)\n\t}\n\tnum\nend",
"def string_to_integer(string)\n\n\tnumbers = {'0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5,\n\t\t\t\t'6' => 6, '7' => 7, '8' => 8, '9' => 9 }\n\n\tarray = string.chars.map do |n|\n\t\tnumbers[n]\n\tend\n\n\tarray.inject(0){ |total, num| total * 10 + num}\n\nend",
"def string_to_integer(string)\n\n\tnumbers = {'0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5,\n\t\t\t\t'6' => 6, '7' => 7, '8' => 8, '9' => 9 }\n\n\tarray = string.chars.map do |n|\n\t\tnumbers[n]\n\tend\n\n\tarray.inject(0){ |total, num| total * 10 + num}\n\nend",
"def get_number_from_string(s)\n s.gsub(/[^\\d]/,\"\").to_i\nend",
"def my_number_parse(num_str)\n output = 0\n\n num_str.split(\"\").reverse.each_with_index do |num, index|\n output = output + num.to_i * (10 ** index)\n end\n\n output\nend",
"def string_to_number(string)\n string.to_i\nend",
"def charToNum(letter)\n return letter.upcase.ord-65 #ensure this is uppercase???\nend",
"def string_to_integer2(string)\n digits = string.chars.map { |char| HASH[char] }\n\n value = 0\n digits.each { |digit| value = 10 * value + digit }\n value\nend",
"def normalize(name)\n name.to_s.scan(/\\d+/o).map(&:to_i)\n end",
"def extractNumber str\n match = STDNUMPAT.match str\n return nil unless match\n return (match[1].gsub(/\\-/, '')).upcase\n end",
"def word_to_digit(words)\n DIGITS_HASH.keys.each do |word|\n words.gsub!(/\\b#{word}\\b/, DIGITS_HASH[word])\n end\n words\nend",
"def string_to_integer(str)\n convert_hash = {\n '0' => 0,\n '1' => 1,\n '2' => 2,\n '3' => 3,\n '4' => 4,\n '5' => 5,\n '6' => 6,\n '7' => 7,\n '8' => 8,\n '9' => 9,\n }\n sum = 0\n value = 0\n str_arr = str.chars\n str_arr.each do |num|\n value = convert_hash[num]\n sum += value * (10 ** (str_arr.length - (str_arr.index(num) + 1)))\n end\n sum\nend",
"def number_builder( number_as_string )\n\n number_array = number_as_string.each_char.to_a\n\n pos_flag = true\n\n # handle the sign\n case number_array.first\n when '-'\n pos_flag = false\n number_array.shift\n when '+'\n number_array.shift\n end\n\n total = 0 \n\n number_array.each do |character|\n # don't validate the number \n total = total*10 + character.to_i\n end\n \n ( total = 0 - total ) if not pos_flag\n\n return total\n\nend",
"def convert_string_to_number(str)\n matches = RE_NUMBER_STR.match(str)\n\n s = matches[:sign] == '-' ? -1 : 1\n i = matches[:integer].to_i\n f = matches[:fractional].to_i\n d = matches[:fractional] ? matches[:fractional].length : 0\n t = matches[:exponent_sign] == '-' ? -1 : 1\n e = matches[:exponent].to_i\n\n # I know this looks nutty, but it's exactly what's defined in the spec,\n # and it works.\n s * (i + f * 10**-d) * 10**(t * e)\n end",
"def to_num(input)\n result = 0\n #iterate on roman number hash\n MAPPING.each do |k,v|\n while input.index(k) == 0 #if \"CL\".index(\"C\") == 0\n result += v #assign value of current hash key\n input.slice!(0) #remove string \"C\" from input and so on\n end\n end\n result\n end",
"def letter_to_num(letter)\n \n if letter?(letter) == false\n return false\n end\n \n if letter.length != 1\n return false\n end\n \n letter = letter.downcase\n \n number = letter.ord - 96\nend",
"def decodeString(s)\n 1 while s.gsub!(/(\\d+)\\[([a-z]*)\\]/) { $2 * $1.to_i }\n s\nend",
"def string_to_integer(str)\n place_idx = (str.length - 1)\n \n num = 0\n while place_idx >= 0\n digit = str[place_idx].ord - '0'.ord\n num = num + digit * (10 ** (str.length - 1 - place_idx))\n place_idx -= 1\n end\n\n num\nend",
"def string_to_integer(string)\n char_to_int = {\n '1'=> 1,\n '2'=> 2,\n '3'=> 3,\n '4'=> 4,\n '5'=> 5,\n '6'=> 6,\n '7'=> 7,\n '8'=> 8,\n '9'=> 9,\n '0'=> 0,\n }\n \n if string[0] == '-' then\n string[1..string.length].chars.reduce(0) { |int, char| int * 10 + char_to_int[char]} * -1\n elsif string[0] == '+' then\n string[1..string.length].chars.reduce(0) { |int, char| int * 10 + char_to_int[char]}\n else\n string.chars.reduce(0) { |int, char| int * 10 + char_to_int[char]}\n end\nend",
"def string_to_integer(str)\n str.chars.map { |chr| chr.ord - 48 }.reduce { |a, e| (a * 10) + e }\nend",
"def get_number_from_string(s)\n s.delete(\"^[0-9]\").to_i\nend",
"def word_to_digit(str)\n num_array = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']\n valid_chars = ('a'..'z').to_a.push(' ')\n\n str_ary = str.downcase.gsub!(/./) {|letter| valid_chars.include?(letter) ? letter : ''}.split\n \n str_ary.each do |word|\n if num_array.include?(word)\n str.gsub!(word, num_array.index(word).to_s)\n end\n end\n \n str\nend",
"def get_number_system(tok)\n ret = String.new(tok)\n if ret[0] == 36 # $\n ret[0] = \"\"\n return ret.to_i(16)\n elsif ret[0] == 67 # C\n ret[0] = \"\"\n return ret.to_i(8)\n elsif ret[0] == 66 # B\n ret[0] = \"\"\n return ret.to_i(2)\n else\n return ret.to_i(10)\n end\n end",
"def string_to_integer(string)\n base_dict = { 1 => 1, 2 => 10, 3 => 100, 4 => 1000, 5 => 10000, 6 => 100000}\n keys = base_dict.keys\n store = []; count = 0 ; result = []; \n string.each_byte {|dec| store.push(dec - 48)}\n base = keys[0,store.length].reverse\n loop do \n result.push(base_dict[base[count]] * store[count])\n count += 1\n break if count == store.length\n end\n result = result.inject(0) {|x, i| x + i}\n puts result\n end",
"def get_number_from_string(s)\n s.scan(/\\d/).map(&:to_i).join.to_i\nend",
"def numberize(options = {})\n # Basisarray das alle zeichen enthält die verschlüsselt werden können\n string_array = STRING_BASE.split(\"\")\n\n if options[:token]\n string_array = string_array.sort_by {|x| x.hash*options[:token].inspect.bytes.join(\"\").to_i}\n end\n\n # Nur Zahlen und buchstaben für die verschlüsselung/mix nehmen wg. URLs\n string_array_filtered = string_array.select {|s| !s.match(/[a-zA-Z0-9\\-_]/).nil? }\n splitted = self.split(\"\")\n\n numbered_string = \"\"\n\n splitted.each do |s|\n position = string_array.index(s)\n if !position.nil?\n numbered_string << (position.to_s.rjust(2, \"0\")+string_array_filtered[rand(string_array_filtered.size-1)])\n end\n end\n\n return options[:base_64] == true ? Base64.encode64(numbered_string) : numbered_string\n end",
"def word_to_digit(phrase)\n numbers = {'zero' => 0, 'one' => 1, 'two' => 2, 'three' => 3, 'four' => 4,\n 'five' => 5, 'six' => 6, 'seven' => 7, 'eight' => 8, 'nine' => 9}\n phrase_arr = phrase.split(\" \")\n phrase_arr.map! do |word|\n if word[-1] == \".\"\n front = word.chop\n if numbers.keys.include?(front)\n word = numbers[front].to_s + \".\"\n else\n word\n end\n elsif numbers.keys.include?(word)\n word = numbers[word]\n else\n word\n end\n end\n p phrase_arr.join(\" \")\nend",
"def word_to_digit(words)\n hash ={\n 'zero' => \"0\",\n 'one' => \"1\",\n 'two' => \"2\",\n 'three' => \"3\",\n 'four' => \"4\",\n 'five' => \"5\",\n 'six' => \"6\",\n 'seven' => \"7\",\n 'eight' => \"8\",\n 'nine' => \"9\"\n }\n# #words.delete(\".\").split(\" \").each{|s| words.gsub!(s, hash[s]) if hash.keys.include?(s)}\n# #WORK OF A GINIUS!!!!!!!\n words.split(/\\b/).map { |word| hash[word] || word }.join(\" \")\n return words\nend",
"def from_alpha(col)\n result = 0\n col = col.split(//)\n col.each_with_index do |c,i|\n result += (c.ord - 64) * (26 ** (col.length - (i+1)))\n end\n result\n end",
"def string_to_integer(string, numbers)\n str_nums = string.chars.reverse\n number = 0\n str_nums.each_with_index do |num, index|\n number += numbers[num] * 10**(index)\n end\n number\nend",
"def scrabble_score(str)\n str.gsub(/\\W+/, '').upcase.chars.inject(0){|sum,x| sum + $dict[x]}\nend",
"def fake_bin(s)\n s.tr('1-9', '00001')\nend",
"def cat_number(string)\n return string.split('-',5)[1].to_i\n end",
"def get_number_from_word(source_text)\n source_letters = source_text.split (\"\")\n result = \"\"\n \n source_letters.each do |next_letter|\n if [\"a\", \"b\", \"c\"].include?(next_letter)\n next_processed_letter = \"2\"\n \n end\n \n \n result = \"#{result}#{next_processed_letter}\"\n \n end\n \n \n return result\n \nend",
"def string_expansion(str)\n result = ''\n last_num = nil\n str.each_char do |char|\n if char.match?(/[a-z]/i) # if it's a letter\n result << char if last_num == nil # append to result string if no number precedes\n result << (char * last_num) if last_num != nil # multiply letter by preceding number then append\n else\n last_num = char.to_i\n end\n end\n result\nend",
"def string_to_integer(string)\n integer_hash = {\n '0' => 0,\n '1' => 1,\n '2' => 2,\n '3' => 3,\n '4' => 4,\n '5' => 5,\n '6' => 6,\n '7' => 7,\n '8' => 8,\n '9' => 9\n }\n\n output_array = []\n\n string.chars.reverse.each_with_index { |val, i| output_array << integer_hash[val] * 10 ** i }\n\n output_array.reduce(:+)\nend",
"def scrabble_score(str)\n str = str.upcase.delete(\"^A-Z\")\n return 0 if str.nil? || str.empty?\n str.chars.map{ |chr| $dict[chr] }.reduce(:+)\nend",
"def atoi(word)\n results = []\n word.chars.each do |char|\n letter = change_letter(char)\n results << letter\n end\n results.each do |integer|\n print integer\n end\n puts \"\"\nend",
"def letter_to_number(letter)\n case letter\n when \"A\", \"B\", \"C\"\n print \"2\"\n when \"D\", \"E\", \"F\"\n print \"3\"\n when \"G\", \"H\", \"I\"\n print \"4\"\n when \"J\", \"K\", \"L\"\n print \"5\"\n when \"M\", \"N\", \"O\"\n print \"6\"\n when \"P\", \"Q\", \"S\", \"T\"\n print \"7\"\n when \"T\", \"U\", \"V\"\n print \"8\"\n when \"W\", \"X\", \"Y\", \"Z\"\n print \"9\"\n when \" \"\n print \"-\"\n else \n print \"Not a letter\"\n end\nend",
"def from_alpha(col)\n result = 0\n col = col.split(//)\n col.each_with_index do |c, i|\n result += (c.ord - 64) * (26**(col.length - (i + 1)))\n end\n result\n end",
"def word_to_integer word\n text = canonize(word.to_s.chomp.strip)\n\n exception = exceptions_to_i[text]\n return exception if exception\n\n power = powers_of_ten_to_i[text]\n return 10 ** power if power\n end",
"def encode(number)\n i = number + @booster\n return @alphabet[0] if i == 0\n s = StringIO.new\n base = @alphabet.length\n while i > 0\n s << @alphabet[i.modulo(base)]\n i /= base\n end\n s.string.reverse\n end",
"def word_to_digit(string)\n digits = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']\n words = string.split\n replaced_digits = words.map do |word|\n digits.include?(word) ? digits.index(word) : word\n end\n\n replaced_digits.join(' ')\nend",
"def string_to_integer(string)\n \n digit_array = string.chars.map do |digit|\n digit = DIGITS[digit]\n end\n \n converted_string = 0\n \n digit_array.each do |digit|\n converted_string = converted_string * 10 + digit\n end\n \n converted_string\nend",
"def str_to_int(str_num)\n arr_num = str_to_array_of_num(str_num)\n new_num = 0\n while arr_num.length > 0\n n = arr_num.length\n i = arr_num.shift\n new_num += i * 10**(n-1)\n end\n new_num\nend",
"def numeric_component(alphanum)\n mtch = alphanum.match(/\\d+/)\n return mtch[0].to_i if mtch\n end",
"def decode1(str)\n num = 0\n i = 0\n while i < str.length\n pow = BASE ** (str.length - i -1)\n num += KEYS.index(str[i]) * pow\n i += 1\n end\n return num\nend",
"def getMaxNumber(str, num)\n number = 0\n dict = countCardValue(str)\n dict.each do |i, j|\n if j == num\n number = i\n end\n end\n replaceCharToNumber(number)\nend",
"def decode3(str)\n num = 0\n str.each_char.with_index do |char, i|\n pow = BASE ** (str.length - i -1)\n num += KEYS.index(char) * pow\n end\n return num\nend",
"def convert_number_string_to_integer(number_string)\n Integer(number_string.gsub(\" \", \"\"))\nend",
"def parse_decimal_part(str)\n map = if str.index('割')\n Numeja::JA_割合用小数\n else\n Numeja::JA_小数\n end\n keys = map.keys()\n keys.reduce(0) do |t, ja_digit|\n index = str.index(ja_digit)\n break t if index.nil?\n unit = str.slice!(0, index)\n str.slice!(0, 1)\n t += (unit.to_f * map[ja_digit])\n t\n end\n end",
"def normalized_cwe_string(cwe)\n cwe.to_s.gsub(/[^0-9]/,'').to_i\n end",
"def string_to_integer(string_num)\n hash = {\n '0'=>0, '1'=>1, '2'=>2, '3'=>3, '4'=>4,\n '5'=>5, '6'=>6, '7'=>7, '8'=>8, '9'=>9\n }\n int_array = string_num.chars.map { |num| hash[num] }\n tens = 1\n integer = 0\n int_array.size.times do\n integer += int_array.pop * tens\n tens *= 10\n end\n integer\nend",
"def string_to_integer(string)\nend",
"def number_or_string(input) #helper for pick_a_story\n new_input = input.gsub(/[^\\d]/, \"\")\n if new_input.empty?\n input\n else #return a valid number\n new_input.to_i.between?(1,146) ? new_input.to_i : 555\n end\n end",
"def super_digit(n)\n s = n.to_s \n if s.length <= 1 # basecase here\n return n\n end\n \n sum = 0 \n s.split(\"\").each do |d|\n sum += d.to_i \n end\n \n return super_digit(sum)\nend",
"def word_to_digit(sentence)\n sentence.split(/\\b/).map { |i| DIGITS.include?(i) ? DIGITS.index(i) : i }\nend",
"def lookup(string)\r\n return 2 ** (string.chr.downcase.ord - ('a'.ord))\r\n end",
"def transform_upvotes(str)\n\tstr.split.map{ |s| eval(s.sub('k', '*1000')).to_i }\nend",
"def string_to_integer(num_string)\n digits = { '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,\n '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9 }\n\n num_string.chars.reverse.map.with_index { |char, idx| digits[char] * (10 ** idx) }.sum\nend",
"def string_to_value(string)\n case string\n when '1p'\n 1\n when '2p'\n 2\n when '5p'\n 5\n when '10p'\n 10\n when '20p'\n 20\n when '50p'\n 50\n when '£1'\n 100\n when '£2'\n 200\n end\n end",
"def unencode_number(param)\n param && SimpleScramble.unscramble_number(CGI.unescape(param))\n end",
"def replaceNumberToChar(number)\n case number\n when 10\n then\n number = 'T'\n when 11\n then\n number = 'J'\n when 12\n then\n number = 'Q'\n when 13\n then\n number = 'K'\n when 14\n then\n number = 'A'\n end\n number.to_s\nend",
"def NumberSearch(str)\n\n num_sum = str.scan(/(\\d)/).flatten.map {|x| x.to_i }.inject(:+)\n letter_count = str.scan(/[a-zA-Z]/).length\n \n return (num_sum.to_f/letter_count).round\n \nend",
"def number_from_text(text)\n return nil unless starts_with_numeric_text?(text)\n text.to_i\n end",
"def str_expansion(s)\n s.gsub(/\\d*(\\d)(\\D*)/) {n = $1.to_i ; $2.gsub(/./) {$& * n}}\nend",
"def decode5(str)\n num = 0\n i = 0\n str.each_char do |char|\n pow = BASE ** (str.length - i -1)\n num += KEYS_HASH[char] * pow\n i += 1\n end\n return num\nend",
"def max_beauty(string)\n chars = Hash.new { |h,k| h[k] = 0 }\n\n string.chars.each do |char|\n chars[char] += 1\n end\n\n next_value = 26\n beauty = 0\n chars.sort_by { |key, value| -value }.each do |_, count|\n beauty += count * next_value\n next_value -= 1\n end\n\n beauty\nend"
] |
[
"0.7554814",
"0.74018365",
"0.7214068",
"0.6957951",
"0.6938035",
"0.6919406",
"0.6909402",
"0.6904871",
"0.6886612",
"0.68702227",
"0.68528515",
"0.6846937",
"0.6729191",
"0.6694879",
"0.6689013",
"0.66629046",
"0.66570514",
"0.66152585",
"0.66128427",
"0.65814877",
"0.6548654",
"0.65132636",
"0.6480601",
"0.64739466",
"0.64698035",
"0.64525026",
"0.6395465",
"0.6395465",
"0.63815665",
"0.637374",
"0.6338729",
"0.63347185",
"0.631773",
"0.6316797",
"0.6316083",
"0.6316083",
"0.63080525",
"0.6304007",
"0.6290392",
"0.6265642",
"0.6263327",
"0.6257501",
"0.6255198",
"0.6252724",
"0.62456065",
"0.6236399",
"0.62210345",
"0.6216188",
"0.62069565",
"0.62056714",
"0.6201653",
"0.61934537",
"0.61823475",
"0.61766523",
"0.61720985",
"0.61381817",
"0.6116956",
"0.61157924",
"0.61145705",
"0.61126083",
"0.6110219",
"0.6105908",
"0.6096668",
"0.60787576",
"0.6066928",
"0.60616267",
"0.6058854",
"0.60565394",
"0.60464966",
"0.60448307",
"0.60440314",
"0.60400265",
"0.60367537",
"0.6034335",
"0.603048",
"0.6028916",
"0.60136217",
"0.6012424",
"0.6008176",
"0.60012615",
"0.59983045",
"0.59832555",
"0.5972809",
"0.59409314",
"0.5935878",
"0.5931609",
"0.5931201",
"0.5930594",
"0.592939",
"0.5928881",
"0.5923747",
"0.59193933",
"0.591857",
"0.59175223",
"0.5914622",
"0.59090316",
"0.59042096",
"0.5903394",
"0.5884585",
"0.5876341",
"0.5866989"
] |
0.0
|
-1
|
You can pass a set of Rools::Rules with a block parameter, or you can pass a filepath to evaluate.
|
def initialize(file = nil, &b)
@rules = {}
@facts = {}
@dependencies = {}
if block_given?
instance_eval(&b)
elsif file
# loading a file, check extension
name,ext = file.split(".")
logger.debug("loading ext: #{name}.#{ext}") if logger
case ext
when 'csv'
load_csv( file )
when 'xml'
load_xml( file )
when 'rb'
load_rb( file )
when 'rules' # for backwards compatibility
load_rb(file)
else
raise RuleLoadingError, "invalid file extension: #{ext}"
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def rule(expression, &block); end",
"def rule(expression, &block); end",
"def process_rules *args, &block\n Shotshare::ProcessRuleContainer.instance.rules = \\\n Docile.dsl_eval(Shotshare::Dsl::ProcessRuleBuilder.new, &block).build\nend",
"def evaluate\n ::File.open path, 'r' do |file|\n self.instance_eval file.read, file.path\n end\n end",
"def each(&block)\n @rules.each(&block)\n end",
"def evaluate_file(file)\n evaluate(parse_file(file))\n end",
"def eval_file; end",
"def evaluates(&block)\n @predicate << Rule.new(self, block)\n self\n end",
"def run(rule)\n end",
"def load_rules(rules)\n self.instance_eval(rules)\n end",
"def rule(pattern, *dependencies, &block)\n if block.nil?\n Rule.new(pattern, *dependencies)\n else\n Rule.new(pattern, *dependencies) do |rule|\n rule.define(&block)\n end\n end\n end",
"def rule(expression, &block)\n case expression\n when Hash\n expression.each do |fact, task|\n fact = define_fact(fact)\n task = define_task(task)\n @rules << Rule.new(fact, &task)\n end\n else\n fact = define_fact(expression)\n @rules << Rule.new(fact, &block)\n end\n\n #rule = Rule.new(@_facts, get_rule_options, &procedure)\n #@rules << rule\n #clear_rule_options\n\n return @rules\n end",
"def subsequent_rules(*args); end",
"def subsequent_rules(*args); end",
"def eval\n @block.eval\n end",
"def each\n @rules.each {|rule, obj| yield obj }\n end",
"def rule(code, name, &block)\n @rules = [] if @rules.nil?\n @rules << Rule.new(code, name)\n yield self\n end",
"def load_rules; end",
"def run( lines )\r\n # Check if this rule already evaluated to true\r\n return if self.result == true\r\n # Check if input is empty\r\n return if self.pattern == \"\"\r\n\r\n if lines.kind_of?(String)\r\n self.result = check_string( lines )\r\n elsif lines.kind_of?(Array)\r\n self.result = check_array( lines )\r\n else\r\n puts \"#{self.class}:run: Received invalid input of type: #{lines.class}\"\r\n return false\r\n end\r\n\r\n puts \"#{self.result.to_s.upcase}: #{self.class}: #{self.pattern}\" if @@DEBUG == true\r\n end",
"def evaluate\r\n @status = PASS\r\n @assert = true\r\n @num_executed = 0;\r\n @num_evaluated = 0;\r\n \r\n get_relevant_rules()\r\n logger.debug(\"no relevant rules\") if logger && @relevant_rules.size==0\r\n \r\n #begin #rescue\r\n \r\n # loop through the available_rules, evaluating each one,\r\n # until there are no more matching rules available\r\n begin # loop\r\n \r\n # the loop condition is reset to break by default after every iteration\r\n matches = false\r\n obj = nil #deprecated\r\n \r\n #logger.debug(\"available rules: #{available_rules.size.to_s}\") if logger\r\n @relevant_rules.each do |rule|\r\n # RuleCheckErrors are caught and swallowed and the rule that\r\n # raised the error is removed from the working-set.\r\n logger.debug(\"evaluating: #{rule}\") if logger\r\n begin\r\n @num_evaluated += 1\r\n if rule.conditions_match?(obj)\r\n logger.debug(\"rule #{rule} matched\") if logger\r\n matches = true\r\n \r\n # remove the rule from the working-set so it's not re-evaluated\r\n @relevant_rules.delete(rule)\r\n \r\n # find all parameter-matching dependencies of this rule and\r\n # add them to the working-set.\r\n if @dependencies.has_key?(rule.name)\r\n logger.debug( \"found dependant rules to #{rule}\") if logger\r\n @relevant_rules += @dependencies[rule.name].select do |dependency|\r\n dependency.parameters_match?(obj)\r\n end\r\n end\r\n \r\n # execute this rule\r\n logger.debug(\"executing rule #{rule}\") if logger\r\n rule.call(obj)\r\n @num_executed += 1\r\n \r\n # break the current iteration and start back from the first rule defined.\r\n break\r\n end # if rule.conditions_match?(obj)\r\n \r\n rescue RuleConsequenceError\r\n fail\r\n rescue RuleCheckError => e\r\n fail\r\n end # begin/rescue\r\n \r\n end # available_rules.each\r\n \r\n end while(matches && @assert)\r\n \r\n #rescue RuleConsequenceError => rce\r\n # RuleConsequenceErrors are allowed to break out of the current assertion,\r\n # then the inner error is bubbled-up to the asserting code.\r\n # @status = FAIL\r\n # raise rce.inner_error\r\n #end\r\n \r\n @assert = false\r\n \r\n return @status\r\n end",
"def initialize(&block)\n @rules = []\n DSL.new(self).execute(&block) unless block.nil?\n end",
"def load_rules\n # Find rules file\n rules_filename = [ 'Rules', 'rules', 'Rules.rb', 'rules.rb' ].find { |f| File.file?(f) }\n raise Nanoc3::Errors::NoRulesFileFound.new if rules_filename.nil?\n\n # Get rule data\n @rules = File.read(rules_filename)\n @rules_mtime = File.stat(rules_filename).mtime\n\n # Load DSL\n dsl.instance_eval(@rules)\n end",
"def eval_file(file)\n file = File.join(__dir__, file)\n eval(File.read(file), nil, file) # rubocop:disable Security/Eval\nend",
"def recipe(&block)\n rules.last.recipe = block\n end",
"def evaluate(scope, locals, &block)\n File.read(eval(data))\n end",
"def evaluate(path)\n ret = @eval_block.call(path)\n case ret\n when :exclude_and_continue then\n org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_CONTINUE\n when :exclude_and_prune then\n org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_PRUNE\n when :include_and_continue then\n org.neo4j.graphdb.traversal.Evaluation::INCLUDE_AND_CONTINUE\n when :include_and_prune then\n org.neo4j.graphdb.traversal.Evaluation::INCLUDE_AND_PRUNE\n else\n raise \"Got #{ret}, only accept :exclude_and_continue,:exclude_and_prune,:include_and_continue and :include_and_prune\"\n end\n end",
"def initialize(&block)\n rules_json, @text, @rules, @json = RULES_JSON.dup, '', [], []\n rules_json << abase if !abase.empty?\n\n open(rules_json, OPEN_URI_OPTS) do |x|\n if x.content_type.include?('/json') and x.status.first.to_i.eql?(200)\n x.each_line do |l|\n @text << l\n end\n end\n end\n\n @json = JSON.parse(@text)\n\n return [] if !@json.key?('rules')\n\n @alerts = @json['rules']\n\n if block_given? \n @alerts.each do |a|\n yield a\n end\n end\n\n self.concat(@rules)\n end",
"def run_rules(input_file)\n\t\tcommand = \"#{@base_command} \\\"#{input_file}\\\"\"\n\t\t#output = Helpers.run_command(command,true,File.dirname(@rule_directory))\n\t\toutput = Helpers.run_command(command,true,@rule_directory)\n\t\treturn output\n\tend",
"def rules_by_name; end",
"def evaluate(&block)\n instance_eval(&block)\n end",
"def load_cop_rules(rules); end",
"def create_rule(*args, &block)\n @ProjectFileLoader.CurrentlyLoadedProjectFile().create_rule(*args, &block)\n end",
"def define(*args, &block)\n NamedRules.new(*args, &block)\n end",
"def raw\n @rules ||= load_rules(\"#{Credy.root}/data/*.yml\")\n end",
"def evaluate(context, statements, file = __FILE__, line = __LINE__)\n eval(statements, @binding, file, line)\n end",
"def evaluate(scope, locals, &block); end",
"def run(&blk)\n raise(\"A block is needed to run\") unless block_given?\n @run_logic = blk\n end",
"def match(*pattern, &block)\n\t\t\t@rules << Rule.new(pattern, block)\n\t\tend",
"def evaluate\n\n end",
"def ruleset(name_and_chain, &block)\n name, chain = parse_ruleset_name(name_and_chain)\n if @rulesets.key?(name)\n ruleset = @rulesets[name]\n ruleset.update(chain, &block)\n else\n ruleset = Ruleset.new(self, name_and_chain, &block)\n @rulesets[name] = ruleset\n end\n ruleset\n end",
"def evaluate(rbot, cmds)\n # instructions(cmds).each do |cmd|\n # p cmd\n # rbot.send(cmd)\n # end\n instructions(cmds).each { |cmd| rbot.send(cmd) }\n end",
"def rule(val); @rule = val; self; end",
"def evaluate(path)\n @context.evaluate(path)\n end",
"def evaluate(*args, &block)\n self.class.evaluate(self, *args, &block)\n self\n end",
"def method_missing(m, *args, &block)\n r = @rules.find{|r| r.name == m}\n if r\n match_rule(r, args[0], args[1])\n else\n super\n end\n end",
"def load_parameter_rules(rules); end",
"def on(path, rule = nil, &block)\n rule = block.arity <= 0 ? Sawtooth::Rules::CallRule.new(&block) : Sawtooth::Rules::CallRule.new(:start => block) if block_given?\n rules.add(path, rule) if rule\n end",
"def evaluate\n instance_eval(@mironfile_path.read)\n end",
"def eval\n yield self\n end",
"def [](*args)\r\n if args.length == 1 and args[0].is_a?(Symbol)\r\n rule(args[0])\r\n else\r\n super\r\n end\r\n end",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def initialize(options = {})\n @rules = options.fetch(:rules, {})\n yield(self) if block_given?\n end",
"def validate(file, _options = {})\n @file = file\n @criteria_list.each do |criteria|\n next if criteria.passed_qrda\n validate_criteria(criteria)\n end\n end",
"def run\n RootRule.new(@units, @ast).apply\n @ast\n end",
"def rule(&block)\n rule = RuleDsl.new(self).instance_eval(&block)\n PolicyDsl.new(self, rule)\n end",
"def compile(identifier, params={}, &block)\n # Require block\n raise ArgumentError.new(\"#compile requires a block\") unless block_given?\n\n # Get rep name\n rep_name = params[:rep] || :default\n\n # Create rule\n rule = Rule.new(identifier_to_regex(identifier), rep_name, block)\n @site.compiler.item_compilation_rules << rule\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def evaluate!(scope, &block)\n new(scope).evaluate(&block)\n end",
"def [](*args)\n sort_if_needed\n @rules[*args]\n end",
"def eval(*args); end",
"def evaluate(context, path)\n content_type, attributes = content_type_of_path(context, path)\n processors = get_all_processors_for_evaluate(context, content_type, attributes, path)\n filter_all_processors(processors)\n evaluate_path_from_context(context, path, processors)\n end",
"def evaluate(scope, locals, &block)\n if ::Requirejs::BuildConfig.new(file).exists?\n compiler = ::Requirejs::Compiler.new(scope: scope, data: data, file: file)\n @output ||= compiler.exec\n else\n @output ||= data\n end\n end",
"def load_rb( file )\r\n begin\r\n str = IO.read(file)\r\n load_rb_rules_as_string(str)\r\n rescue Exception => e\r\n raise RuleLoadingError, \"loading ruby file\"\r\n end\r\n end",
"def rule; end",
"def rule; end",
"def rule; end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def run_tests(&block)\n\n @sources.each do |source|\n result = test_source(File.absolute_path(source))\n block.call({ :source => source, :result => result })\n end\n\n end",
"def lexical(filename, content)\n @lexicals.each do |lexical|\n lexical.check(filename, content)\n end\n end",
"def rule(name, &definition)\n r = DSL::Rule.new name\n r.instance_eval(&definition)\n @rules << r\n r\n end",
"def doing_evaluate(activity, line_num, file_read)\n val = evaluate_expression(activity, line_num, file_read).to_s\n puts val unless val.empty? || file_read\n end",
"def each_rule(&x) #:yields: elem\n elements.each(&x)\n end",
"def eval_lines(fn, lines)\n eval( File.readlines(fn)[lines].join)\nend",
"def validate(*values)\n raise \"Missing validation block on #{self}\" unless @block\n @block.call(*values)\n end",
"def _run (expr)\n _ruby_eval expr\n end",
"def rule!(name, opts = {}, &definition)\n rule(name, opts) { self.instance_eval(&definition).as(name) }\n end",
"def evaluate(block, *args)\n return if block.nil?\n if block.is_a? Symbol\n instance_exec(self, *args, &block)\n else\n instance_exec(*args, &block)\n end\n end",
"def runner(&blk); end",
"def runner(&blk); end",
"def rule(lhs, *rhs)\n ensure_syntax_definition_not_completed!\n\n @raw_rules << [lhs, rhs]\n end",
"def rule(chain, description = nil, &block)\n rule = Riptables::Rule.new(@table.chain(chain))\n rule.description = description\n rule.dsl.instance_eval(&block)\n @table.chain(chain).rules << rule\n end",
"def search(*rules); end",
"def search(*rules); end",
"def execute(&block)\n DSLHelper.new(Class => [:&, :|, :not]) do\n Kernel.load(File.join(File.dirname(__FILE__), 'dsl_ruby_extensions.rb'))\n self.instance_eval(&block)\n end\n end",
"def evaluate\n made_discovery = true\n while made_discovery do\n made_discovery = self.rules.any? do |rule|\n if rule.fired?\n false\n else\n rule.evaluate\n rule.fired?\n end\n end\n end\n end",
"def evaluate(control_name)\n return Rule.enabled if @rules.nil?\n start_time = Time.now\n rule_name = control_name\n if control_name.to_s.end_with?('_id') && !@rules.has_key?(rule_name)\n rule_name = control_name.to_s.gsub(/_id$/, \"\").to_sym\n spent_time = Time.now - start_time\n @total_evaluation_time += spent_time\n debug \":#{control_name} rule is not defined, trying #{rule_name}\"\n end\n ret_val = @rules.fetch(rule_name, @rule_set.default_rule )\n if self.class.logger\n spent_time = Time.now - start_time\n @total_evaluation_time += spent_time\n debug \":#{rule_name} evaluated as :#{ret_val.inspect}\"\n debug \"Spent: #{ spent_time } s, accumulated: #{ @total_evaluation_time }s\"\n end\n ret_val\n end",
"def evaluate(script, filename = nil, linenum = nil)\n compiled_script = compile(script, filename, linenum)\n evaluate_compiled_script(compiled_script)\n end",
"def evaluate(script, filename = nil, linenum = nil)\n compiled_script = compile(script, filename, linenum)\n evaluate_compiled_script(compiled_script)\n end",
"def parsed_lines\n eval(file_lines)\n end",
"def add_rules\n\n raise 'Not a single yml location is defined for rules' if yml.empty?\n\n yml.each do |location|\n\n RuleParser.yml location, self\n\n end\n\n end",
"def evaluate(input)\n result = parse(input, :Expr, @rules, **@options)\n # This is called for each Expr\n puts result\n end",
"def initialize(&block)\n @rules = Sawtooth::Rules::Set.new\n self.instance_eval(&block) if block_given?\n end",
"def rule(name, obj=nil, &block)\n sym = name.to_sym\n obj = block.call if block\n\n if obj\n rule_names << sym unless has_rule?(sym)\n\n rule = Rule.for(obj)\n rule.name = name\n setup_super(rule, name)\n rule.grammar = self\n\n rules[sym] = rule\n end\n\n rules[sym] || super_rule(sym)\n rescue => e\n e.message.replace(\"Cannot create rule \\\"#{name}\\\": #{e.message}\")\n raise e\n end",
"def eval\n execute\n end"
] |
[
"0.6878293",
"0.6878293",
"0.6278457",
"0.62452257",
"0.6171773",
"0.6100549",
"0.60940397",
"0.58921695",
"0.58468896",
"0.5838046",
"0.5811137",
"0.57737714",
"0.5721038",
"0.5721038",
"0.5629911",
"0.5594984",
"0.5594359",
"0.55670804",
"0.54709446",
"0.5458658",
"0.5446444",
"0.54418623",
"0.5431903",
"0.5418595",
"0.5368957",
"0.5368709",
"0.5368471",
"0.5356686",
"0.53460336",
"0.5325057",
"0.53126526",
"0.5284648",
"0.5255682",
"0.5244139",
"0.5210238",
"0.5204525",
"0.51988363",
"0.5196888",
"0.5190784",
"0.5182049",
"0.5175619",
"0.5167691",
"0.51577765",
"0.5144556",
"0.5141094",
"0.5137268",
"0.512241",
"0.5121254",
"0.512028",
"0.51151884",
"0.51136297",
"0.5094041",
"0.50934416",
"0.5088941",
"0.5084854",
"0.5084211",
"0.5081019",
"0.5081019",
"0.5081019",
"0.5081019",
"0.5081019",
"0.5081019",
"0.5081019",
"0.5080896",
"0.5077754",
"0.5076287",
"0.506761",
"0.50636905",
"0.505362",
"0.50386816",
"0.50386816",
"0.50386816",
"0.5037528",
"0.5025599",
"0.5019501",
"0.50192505",
"0.50187",
"0.50136685",
"0.5002526",
"0.49945137",
"0.4985619",
"0.49669352",
"0.49620456",
"0.4961662",
"0.4961662",
"0.49541038",
"0.4952298",
"0.49346572",
"0.49346572",
"0.49241868",
"0.49176726",
"0.4913844",
"0.49114612",
"0.49114612",
"0.49110475",
"0.4908344",
"0.4900282",
"0.48996532",
"0.48949566",
"0.48909342"
] |
0.55607903
|
18
|
XML File format loading
|
def load_xml( fileName )
begin
str = IO.read(fileName)
load_xml_rules_as_string(str)
rescue Exception => e
raise RuleLoadingError, "loading xml file"
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def xml\n File.read(\"#{@file_path}.xml\")\n end",
"def load_xml file\n f = File.open file\n doc = Nokogiri::XML f\n f.close\n doc\n end",
"def load_xml(file_path)\n # Read the source XML file.\n puts \"file_path: #{file_path}\"\n raw_xml = File.read(file_path)\n\n # Parse raw_xml using Nokogiri.\n parsed_doc = Nokogiri.XML(raw_xml)\nend",
"def load_xml_doc( filename )\n File.open( filename, 'r') do |file|\n return Oga.parse_xml( file )\n end\n\n puts \"ERROR: loading #{filename}\"\n return nil\n end",
"def load_XML(file)\n begin\n xml_file = File.open(file)\n xml_obj = Document.new(xml_file)\n xml_file.close\n rescue => e\n puts \"ERROR: Unable to create XML object from file: #{file}\"\n puts e.message\n puts e.backtrace\n exit 1\n end\n return xml_obj\nend",
"def parse_xml(filename)\n @parser = Parser.new :pregenerated => filename\n @parser.parse\n end",
"def from_file(file_path)\n from_xml(File.read(file_path))\n end",
"def load_xml(source)\n #begin\n if source.is_a? Nokogiri::XML::Document\n @document = source\n else\n #source =~ /\\<DIF\\>/\n if source.size < 255 and File.exists? source\n source = File.read source\n end\n @document = Nokogiri::XML::Document.parse( source, nil, nil ) #, Nokogiri::XML::ParseOptions::NOBLANKS\n end\n # Sets all properties like Entry_ID for this instance\n load_hash(document_to_hash)\n \n #rescue => e\n #puts e.backtrace\n #raise ArgumentError, \"Cannot load DIF XML: \" + e.message[0..255]\n #end\n end",
"def load_xml(path)\n fail MethodDenied, :load_xml if infobase.read_only?\n infobase.designer do\n loadConfigFromFiles path\n end.run.wait.result.verify!\n path\n end",
"def load_xml(file_name = @file_name)\n\t\tputs \"loading xml...\"+file_name\n\t\ttweet_loader = TweetLoader.new(file_name)\n\t\ttweet_loader.load_tweets\n\t\t@tweets = tweet_loader.get_tweets\n\tend",
"def load_from_xml(f)\n case f\n when Array\n f.each { |filename| load_from_xml(filename) }\n when String\n load_from_xml(File.open(f))\n when IO\n tf = PROIELXML::Reader.parse_io(f)\n\n tf.proiel.sources.each do |s|\n @sources << Source.new(self, s.id, tf.proiel.export_time, s.language, s.dialect,\n bundle_metadata(s), s.alignment_id) do |source|\n build_divs(s, source)\n end\n\n index_source_objects!(@sources.last)\n end\n\n tf.proiel.dictionaries.each do |s|\n @dictionaries << Dictionary.new(self, tf.proiel.export_time, s.language, s.dialect, s)\n\n index_dictionary_objects!(@dictionaries.last)\n end\n\n annotation_schema = AnnotationSchema.new(tf.proiel.annotation)\n schema_version = tf.proiel.schema_version\n\n @annotation_schema ||= annotation_schema\n @schema_version ||= schema_version\n\n if @annotation_schema == annotation_schema and @schema_version == schema_version\n # FIXME: consolidate export times? This is a design flaw in PROIEL XML\n # 2.0: export time ought to be per source not per PROIEL XML file, so\n # not clear what to do here. Pass it down to the source object?\n # @export_time = tf.proiel.export_time\n else\n raise SchemaMismatch\n end\n else\n raise ArgumentError, 'expected filename, IO or array of these'\n end\n\n self\n end",
"def read_xml\n @epub.file.read_xml(abs_filepath)\n end",
"def xml_load(file_path)\n result = MultiXml.parse(File.read(file_path)).to_smash[:configuration]\n xml_format(result)\n end",
"def DataLoadFromFile(filename)\n file = File.new(filename)\n \n @xml_data = file\n self.ScrapAnalyse()\n end",
"def read( nexml )\n case nexml\n when /\\.xml$/\n XML::Reader.file( nexml, :options => parse_opts )\n when IO\n XML::Reader.io( nexml, :options => parse_opts )\n when String\n XML::Reader.string( nexml, :options => parse_opts )\n end\n end",
"def load_xml(xml_url)\n\t\t\tfile = File.new(xml_url)\n\t\t\tload_map(file)\n\t\t\tfile.close\n\t\tend",
"def from_xml(xml)\n\t\tend",
"def initialize(path)\n @filename = path\n file = nil\n file = open(path)\n @errors = [] \n \n @document = Nokogiri::XML(file)\n @document.remove_namespaces!\n @node = @document.root\n unless self.valid?\n self.errors << {:xml => 'invalid xml passed in'}\n #raise \"Unable to load file. Is it in the correct format?\"\n end\n end",
"def read\n Hash.from_xml(File.open(file_name))\n end",
"def load_xml_document file_name\n xml_file = File.new file_name, \"r\"\n return Document.new xml_file\n end",
"def read_xml(xml)\n REXML::Document.new(File.read(xml)).root\nend",
"def load_unattend(xml_path)\n print_status(\"Reading #{xml_path}\")\n f = session.fs.file.new(xml_path)\n raw = \"\"\n until f.eof?\n raw << f.read\n end\n\n begin\n xml = REXML::Document.new(raw)\n rescue REXML::ParseException => e\n print_error(\"Invalid XML format\")\n vprint_line(e.message)\n return nil, raw\n end\n\n return xml, raw\n end",
"def load_model file\n self.clear_model\n\n xml_file = File.new file\n doc = Document.new xml_file\n\n doc.elements.each(\"model/entities/entity\") do |element|\n\n id = element.elements[1].text.to_i\n name = element.elements[2].text\n type = element.elements[3].text\n definition = element.elements[4].text\n x = element.elements[5].text.to_i\n y = element.elements[6].text.to_i\n\n if id.to_i > @max_id\n @max_id = id.to_i\n end\n\n ent = self.add_entity name, type, definition, x, y\n ent.id = id\n end\n\n doc.elements.each(\"model/connections/connection\") do |element|\n name = element.elements[1].text\n definition = element.elements[2].text\n source_entity_id = element.elements[3].text.to_i\n target_entity_id = element.elements[4].text.to_i\n source_point_type = element.elements[5].text\n target_point_type = element.elements[6].text\n source_point_x = element.elements[7].text.to_i\n source_point_y = element.elements[8].text.to_i\n target_point_x = element.elements[9].text.to_i\n target_point_y = element.elements[10].text.to_i\n label_x = element.elements[11].text.to_i\n label_y = element.elements[12].text.to_i\n\n source_entity = self.get_entity source_entity_id\n target_entity = self.get_entity target_entity_id\n source_point = Point2D::Double.new source_point_x, source_point_y\n target_point = Point2D::Double.new target_point_x, target_point_y\n\n con = self.add_connection_specific_endpoints source_entity,\n target_entity,\n source_point,\n target_point,\n source_point_type,\n target_point_type,\n name,\n definition\n\n con.label.set_location label_x, label_y\n end\n @panel.repaint\n end",
"def xml_parser(directory_name, filename)\n @doc = Document.new File.new(directory_name + filename)\n get_dataset_name(filename)\n set_topics\n set_dataset_rel_and_attr\n get_footnotes\n record_attributes\n @dataset.save\n end",
"def load(filename)\n\t\tend",
"def initialize(file_content)\n # Open XML file\n self.fichero = file_content\n # Initialize XML Document\n @doc = Document.new self.fichero\n # Initialize attribute default values\n self.lista_devoluciones = []\n end",
"def load_rop(file_path)\n f = File.open(file_path, 'rb')\n xml = REXML::Document.new(f.read(f.stat.size))\n f.close\n return xml\n end",
"def parse filename\n doc = Document.new(File.new(filename))\n elements = doc.elements\n # Let each entity definition do it's own lower level parsing\n self.entities.each do |e|\n @instances[e.name] = e.parse(self, elements)\n end\n # Let each relationship definition do it's own lower level parsing\n self.relationships.each do |r|\n r.parse(self, @instances)\n end\n end",
"def read_file(filename)\n File.open(filename, \"r\") {|f| load_xml(f.read)}\n end",
"def from_file(filename, encoding = nil, options = Nokogiri::XML::ParseOptions::DEFAULT_XML)\n file = File.open(filename)\n @mods_ng_xml = Nokogiri::XML(file)\n file.close\n normalize_mods\n end",
"def read(file)\n\t\tf = File.open file\n\t\t@doc = Nokogiri::XML(f)\n\t\t@current_node = @doc.root;\n\t\tf.close\n\tend",
"def load(file); end",
"def load_ingest_content( filename )\n xml_doc = TaskHelpers.load_xml_doc( filename )\n return xml_doc\n end",
"def parse\n Ox.parse(@xml)\n end",
"def read_XML_file(xfile)\n result_array = []\n if File.file?(xfile)\n puts \"\\n\\nOPENING #{xfile}\"\n f = File.open(xfile)\n doc = Nokogiri::XML(f)\n if is_squish?(doc)\n result_array = squish_parser(doc)\n else\n result_array = rspec_parser(doc)\n end\n else\n puts \"\\nNot a file: #{xfile} - verify options (-x for directory, -f for a specific file)\"\n end\n return result_array \n end",
"def load(filename)\n end",
"def parse_xml\n\n raise \"parse_xml method has not been implemented in this class\"\n \n end",
"def initialize(xml)\n @source = isxml?(xml) ? xml : File.read(xml)\n @doc_stream = AltoDocStream.new\n parser = Nokogiri::XML::SAX::Parser.new(doc_stream)\n parser.parse(@source)\n end",
"def load_from_xml(node)\n # Get all information from the root's children nodes\n node.children.each do |child|\n case child.name.to_s\n when 'id'\n @id = child.content.to_i\n when 'title'\n @title = child.content\n when 'image'\n check_image_node(child)\n when 'date'\n @date = Time.parse(child.content)\n when 'streamable'\n check_streamable_node(child)\n when 'size'\n @size = child.content.to_i\n when 'description'\n @description = child.content\n when 'duration'\n @duration = child.content.to_i\n when 'creator'\n @creator = child.content\n when 'url'\n @url = child.content\n when 'text'\n # ignore, these are only blanks\n when '#text'\n # libxml-jruby version of blanks\n else\n raise NotImplementedError, \"Field '#{child.name}' not known (#{child.content})\"\n end #^ case\n end #^ do |child|\n end",
"def read(file) \n @file = Nokogiri::XML(file){ |cfg| cfg.noblanks } \n end",
"def load(file_path); end",
"def load(file_path); end",
"def load(fname)\n # search for configuration file\n unless File.exist?(fname)\n fname = File.exist?(File.expand_path(fname)) ?\n File.expand_path(fname) :\n File.join(PATH[\"config\"], fname)\n end\n \n # parsing document by REXML lib\n doc = REXML::Document.new File.new(fname)\n \n # get configuration node\n config = doc.root\n \n # initialize array of instances of ModelConfig\n marr = Array.new\n\n # load texture library\n # --------------------\n # get material handle of SketchUp\n mts = Sketchup.active_model.materials\n # load materials with specific texture\n config.elements.each(\"texture\") do |t|\n tname = t.attributes[\"name\"].downcase\n # add new material if not exist\n unless mts[tname]\n # add a new material\n mt = mts.add(tname)\n # search for texture file\n tfile = File.exist?(t.text) ? t.text : File.expand_path(t.text)\n tfile = File.join(PATH[\"texture\"], t.text) unless File.exist?(tfile)\n # assigne texture file to it\n mt.texture = tfile\n # show information\n puts \"Loaded Texture : #{tname}\"\n end\n end\n \n # load surface library\n # --------------------\n config.elements.each(\"surflib\") do |sl|\n slname = sl.attributes[\"name\"].downcase\n # add new surface to surface library if not exist before\n unless @@surflib[slname]\n # add new surface\n @@surflib[slname] = SurfConfig.new(sl)\n # print information\n puts \"Loaded Surface : #{slname} [Surface Library]\"\n end\n end\n\n # generate ModelConfig instance for each model node\n config.elements.each(\"model\") {|m| marr << ModelConfig.new(m)}\n \n # return the array of model configuration\n return marr\n end",
"def init_from_xml(xmlDoc)\r\n @type = xmlDoc.expanded_name\r\n xmlDoc.each_element(\"ID\") { |e| @procID = e.text }\r\n xmlDoc.each_element(\"GROUP\") { |e| @group = e.text }\r\n xmlDoc.each_element(\"PATH\") { |e| @path = e.text }\r\n xmlDoc.each_element(\"ARGSLINE\") { |e| @cmdLineArgs = e.text }\r\n xmlDoc.each_element(\"ENV\") { |e| @env = e.text }\r\n # Dump the XML description of the OML configuration into a file\r\n xmlDoc.each_element(\"OML_CONFIG\") { |config|\r\n configPath = nil\r\n config.each_element(\"omlc\") { |omlc|\r\n configPath = \"/tmp/#{omlc.attributes['exp_id']}-#{@procID}.xml\"\r\n }\r\n f = File.new(configPath, \"w+\")\r\n config.each_element {|el|\r\n f << el.to_s\r\n }\r\n f.close\r\n # Set the OML_CONFIG environment with the path to the XML file\r\n @env << \" OML_CONFIG=#{configPath} \"\r\n }\r\n end",
"def xml(path)\n Nokogiri::XML read path\n end",
"def initialize(xml_file_name)\n @xml_file_name = xml_file_name\n @kinvars = Array.new\n doc = REXML::Document.new(File.new(xml_file_name)) \n kv_elem = doc.elements['kinematic-variables']\n kv_elem.elements.each('kinvar'){|kv| @kinvars.push Kinvar.new(kv)}\n @data_file = kv_elem.elements['dat-file'].attributes['file']\n @file = File.new(@data_file,'rb')\n end",
"def parse_xml(file)\n\t\tdata = []\n\t\t# Break open XML and go through nodes\n\t\tbegin\n\t\t\tfile = file_sanitizer(file)\n\t\t\tdata = XmlSimple.xml_in(file, {'ForceArray' => false })\n\t\trescue Exception => e\n\t\t\traise e\n\t\tend\n\t\tdata\n\tend",
"def import_nessus_xml_file(args={})\n\t\tfilename = args[:filename]\n\t\twspace = args[:wspace] || workspace\n\n\t\tf = File.open(filename, 'rb')\n\t\tdata = f.read(f.stat.size)\n\n\t\tif data.index(\"NessusClientData_v2\")\n\t\t\timport_nessus_xml_v2(args.merge(:data => data))\n\t\telse\n\t\t\timport_nessus_xml(args.merge(:data => data))\n\t\tend\n\tend",
"def initialize(xFile)\n @xNodeName = \"00000\"\n\t @bShowText = true\n\t @bShowAttrs = true\n \n @oReXML = REXML::Document::new( File::new( xFile ) )\n @oGraph = \"digraph XML {\\n\"\n _init( @oReXML.root() )\n @oGraph << \"}\\n\"\n end",
"def parse_xml(file)\n @data_pts = Array.new\n doc = REXML::Document.new File.new(file)\n doc.elements.each('data/pt'){|pt|\n value = nil\n error = nil\n vars = Hash.new\n pt.attributes.each{|tag,val|\n\tif(tag == 'value')\n\t value = val.to_f\n\telsif(tag == 'error')\n\t error = val.to_f\n\telse\n\t vars[tag] = val.to_f\n\tend\t\n }\n @data_pts.push(DataPt.new(value,error,vars))\n }\n end",
"def load(fName)\n file = File.new(fName)\n xmlDoc = REXML::Document.new file\n\n xmlDoc.elements[\"GLOBAL_PROFILE\"].elements.each { |profElem|\n #puts profElem\n if profElem.name == \"AUTHOR\"\n @codeAuthor = profElem.attributes[\"name\"]\n @codeCompany = profElem.attributes[\"company\"]\n # puts @codeAuthor\n elsif profElem.name == \"DEFAULT_LICENSE\"\n @codeLicense = profElem.texts.join\n # puts @codeLicense\n end\n }\n end",
"def read_xml\n # date & time of rejections\n self.fecha_hora_confeccion = @doc.get_elements('//CreDtTm')[0].text\n self.process_date_time = Date.parse(self.fecha_hora_confeccion[0,10]) rescue Date.today\n # fiscal id, bank suffix & date of order\n self.OrgnlMsgId = @doc.get_elements('//OrgnlMsgId')[0].text\n self.OrgnlPmtInfId = @doc.get_elements('//OrgnlPmtInfId')[0].text\n begin # sufijo based on OrgnlPmtInfId\n self.sufijo = self.OrgnlPmtInfId[4,3]\n rescue # sufijo based on OrgnlMsgId\n self.sufijo = self.OrgnlMsgId[22,3]\n end\n begin # nif based on OrgnlPmtInfId\n self.nif = self.OrgnlPmtInfId[7,9]\n rescue # nif based on OrgnlMsgId\n self.nif = self.OrgnlMsgId[25,9]\n end\n begin # nif based on OrgnlPmtInfId\n self.fecha_devolucion = self.OrgnlPmtInfId[16,8].to_date\n rescue # nif based on OrgnlMsgId\n self.fecha_devolucion = self.OrgnlMsgId[3,8].to_date\n end\n # Original file data\n self.numero_total_adeudos = @doc.elements['//CstmrPmtStsRpt'].elements['OrgnlPmtInfAndSts'].elements['OrgnlNbOfTxs'].text\n self.importe_total = @doc.elements['//CstmrPmtStsRpt'].elements['OrgnlPmtInfAndSts'].elements['OrgnlCtrlSum'].text\n #\n # Loop thru rejections (TxInfAndSts)\n #\n receipt_no = ''\n remesa_old = ''\n referencia_tipo = ''\n cuenta_acreedor = ''\n @doc.elements.each('//TxInfAndSts') do |e|\n referencia_adeudo = e.elements['OrgnlEndToEndId'].text\n codigo_rechazo = e.elements['StsRsnInf'].elements['Rsn'].elements['Cd'].text\n importe_adeudo = (e.elements['OrgnlTxRef'].elements['Amt'].elements['InstdAmt'].text.to_d) * (-1)\n fecha_cobro = e.elements['OrgnlTxRef'].elements['ReqdColltnDt'].text.to_date\n referencia_mandato = e.elements['OrgnlTxRef'].elements['MndtRltdInf'].elements['MndtId'].text\n fecha_firma_mandato = e.elements['OrgnlTxRef'].elements['MndtRltdInf'].elements['DtOfSgntr'].text.to_date\n concepto = e.elements['OrgnlTxRef'].elements['RmtInf'].elements['Ustrd'].text\n nombre_deudor = e.elements['OrgnlTxRef'].elements['Dbtr'].elements['Nm'].text\n cuenta_deudor = e.elements['OrgnlTxRef'].elements['DbtrAcct'].elements['Id'].elements['IBAN'].text\n cuenta_acreedor = e.elements['OrgnlTxRef'].elements['CdtrAcct'].elements['Id'].elements['IBAN'].text\n referencia_tipo = referencia_adeudo[34,1]\n id_bill = referencia_adeudo[0,9].to_i # if referencia_tipo=='I'->invoice_id else referencia_tipo!='I'->bill_id\n id_client_payment = referencia_adeudo[9,9].to_i\n receipt_no = referencia_adeudo[18,6]\n id_client = referencia_mandato.last(8).to_i\n remesa_old = referencia_adeudo[10,6]\n\n # *** Save in returns array ***\n self.lista_devoluciones.push(referencia_adeudo: referencia_adeudo,\n codigo_rechazo: codigo_rechazo,\n importe_adeudo: importe_adeudo,\n fecha_cobro: fecha_cobro,\n referencia_mandato:referencia_mandato,\n fecha_firma_mandato: fecha_firma_mandato,\n concepto: concepto,\n nombre_deudor: nombre_deudor,\n cuenta_deudor: cuenta_deudor,\n bill_id: id_bill,\n client_payment_id: id_client_payment,\n receipt_no: receipt_no,\n client_id: id_client)\n end\n self.cuenta_acreedor = cuenta_acreedor\n self.remesa = receipt_no\n self.remesa_old = remesa_old\n self.referencia_tipo = referencia_tipo\n end",
"def parse(file)\n doc = Nokogiri::XML( File.open( file ) )\n @type = doc.xpath(\"/probe/header/@type\").to_s\n @vendor = doc.xpath(\"/probe/header/@vendor\").to_s\n @services = \"<TODO>\"\n @indexes = \"<TODO>\"\n end",
"def init\n f = File.open(@pref_file)\n @doc = Nokogiri::XML(f)\n f.close\n @doc.remove_namespaces! \n end",
"def load_file(file); end",
"def load_file(filename); end",
"def load_file(filename); end",
"def load_from_xml(node)\n # Get all information from the root's children nodes\n node.children.each do |child|\n case child.name.to_s\n when 'id'\n @id = child.content.to_i\n when 'title'\n @title = child.content.to_s\n when 'artists'\n @artists = [] if @artists.nil?\n child.children.each do |artist|\n @artists << Artist.new(:name => artist.content) if artist.name == 'artist'\n @headliner = Artist.new(:name => artist.content) if artist.name == 'headliner'\n end\n @artists << @headliner unless @headliner.nil? || headliner_alrady_listed_in_artist_list?\n when 'image'\n check_image_node(child)\n when 'url'\n @url = child.content\n when 'description'\n @description = child.content\n when 'attendance'\n @attendance = child.content.to_i\n when 'reviews'\n @reviews = child.content.to_i\n when 'tag'\n @tag = child.content\n when 'startDate'\n @start_date = Time.parse(child.content)\n when 'startTime'\n @start_time = child.content\n when 'endDate'\n @end_date = Time.parse(child.content)\n when 'tickets'\n # @todo Handle tickets\n when 'venue'\n @venue = Venue.new_from_xml(child)\n when 'website'\n @website = child.content.to_s\n when 'text'\n # ignore, these are only blanks\n when '#text'\n # libxml-jruby version of blanks\n else\n raise NotImplementedError, \"Field '#{child.name}' not known (#{child.content})\"\n end #^ case\n end #^ do |child|\n @artists.uniq!\n end",
"def initialize(filename)\n @reader = GedReader.new(filename)\n @builder = Builder::XmlMarkup.new(:indent=>2)\n @builder.gencom { parse }\n @xml = @builder.target!\n end",
"def nokogiri_xml(file_path)\n Nokogiri::XML(File.open(file_path), nil, 'UTF-8')\n end",
"def load\r\n \r\n end",
"def import_xml xml_data\n ###\n [table, id]\n end",
"def load!(xml)\n root = Nokogiri::XML(xml).root\n try(root.xpath(\"//network\")) do |network|\n try(network.xpath(\"name\")) { |result| self.name = result.text }\n try(network.xpath(\"uuid\")) { |result| self.uuid = result.text }\n try(network.xpath(\"bridge\")) { |result| self.bridge = Bridge.new(result) }\n try(network.xpath(\"ip\")) { |result| self.ip = IP.new(result) }\n end\n end",
"def parse_file(filename); end",
"def parse_file_to_ar(f)\n pp_ok \"STARTING PARSE for file #{f}...\"\n\n @doc = Nokogiri::XML(File.open(f), 'UTF-8') do |config|\n config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS\n end\n\n # Extend name space to include METS\n # couldn't get the following to work\n # example: node.xpath('.//foo:name', {'foo' => 'http://example.org/'})\n # example: node.xpath('.//xmlns:name', node.root.namespaces)\n # my try: puts @doc.xpath(\"xmlns:METS\", {\"METS\" => \"http://www.loc.gov/METS/\"})\n\n # The following actually modifies the xml, which we don't want. But it works.\n ns = @doc.root.add_namespace_definition(\"xmlns:METS\", \"http://www.loc.gov/METS/\")\n\n\n\n pp_ok \"Current file is: #{f}\"\n # issue information -------------\n # note: issue_id is autoincremented by the db\n # and we will want to select it from the last row created\n\n pp_ok \"ISSUE INFO:\"\n hathitrust = @doc.xpath(\"//MODS:identifier[@type='hathitrust']/text()\").to_s\n pp_ok \"hathitrust value is #{hathitrust}\"\n\n volume = @doc.xpath(\"//MODS:detail[@type='volume']/MODS:number/text()\").to_s\n pp_ok \"volume value is #{volume}\"\n\n issue_no = @doc.xpath(\"//MODS:detail[@type='issue']/MODS:number/text()\").to_s\n pp_ok \"issues value is #{issue_no}\"\n\n edition = @doc.xpath(\"//MODS:detail[@type='edition']/MODS:number/text()\").to_s\n pp_ok \"edition value is #{edition}\"\n\n date_issued = @doc.xpath(\"//MODS:dateIssued/text()\").to_s\n pp_ok \"dateIssued value is #{date_issued}\"\n\n newspaper = @doc.xpath(\"/METS:mets/@LABEL\").to_s\n newspaper = newspaper.split(\",\").first.strip\n pp_ok \"newspaper is #{newspaper}\"\n\n\n issue_id = add_data_issue_ar(hathitrust, volume, issue_no, edition, date_issued, newspaper)\n\n pp_ok \"ISSUE ID IS: #{issue_id}\"\n\n # page information -------------\n # note: page_id is autoincremented by the db\n\n pages_target = \"//METS:structMap/METS:div[@TYPE='np:issue'][@DMDID='issueModsBib']/METS:div[@TYPE='np:page']\"\n\n pages = @doc.xpath(pages_target)\n\n @doc.xpath(pages_target).each do |node|\n\n pp_ok \"PAGE INFO:\"\n\n pp_ok \"issue_id value is #{issue_id}\"\n\n page_no = node.xpath(\"@ORDERLABEL\").to_s\n pp_ok \"page_no value is #{page_no}\"\n\n sequence = node.xpath(\"@ORDER\").to_s.to_i\n pp_ok \"sequence value is #{sequence}\"\n\n text_link = node.xpath(\"METS:mptr[1]/@xlink:href\").to_s\n pp_ok \"text_link value is #{text_link}\"\n\n img_link = node.xpath(\"METS:mptr[2]/@xlink:href\").to_s\n pp_ok \"img_link value is #{img_link}\"\n\n add_data_page_ar(issue_id, page_no, sequence, text_link, img_link)\n\n end # each\n\n pp \"File #{f} processed\"\n\n end",
"def parse\n raise ERROR_FILE_NOT_SET if report.nil? || report.empty?\n raise format(ERROR_FILE_NOT_FOUND, report) unless File.exist?(report)\n\n Oga.parse_xml(File.read(report))\n end",
"def load_xml(str)\r\n @xml = REXML::Document.new(str.to_s)\r\n xml_to_instance\r\n self\r\n end",
"def parse(file)\n document = Nokogiri::XML(file).remove_namespaces!\n document.xpath('//types').each do |type|\n name = type.xpath('name').first.content\n key = name.underscore.to_sym\n type.xpath('members').each do |member|\n self[key] << member.content\n end\n end\n self\n end",
"def load\n @filename = File.expand_path(file_name('feeds.yml'))\n end",
"def get_image_data_from_file(xml_file_path)\n document = Nokogiri::XML(File.open(xml_file_path))\n recording = document.at_xpath('//Recordings//Recording')\n img_path = \"dvd#{recording.at_xpath('//URL/@root').to_s[-1]}/#{recording.at_xpath('//URL/@relative')}\"\n\n ImageData.from_xml(recording.at_xpath('//Subject'), img_path)\nend",
"def readSrepData(config_index)\n file_name = $srep_file_path + config_index.to_s() + \".xml\"\n f = File.open(file_name)\n doc = Nokogiri::XML(f)\n f.close\n return doc\nend",
"def import_nexpose_simplexml_file(args={})\n\t\tfilename = args[:filename]\n\t\twspace = args[:wspace] || workspace\n\n\t\tf = File.open(filename, 'rb')\n\t\tdata = f.read(f.stat.size)\n\t\timport_nexpose_simplexml(args.merge(:data => data))\n\tend",
"def load; end",
"def load; end",
"def load; end",
"def load\n doc = Nokogiri::XML(open(filename))\n xml_template_code = doc.css('Code')[0].content\n unless code == xml_template_code\n raise StandardError, \"template codes '#{code}' and '#{xml_template_code}' don't match\"\n end\n @xml_doc = doc\n end",
"def initialize(file)\n\t\t@file = file\n\t\t@doc = Hpricot.XML(file)\n\tend",
"def parse\n parse_file\n self\n end",
"def parse_from_file filename\n parse File.open(filename)\n end",
"def get_demographics_from_file(feret_xml_path, subject_id)\n subject_xml_full_path = \"#{feret_xml_path}/#{subject_id}\"\n subject_doc = Nokogiri::XML(File.open(\"#{subject_xml_full_path}/#{subject_id}.xml\"))\n\n FeretSubject.from_xml(subject_doc.at_xpath('//Subjects//Subject'))\nend",
"def initialize(xml_elem, xrc_file)\n @xml_src = xml_elem\n @file_name = xrc_file\n\n @base_id = xml_elem.attributes['name']\n @wx_class = xml_elem.attributes['class']\n @sub_class = xml_elem.attributes['subclass']\n @controls = []\n read_controls\n end",
"def load(fldDefs, filename)\r\n input = File.new(filename)\r\n doc = Document.new(input)\r\n root = doc.root\r\n input.close\r\n\r\n transCase = self.new(fldDefs)\r\n transCase.name = root.attribute('name').value if root.attributes.has_key? 'name'\r\n transCase.desc = root.attribute('desc').value if root.attributes.has_key? 'desc'\r\n if root.attributes.has_key? 'card_index'\r\n transCase.cardIndex = root.attribute('card_index').value.to_i\r\n end\r\n if root.attributes.has_key? 'acquirer_index'\r\n transCase.acquirerIndex = root.attribute('acquirer_index').value.to_i\r\n end\r\n\r\n root.elements.each(\"action\") do |elm|\r\n transCase.actions << loadAction(transCase, elm)\r\n end\r\n\r\n transCase\r\n end",
"def load\n @content = @reader.read\n if @content.nil?\n return\n end\n @attribute_storage = {}\n attributes = @content.first.class.attributes\n attributes.each do |key, attribute|\n if attribute.options.has_key? :storage\n @attribute_storage[key] = attribute.options[:storage].new\n else\n @attribute_storage[key] = Hash.new\n end\n end\n @content.each do |doc|\n add_doc doc\n end\n end",
"def load\n yaml_filespec = @filespec.ext('.yaml')\n if File.exist?(yaml_filespec) && (File.mtime(yaml_filespec) > File.mtime(@filespec))\n load_from_yaml(yaml_filespec)\n else\n load_from_xml(@filespec)\n end\n end",
"def moddify_document(path)\n doc = nil\n File.open(path,'r+') do | file|\n xml_string = file.read\n doc = process_xml(xml_string) if valid_xml?(xml_string)\n end\n doc\nend",
"def load_graph()\n\n\t\t# Get bounds which are needed later\n\t\tdoc = File.open(@filename) { |f| Nokogiri::XML (f) }\n\n\t\t# get bounds\n\t\tbounds = {}\n\n\t\tdoc.xpath(\"//bounds\").each do |boundsValues|\n\t\t\tbounds[:minlon] = boundsValues[:minlon]\n\t\t\tbounds[:minlat] = boundsValues[:minlat]\n\t\t\tbounds[:maxlon] = boundsValues[:maxlon]\n\t\t\tbounds[:maxlat] = boundsValues[:maxlat]\n\t\tend\n\n\t\t# load nodes\n\t\tvertices = {}\n\t\tvisualVertices = {}\n\t\tdoc.xpath(\"//node\").each do |node|\n\t\t\t# this vertex\n\t\t\tnormalVertex = Vertex.new(node[:id])\n\t\t\tvertices[node[:id]] = normalVertex\n\n\t\t\t# kinda confusing to have lat, lon and x, y when they have the same value\n\t\t\tvisualVertex = VisualVertex.new(node[:id], normalVertex, node[:lat], node[:lon], node[:lat], node[:lon])\n\t\t\tvisualVertices[node[:id]] = visualVertex\n\t\tend\n\n\t\t# load edges\n\t\tedgesAr = []\n\t\tvisualEdgesAr = []\n\t\tv1 = nil\n\t\tskip = true\n\t\twayCounter = 0\n\t\twayCounter2 = 0\n\n\n\n\t\tdoc.xpath(\"//way\").each do |way|\n\t\t\tdoc2 = Nokogiri::XML(way.to_s)\n\t\t\t# for each way check tags for highway, speed etc\n\t\t\twayCounter2 = wayCounter2 + 1\n\t\t\tv1 = nil\n\t\t\tskip = true\n\t\t\tmaxSpeed = 50\n\t\t\toneWay = false\n\n\t\t\tdoc2.xpath(\"//tag\").each do |tag|\n\t\t\t\tif tag[:k] == \"highway\" && (@highway_attributes.include? tag[:v])\n\t\t\t\t\tskip = false\n\t\t\t\tend\n\n\t\t\t\tif tag[:k] == \"maxspeed\"\n\t\t\t\t\tmaxSpeed = tag[:v].to_i\n\t\t\t\tend\n\n\t\t\t\tif tag[:k] == \"oneway\" && tag[:v] == \"yes\"\n\t\t\t\t\toneWay = true\n\t\t\t\tend\n\n\t\t\t\t# Set max speed based on the tag\n\t\t\t\tif tag[:k] == \"source:maxspeed\"\n\t\t\t\t\tif tag[:v] == \"CZ:motorway\"\n\t\t\t\t\t\tmaxSpeed = 130\n\t\t\t\t\telsif tag[:v] == \"CZ:trunk\"\n\t\t\t\t\t\tmaxSpeed = 110\n\t\t\t\t\telsif tag[:v] == \"CZ:rural\"\n\t\t\t\t\t\tmaxSpeed = 90\n\t\t\t\t\telsif tag[:v] == \"CZ:urban_motorway\"\n\t\t\t\t\t\tmaxSpeed = 80\n\t\t\t\t\telsif tag[:v] == \"CZ:urban_trunk\"\n\t\t\t\t\t\tmaxSpeed = 80\n\t\t\t\t\telsif tag[:v] == \"CZ:urban\"\n\t\t\t\t\t\tmaxSpeed = 50\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\n\t\t\tif !skip\n\t\t\t\twayCounter = wayCounter + 1\n\n\t\t\t\tdoc2.xpath(\"//nd\").each do |point|\n\t\t\t\t\tif v1 == nil\n\t\t\t\t\t\tv1 = point[:ref]\n\t\t\t\t\telse\n\t\t\t\t\t\t# create normal edge\n\t\t\t\t\t\tnewEdge = {:vertex1 => v1, :vertex2 => point[:ref], :maxSpeed => maxSpeed, :oneWay => oneWay}\n\t\t\t\t\t\tedgesAr << newEdge\n\n\n\t\t\t\t\t\t# edges << Edge.new(v1, point[:ref], maxSpeed, oneWay)\n\t\t\t\t\t\tv1 = point[:ref]\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\n\t\t# we have all the edges eg lines. there is a lot of duplicates so reduce them!\n\t\tedgesArReduced = edgesAr.uniq\n\n\t\t# used is a unique hash of used vertices - we don't need points that are not being referenced by any path\n\t\tusedVertices = {}\n\t\tusedVisualVertices = {}\n\t\tedges = []\n\t\t# now put them into the array as instances of the required class Edge\n\t\tedgesArReduced.each do |edge|\n\t\t\tnewEdgeReduced = Edge.new(vertices[edge[:vertex1]], vertices[edge[:vertex2]], edge[:maxSpeed], edge[:oneWay])\n\n\t\t\t# used vertices\n\t\t\tusedVertices[edge[:vertex1]] = vertices[edge[:vertex1]]\n\t\t\tusedVertices[edge[:vertex2]] = vertices[edge[:vertex2]]\n\n\t\t\tedges << newEdgeReduced # create visual edge\n\n\n\t\t\tvisualEdge = VisualEdge.new(newEdgeReduced, visualVertices[edge[:vertex1]], visualVertices[edge[:vertex2]])\n\t\t\tusedVisualVertices[edge[:vertex1]] = visualVertices[edge[:vertex1]]\n\t\t\tusedVisualVertices[edge[:vertex2]] = visualVertices[edge[:vertex2]]\n\n\t\t\tvisualEdgesAr << visualEdge\n\t\tend\n\n\t\t# load\n\t\t#\n\t\t# test generating the graph with the graphwiz - all seems good in the exported file\n\t\tgraph = Graph.new(usedVertices, edges)\n\t\tvisualGraph = VisualGraph.new(graph, usedVisualVertices, visualEdgesAr, bounds)\n\n\t\t# we have edges nwo find the largest component\n\t\tcomponents = {}\n\n\n\t\treturn graph, visualGraph\n\n\tend",
"def load_xml(xml)\n @mmdoc = REXML::Document.new(xml)\n end",
"def load(filename)\n file_content = File.open(filename).read\n TOMLP::Parser.new(file_content).parse\n end",
"def read_file(file)\n build_xml(Ripper::SexpBuilder.new(IO.read(file)).parse)\n end",
"def read_file(file)\n build_xml(Ripper::SexpBuilder.new(IO.read(file)).parse)\n end",
"def open_file(language)\n begin\n xml_file = File.open(file_path(language))\n doc = Nokogiri::XML(xml_file)\n yield doc\n rescue Errno::ENOENT => e\n abort(e.message)\n end\n end",
"def getRoot(filename, debug=false)\r\n\troot = Nokogiri::XML(open(filename))\r\n\troot.encoding = 'UTF-8'\r\n\t#printl \"it's open\",debug\r\n\treturn root\r\nend",
"def initialize(filename)\n @filename = filename\n Powirb.log.debug(\"Retrieving workitem from #{@filename}\")\n begin\n\t @doc = Nokogiri::XML(open(@filename))\n\trescue Exception => e\n\t Powirb.log.error(e)\n\tend\t\n end",
"def load_model_element_file(filename)\n YAML.load(File.open(filename, 'r'))\n end",
"def load_and_parse\n\n if @infile\n @graph = RDF::Graph.load(@infile)\n end\n\n end",
"def load(path); end",
"def metadata_xml\n Nokogiri::XML(original_file.content)\n end",
"def load_specification(file_name); end",
"def fromFile( filename ) \n lines = IO.readlines( filename )\n loadAll( lines )\n end",
"def load\n end"
] |
[
"0.7083245",
"0.6956713",
"0.69328636",
"0.6878722",
"0.67321295",
"0.67237556",
"0.6714798",
"0.66518545",
"0.6639957",
"0.6627784",
"0.660921",
"0.6597494",
"0.65765256",
"0.6517185",
"0.6513018",
"0.6509384",
"0.6416764",
"0.6402708",
"0.63981956",
"0.639698",
"0.6383532",
"0.6328173",
"0.63177925",
"0.6314639",
"0.62842476",
"0.62748903",
"0.6252059",
"0.62350434",
"0.62216765",
"0.62149906",
"0.62113476",
"0.62073714",
"0.61853755",
"0.6120052",
"0.6101033",
"0.608579",
"0.6083971",
"0.60679543",
"0.6056408",
"0.60535234",
"0.6043862",
"0.6043862",
"0.6036341",
"0.6020808",
"0.60089296",
"0.6007456",
"0.60070163",
"0.60032463",
"0.6000785",
"0.59954214",
"0.5981746",
"0.5981523",
"0.5968987",
"0.5968501",
"0.5949652",
"0.5945859",
"0.5945859",
"0.5935906",
"0.59269845",
"0.58884126",
"0.5885332",
"0.5882828",
"0.5880014",
"0.58692753",
"0.5855233",
"0.58537513",
"0.5850535",
"0.5840238",
"0.5832678",
"0.58242595",
"0.58216476",
"0.5820358",
"0.58201474",
"0.58201474",
"0.58201474",
"0.58150274",
"0.5800973",
"0.57998574",
"0.57818735",
"0.5764735",
"0.5756889",
"0.575585",
"0.5746667",
"0.57434785",
"0.5742904",
"0.57373774",
"0.5734694",
"0.571034",
"0.57039136",
"0.57039136",
"0.57000226",
"0.5695449",
"0.5687047",
"0.5669227",
"0.56643987",
"0.5653597",
"0.5636466",
"0.56361836",
"0.5630312",
"0.5627625"
] |
0.63386256
|
21
|
load xml rules as a string
|
def load_xml_rules_as_string( str )
begin
doc = REXML::Document.new str
doc.elements.each( "rule-set") { |rs|
facts = rs.elements.each( "facts") { |f|
facts( f.attributes["name"] ) do f.text.strip end
}
rules = rs.elements.each( "rule") { |rule_node|
rule_name = rule_node.attributes["name"]
priority = rule_node.attributes["priority"]
rule = Rule.new(self, rule_name, priority, nil)
parameters = rule_node.elements.each("parameter") { |param|
#logger.debug "xml parameter: #{param.text.strip}"
rule.parameters(eval(param.text.strip))
}
conditions = rule_node.elements.each("condition") { |cond|
#logger.debug "xml condition #{cond}"
rule.condition do eval(cond.text.strip) end
}
consequences = rule_node.elements.each("consequence") { |cons|
#logger.debug "xml consequence #{cons}"
rule.consequence do eval(cons.text.strip) end
}
@rules[rule_name] = rule
}
logger.debug( "loaded #{rules.size} rules") if logger
}
rescue Exception => e
raise RuleLoadingError, "loading xml file"
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def load_rb_rules_as_string( str )\r\n instance_eval(str) \r\n end",
"def load_xml( fileName )\r\n begin\r\n str = IO.read(fileName)\r\n load_xml_rules_as_string(str)\r\n rescue Exception => e\r\n raise RuleLoadingError, \"loading xml file\"\r\n end\r\n end",
"def load_rules; end",
"def load_rules(rules)\n self.instance_eval(rules)\n end",
"def load_cop_rules(rules); end",
"def to_xml_string(str = +'')\n str << '<conditionalFormatting sqref=\"' << sqref << '\">'\n rules.each_with_index do |rule, index|\n str << ' ' unless index.zero?\n rule.to_xml_string(str)\n end\n str << '</conditionalFormatting>'\n end",
"def to_s\n rules.map {|r| r.embed }.join(' ')\n end",
"def to_s\n rules.map {|r| r.embed }.join(' ')\n end",
"def to_s\n rules.map {|r| r.embed }.join(' | ')\n end",
"def dumpRules()\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULE DUMP\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n if(@rules.length > 0)\r\n rules = @rules.sort\r\n rules.each do |key, rule|\r\n puts \"#{rule.name}\\t(#{rule.alias})\"\r\n puts \"#{rule.xml}\"\r\n 40.times {print \"-\"}\r\n puts\r\n end\r\n\r\n else\r\n puts \"No rules to dump.\"\r\n end\r\n\r\n puts \"\"\r\n end",
"def to_s\n rule.inspect\n end",
"def loadRulesYAML(file)\n #Open file and parse, looking for rule/tag pairs\n ruleset = YAML.load_file(file)\n rules = ruleset[\"rules\"]\n rules.each do |rule|\n #p rule\n @rules << rule\n end\n end",
"def load_parameter_rules(rules); end",
"def to_s\n rule\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' ')\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' | ')\n end",
"def load_rules\n # Find rules file\n rules_filename = [ 'Rules', 'rules', 'Rules.rb', 'rules.rb' ].find { |f| File.file?(f) }\n raise Nanoc3::Errors::NoRulesFileFound.new if rules_filename.nil?\n\n # Get rule data\n @rules = File.read(rules_filename)\n @rules_mtime = File.stat(rules_filename).mtime\n\n # Load DSL\n dsl.instance_eval(@rules)\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' | ')\n end",
"def raw\n @rules ||= load_rules(\"#{Credy.root}/data/*.yml\")\n end",
"def construct_rules rules\n parsed_rules = {:rules => []}\n rules.each do |rule|\n parsed_rules[:rules] << rule.attributes\n end\n parsed_rules.to_json\n end",
"def to_s\n rule_name.to_s\n end",
"def to_s\n\t\tmap { |k,v|\n\t\t\tv.to_s + \" ::= \" + v.rules.map { |r| r.map{|e| e.inspect}.join(\" \") }.join(\" | \")\n\t\t}.join(\"\\n\")\n\tend",
"def to_ruby\n \"EBNF::Rule.new(#{sym.inspect}, #{id.inspect}, #{expr.inspect}#{', kind: ' + kind.inspect unless kind == :rule})\"\n end",
"def run_rules(url, rules)\n str = url.to_s\n return str if rules.nil?\n rules.each do |rule|\n case rule\n when 'noproto'\n str = str.gsub(%r{^https?://}, '')\n when 'nossl', 'http'\n str = str.gsub(%r{^https://}, 'http://')\n when 'ssl', 'https'\n str = str.gsub(%r{^http://}, 'https://')\n when 'base32'\n str = Base32.encode(str).to_s\n when 'base64'\n str = Base64.encode64(str).delete(\"\\n\")\n when 'md4'\n str = OpenSSL::Digest::MD4.hexdigest(str)\n when 'md5'\n md5 = Digest::MD5.new\n md5.update str\n str = md5.hexdigest\n when 'sha1'\n str = Digest::SHA1.hexdigest(str)\n when 'reverse'\n str = str.reverse\n when 'upcase'\n str = str.upcase\n when 'downcase'\n str = str.downcase\n when 'rot13'\n str = str.tr('A-Za-z', 'N-ZA-Mn-za-m')\n when 'urlencode'\n str = CGI.escape(str).gsub(/\\+/, '%20')\n when 'urldecode'\n str = CGI.unescape(str)\n when 'append-hash'\n str = \"#{str}##{rand(36**6).to_s(36)}\"\n when 'append-method-get'\n separator = str.include?('?') ? '&' : '?'\n str = \"#{str}#{separator}method=get&_method=get\"\n else\n logger.warn(\"Unknown rule: #{rule}\")\n end\n end\n str\n end",
"def readable\n \"Rules:\\n#{rules.collect {|r| r.readable }.join('\\n')}\\nFacts:\\n#{all_facts.collect {|f| f.readable }.join('\\n')}\"\n end",
"def dump\n Wrapper.msc_rules_dump rules_ptr\n self\n end",
"def to_sxp\n require 'sxp' unless defined?(SXP)\n # Output rules as a formatted S-Expression\n SXP::Generator.string(@ast.map(&:for_sxp))\n end",
"def to_sxp\n require 'sxp' unless defined?(SXP)\n # Output rules as a formatted S-Expression\n SXP::Generator.string(@ast.map(&:for_sxp))\n end",
"def dumpRule(als)\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULE: #{als}\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n rule = @rules[als]\r\n if (nil != rule)\r\n puts \"#{rule.name}\\t(#{rule.alias})\"\r\n puts \"#{rule.xml}\"\r\n\r\n else\r\n puts \"Cannot find matching rule.\"\r\n end\r\n\r\n puts \"\"\r\n end",
"def inspect\r\n @rules.each{|r|\r\n r[1].each{|d|\r\n print r[0].to_s + \" => \" + d[0].inspect + \" TXTO \" + d[1].inspect + \"\\n\"\r\n }\r\n }\r\n end",
"def to_s\n \"#{rule} #{type_class} #{name} = #{tag} #{default ? \"[default=#{default.inspect}]\" : ''}\"\n end",
"def to_s\n 'rule: ' + @symbol.to_s\n end",
"def to_s\n constraints = String.new\n @value_constraints.each do |key, value|\n constraints << <<-XML\n <constraint name=\"#{key.gsub(/\\s/, '_')}\">\n <value>\n <element ns=\"#{value[\"namespace\"]}\" name=\"#{value[\"element\"]}\"/>\n </value>\n </constraint>\n XML\n end\n\n @word_constraints.each do |key, value|\n constraints << <<-XML\n <constraint name=\"#{key.gsub(/\\s/, '_')}\">\n <word>\n <element ns=\"#{value[\"namespace\"]}\" name=\"#{value[\"element\"]}\"/>\n </word>\n </constraint>\n XML\n end\n\n @range_constraints.each do |key, value|\n constraints << <<-XML\n <constraint name=\"#{key.gsub(/\\s/, '_')}\">\n <range type=\"#{value[\"type\"]}\"\n XML\n if value.has_key?(\"collation\")\n constraints << \"collation=\\\"#{value[\"collation\"]}\\\"\"\n end\n\n constraints << <<-XML\n >\n <element ns=\"#{value[\"namespace\"]}\" name=\"#{value[\"element\"]}\"/>\n XML\n\n if value.has_key?(\"computed_buckets\")\n value[\"computed_buckets\"].each do |computed_bucket|\n constraints << computed_bucket.to_s if computed_bucket.instance_of?(ActiveDocument::MarkLogicSearchOptions::ComputedBucket)\n end\n end\n constraints << \"</range></constraint>\"\n end\n\n value = <<-XML\n <options xmlns=\"http://marklogic.com/appservices/search\">\n <return-facets>#{@return_facets}</return-facets>\n XML\n\n # add in constraints\n unless constraints.empty?\n value << constraints\n end\n # close the options node\n value << \"</options>\"\n\n end",
"def rules=(value)\n @rules = value\n end",
"def formatRules config\n\tresult = \"\"\n\t\n\t# rule set filename is not indicated from the name of the rule set, so a mapping is used\n\trulesetFiles = {\"Android\" => \"android\",\"Basic\" => \"basic\",\"Braces\" => \"braces\",\"Clone Implementation\" => \"clone\",\"Code Size\" => \"codesize\",\"Comments\" => \"comments\",\"Controversial\" => \"controversial\",\"Coupling\" => \"coupling\",\"Design\" => \"design\",\"Empty Code\" => \"empty\",\"Finalizer\" => \"finalizers\",\"Import Statements\" => \"imports\",\"J2EE\" => \"j2ee\",\"JavaBeans\" => \"javabeans\",\"JUnit\" => \"junit\",\"Jakarta Commons Logging\" => \"logging-jakarta-commons\",\"Java Logging\" => \"logging-java\",\"Migration\" => \"migrating\",\"Naming\" => \"naming\",\"Optimization\" => \"optimizations\",\"Strict Exceptions\" => \"strictexception\",\"String and StringBuffer\" => \"strings\",\"Security Code Guidelines\" => \"sunsecure\",\"Type Resolution\" => \"typeresolution\",\"Unnecessary\" => \"unnecessary\",\"Unused Code\" => \"unusedcode\"}\n\t\n\tfor r in config[\"pmd\"][\"rules\"] do\n\t\tresult += \"java-\" + rulesetFiles[r] + \",\"\n\tend\n\treturn result[0..-2]\nend",
"def rules_config\n @squeezed_rules_config\n end",
"def initialize_rules\n @parser = Rule.rulesParserFromReader(BufferedReader.new(FileReader.new(\"ontology/lattes.rules\")))\n @ruleReasoner = GenericRuleReasoner.new(Rule.parseRules(@parser))\n @ruled = ModelFactory.createInfModel(@ruleReasoner, @schema)\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def xml_string\n str =\n%Q{<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<selector xmlns:android=\"http://schemas.android.com/apk/res/android\">\n}\n\n self.sorted_states.each do |state, drawable_states|\n drawable_states.each do |drawable_state|\n if !str.include?(drawable_state.xml_string)\n str <<\n%Q{ #{drawable_state.xml_string}\n}\n end\n end\n end\n\n default_drawable = \"<item android:drawable=\\\"@drawable/#{FINAL_FILE_PREFIX}#{self.name}\\\" />\\n\"\n if !str.include?(default_drawable)\n str <<\n%Q{ #{default_drawable}}\n end\n\n str <<\n%Q{</selector>}\n end",
"def get_rules\r\n @rules\r\n end",
"def to_citrus # :nodoc:\n '~' + rule.to_embedded_s\n end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def load(filename)\n @config.load(filename)\n @rules.concat(@config.rules)\n self\n end",
"def rules_by_name; end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def load_schemas\n\t\t\tschema_instructions = []\n\t\t\tschema_pi = self.find_all { |i| i.is_a? REXML::Instruction and i.target == 'xml:schema' }\n\t\t\tschema_pi.each do |i|\n\t\t\t\tif i.attributes.has_key?('url')\n i.attributes['source'] = i.attributes['url']\n elsif i.attributes.has_key?('source')\n i.attributes['url'] = i.attributes['source']\n else\n raise \"parse error schema instruction missing required url attribute\"\n end\n if i.attributes.has_key?('uri')\n i.attributes['space'] = i.attributes['uri']\n elsif i.attributes.has_key?('space')\n i.attributes['uri'] = i.attributes['space']\n else\n raise \"parse error schema instruction missing required type attribute\"\n end\n schema_instructions << i\n\t\t\tend\n\t\t\treturn schema_instructions\n\t\tend",
"def to_citrus # :nodoc:\n '&' + rule.to_embedded_s\n end",
"def distributed_engine_rules_2_json_simple(rules)\n\n end",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def rules\n @rules=get_endpoint('rule').keys\n end",
"def to_s\n label.to_s + ':' + rule.embed\n end",
"def to_s\n \"v=#{@version} #{@rules.join(' ')}\"\n end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def rules(rules)\n rules = QL.to_rules(rules)\n GRel::Debugger.debug \"STORING IN SCHEMA #{@schema_graph}\"\n GRel::Debugger.debug rules\n GRel::Debugger.debug \"IN\"\n GRel::Debugger.debug @db_name\n @connection.add(@db_name, rules, @schema_graph, \"application/rdf+xml\")\n self\n end",
"def rule(rule)\r\n\r\n # Rule output is generated in GdlDoc.visitRule()\r\n return rule.src\r\n\r\n end",
"def rulelist(ruleset, ctx)\r\n\r\n outlist = \"\"\r\n\r\n ruleset.rules.each do |ralias|\r\n rname = ctx.rules[ralias].name\r\n outlist += reference(\"rule\", rname)\r\n\r\n end # rules.each\r\n\r\n return outlist\r\n\r\n end",
"def to_s\n label_name.to_s + ':' + rule.embed\n end",
"def visitRule(elem, data)\r\n @@log.debug(\"XmlRuleVisitor::visitRule\")\r\n @@log.debug(elem.inspect)\r\n\r\n\r\n ruleAlias = elem.attributes['Name']\r\n ruleData = @context.rules[ruleAlias]\r\n raise \"Rule data not found: #{ruleAlias}\" unless (ruleData.kind_of? Rule)\r\n\r\n ruleName = ruleData.name\r\n\r\n ruleCond = \"\"\r\n elem.each_element do |child|\r\n if (\"Condition\" == child.name)\r\n ruleCond = visit(child, ruleCond)\r\n break\r\n end\r\n end\r\n\r\n ifActions = \"\"\r\n elem.each_element do |child|\r\n if (\"IfActions\" == child.name)\r\n ifActions = visit(child, ifActions)\r\n break\r\n end\r\n end\r\n\r\n elseActions = \"\"\r\n elem.each_element do |child|\r\n if (\"ElseActions\" == child.name)\r\n elseActions = visit(child, elseActions)\r\n break\r\n end\r\n end\r\n\r\n\r\n ifMsgs = \"\" # Generate 'If' messages\r\n ruleData.ifMsgs.each do |msgTxt|\r\n ifMsgs += generateMsg(msgTxt)\r\n end # ifMsgs.each\r\n\r\n elseMsgs = \"\" # Generate 'Else' messages\r\n ruleData.elseMsgs.each do |msgTxt|\r\n elseMsgs += generateMsg(msgTxt)\r\n end # ifMsgs.each\r\n\r\n\r\n\r\n aliasStmt = \"\" # Don't create an alias statement if it is not needed.\r\n if (ruleName != ruleAlias)\r\n aliasStmt = <<EOF\r\nalias(rule, #{ruleName}, \"#{ruleAlias}\");\r\nEOF\r\n end # if rulename...\r\n\r\n # Create rule template\r\n output = <<EOF\r\n#{aliasStmt}\r\n// ############################################\r\n// #{ruleName}\r\n\r\nrule #{ruleName}()\r\n if(\r\n #{ruleCond}\r\n )\r\n then\r\n #{ifActions}\r\n#{ifMsgs}\r\nEOF\r\n\r\n if (elseActions.length > 0)\r\n output += <<EOF\r\n else\r\n #{elseActions}\r\n#{elseMsgs}\r\nEOF\r\n end\r\n\r\n output += <<EOF\r\n end\r\nend // rule\r\n\r\n\r\n\r\n\r\nEOF\r\n\r\n data += output\r\n return data\r\n end",
"def rule_js\n @rules.collect { |sel, js| behaviour_rule(sel, js) }.join(\",\\n\")\n end",
"def parse_rules(rules)\n key = nil\n rules.each do |s|\n s.split.each do |ru|\n if key.nil? and /^:([a-z_]+)=(\\S+)*/ =~ ru\n key = $1\n var = $2\n @attr[key] = var\n key = nil\n elsif /^:([a-z_]+)+/ =~ ru\n key = $1\n if @attr[key].nil?\n @attr[key] = []\n end\n elsif not key.nil?\n @attr[key].push ru unless key.nil?\n else\n if /([a-z0-9_.:-]+)([=!><\\~][=>]*)(.*)/ =~ ru\n names = $1\n op = $2\n ver = $3\n r = Gem::Version.new ver\n name, new_name = names.split(/:/, 2)\n @requirements[name] = {\n :method => :update,\n :op => op,\n :version => r,\n :name => new_name\n }\n elsif /([a-z0-9_-]+):$/ =~ ru\n name = $1\n @requirements[name] = {\n :method => :delete,\n }\n end\n end\n end\n end\n end",
"def data_to_ruleset \n\n\t\ttemp_array = []\n\t\trule_name = self.fctr_code.blank? ? (\"rule_\" + self.id.to_s) : self.fctr_code + \": \"\n\n\t\tif not self.where_country.blank?\n\t\t\ttemp_array << (\"c_where_country = \" + self.where_country.subfctr_name)\n\t\tend\n\n\t\tif not self.where_zone.blank?\n\t\t\ttemp_array << (\"c_where_zone = \" + self.where_zone.subfctr_name)\n\t\tend\n\n\t\tif not self.where_network.blank?\n\t\t\ttemp_array << (\"c_where_network = \" + self.where_network.subfctr_name)\n\t\tend\n\n\t\tif not self.where_custom.blank?\n\t\t\ttemp_array << (\"c_where_custom = \" + self.where_custom.subfctr_name)\n\t\tend\n\n\t\tif temp_array.size > 0\n\t\t\treturn rule_name + temp_array.join(\", \")\n\t\telse\n\t\t\treturn \"\"\n\t\tend\n\tend",
"def initialize(rules)\n @rules = rules\n end",
"def rules\n I18n.t(\"rubrics.item.rule.#{basename.underscore}\")\n end",
"def to_s\n '!' + rule.embed\n end",
"def to_s\n '!' + rule.embed\n end",
"def rules\n rule_applier.rules\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n self.class.rules\n end",
"def load_rb( file )\r\n begin\r\n str = IO.read(file)\r\n load_rb_rules_as_string(str)\r\n rescue Exception => e\r\n raise RuleLoadingError, \"loading ruby file\"\r\n end\r\n end",
"def transform(xsl, xml)\n Rexslt.new(xsl, xml).to_s\n end",
"def printRules\n\t\n\t@i = 1\n\t@@rulesArray.each do |rule|\n\t\tputs \"#{@i}-#{rule.fetch('src_ip')}/#{rule.fetch('src_netmask')}:#{rule.fetch('src_port')} #{rule.fetch('dest_ip')}/#{rule.fetch('dest_netmask')}:#{rule.fetch('dest_port')} #{rule.fetch('protocol')} #{rule.fetch('action')}\"\n\t\t@i += 1\n\tend\n\n\tif @i == 1\n\t\tputs \"No rules to print!\"\n\telse\n\t\tputs \"Rules Loaded!\"\n\tend\nend",
"def to_s\n output = ['Rule Warnings:']\n\n if @warnings.empty?\n output << ' * None'\n else\n output << %{ * #{@warnings.join(\"\\n *\")}}\n end\n\n output << ['']\n output << ['Rule Errors:']\n\n if @errors.empty?\n output << ' * None'\n else\n output << %{ * #{@errors.join(\"\\n *\")}}\n end\n\n output.join(\"\\n\")\n end",
"def save(directory, comment_type = :none)\n if !rules.empty?\n File.open(directory + filename, 'w') {|f| f.puts self.to_xml(comment_type)}\n else\n puts \"No rules for #{name}\"\n end\n end",
"def to_s\n '&' + rule.embed\n end",
"def to_s\n rule.embed + operator\n end",
"def visit_rule(node)\n rules = node.rule[0].split(',')\n\n rules.each do |rule|\n append_child_rules(node, rule.strip)\n end\n end",
"def ruleset_rules\n @rulesets.collect do |r|\n [\"# Begin [#{r.name}]\",\n r.firewall_rules,\n \"# End [#{r.name}]\",\n \"\"]\n end\n end",
"def openRule(attributes)\r\n if (inRule?)\r\n closeRule()\r\n end # if inRule\r\n\r\n if ($DEBUG)\r\n puts \"openRule:\"\r\n\r\n if(!attributes.empty?)\r\n puts \" Attr:\"\r\n attributes.each do |attr|\r\n puts \" #{attr[0]}: #{attr[1]}\"\r\n end\r\n end\r\n end # if verbose\r\n\r\n @inRule = true\r\n\r\n @curRuleName = attributes['Name']\r\n\r\n @curRuleSrc = String.new(\"<Rule\")\r\n @curRuleSrc += buildAttrString(attributes)\r\n @curRuleSrc += \">\"\r\n\r\n puts \"Collecting rule XML: #{@curRuleName}\" if verbose?\r\n\r\n end",
"def rules(section_id = @one_section_id)\n url = @url_sections + '/' + section_id + '/rules'\n @nsx_client.get(url)\n end",
"def rules\n @rules ||= {}\n end",
"def to_rules\n Array.new.tap do |rules|\n new_rule = Rule.new(rule.chain)\n new_rule.description = \"#{rule.description} (#{self.description})\"\n new_rule.rule = rule.rule.gsub(/\\{\\{(\\w+)\\}\\}/) do\n if value = self.options[$1.to_sym]\n value\n else\n \"{{#{$1}}}\"\n end\n end\n new_rule.action = rule.action\n new_rule.conditions = rule.conditions | self.conditions\n if self.version\n new_rule.versions = [self.version]\n end\n\n if has_host_group?\n host_group = @rule.chain.table.base.host_groups[self.options[:ip]]\n host_group.hosts.each do |key, host|\n host.ips.each do |v, ip|\n hg_rule = new_rule.dup\n hg_rule.description += \" (#{host.name} via #{host_group.name})\"\n hg_rule.rule.gsub!(host_group.name.to_s, ip)\n hg_rule.versions = [v]\n rules << hg_rule\n end\n end\n else\n rules << new_rule\n end\n end\n end",
"def add_rules\n\n raise 'Not a single yml location is defined for rules' if yml.empty?\n\n yml.each do |location|\n\n RuleParser.yml location, self\n\n end\n\n end",
"def normalize_xmlliteral(contents, options = {})\n options[:namespaces] ||= {}\n\n begin\n # Only normalize if Nokogiri is included\n require 'nokogiri' unless defined?(Nokogiri)\n rescue LoadError => e\n contents.to_s # No normalization\n end\n \n if contents.is_a?(String)\n ns_hash = {}\n options[:namespaces].each_pair do |prefix, uri|\n attr = prefix.to_s.empty? ? \"xmlns\" : \"xmlns:#{prefix}\"\n ns_hash[attr] = uri.to_s\n end\n ns_strs = []\n ns_hash.each_pair {|a, u| ns_strs << \"#{a}=\\\"#{u}\\\"\"}\n\n # Add inherited namespaces to created root element so that they're inherited to sub-elements\n contents = Nokogiri::XML::Document.parse(\"<foo #{ns_strs.join(\" \")}>#{contents}</foo>\").root.children\n end\n\n # Add already mapped namespaces and language\n contents.map do |c|\n if c.is_a?(Nokogiri::XML::Element)\n c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).root\n # Gather namespaces from self and decendant nodes\n c.traverse do |n|\n ns = n.namespace\n next unless ns\n prefix = ns.prefix ? \"xmlns:#{ns.prefix}\" : \"xmlns\"\n c[prefix] = ns.href.to_s unless c.namespaces[prefix]\n end\n \n # Add lanuage\n if options[:language] && c[\"lang\"].to_s.empty?\n c[\"xml:lang\"] = options[:language]\n end\n end\n c.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)\n end.join(\"\")\n end",
"def to_citrus # :nodoc:\n '!' + rule.to_embedded_s\n end",
"def to_citrus # :nodoc:\n rule.to_embedded_s + operator\n end",
"def create_security_rule(rule_hash:)\n # construct the XML elements for the request\n element_xpath = \"/config/devices/entry/vsys/entry/rulebase/security/rules/entry[@name='#{rule_hash[:name]}']\"\n\n element_value = \"<action>\" + rule_hash[:action] + \"</action>\"\n element_value += \"<from>\" + rule_hash[:from_zones].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</from>\"\n element_value += \"<to>\" + rule_hash[:to_zones].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</to>\"\n element_value += \"<source>\" + rule_hash[:sources].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</source>\" if rule_hash[:sources]\n element_value += \"<destination>\" + rule_hash[:destinations].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</destination>\" if rule_hash[:destinations]\n element_value += \"<source-user>\" + rule_hash[:source_users].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</source-user>\" if rule_hash[:source_users]\n element_value += \"<service>\" + rule_hash[:services].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</service>\" if rule_hash[:services]\n element_value += \"<category>\" + rule_hash[:categories].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</category>\" if rule_hash[:categories]\n element_value += \"<application>\" + rule_hash[:applications].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</application>\" if rule_hash[:applications]\n element_value += \"<hip-profiles>\" + rule_hash[:hip_profiles].split(',').map{ |e| \"<member>#{e}</member>\" }.join + \"</hip-profiles>\" if rule_hash[:hip_profiles]\n element_value += \"<log-start>\" + rule_hash[:log_session_start] + \"</log-start>\" if rule_hash[:log_session_start]\n element_value += \"<log-end>\" + rule_hash[:log_session_end] + \"</log-end>\" if rule_hash[:log_session_end]\n\n # configure options for the request\n options = {}\n options[:url] = self.endpoint\n options[:method] = :post\n options[:payload] = { type: \"config\",\n action: \"set\",\n key: self.auth_key,\n xpath: element_xpath,\n element: element_value }\n\n html_result = Helpers::Rest.make_request(options)\n\n raise \"Error during security rule create\" if html_result.nil?\n\n # parse the XML data\n data = Nokogiri::XML(html_result)\n\n # check that the operation was successful\n if data.xpath('//response/@status').to_s == \"success\"\n # commit the change to be operational\n # TODO: Should probably do partial commit once device IDs are built in\n options = {}\n options[:url] = self.endpoint\n options[:method] = :post\n options[:payload] = { type: \"commit\",\n key: self.auth_key,\n cmd: \"<commit></commit>\" }\n\n html_result = Helpers::Rest.make_request(options)\n\n raise \"Error during security rule commit\" if html_result.nil?\n\n # parse the XML data\n data = Nokogiri::XML(html_result)\n\n # check that the operation was successful and return the job ID\n if data.xpath('//response/@status').to_s == \"success\"\n return data.xpath('//response/result/job')[0].content.to_s\n else\n raise \"#{Crack::XML.parse(data.to_xml)}\"\n end\n else\n raise \"#{Crack::XML.parse(data.to_xml)}\"\n end\n end",
"def initialize(rules)\n @rules = rules\n end",
"def yaml2yaxml yaml, options\r\n if ENCODINGS.include? options[:source_encoding]\r\n yaml = yaml.encode(options[:target_encoding], options[:source_encoding], :replace => '?')\r\n else\r\n yaml = yaml.encode(\"UTF-8\")\r\n end\r\n\r\n hash = YAML::load(yaml)\r\n hash, target_language = set_target_language(hash, options[:target_language])\r\n YAXML::yaml2yaxml(hash.to_yaml, :root_name => target_language || root, :from_yaml=> true).to_s\r\n end",
"def to_citrus # :nodoc:\n rule_name.to_s\n end",
"def config_entityengine_xml()\n ee_xml = File.readlines(self.entityengine_xml()).map do |line|\n if m = /(#{Regexp.quote(self.entityengine_xml_db_token())})/.match(line)\n self.debug(m[0])\n new_str = \"#{m.pre_match}#{entityengine_db}#{m.post_match}\"\n self.debug(new_str)\n new_str\n elsif m = /(#{Regexp.quote(self.entityengine_xml_schema_token())})/.match(line)\n self.debug(m[0])\n new_str = \"#{m.pre_match}#{self.entityengine_schema()}#{m.post_match}\"\n self.debug(new_str)\n new_str\n else\n line\n end\n end\n \n File.open(self.entityengine_xml(), \"w\") do |io|\n ee_xml.each { |line| io.puts(line) }\n end\n end"
] |
[
"0.6614879",
"0.6465752",
"0.62848926",
"0.5847496",
"0.58037853",
"0.57882994",
"0.5785168",
"0.5785168",
"0.57822543",
"0.5594589",
"0.55761635",
"0.553359",
"0.55334383",
"0.5523808",
"0.5498931",
"0.54329294",
"0.5421628",
"0.5413334",
"0.5360488",
"0.5326475",
"0.5317063",
"0.53063864",
"0.53053415",
"0.5282982",
"0.52606535",
"0.52351135",
"0.52319264",
"0.52319264",
"0.5231279",
"0.5207941",
"0.51712036",
"0.51416373",
"0.51202303",
"0.5073209",
"0.50666094",
"0.5058606",
"0.5025664",
"0.50130683",
"0.50130683",
"0.50130683",
"0.50130683",
"0.50130683",
"0.50130683",
"0.50130683",
"0.5005542",
"0.49800682",
"0.49770868",
"0.49752724",
"0.49725795",
"0.49688822",
"0.49624124",
"0.49624124",
"0.4962245",
"0.49469817",
"0.49401835",
"0.49269602",
"0.49244198",
"0.49241215",
"0.49158797",
"0.4884522",
"0.48807883",
"0.48787564",
"0.4877838",
"0.48769957",
"0.4876435",
"0.48624027",
"0.48617396",
"0.4858802",
"0.48486876",
"0.48382396",
"0.48333776",
"0.48311442",
"0.48311442",
"0.48260516",
"0.48205322",
"0.48205322",
"0.48205322",
"0.48157778",
"0.48078352",
"0.48070467",
"0.47988504",
"0.47856927",
"0.4763083",
"0.47620368",
"0.47615528",
"0.47606575",
"0.4755436",
"0.47525454",
"0.4750722",
"0.47504973",
"0.4748608",
"0.47384372",
"0.47158247",
"0.47002387",
"0.46980163",
"0.4693244",
"0.46865007",
"0.46659514",
"0.46647382",
"0.46624565"
] |
0.8187123
|
0
|
Ruby File format loading
|
def load_rb( file )
begin
str = IO.read(file)
load_rb_rules_as_string(str)
rescue Exception => e
raise RuleLoadingError, "loading ruby file"
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def load(file); end",
"def load(file_path); end",
"def load(file_path); end",
"def load_file(file); end",
"def load_file(filename); end",
"def load_file(filename); end",
"def load(path); end",
"def load_rb(filename); end",
"def load(filename)\n end",
"def parse_file(filename); end",
"def load(filename)\n Format.load(filename)\n end",
"def read(path); end",
"def load(filename)\n\t\tend",
"def load(name); end",
"def load_specification(file_name); end",
"def parse_from_file filename\n parse File.open(filename)\n end",
"def parse_file\n File.read(file_with_ext).to_s\n end",
"def read_file(filename); end",
"def read_data_file(path); end",
"def load(filename, wrap=false) end",
"def l(filename)\n load \"#{filename}.rb\"\nend",
"def load_file(path)\n load_string(File.binread(path))\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def parse_file path\n self.filename = path\n open path do |f|\n parse f.read\n end\n end",
"def load_from_file(file, options = T.unsafe(nil)); end",
"def load(files = T.unsafe(nil), reparse = T.unsafe(nil)); end",
"def load_dataE(filename)\r\n Log.ger.debug('Read '+filename)\r\n File.open(filename, \"rb\") { |f|\r\n obj = Marshal.load(f)\r\n }\r\nend",
"def read_binary(file); end",
"def read(files); end",
"def read(files); end",
"def load; end",
"def load; end",
"def load; end",
"def read file\n File.open file\n end",
"def from_file(file)\n from_s Utils::read_file file\n end",
"def from_file(file)\n from_s Utils::read_file file\n end",
"def parse_file\n @filecontent ||= File.read(@filepath)\n end",
"def load(file)\r\n if file == String # does this work?\r\n @path = file\r\n end\r\n\r\n @reader = Reader.new(file)\r\n load_section self, @reader\r\n @reader.close\r\n end",
"def fromFile( filename ) \n lines = IO.readlines( filename )\n loadAll( lines )\n end",
"def load(file)\n File.open(path(file)).read\n end",
"def load_format(name)\n require \"txt2tags/#{name}\"\n Object.const_get(File.basename(name, '.rb').capitalize!)\n end",
"def transform(file, format:); end",
"def parse_input(input_file); end",
"def parse_input(input_file); end",
"def loadfile(filename)\n file = nil\n open(filename, 'r') do |f|\n file = f.read\n end\n file\nend",
"def load filepath\n require 'zip'\n\n ::Zip::File.open filepath do |zip|\n entry = zip.entries.first\n entry_path = path entry.name\n entry.extract entry_path\n\n serializer = serializers.resolve entry.name\n serializer.load entry_path\n end\n end",
"def load\n input(@infile)\n true\n end",
"def parse_input (input_file)\nend",
"def read ( file, trace_dir )\n extension = File.extname(file)\n case extension\n when '.csv' then read_csv(file)\n when '.bag' then read_bag(file,trace_dir)\n else abort(\"file extension #{extension} not supported\")\n end\nend",
"def parse_file(file_path)\n Cabrillo.parse(IO.read(file_path))\n end",
"def parse(file)\n puts \"Not yet implemented\"\nend",
"def read_file(absolute_path); end",
"def parse f\n raise \"called parse with type not set\" unless self.type\n #return if self.data\n\n self.data = []\n return nil unless file_offset\n\n case type\n when 'BITMAP','ICON'\n f.seek file_offset\n if f.read(4) == \"\\x89PNG\"\n data << 'PNG'\n else\n f.seek file_offset\n data << BITMAPINFOHEADER.read(f)\n end\n when 'CURSOR'\n f.seek file_offset\n data << CURSOR_HOTSPOT.read(f)\n data << BITMAPINFOHEADER.read(f)\n when 'GROUP_CURSOR'\n f.seek file_offset\n data << CUR_ICO_HEADER.read(f)\n nRead = CUR_ICO_HEADER::SIZE\n data.last.wNumImages.to_i.times do\n if nRead >= self.size\n PEdump.logger.error \"[!] refusing to read CURDIRENTRY beyond resource size\"\n break\n end\n data << CURDIRENTRY.read(f)\n nRead += CURDIRENTRY::SIZE\n end\n when 'GROUP_ICON'\n f.seek file_offset\n data << CUR_ICO_HEADER.read(f)\n nRead = CUR_ICO_HEADER::SIZE\n data.last.wNumImages.to_i.times do\n if nRead >= self.size\n PEdump.logger.error \"[!] refusing to read ICODIRENTRY beyond resource size\"\n break\n end\n data << ICODIRENTRY.read(f)\n nRead += ICODIRENTRY::SIZE\n end\n when 'STRING'\n f.seek file_offset\n 16.times do\n break if f.tell >= file_offset+self.size\n nChars = f.read(2).to_s.unpack('v').first.to_i\n t =\n if nChars*2 + 1 > self.size\n # TODO: if it's not 1st string in table then truncated size must be less\n PEdump.logger.error \"[!] string size(#{nChars*2}) > stringtable size(#{self.size}). truncated to #{self.size-2}\"\n f.read(self.size-2)\n else\n f.read(nChars*2)\n end\n data <<\n begin\n t.force_encoding('UTF-16LE').encode!('UTF-8')\n rescue\n t.force_encoding('ASCII')\n tt = t.size > 0x10 ? t[0,0x10].inspect+'...' : t.inspect\n PEdump.logger.error \"[!] cannot convert #{tt} to UTF-16\"\n [nChars,t].pack('va*')\n end\n end\n # XXX: check if readed strings summary length is less than resource data length\n when 'VERSION'\n f.seek file_offset\n data << PEdump::VS_VERSIONINFO.read(f)\n end\n\n data.delete_if do |x|\n valid = !x.respond_to?(:valid?) || x.valid?\n PEdump.logger.warn \"[?] ignoring invalid #{x.class}\" unless valid\n !valid\n end\n ensure\n validate\n end",
"def load(fn)\n return if ! File.exists?(fn)\n lines = File.read fn\n lines.gsub!(/\\\\ /, SPACE_MARK)\n lines.gsub!(/#[^\\n]*\\n/m, \"\")\n lines.gsub!(/\\\\\\n/, ' ')\n lines.each_line do |line|\n process_line(line)\n end\n end",
"def read_file(file, context); end",
"def load(data)\n end",
"def load_file( filename )\n begin\n read_in = File.new( filename, 'r' )\n rescue\n abort \"\\\"#{ filename }\\\" not found\"\n end\nend",
"def parser_type_for_filename(filename); end",
"def from_file path\n run File.read(path) if File.exists? path\n end",
"def load_file(path)\n load(path)\n end",
"def read\n IO.read(full_path)\n end",
"def parse\n # we need one of them at least\n return nil if !@id.present? && !@filepath.present? \n # get key from filepath if needs\n @id.nil? ? filepath_to_id : id_to_filepath\n # set default locale if null\n @locale ||= I18n.locale.to_s\n # cleanup blanks\n @handler = nil if @handler.blank?\n # set default format\n @format ||= FORMATS[@dir]\n # rebuild key\n @id = [\"\",@dir,@path].compact.join(\"/\")\n # rebuild filepath\n dir = (is_asset? ? \"assets/#{@dir}\" : (is_content? ? \"content/#{@dir}\" : @dir))\n\n @filepath = Grass.app_root + [\"\",dir,@path].compact.join(\"/\") + [\"\",@locale,@format,@handler].compact.join(\".\") \n\n end",
"def load_data(filename=nil)\n filename=data_file(filename)\n return unless File.exist?(filename)\n case File.extname(filename).downcase\n when \".yaml\",\".yml\"\n YAML.load(File.open(filename))\n when \".json\"\n JSON.parse(File.read(filename))\n else\n File.read(filename)\n end\n end",
"def ovl_read_file(rel_file)\n File.read(ovl_expand_file(rel_file), encoding: \"UTF-8\")\n end",
"def parse! filename\n parse_! filename\n end",
"def load(fn) # :nodoc:\n lines = File.read fn\n lines.gsub!(/\\\\ /, SPACE_MARK)\n lines.gsub!(/#[^\\n]*\\n/m, \"\")\n lines.gsub!(/\\\\\\n/, \" \")\n lines.each_line do |line|\n process_line(line)\n end\n end",
"def parse_multifile(filename: \"\", type: \"old\")\r\n !filename.empty? ? file = File.binread(filename) : return\r\n case type\r\n when \"old\"\r\n file.split(\"\\n\").map(&:strip).reject(&:empty?).map{ |m|\r\n title = m.split('#')[0][1..-1] rescue \"\"\r\n author = \"Metanet Software\"\r\n map = parse_map(data: m.split(\"#\")[1], type: \"old\") rescue {tiles: [], objects: []}\r\n {title: title, author: author, tiles: map[:tiles], objects: map[:objects]}\r\n }\r\n else\r\n print(\"ERROR: Incorrect type (old).\")\r\n return 0\r\n end\r\nend",
"def load(raw)\n raw\n end",
"def in_file(filename); end",
"def initialize(filename)\n @filename = filename\n extension = ::File.extname(@filename)\n @format = load_format(extension)\n @name = ::File.basename(@filename, extension)\n @data = ::File.open(@filename, 'rb') { |f| f.read } if valid? && ::File.exists?(@filename)\n end",
"def load\n return unless @file_path && File.exist?(@file_path)\n File.open(@file_path, 'rb') do |file|\n return Marshal.load(file)\n end\n end",
"def parse_multifile(filename: \"\", type: \"old\")\n !filename.empty? ? file = File.binread(filename) : return\n case type\n when \"old\"\n file.split(\"\\n\").map(&:strip).reject(&:empty?).map{ |m|\n title = m.split('#')[0][1..-1] rescue \"\"\n author = \"Metanet Software\"\n map = parse_map(data: m.split(\"#\")[1], type: \"old\") rescue {tiles: [], objects: []}\n {title: title, author: author, tiles: map[:tiles], objects: map[:objects]}\n }\n else\n print(\"ERROR: Incorrect type (old).\")\n return 0\n end\nend",
"def read_files\r\n @prefixes = IO.read('prefixes.txt').split(' ')\r\n @syllables = IO.read('syllables.txt').split(' ')\r\n @postfixes = IO.read('postfixes.txt').split(' ')\r\n end",
"def loadFile _args\n \"loadFile _args;\" \n end",
"def initialize(filename)\n\t\tbegin\n @sourcefile = filename\n \n\t\t\tFile.open(filename, \"r\") do |objfile|\n\t\t\t\tunless getl(objfile) == \"LINK\"\n\t\t\t\t\tputs \"Invalid file format: \" + filename\n\t\t\t\t\treturn nil\n\t\t\t\tend\n\n\t\t\t\t# Read header info\n\t\t\t\t@nsegs, @nsyms, @nrlocs = getl(objfile).split(' ').collect {|x| x.to_i}\n\t\t\t\t\n\t\t\t\t# Parse segs\n\t\t\t\t@segrecs = [], @segnames = {}\n\t\t\t\tgather_segs(objfile)\n\t\t\t\t\n\t\t\t\t# Parse symbols\n\t\t\t\t@symrecs = [], @symnames = {}\n\t\t\t\tgather_syms(objfile)\n\t\t\t\t\n\t\t\t\t# Parse relocations\n\t\t\t\t@rlocrecs = []\n\t\t\t\tgather_rlocs(objfile)\n\t\t\t\t\n\t\t\t\t# Slurp in data\n\t\t\t\t@segrecs.select {|seg| /P/===seg[:type]}.each do |seg|\n\t\t\t\t\tseg[:data] = getl(objfile).hex2bin\n\t\t\t\tend\n\n\t\t\tend\n\t\trescue\n\t\t\tputs \"Could not open object file: \" + filename\n\t\tend\n\tend",
"def read_file(template)\r\n File.read(template)\r\nend",
"def read filepath\n\t\t\tbin = File.binread(filepath).unpack(\"C*\")\n\t\t\telf_ident = bin[0, ELF_IDENT_SIZE]\n\n\t\t\t# check magic number\n\t\t\tunless is_elf? elf_ident\n\t\t\t\tthrow \"This is not ELF Format File\"\n\t\t\tend\n\n\t\t\t# Check ELF class\n\t\t\tval = elf_ident[ELF_IDENT_OFFSET_CLASS].ord\n\t\t\tcase val\n\t\t\twhen ELF_CLASS_ELF32\n\t\t\t\t@elf_class = ELF_CLASS_ELF32\n\n\t\t\t\t# set Address and Offset size for ELF32\n\t\t\t\t@address_size = ELF_SIZE_ADDR_32\n\t\t\t\t@offset_size = ELF_SIZE_OFFSET_32\n\t\t\twhen ELF_CLASS_ELF64\n\t\t\t\t@elf_class = ELF_CLASS_ELF64\n\n\t\t\t\t# set Address and Offset size for ELF64\n\t\t\t\t@address_size = ELF_SIZE_ADDR_64\n\t\t\t\t@offset_size = ELF_SIZE_OFFSET_64\n\t\t\telse\n\t\t\t\tthrow \"Invalid ELF Class:#{val}\"\n\t\t\tend\n\n\t\t\t# Check Endian\n\t\t\tval = elf_ident[ELF_IDENT_OFFSET_ENDIAN].ord\n\t\t\tcase val\n\t\t\twhen ELF_LITTLE_ENDIAN, ELF_BIG_ENDIAN\n\t\t\t\t@elf_endian = val\n\t\t\telse\n\t\t\t\tthrow \"Invalid ELF Endian:#{val}\"\n\t\t\tend\n\n\t\t\t# Check ELF Format Version\n\t\t\tval = elf_ident[ELF_IDENT_OFFSET_FORMAT_VERSION].ord\n\t\t\tunless val == 1\n\t\t\t\tthrow \"Unsuppoted ELF Format Version:#{val}\"\n\t\t\tend\n\t\t\t@elf_version = val\n\n\t\t\t# Check OS ABI\n\t\t\tval = elf_ident[ELF_IDENT_OFFSET_OS_ABI].ord\n\t\t\tcase val\n\t\t\twhen OS_ABI_UNIX, OS_ABI_LINUX\n\t\t\t\t@os_abi = val\n\t\t\telse\n\t\t\t\tthrow \"Unsuppoted OS ABI Format:#{val}\"\n\t\t\tend\n\n\t\t\t# Check OS ABI Version\n\t\t\t@os_abi_version = elf_ident[ELF_IDENT_OFFSET_OS_ABI_VERSION]\n\n\t\t\t@bin = bin\n\t\t\t@ident = elf_ident\n\n\t\t\tis_little = @elf_endian == ELF_LITTLE_ENDIAN\n\t\t\tcase @elf_class\n\t\t\twhen ELF_CLASS_ELF32\n\t\t\t\t@elf_type = @bin[ELF32_OFFSET_TYPE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_machine = @bin[ELF32_OFFSET_MACHINE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_version = @bin[ELF32_OFFSET_VERSION, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_entry = @bin[ELF32_OFFSET_ENTRY, ELF_SIZE_ADDR_32].to_i(is_little)\n\t\t\t\t@elf_program_h_offset = @bin[ELF32_OFFSET_PROGRAM_HEADER, ELF_SIZE_OFFSET_32].to_i(is_little)\n\t\t\t\t@elf_section_h_offset = @bin[ELF32_OFFSET_SECTION_HEADER, ELF_SIZE_OFFSET_32].to_i(is_little)\n\t\t\t\t@elf_flags = @bin[ELF32_OFFSET_FLAGS, ELF_SIZE_WORD].to_i(is_little)\n\t\t\t\t@elf_h_size \t\t= @bin[ELF32_OFFSET_ELF_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_program_h_size = @bin[ELF32_OFFSET_PROGRAM_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_program_h_num = @bin[ELF32_OFFSET_PROGRAM_HEADER_NUM, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_h_size = @bin[ELF32_OFFSET_SECTION_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_h_num = @bin[ELF32_OFFSET_SECTION_HEADER_NUM, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_name_idx = @bin[ELF32_OFFSET_SECTION_NAME_IDX, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\twhen ELF_CLASS_ELF64\n\t\t\t\t@elf_type = @bin[ELF64_OFFSET_TYPE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_machine = @bin[ELF64_OFFSET_MACHINE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_version = @bin[ELF64_OFFSET_VERSION, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_entry = @bin[ELF64_OFFSET_ENTRY, ELF_SIZE_ADDR_64].to_i(is_little)\n\t\t\t\t@elf_program_h_offset = @bin[ELF64_OFFSET_PROGRAM_HEADER, ELF_SIZE_OFFSET_64].to_i(is_little)\n\t\t\t\t@elf_section_h_offset = @bin[ELF64_OFFSET_SECTION_HEADER, ELF_SIZE_OFFSET_64].to_i(is_little)\n\t\t\t\t@elf_flags = @bin[ELF64_OFFSET_FLAGS, ELF_SIZE_WORD].to_i(is_little)\n\t\t\t\t@elf_h_size \t\t= @bin[ELF64_OFFSET_ELF_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_program_h_size = @bin[ELF64_OFFSET_PROGRAM_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_program_h_num = @bin[ELF64_OFFSET_PROGRAM_HEADER_NUM, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_h_size = @bin[ELF64_OFFSET_SECTION_HEADER_SIZE, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_h_num = @bin[ELF64_OFFSET_SECTION_HEADER_NUM, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\t\t@elf_section_name_idx = @bin[ELF64_OFFSET_SECTION_NAME_IDX, ELF_SIZE_HALF_WORD].to_i(is_little)\n\t\t\telse\n\t\t\t\tthrow \"Invalid ELF Class #{@elf_class}\"\n\t\t\tend\n\n\t\t\t# create section name - section index map.\n\t\t\tinitialize_section_h_map\n\n\t\t\t# DEBUG\n\t\t\t#show_elf_header\n\n\t\t\tget_program_header\n\t\tend",
"def read\n raise Errors::FileMissing, @pathname unless @pathname.exist?\n\n JSON.parse(\n @pathname.read,\n symbolize_names: true\n )\n rescue JSON::ParserError => e\n raise Errors::ParserError, e\n end",
"def read\n file = File.read(@filename)\n JSON.parse(file)\n end",
"def read_data(file_name)\n file = File.open(file_name,\"r\")\n object = eval(file.gets.untaint.encode('UTF-8', :invalid => :replace, :replace => '').gsub('\\n', \"\"))\n file.close()\n return object\nend",
"def load!\n JSON.load(File.read(@name))\n rescue JSON::ParserError => e\n raise LogFile::LoadError, e.message\n end",
"def read_data(file_name)\r\n file = File.open(file_name,\"r\")\r\n object = eval(file.gets.untaint.encode('UTF-8', :invalid => :replace))\r\n file.close()\r\n return object\r\nend",
"def parse_file!(file, arg={})\n spx = ICU::Util::File.read_utf8(file)\n arg[:is_utf8] = true\n parse!(spx, arg)\n end",
"def load_file(file)\n File.open(file, \"r\") { |f| load(f) }\n end",
"def load\r\n \r\n end",
"def load_from_file(filename) #:nodoc:\n if defined? ::Encoding\n data = File.open(filename, 'r:UTF-8') { |f| f.read }\n else\n data = File.open(filename) { |f| f.read }\n end\n data = data.split($/)\n mime = MIME::Types.new\n data.each_with_index { |line, index|\n item = line.chomp.strip\n next if item.empty?\n\n begin\n m = TEXT_FORMAT_RE.match(item).captures\n rescue Exception\n puts \"#{filename}:#{index}: Parsing error in MIME type definitions.\"\n puts \"=> #{line}\"\n raise\n end\n\n unregistered, obsolete, platform, mediatype, subtype, extensions,\n encoding, urls, docs, comment = *m\n\n if mediatype.nil?\n if comment.nil?\n puts \"#{filename}:#{index}: Parsing error in MIME type definitions.\"\n puts \"=> #{line}\"\n raise RuntimeError\n end\n\n next\n end\n\n extensions &&= extensions.split(/,/)\n urls &&= urls.split(/,/)\n\n mime_type = MIME::Type.new(\"#{mediatype}/#{subtype}\") do |t|\n t.extensions = extensions\n t.encoding = encoding\n t.system = platform\n t.obsolete = obsolete\n t.registered = false if unregistered\n t.docs = docs\n t.url = urls\n end\n\n mime.add(mime_type)\n }\n mime\n end",
"def load\n end",
"def load!; end",
"def parse\n parse_file\n self\n end",
"def parse_file(path, **options)\n parse(::File.read(path), **options)\n end",
"def load_source\n case File.extname(config[:source])\n when '.json'\n Yajl.load(File.open(config[:source]))\n when '.yml'\n YAML.load(File.open(config[:source]))\n else\n raise 'unknown source file extension'\n end\n end",
"def read_file(file)\n File.read(file)\nend",
"def load\n initialize(File.info(uuid).entity)\n end",
"def load file='GOL.sav'\n self.state=File.open(file,'r') do |f|\n Marshal.load(f)\n end\n end",
"def load_json(filename); end",
"def load_file( file )\n\t\tbegin\n\t\t\t@filename = file\n\t\trescue Exception => e\n\t\t\tbaxter( e )\n\t\tend\n\tend",
"def load_yaml(filename); end"
] |
[
"0.7755398",
"0.76378787",
"0.76378787",
"0.7594539",
"0.74882066",
"0.74882066",
"0.740394",
"0.72689676",
"0.7105456",
"0.69953686",
"0.69162524",
"0.68671757",
"0.678695",
"0.6743152",
"0.67321265",
"0.66591966",
"0.66520256",
"0.6648247",
"0.6588965",
"0.65884817",
"0.65622824",
"0.6537403",
"0.65259784",
"0.65259784",
"0.65259784",
"0.65259784",
"0.65259784",
"0.65259784",
"0.651794",
"0.64930433",
"0.6491334",
"0.639826",
"0.63783306",
"0.63783306",
"0.633427",
"0.633427",
"0.633427",
"0.63126147",
"0.6284495",
"0.6284495",
"0.6273724",
"0.62707007",
"0.6265331",
"0.6247126",
"0.62302506",
"0.62275356",
"0.6216385",
"0.6216385",
"0.61941725",
"0.6192177",
"0.61869717",
"0.6174279",
"0.6171612",
"0.61479104",
"0.61394423",
"0.61362445",
"0.61283386",
"0.61236215",
"0.61159253",
"0.6087141",
"0.6075351",
"0.6073472",
"0.6069285",
"0.6065846",
"0.6061108",
"0.6052781",
"0.6047015",
"0.6040063",
"0.60400176",
"0.6038934",
"0.6038779",
"0.603076",
"0.60291916",
"0.60270935",
"0.600742",
"0.5979227",
"0.5979182",
"0.5977553",
"0.5971426",
"0.5968088",
"0.5965597",
"0.59646595",
"0.5962599",
"0.5959703",
"0.59571916",
"0.5955801",
"0.5944354",
"0.59316945",
"0.5928951",
"0.5927226",
"0.5918916",
"0.5917658",
"0.5917534",
"0.59154356",
"0.59151286",
"0.5914376",
"0.5914052",
"0.5910396",
"0.5909145",
"0.5901664",
"0.5894717"
] |
0.0
|
-1
|
load ruby rules as a string
|
def load_rb_rules_as_string( str )
instance_eval(str)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def load_rules; end",
"def load_cop_rules(rules); end",
"def load_rb( file )\r\n begin\r\n str = IO.read(file)\r\n load_rb_rules_as_string(str)\r\n rescue Exception => e\r\n raise RuleLoadingError, \"loading ruby file\"\r\n end\r\n end",
"def load_rules(rules)\n self.instance_eval(rules)\n end",
"def raw\n @rules ||= load_rules(\"#{Credy.root}/data/*.yml\")\n end",
"def load_rules\n # Find rules file\n rules_filename = [ 'Rules', 'rules', 'Rules.rb', 'rules.rb' ].find { |f| File.file?(f) }\n raise Nanoc3::Errors::NoRulesFileFound.new if rules_filename.nil?\n\n # Get rule data\n @rules = File.read(rules_filename)\n @rules_mtime = File.stat(rules_filename).mtime\n\n # Load DSL\n dsl.instance_eval(@rules)\n end",
"def load_parameter_rules(rules); end",
"def load_xml_rules_as_string( str )\r\n begin\r\n doc = REXML::Document.new str\r\n doc.elements.each( \"rule-set\") { |rs| \r\n facts = rs.elements.each( \"facts\") { |f| \r\n facts( f.attributes[\"name\"] ) do f.text.strip end\r\n }\r\n \r\n rules = rs.elements.each( \"rule\") { |rule_node|\r\n rule_name = rule_node.attributes[\"name\"]\r\n priority = rule_node.attributes[\"priority\"]\r\n \r\n rule = Rule.new(self, rule_name, priority, nil)\r\n \r\n parameters = rule_node.elements.each(\"parameter\") { |param|\r\n #logger.debug \"xml parameter: #{param.text.strip}\"\r\n rule.parameters(eval(param.text.strip))\r\n } \r\n \r\n conditions = rule_node.elements.each(\"condition\") { |cond|\r\n #logger.debug \"xml condition #{cond}\"\r\n rule.condition do eval(cond.text.strip) end\r\n } \r\n \r\n consequences = rule_node.elements.each(\"consequence\") { |cons|\r\n #logger.debug \"xml consequence #{cons}\"\r\n rule.consequence do eval(cons.text.strip) end\r\n } \r\n \r\n @rules[rule_name] = rule\r\n }\r\n logger.debug( \"loaded #{rules.size} rules\") if logger\r\n }\r\n rescue Exception => e\r\n raise RuleLoadingError, \"loading xml file\"\r\n end\r\n \r\n end",
"def to_ruby\n \"EBNF::Rule.new(#{sym.inspect}, #{id.inspect}, #{expr.inspect}#{', kind: ' + kind.inspect unless kind == :rule})\"\n end",
"def to_s\n rules.map {|r| r.embed }.join(' | ')\n end",
"def to_s\n rules.map {|r| r.embed }.join(' ')\n end",
"def to_s\n rules.map {|r| r.embed }.join(' ')\n end",
"def readable\n \"Rules:\\n#{rules.collect {|r| r.readable }.join('\\n')}\\nFacts:\\n#{all_facts.collect {|f| f.readable }.join('\\n')}\"\n end",
"def run_rules(url, rules)\n str = url.to_s\n return str if rules.nil?\n rules.each do |rule|\n case rule\n when 'noproto'\n str = str.gsub(%r{^https?://}, '')\n when 'nossl', 'http'\n str = str.gsub(%r{^https://}, 'http://')\n when 'ssl', 'https'\n str = str.gsub(%r{^http://}, 'https://')\n when 'base32'\n str = Base32.encode(str).to_s\n when 'base64'\n str = Base64.encode64(str).delete(\"\\n\")\n when 'md4'\n str = OpenSSL::Digest::MD4.hexdigest(str)\n when 'md5'\n md5 = Digest::MD5.new\n md5.update str\n str = md5.hexdigest\n when 'sha1'\n str = Digest::SHA1.hexdigest(str)\n when 'reverse'\n str = str.reverse\n when 'upcase'\n str = str.upcase\n when 'downcase'\n str = str.downcase\n when 'rot13'\n str = str.tr('A-Za-z', 'N-ZA-Mn-za-m')\n when 'urlencode'\n str = CGI.escape(str).gsub(/\\+/, '%20')\n when 'urldecode'\n str = CGI.unescape(str)\n when 'append-hash'\n str = \"#{str}##{rand(36**6).to_s(36)}\"\n when 'append-method-get'\n separator = str.include?('?') ? '&' : '?'\n str = \"#{str}#{separator}method=get&_method=get\"\n else\n logger.warn(\"Unknown rule: #{rule}\")\n end\n end\n str\n end",
"def rules_by_name; end",
"def set_used_rules(rules)\n\t\t@used_rules = rules\n\t\tinclude_file = File.join(@rule_directory,\"@include.list\")\n\t\tFile.open(include_file,\"w:utf-8\") do |file|\n\t\t\t@used_rules.each do |rule|\n\t\t\t\tfile.puts \"include \\\"#{rule.file_path}\\\"\"\n\t\t\tend\n\t\tend\n\t\t@base_command = \"\\\"#{@executable_path}\\\" \\\"#{include_file}\\\"\"\n\tend",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def distributed_engine_rules_2_json_simple(rules)\n\n end",
"def rubyize!\n\n self.definition = Ruote::Reader.to_ruby(tree).strip\n end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def loadRulesYAML(file)\n #Open file and parse, looking for rule/tag pairs\n ruleset = YAML.load_file(file)\n rules = ruleset[\"rules\"]\n rules.each do |rule|\n #p rule\n @rules << rule\n end\n end",
"def load_authorization_rules\n instance = Alchemy::AuthEngine.get_instance\n instance.load(File.join(File.dirname(__FILE__), '../../dummy', 'config/authorization_rules.rb'))\n end",
"def to_s\n rule.inspect\n end",
"def translate_file(inp, literal=false)\n pn = Pathname.new(inp)\n # check file exists\n if pn.exist?\n # open and read\n text = File.open(inp).read\n ruleset = text.gsub(/\\r\\n?/, \"\\n\").split(\"\\n\") # split into rules\n out = \"\"\n # feed rules into converter and put output into variable\n ruleset.each { |rule| out << \"#{Phomo2Sce.new(rule).to_sce(literal)}\\n\" }\n out # return translated file\n else\n puts \"Error! Could not find file with path #{inp}\"\n end\nend",
"def to_s\n\t\tmap { |k,v|\n\t\t\tv.to_s + \" ::= \" + v.rules.map { |r| r.map{|e| e.inspect}.join(\" \") }.join(\" | \")\n\t\t}.join(\"\\n\")\n\tend",
"def command_rel(elts)\n\n load(__FILE__)\n end",
"def rules\n I18n.t(\"rubrics.item.rule.#{basename.underscore}\")\n end",
"def formatRules config\n\tresult = \"\"\n\t\n\t# rule set filename is not indicated from the name of the rule set, so a mapping is used\n\trulesetFiles = {\"Android\" => \"android\",\"Basic\" => \"basic\",\"Braces\" => \"braces\",\"Clone Implementation\" => \"clone\",\"Code Size\" => \"codesize\",\"Comments\" => \"comments\",\"Controversial\" => \"controversial\",\"Coupling\" => \"coupling\",\"Design\" => \"design\",\"Empty Code\" => \"empty\",\"Finalizer\" => \"finalizers\",\"Import Statements\" => \"imports\",\"J2EE\" => \"j2ee\",\"JavaBeans\" => \"javabeans\",\"JUnit\" => \"junit\",\"Jakarta Commons Logging\" => \"logging-jakarta-commons\",\"Java Logging\" => \"logging-java\",\"Migration\" => \"migrating\",\"Naming\" => \"naming\",\"Optimization\" => \"optimizations\",\"Strict Exceptions\" => \"strictexception\",\"String and StringBuffer\" => \"strings\",\"Security Code Guidelines\" => \"sunsecure\",\"Type Resolution\" => \"typeresolution\",\"Unnecessary\" => \"unnecessary\",\"Unused Code\" => \"unusedcode\"}\n\t\n\tfor r in config[\"pmd\"][\"rules\"] do\n\t\tresult += \"java-\" + rulesetFiles[r] + \",\"\n\tend\n\treturn result[0..-2]\nend",
"def to_s\n 'rule: ' + @symbol.to_s\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def initialize_rules\n @parser = Rule.rulesParserFromReader(BufferedReader.new(FileReader.new(\"ontology/lattes.rules\")))\n @ruleReasoner = GenericRuleReasoner.new(Rule.parseRules(@parser))\n @ruled = ModelFactory.createInfModel(@ruleReasoner, @schema)\n end",
"def to_s\n rule\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' | ')\n end",
"def eval_file; end",
"def load(filename)\n @config.load(filename)\n @rules.concat(@config.rules)\n self\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' ')\n end",
"def to_citrus # :nodoc:\n rules.map {|r| r.to_embedded_s }.join(' | ')\n end",
"def loadFormRules\n DataMetaParse.loadBaseRulz\n Treetop.load(File.join(File.dirname(__FILE__), '..', '..', 'grammar', 'ptf'))\n end",
"def l(filename)\n load \"#{filename}.rb\"\nend",
"def rule_js\n @rules.collect { |sel, js| behaviour_rule(sel, js) }.join(\",\\n\")\n end",
"def initialize(rules)\n @rules = rules\n end",
"def to_s\n rule_name.to_s\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def load(name); end",
"def construct_rules rules\n parsed_rules = {:rules => []}\n rules.each do |rule|\n parsed_rules[:rules] << rule.attributes\n end\n parsed_rules.to_json\n end",
"def compile_to_ruby\n operator_ruby_string + \"(\" + @expression.compile_to_ruby + \")\"\n end",
"def run_rules(input_file)\n\t\tcommand = \"#{@base_command} \\\"#{input_file}\\\"\"\n\t\t#output = Helpers.run_command(command,true,File.dirname(@rule_directory))\n\t\toutput = Helpers.run_command(command,true,@rule_directory)\n\t\treturn output\n\tend",
"def initialize(rules, start_symbol=nil)\n \n # Allow a previously-generated hash to be dropped into place\n #FIXME validate the hash?\n @rules = rules if rules.kind_of? Hash\n @rules ||= Hash.new\n\n # Allow a single rule expressed as a string\n \n if rules.kind_of? String\n if rules.include? \"\\n\"\n rules = rules.parse_rules\n else\n rules = [rules.parse_rule]\n end\n end\n rules = [rules] if rules.kind_of? String\n rules.each { |r| push(r) }\n\n # If no start symbol is given, assume the left-most head symbol of the first\n # rule supplied to be start symbol\n @start_symbol = start_symbol\n @start_symbol ||= first(1).head[0]\n\n end",
"def to_s\n \"v=#{@version} #{@rules.join(' ')}\"\n end",
"def dumpRules()\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULE DUMP\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n if(@rules.length > 0)\r\n rules = @rules.sort\r\n rules.each do |key, rule|\r\n puts \"#{rule.name}\\t(#{rule.alias})\"\r\n puts \"#{rule.xml}\"\r\n 40.times {print \"-\"}\r\n puts\r\n end\r\n\r\n else\r\n puts \"No rules to dump.\"\r\n end\r\n\r\n puts \"\"\r\n end",
"def parse_rules(rules)\n key = nil\n rules.each do |s|\n s.split.each do |ru|\n if key.nil? and /^:([a-z_]+)=(\\S+)*/ =~ ru\n key = $1\n var = $2\n @attr[key] = var\n key = nil\n elsif /^:([a-z_]+)+/ =~ ru\n key = $1\n if @attr[key].nil?\n @attr[key] = []\n end\n elsif not key.nil?\n @attr[key].push ru unless key.nil?\n else\n if /([a-z0-9_.:-]+)([=!><\\~][=>]*)(.*)/ =~ ru\n names = $1\n op = $2\n ver = $3\n r = Gem::Version.new ver\n name, new_name = names.split(/:/, 2)\n @requirements[name] = {\n :method => :update,\n :op => op,\n :version => r,\n :name => new_name\n }\n elsif /([a-z0-9_-]+):$/ =~ ru\n name = $1\n @requirements[name] = {\n :method => :delete,\n }\n end\n end\n end\n end\n end",
"def loadAll( lines )\n self.reset()\n mode = true\n lines.each{\n |line|\n if line =~ / *mode *= *([a-zA-Z]+) */ then\n if $1 != 'include' and $1 != 'exclude' then\n raise \"CRM114 mode non 'exclude' or 'include' was |#{$1}\"\n end\n mode = $1 == 'include'\n else\n line.strip!\n puts \"CRM114.loadAll; adding |#{line}| as regexp\\n\"\n @regexps << Regexp.new( '^'+line+'$', Regexp::IGNORECASE )\n @modes << mode\n end\n }\n end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def to_s\n # Sorted by filename and line number.\n #\n # FC123: My rule name: foo/recipes/default.rb\n warnings_to_display.map do |w|\n [\"#{w.rule.code}: #{w.rule.name}: #{w.match[:filename]}\",\n w.match[:line].to_i]\n end.sort do |x,y|\n x.first == y.first ? x[1] <=> y[1] : x.first <=> y.first\n end.map{|w|\"#{w.first}:#{w[1]}\"}.uniq.join(\"\\n\")\n end",
"def rule(rule)\r\n\r\n # Rule output is generated in GdlDoc.visitRule()\r\n return rule.src\r\n\r\n end",
"def compile_to_ruby\n statements.collect { |s| s.compile_to_ruby }.join(\"\\n\")\n end",
"def compile_to_ruby_source_as parser_class_name\r\n result = \"class #{parser_class_name} < Dhaka::CompiledParser\\n\\n\"\r\n result << \" self.grammar = #{grammar.name}\\n\\n\"\r\n result << \" start_with #{start_state.id}\\n\\n\"\r\n states.each do |state|\r\n result << \"#{state.compile_to_ruby_source}\\n\\n\"\r\n end\r\n result << \"end\"\r\n result\r\n end",
"def load(raw)\n raw\n end",
"def initialize(file = nil, &b)\r\n \r\n @rules = {}\r\n @facts = {}\r\n @dependencies = {}\r\n \r\n if block_given?\r\n instance_eval(&b)\r\n elsif file\r\n # loading a file, check extension\r\n name,ext = file.split(\".\")\r\n logger.debug(\"loading ext: #{name}.#{ext}\") if logger\r\n case ext\r\n when 'csv'\r\n load_csv( file )\r\n \r\n when 'xml'\r\n load_xml( file )\r\n \r\n when 'rb'\r\n load_rb( file )\r\n \r\n when 'rules' # for backwards compatibility\r\n load_rb(file)\r\n \r\n else\r\n raise RuleLoadingError, \"invalid file extension: #{ext}\"\r\n end\r\n end\r\n end",
"def to_s\n rule.embed + operator\n end",
"def load(str=nil)\r\n case language\r\n when :boolexp\r\n self.src = str\r\n log.info \"Load of BoolExp program - #{name}\"\r\n true\r\n when :fart\r\n File.open(\"farts/#{name}.fart\") {|f|\r\n self.src = f.read\r\n }\r\n log.info \"Load of FART program - #{name}\"\r\n true\r\n else\r\n false\r\n end\r\n end",
"def load(file); end",
"def load(path); end",
"def to_rules\n Array.new.tap do |rules|\n new_rule = Rule.new(rule.chain)\n new_rule.description = \"#{rule.description} (#{self.description})\"\n new_rule.rule = rule.rule.gsub(/\\{\\{(\\w+)\\}\\}/) do\n if value = self.options[$1.to_sym]\n value\n else\n \"{{#{$1}}}\"\n end\n end\n new_rule.action = rule.action\n new_rule.conditions = rule.conditions | self.conditions\n if self.version\n new_rule.versions = [self.version]\n end\n\n if has_host_group?\n host_group = @rule.chain.table.base.host_groups[self.options[:ip]]\n host_group.hosts.each do |key, host|\n host.ips.each do |v, ip|\n hg_rule = new_rule.dup\n hg_rule.description += \" (#{host.name} via #{host_group.name})\"\n hg_rule.rule.gsub!(host_group.name.to_s, ip)\n hg_rule.versions = [v]\n rules << hg_rule\n end\n end\n else\n rules << new_rule\n end\n end\n end",
"def eval(s, bndng=nil, filename=nil, lineno=nil)\n\n loadstring_and_call(s, bndng, filename, lineno)\n end",
"def to_s\n '!' + rule.embed\n end",
"def to_s\n '!' + rule.embed\n end",
"def load!; end",
"def data_to_ruleset \n\n\t\ttemp_array = []\n\t\trule_name = self.fctr_code.blank? ? (\"rule_\" + self.id.to_s) : self.fctr_code + \": \"\n\n\t\tif not self.where_country.blank?\n\t\t\ttemp_array << (\"c_where_country = \" + self.where_country.subfctr_name)\n\t\tend\n\n\t\tif not self.where_zone.blank?\n\t\t\ttemp_array << (\"c_where_zone = \" + self.where_zone.subfctr_name)\n\t\tend\n\n\t\tif not self.where_network.blank?\n\t\t\ttemp_array << (\"c_where_network = \" + self.where_network.subfctr_name)\n\t\tend\n\n\t\tif not self.where_custom.blank?\n\t\t\ttemp_array << (\"c_where_custom = \" + self.where_custom.subfctr_name)\n\t\tend\n\n\t\tif temp_array.size > 0\n\t\t\treturn rule_name + temp_array.join(\", \")\n\t\telse\n\t\t\treturn \"\"\n\t\tend\n\tend",
"def literal_validation\n Validation::Literal.from_string(path)\n end",
"def printRules\n\t\n\t@i = 1\n\t@@rulesArray.each do |rule|\n\t\tputs \"#{@i}-#{rule.fetch('src_ip')}/#{rule.fetch('src_netmask')}:#{rule.fetch('src_port')} #{rule.fetch('dest_ip')}/#{rule.fetch('dest_netmask')}:#{rule.fetch('dest_port')} #{rule.fetch('protocol')} #{rule.fetch('action')}\"\n\t\t@i += 1\n\tend\n\n\tif @i == 1\n\t\tputs \"No rules to print!\"\n\telse\n\t\tputs \"Rules Loaded!\"\n\tend\nend",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def script_load(script); end",
"def parse_rule(input = T.unsafe(nil)); end",
"def load(playground, stack, file)\n raise \"Circular dependency detected: #{stack.join('=>')}=>#{file}\" if stack.include?(file)\n\n source = File.read(file)\n stack.push file\n id = File.basename(file, \".rb\").downcase.gsub(/\\W/, \"_\").to_sym\n context = Object.new\n context.instance_eval do\n extend Definition\n metric = eval(source, context.new_binding(playground, id), file) # rubocop:todo Security/Eval\n raise NameError.new(\"Expected #{file} to define metric #{id}\", id) unless playground.metrics[id]\n\n metric\n end\n rescue StandardError\n error = NameError.exception($!.message, id)\n error.set_backtrace $!.backtrace\n raise error\n ensure\n stack.pop\n end",
"def ruby_source_from_string(s)\n parser = MetagrammarParser.new\n result = parser.parse(s)\n unless result\n raise RuntimeError.new(parser.failure_reason)\n end\n result.compile\n end",
"def load(fn) # :nodoc:\n lines = File.read fn\n lines.gsub!(/\\\\ /, SPACE_MARK)\n lines.gsub!(/#[^\\n]*\\n/m, \"\")\n lines.gsub!(/\\\\\\n/, \" \")\n lines.each_line do |line|\n process_line(line)\n end\n end",
"def string!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 29 )\n\n\n\n type = STRING\n channel = ANTLR3::DEFAULT_CHANNEL\n # - - - - label initialization - - - -\n\n\n # - - - - main rule block - - - -\n # at line 195:5: '\\\"' ( '\\\\\\\\' '\\\"' |~ ( '\\\"' | '\\\\r' | '\\\\n' ) )* '\\\"'\n match( 0x22 )\n # at line 196:5: ( '\\\\\\\\' '\\\"' |~ ( '\\\"' | '\\\\r' | '\\\\n' ) )*\n while true # decision 3\n alt_3 = 3\n look_3_0 = @input.peek( 1 )\n\n if ( look_3_0 == 0x5c )\n look_3_2 = @input.peek( 2 )\n\n if ( look_3_2 == 0x22 )\n look_3_4 = @input.peek( 3 )\n\n if ( look_3_4.between?( 0x0, 0x9 ) || look_3_4.between?( 0xb, 0xc ) || look_3_4.between?( 0xe, 0xffff ) )\n alt_3 = 1\n\n else\n alt_3 = 2\n\n end\n elsif ( look_3_2.between?( 0x0, 0x9 ) || look_3_2.between?( 0xb, 0xc ) || look_3_2.between?( 0xe, 0x21 ) || look_3_2.between?( 0x23, 0xffff ) )\n alt_3 = 2\n\n end\n elsif ( look_3_0.between?( 0x0, 0x9 ) || look_3_0.between?( 0xb, 0xc ) || look_3_0.between?( 0xe, 0x21 ) || look_3_0.between?( 0x23, 0x5b ) || look_3_0.between?( 0x5d, 0xffff ) )\n alt_3 = 2\n\n end\n case alt_3\n when 1\n # at line 196:7: '\\\\\\\\' '\\\"'\n match( 0x5c )\n match( 0x22 )\n\n when 2\n # at line 197:7: ~ ( '\\\"' | '\\\\r' | '\\\\n' )\n if @input.peek( 1 ).between?( 0x0, 0x9 ) || @input.peek( 1 ).between?( 0xb, 0xc ) || @input.peek( 1 ).between?( 0xe, 0x21 ) || @input.peek( 1 ).between?( 0x23, 0xff )\n @input.consume\n else\n mse = MismatchedSet( nil )\n recover mse\n raise mse\n\n end\n\n\n\n else\n break # out of loop for decision 3\n end\n end # loop for decision 3\n\n match( 0x22 )\n\n\n @state.type = type\n @state.channel = channel\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 29 )\n\n\n end",
"def initialize(app,rules)\n @app = app\n \n patterns = []\n paths = []\n \n rules.each do |pattern|\n if pattern.kind_of?(Regexp)\n patterns << pattern\n else\n paths << pattern\n end\n end\n \n @rules = patterns + paths.sort.reverse\n end",
"def load(fn)\n return if ! File.exists?(fn)\n lines = File.read fn\n lines.gsub!(/\\\\ /, SPACE_MARK)\n lines.gsub!(/#[^\\n]*\\n/m, \"\")\n lines.gsub!(/\\\\\\n/, ' ')\n lines.each_line do |line|\n process_line(line)\n end\n end",
"def to_s\n label.to_s + ':' + rule.embed\n end",
"def rsg(filename)\n grammar = []\n definition = read_grammar_defs filename\n for line in definition\n grammar.push(split_definition(line))\n end\n hash = to_grammar_hash(grammar)\n print(expand(hash))\nend",
"def rules=(value)\n @rules = value\n end",
"def init_rule(rule)\n # categories get square brackets and ? becomes <, also split rule\n r = rule.gsub(/\\p{Lu}/,'[\\\\0]').gsub('?', '<').split('/')\n unless r[0].gsub!('#', '*').nil?\n # change # to * (in TRG) or % (in CHG) when not with _\n r[1].gsub!(/(?<!_)#(?!_)/, '%')\n end\n r[1].gsub!(/(?<!@)\\-/, '#') # - becomes # for word-insertions\n r # return ruleset as initialised array\n end",
"def spellout_rules = rbnf(:spellout_rules)",
"def read_grammar_defs(filename)\r\n filename = 'grammars/' + filename unless filename.start_with? 'grammars/'\r\n filename += '.g' unless filename.end_with? '.g'\r\n contents = open(filename, 'r') {|f| f.read}\r\n contents.scan(/\\{(.+?)\\}/m).map do |rule_array|\r\n rule_array[0]\r\n end\r\nend",
"def to_s\n # Sorted by filename and line number.\n #\n # FC123: My rule name: foo/recipes/default.rb\n @warnings.map do |w|\n [\"#{w.rule.code}: #{w.rule.name}: #{w.match[:filename]}\",\n w.match[:line].to_i]\n end.sort do |x,y|\n x.first == y.first ? x[1] <=> y[1] : x.first <=> y.first\n end.map{|w|\"#{w.first}:#{w[1]}\"}.uniq.join(\"\\n\")\n end",
"def from_file(path)\n\t\t\t\told_eval_path,@current_eval_path = @current_eval_path,path\n\t\t\t\tinstance_eval path.read, path.to_s\n\t\t\tensure\n\t\t\t\t@current_eval_path = old_eval_path\n\t\t\tend",
"def eval(str)\n end"
] |
[
"0.71179456",
"0.6813576",
"0.67687064",
"0.6730322",
"0.64818746",
"0.64786035",
"0.6327589",
"0.6291419",
"0.62018955",
"0.6122252",
"0.60696495",
"0.60696495",
"0.5879198",
"0.57756126",
"0.5710738",
"0.56699216",
"0.5638297",
"0.5631757",
"0.56191456",
"0.56005305",
"0.559132",
"0.5544862",
"0.5445227",
"0.5440679",
"0.5439138",
"0.54268575",
"0.54235715",
"0.5411983",
"0.53903085",
"0.5374096",
"0.5374096",
"0.5374096",
"0.5374096",
"0.5374096",
"0.5374096",
"0.5374096",
"0.53711826",
"0.53678817",
"0.5337517",
"0.53296965",
"0.5309797",
"0.53015274",
"0.5279498",
"0.5277352",
"0.52647376",
"0.52272385",
"0.52195096",
"0.52164763",
"0.5171524",
"0.51683956",
"0.51683086",
"0.5159519",
"0.5119335",
"0.51092935",
"0.5109281",
"0.51011944",
"0.5093544",
"0.50931513",
"0.50913125",
"0.50912094",
"0.50912094",
"0.50912094",
"0.50605726",
"0.50557476",
"0.5053296",
"0.5045614",
"0.50309706",
"0.50217336",
"0.5016198",
"0.50161004",
"0.50152224",
"0.5011689",
"0.5004954",
"0.4995337",
"0.49872833",
"0.4986851",
"0.4986851",
"0.49768046",
"0.49764186",
"0.49711138",
"0.49657926",
"0.49649283",
"0.49649283",
"0.49631843",
"0.49574202",
"0.49567994",
"0.49541786",
"0.49495497",
"0.49341255",
"0.49326494",
"0.4930613",
"0.49296707",
"0.49162677",
"0.49138984",
"0.4912513",
"0.4908891",
"0.49080777",
"0.49042594",
"0.48983696",
"0.48873368"
] |
0.7973769
|
0
|
returns an array of facts
|
def get_facts
@facts
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def facts\n @facts ||= {}\n end",
"def list\n load_all\n return @facts.keys\n end",
"def list\n load_all\n @facts.keys\n end",
"def all_facts\n @facts.values.collect { |property_facts| property_facts.values }.flatten\n end",
"def facts_for(entity, property)\n return [] if @facts[entity].nil? || @facts[entity][property].nil?\n return @facts[entity][property]\n end",
"def facts\n @facts ||= begin\n content = Util.read_file(:facts)\n if !content || content.empty?\n content = \"{}\"\n end\n JSON.parse(content)\n rescue SyntaxError, JSON::ParserError => exc\n Util::bail! \"Could not parse facts.json -- #{exc}\"\n end\n end",
"def get_facts(name, environment:)\n headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Node::Facts).join(', '))\n\n response = @client.get(\n with_base_url(\"/facts/#{name}\"),\n headers: headers,\n params: { environment: environment }\n )\n\n process_response(response)\n\n [response, deserialize(response, Puppet::Node::Facts)]\n end",
"def facts(facts = [])\n fields = Hash[facts.collect { |fact| [fact.to_sym, 1] }]\n collection = connection[vms_collection]\n result = {}\n collection.find.batch_size(999).projection(fields).each do |values|\n id = values.delete('_id')\n result[id] = values\n end\n result\n end",
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def facts\n setup_or_refresh_rest_session\n PuppetX::Cisco::ACIUtils.facts\n end",
"def node_facts(certname)\n Puppet.debug(\"Querying PuppetDB for Facts for: #{certname}\")\n pql = ['from', 'facts',\n ['extract', ['name', 'value'],\n ['and',\n ['=', 'certname', certname],\n ['=', 'environment', @environment],\n ]\n ]\n ]\n results = query_puppetdb(pql)\n return nil if results.nil?\n Puppet.debug(results)\n facts = {}\n results.each do |fact, _nil|\n facts[fact['name']] = fact['value']\n end\n facts\n end",
"def facts_from_params(params)\n\n facts = []\n\n params.each do |name, value|\n\n if is_fact? name\n\n facts << create_fact(name, value)\n\n end\n\n end\n\n # return facts\n facts\n\n end",
"def get_facts(nodename)\n facts_puppetdb = Hash.new\n response_facts = RestClient.get\"http://#{Tayu.puppetdb_server}:#{Tayu.puppetdb_port}/facts/\" + nodename, { :accept => :json}\n\n # json string holds two object, we only need te facts object\n json_object = JSON.parse(response_facts)\n json_object.each do |key, value|\n if key == 'facts'\n facts_puppetdb = value\n end\n end \n return facts_puppetdb\n end",
"def facts(context)\n\n oem_model = @system.raw['Model']\n oem_vendor = @client['Oem'].raw.keys[0]\n health_status = @system.raw['Status']['Health']\n redfish_version = @client['RedfishVersion']\n power_state = self.get_powerstate\n attributes = self.get_bios_attributes\n firmware = self.get_firmware_version\n\n context.debug('Retrieving facts')\n {\n 'operatingsystem' => 'redfish',\n 'oemmodel' => oem_model.to_s,\n 'oemvendor' => oem_vendor.to_s,\n 'healthstatus' => health_status.to_s,\n 'redfishversion' => redfish_version.to_s,\n 'powerstate' => power_state.to_s,\n 'biosattributes' => attributes,\n 'firmwareversion' => firmware.to_s,\n }\n end",
"def get_all_food(people)\n food_array = []\n for person in people\n food_array += person[:favourites][:things_to_eat]\n end\n return food_array\nend",
"def facts\n spin(facts_cpu_time, facts_wait_time)\n {}\n end",
"def external_facts\n return @external_facts unless @external_facts.nil?\n\n load_external_facts\n @external_facts = @facts.select { |_k, v| v.options[:fact_type] == :external }\n end",
"def global_food(people)\n food_array = []\n for person in people\n food_array.push(person[:favourites][:snacks])\n #food_array.concat(person[:favourites][:snacks])\n # if we want to return only one array\n end\n return food_array\nend",
"def index\n @facts = Fact.all\n end",
"def index\n @facts = Fact.all\n end",
"def pull_all\n storage = Array.new\n @catchpoint.get(\"tests\")[\"items\"].each do |test|\n test = Dish(test)\n storage << Dish(test)\n end\n return storage\n end",
"def features\n return @discovery_document['features'] || []\n end",
"def get_facts(host)\n curl = setup_curl(\"#{@puppetdb_url}/v3/nodes/#{host}/facts\")\n curl.get\n result = JSON.parse(curl.body_str)\n warn \"Error #{host} not found in puppetdb\" if result.empty?\n result\n end",
"def facts\n {\n \"choria\" => {\n \"playbook\" => @plan\n }\n }\n end",
"def facts_for_node(certnames)\n return {} if certnames.empty? || certnames.nil?\n\n certnames.uniq!\n name_query = certnames.map { |c| [\"=\", \"certname\", c] }\n name_query.insert(0, \"or\")\n result = make_query(name_query, 'inventory')\n\n result&.each_with_object({}) do |node, coll|\n coll[node['certname']] = node['facts']\n end\n end",
"def all_fav_foods(people)\n fav_foods = []\n for person in people\n fav_foods.concat(person[:favourites][:things_to_eat])\nend\nreturn fav_foods\nend",
"def predicates\n elements_with_type(N::RDF.Property, N::Predicate).map { |p| p.local_name }\n end",
"def predicates\n @predicates.values\n end",
"def all_foods(people)\n all_foods = []\n for person in people\n all_foods.concat(person[:favourites][:things_to_eat])\n end\n return all_foods\nend",
"def facts_for_node(certnames)\n return {} if certnames.empty? || certnames.nil?\n\n certnames.uniq!\n name_query = certnames.map { |c| [\"=\", \"certname\", c] }\n name_query.insert(0, \"or\")\n\n @logger.debug(\"Querying certnames\")\n result = make_query(name_query, 'inventory')\n\n result&.each_with_object({}) do |node, coll|\n coll[node['certname']] = node['facts']\n end\n end",
"def features\n []\n end",
"def fact( obj )\r\n #begin\r\n # check if facts already exist for that class\r\n # if so, we need to add it to the existing list\r\n cls = obj.class.to_s.downcase\r\n cls.gsub!(/:/, '_')\r\n if @facts.key? cls\r\n logger.debug( \"adding to facts: #{cls}\") if logger\r\n @facts[cls].fact_value << obj\r\n else\r\n logger.debug( \"creating facts: #{cls}\") if logger\r\n arr = Array.new\r\n arr << obj\r\n proc = Proc.new { arr }\r\n @facts[cls] = Facts.new(self, cls, proc ) \r\n end\r\n #rescue Exception=> e\r\n # logger.error e if logger\r\n #end\r\n end",
"def extract_species_array(csv)\n\t\t@collect = []\n\t\tspc_arr = Fish.all.map {|fish| fish.name}\n\t\tcsv.headers.each do |read_header|\n\t\t\tspc_arr.each do |read_fish|\n\t\t\t\tif read_header == read_fish\n\t\t\t\t\t@collect.push(read_header)\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\treturn @collect\n\tend",
"def all\n return @recipearray\n end",
"def get_all_fences\n @coll.find.to_a\n end",
"def features\n []\n end",
"def custom_facts\n return @custom_facts if @valid_custom_facts\n\n @valid_custom_facts = true\n\n internal_loader.load_all unless @loaded\n @loaded = true\n\n @custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }\n end",
"def each\n load_all\n @facts.each do |name, fact|\n value = fact.value\n yield name.to_s, value unless value.nil?\n end\n end",
"def facts_hash(fact_hash, facts)\n fact_hash.reduce({}) do |ret, fact|\n # Array#include? only matches on values of the same type, so if we find\n # a matching string, it's not a nested query.\n name, value = if facts.include?(fact['name']) || facts == [:all] ||\n # in case a regex pattern is used in the facts query\n facts.index{ |factname| factname =~ /^\\/(.+)\\/$/ && Regexp.new(factname.match(/^\\/(.+)\\/$/)[1]).match(fact['name']) }\n\n [fact['name'], fact['value']]\n else\n # Find the set of keys where the first value is the fact name\n nested_keys = facts.select do |x|\n x.is_a?(Array) && x.first == fact['name']\n end.flatten\n\n # Join all the key names together with an underscore to give\n # us a unique name, and then send all the keys but the fact\n # name (which was already queried out) to extract_nested_fact\n [\n nested_keys.join(\"_\"),\n extract_nested_fact([fact], nested_keys[1..-1]).first\n ]\n end\n\n if ret.include? fact['certname']\n ret[fact['certname']][name] = value\n else\n ret[fact['certname']] = { name => value }\n end\n ret\n end\n end",
"def dice_values(dice)\n values = []\n Cube.find(dice).each do |die|\n values << die.face\n end\n values\n end",
"def features\n @inventory.features(self).to_a\n end",
"def find_castings_by_movie\n sql = \"SELECT fee FROM castings\n WHERE movie_id = $1 \"\n values = [@id]\n movie_casting_info = SqlRunner.run(sql, values)\n return movie_casting_info.map { |casting| Casting.new(casting)}\n # fees_array.each { |casting, fee| casting['fee'] }\n # fees_only = fees_array\n end",
"def features\n\t\tcollection = []\n\t\tclasses.each do |_class|\n\t\t\t_class.features.each do |feature|\n\t\t\t\tcollection << feature\n\t\t\tend\n\t\tend\n\t\trace.features.each do |feature|\n\t\t\tcollection << feature\n\t\tend\n\t\tfeats.each do |feat|\n\t\t\tcollection << feat\n\t\tend\n\t\tcollection\n\tend",
"def servers_with_fact(factname)\n servers = {}\n response = fact_request('facts', factname)\n response.each do |r|\n hostname = r['certname']\n factname = r['value']\n servers[hostname] = factname\n end\n\n servers\nend",
"def list\n specs = Array.new\n @public_holiday_specifications.each { |phs| specs << phs.to_s }\n specs\n end",
"def return_descriptions_array(doc)\n descriptions = doc.css(\".search-content .field-item.even\")\n recipe_descriptions = []\n descriptions.each do |element|\n recipe_descriptions << element.text\n end\n return recipe_descriptions\n end",
"def query_facts(query, facts = [])\n mongo_query = convert.query(query)\n fields = Hash[facts.collect { |fact| [fact.to_sym, 1] }]\n collection = connection[vms_collection]\n result = {}\n collection.find(mongo_query).batch_size(999).projection(fields).each do |values|\n id = values.delete('_id')\n result[id] = values\n end\n result\n end",
"def make_array\n [@name, @author, @deviation_url, @views, @favs, @comments]\n end",
"def facts\n if ENV['MK_EXTERNAL_FACTS']\n begin\n Facter::Util::Config.ext_fact_loader = Facter::Util::DirectoryLoader.loader_for(ENV['MK_EXTERNAL_FACTS'])\n rescue Facter::Util::DirectoryLoader::NoSuchDirectoryError\n # An error here should go back to the server; though how ?\n # But carry on anyway\n end\n end\n Facter::to_hash\n end",
"def facts_query(query, facts = nil)\n nodequery = parse(query, :facts)\n if facts.nil?\n nodequery\n else\n factquery = ['or', *facts.collect { |f|\n if (f =~ /^\\/(.+)\\/$/)\n ['~', 'name', f.scan(/^\\/(.+)\\/$/).last.first]\n else\n ['=', 'name', f]\n end\n }]\n if nodequery\n ['and', nodequery, factquery]\n else\n factquery\n end\n end\n end",
"def getSevenFacts()\n\n # Invoke \"system-get-info\" call to gather system information.\n result = @transport.invoke(\"system-get-info\")\n\n # Pull out system-info subset.\n sys_info = result.child_get(\"system-info\")\n\n # Array of values to get\n [\n 'system-name',\n 'system-id',\n 'system-model',\n 'system-machine-type',\n 'system-serial-number',\n 'partner-system-id',\n 'partner-serial-number',\n 'system-revision',\n 'number-of-processors',\n 'memory-size',\n 'cpu-processor-type',\n 'vendor-id',\n ].each do |key|\n @facts[key] = sys_info.child_get_string(\"#{key}\".to_s)\n end\n\n # Get DNS domainname to build up fqdn\n result = @transport.invoke(\"options-get\", \"name\", \"dns.domainname\")\n domain_name = result.child_get_string(\"value\")\n @facts['domain'] = domain_name.downcase if domain_name\n\n # Get the network config\n result = @transport.invoke(\"net-ifconfig-get\")\n if result.results_status == 'failed'\n Puppet.debug \"API call net-ifconfig-get failed. Probably not supported. Not gathering interface facts\"\n else\n # Create an empty array to hold interface list\n interfaces = []\n # Create an empty hash to hold interface_config\n interface_config = {}\n\n # Get an array of interfaces\n ifconfig = result.child_get(\"interface-config-info\")\n ifconfig = ifconfig.children_get()\n # Itterate over interfaces\n ifconfig.each do |iface|\n iface_name = iface.child_get_string(\"interface-name\")\n iface_mac = iface.child_get_string(\"mac-address\")\n iface_mtu = iface.child_get_string(\"mtusize\")\n\n # Need to dig deeper to get IP address'\n iface_ips = iface.child_get(\"v4-primary-address\")\n if iface_ips\n iface_ips = iface_ips.child_get(\"ip-address-info\")\n iface_ip = iface_ips.child_get_string(\"address\")\n iface_netmask = iface_ips.child_get_string(\"netmask-or-prefix\")\n end\n\n # Populate interfaces array\n interfaces << iface_name\n # Populate interface_config\n interface_config[\"ipaddress_#{iface_name}\"] = iface_ip if iface_ip\n interface_config[\"macaddress_#{iface_name}\"] = iface_mac if iface_mac\n interface_config[\"mtu_#{iface_name}\"] = iface_mtu if iface_mtu\n interface_config[\"netmask_#{iface_name}\"] = iface_netmask if iface_netmask\n end\n\n # Add network details to @facts hash\n @facts['interfaces'] = interfaces.join(\",\")\n @facts.merge!(interface_config)\n # Copy e0M config into top-level network facts\n @facts['ipaddress'] = @facts['ipaddress_e0M'] if @facts['ipaddress_e0M']\n @facts['macaddress'] = @facts['macaddress_e0M'] if @facts['macaddress_e0M']\n @facts['netmask'] = @facts['netmask_e0M'] if @facts['netmask_e0M']\n end\n end",
"def entries\n return Array(@entries)\n end",
"def predicate_objects(namespace, name) #:nodoc:\n predicate(namespace, name).values.flatten.map(&:to_s)\n end",
"def get_days\n\t\tbool_array = []\n\n\t\tbool_array << self[:monday]\n\t\tbool_array << self[:tuesday]\n\t\tbool_array << self[:wednesday]\n\t\tbool_array << self[:thursday]\n\t\tbool_array << self[:friday]\n\t\tbool_array << self[:saturday]\n\t\tbool_array << self[:sunday]\n\n\t\treturn bool_array\n\tend",
"def food_list \n @res_arr\nend",
"def parse_actors_array(hash)\n actorsArray = Array.new\n hash[\"cast\"].each do |actor|\n actorsArray.push(Actor.new(actor))\n end\n return actorsArray\n end",
"def collections\n return [] unless data.at_xpath(\"#{data_root}/context/collectionInfo/unittitle\") && data.at_xpath(\"#{data_root}/context/collectionInfo/unitid\")\n [{\n title: data.at_xpath(\"#{data_root}/context/collectionInfo/unittitle\").content,\n identifier: data.at_xpath(\"#{data_root}/context/collectionInfo/unitid\").content\n }]\n end",
"def animal_species\n animal_arr = self.animals.map do |animal|\n animal.species\n end.uniq\n end",
"def exploitablity_matrix findings\n\t\t\t\t\tresults = Array.new\n\n\t\t\t\t\tfindings.each do |item|\n\t\t\t\t\t\tplugin = Plugin.where(:id => item.plugin_id).first\n\n\t\t\t\t\t\tname = scrub_plugin_name(plugin.plugin_name)\n\t\t\t\t\t\ttotal = Item.where(:plugin_id => item.plugin_id).count\n\t\t\t\t\t\tcore = plugin.exploit_framework_core? ? \"Yes\" : nil\n\t\t\t\t\t\tmetasploit = plugin.exploit_framework_metasploit? ? \"Yes\" : nil\n\t\t\t\t\t\tcanvas = plugin.exploit_framework_canvas? ? \"Yes\" : nil\n\t\t\t\t\t\texploithub = plugin.exploit_framework_exploithub? ? \"Yes\" : nil\n\t\t\t\t\t\td2elliot = plugin.exploit_framework_d2_elliot? ? \"Yes\" : nil\n\n\t\t\t\t\t\tresults.push [name, total, core, metasploit, canvas, exploithub, d2elliot]\n\t\t\t\t\tend\n\n\t\t\t\t\treturn results\n\t\t\t\tend",
"def find_entities\n []\n end",
"def all\n return @recipes\n end",
"def get_all_contestants data \n people = []\n data.each { | season | contestants = season[1]; \n contestants.each { | person | people << person } }\n people \nend",
"def recipes\n recipe_cards.map { |c| c.recipe }\n end",
"def results\n parse_results\n rescue StandardError => e\n Facter.log_exception(e, \"Failed to handle #{filename} as #{self.class} facts: #{e.message}\")\n nil\n end",
"def species\n species = Array.new\n\n mobs.each do |mob|\n species << mob.specie\n end\n\n return species.uniq\n end",
"def return_difficulties_array(doc)\n difficulties = doc.css(\".search-content .teaser-item__info-item--skill-level\")\n recipe_difficulties = []\n difficulties.each do |element|\n recipe_difficulties << element.text.strip\n end\n return recipe_difficulties\n end",
"def recipes\n recipe_cards.map {|recipe_card| recipe_card.recipe}\n end",
"def fmm(wantData)\n puts \"Movies with multiple actors\"\n ar = []\n Movie.find_all.each {|mm| \n\t\t\tif mm.actors.count > 1 then \n\t\t\t print \"\\n\",mm.id,' ',mm.name,' ',mm.actors.count \n\t\t\t ar.push(mm)\n\t\t\tend\n\t\t }\n puts\n if wantData\n return ar\n end\n end",
"def getAll(testbed = nil)\n load\n return @@nds if testbed.nil?\n ret = []\n @@nds.each{|n| ret << n if n['testbed'] == testbed}\n ret\n end",
"def predicates\n @graphs.inject([]) {|memo, g| memo += g.predicates}\n end",
"def listfeatures\n myfeatures=Array.new\n for f in self.features\n myfeatures << f.title\n myfeatures << f.description\n end\n return myfeatures.join(\" \")\n end",
"def forecast_array\n @forecast ||= HTTParty.get(\"http://api.openweathermap.org/data/2.5/forecast/daily?q=Seattle&cnt=3&units=imperial&mode=json\").parsed_response[\"list\"]\n end",
"def all_contestants(data)\n\tarray_of_people = []\n\tdata.each do |season, people|\n\t\tarray_of_people << people\n\tend\n\tarray_of_people.flatten\nend",
"def associated_acts\n if self.type == \"Person\"\n arr = Array.new\n artist_relations = get_relations(self.relations, \"artist\")\n artist_relations.each do |relation|\n if relation[\"type\"] == \"member of band\"\n arr << relation\n end\n end\n return arr\n else\n return nil\n end\n end",
"def definitions() return @definitions end",
"def prime_factors(num)\n facts = []\n\n (1..num).each do |i|\n if num % i == 0 && prime?(i)\n facts << i\n end\n end\n \n return facts\nend",
"def predicates\n @set\n end",
"def films\n self.screenings.map do |screening|\n screening.festival.title\n end\n end",
"def gyms\n #Access the Memberships.all array\n #Determine whether or not the memberships are mine/lifters\n my_memberships = self.memberships\n #create array of gyms from the memberships array\n my_memberships.map do |m|\n m.gym\n end\n end",
"def getDiscs(types)\n\tdiscs = Array.new\n\n\t@discs_doc.elements.each('acda-discs/disc') { |elem|\n\t\tdisc = parseDisc(elem, types)\n\t\tdiscs.push disc\n\t}\n\n\tdiscs\nend",
"def getCategoriesAndTherapists(query)\n query = query.gsub(\"'\", \"\")\n\n f = open(\"|python ../nlp/FindTherapistsByQuery.py #{query}\")\n output = f.read().strip().gsub(\"\\n\", \", \").split(\", \")\n categories = Array.new()\n\n output[0..2].each do |x|\n x.sub!('[', '')\n x.sub!(']', '')\n categories << x\n end\n\n therapists = Array.new()\n output[3..-1].each do |x|\n x.sub!('[', '')\n x.sub!(']', '')\n therapists << x.to_i\n end\n return [categories,therapists]\n end",
"def measure_defs\n return [] if !measure_ids\n \n self.measure_ids.collect do |measure_id|\n Measure.where(id: measure_id).order_by([[:sub_id, :asc]]).all()\n end.flatten\n end",
"def facets(fs)\n raise \"facts requires an Array of Strings.\" unless fs.is_a? Array\n @facet = fs\n self\n end",
"def fact_attributes\n @fact_attributes ||= Array.new.tap do |fa|\n fact_class.aggregate_fields.each { |field| fa << field }\n fact_class.calculated_fields.each { |field| fa << field }\n end\n end",
"def piedata\n\t\tlist = Array.new\n\t\tlabel = self.descriptions.joins(:identity).group(\"identities.name\").order(\"identities.name\").count\n\t\tlabel.each do |key, val|\n\t\t\th = Hash.new\n\t\t\th[:label] = key\n\t\t\th[:value] = val\n\t\t\tlist << h\n\t\tend\n\t\treturn list\n\tend",
"def to_hash\n @facts.each_with_object({}) do |ary, h|\n value = ary[1].value\n unless value.nil?\n # For backwards compatibility, convert the fact name to a string.\n h[ary[0].to_s] = value\n end\n end\n end",
"def spicy_foods \n [\n { name: 'Green Curry', cuisine: 'Thai', heat_level: 9 },\n { name: 'Buffalo Wings', cuisine: 'American', heat_level: 3 },\n { name: 'Mapo Tofu', cuisine: 'Sichuan', heat_level: 6 }\n ]\nend",
"def entities\r\n result = []\r\n result.concat( patches )\r\n result.concat( edges )\r\n result.concat( control_points )\r\n result\r\n end",
"def getMembersAsArray() \n ret = []\n it = self.getIterator() \n while(it.hasMoreResources())\n ret << it.nextResource().getContentAsREXML()\n end\n \n return ret\n end",
"def traits\n traits = sky_table.get_properties()\n traits.select!{|p| !p.transient }\n return traits\n end",
"def format_facts(array, factname)\n array.each do |h|\n h.store(factname, h.delete('value'))\n h.delete('name')\n end\nend",
"def questions\n extracted_questions = []\n\n unless self.qp_questions.nil?\n self.qp_questions.each do |question| \n extracted_questions.push(Question.new(question))\n end \n end\n\n return extracted_questions\t\t\t\n\t\tend",
"def atoms\n each_atom.map.to_a\n end",
"def atoms\n each_atom.map.to_a\n end",
"def inferred_truths_new\n inferred_truths_new = []\n inferred_truths_unique = self.inferred_truths_unique\n inferred_truths_unique.each do |proposition|\n if proposition.unique?(@unique_propositions)\n inferred_truths_new << proposition\n end\n end\n return inferred_truths_new\n end",
"def get_festivals() \n #Start from 3 days ago since can be in the middle of a festival\n threeDaysAgo = (Time.now - (3*24*60*60)).strftime('%Y-%m-%d')\n #Find relevant events\n events = Event.where(festival: 1).where('date >= ?', threeDaysAgo).order(:date)\n\n #Make hash of hashes that include all necessary info\n festivalDatesArr = {}\n events.each do |event|\n #Need to account for same name different locations\n name = \"#{event.title} #{event.location}\"\n if festivalDatesArr.has_key?(name)\n festivalDatesArr[name]['dates'].push(event.date) \n else\n festName = \"#{event.title} #{event.location}\"\n festivalDatesArr[festName] = {\n 'dates' => [event.date],\n 'id' => event.id,\n 'title' => event.title,\n 'location' => event.location,\n 'ages' => event.ages,\n 'link' => event.ticketLink,\n 'address' => event.address\n }\n end\n end\n return festivalDatesArr\n end",
"def get_all_facts(searchfield, arg)\n $found_file = nil\n Dir.glob(\"#{Puppet[:vardir]}/yaml/facts/*\") {|file|\n $tempfile = YAML::load_file(file).values\n if $tempfile[searchfield] == arg\n $found_file = true\n break\n end\n }\n \n if $found_file\n $tempfile.each_pair{|key, value|\n puts \"#{key} = #{value}\"\n }\n else\n return \"That #{searchfield} was not found.\"\n end\n \n end",
"def desserts\n self.dessert_ingredients.map {|di| di.dessert}\n end",
"def spells()\n learnings = self.learnings()\n spells = learnings.map { |learning| learning.spell }\n return spells\n end",
"def get_descriptions( vacancies )\n descriptions = []\n vacancies.each do |vacancy|\n descriptions << vacancy['description']\n end\n\n return descriptions\nend"
] |
[
"0.7494817",
"0.7268276",
"0.7104335",
"0.7043786",
"0.67014706",
"0.66596556",
"0.6551511",
"0.6504118",
"0.63914436",
"0.6369102",
"0.62914336",
"0.62493324",
"0.61840606",
"0.6106346",
"0.60129654",
"0.60018766",
"0.5938833",
"0.5759471",
"0.57307464",
"0.57307464",
"0.57018644",
"0.5667432",
"0.56663924",
"0.5600039",
"0.55977345",
"0.5593386",
"0.55666125",
"0.5561336",
"0.5530959",
"0.55191255",
"0.5516992",
"0.5514685",
"0.5510901",
"0.5496107",
"0.5485335",
"0.5478594",
"0.54670346",
"0.54430944",
"0.5434035",
"0.54307425",
"0.54295146",
"0.54273725",
"0.53733563",
"0.5362664",
"0.5305199",
"0.52967954",
"0.52920276",
"0.528814",
"0.5269629",
"0.5265561",
"0.5258608",
"0.52374357",
"0.5236496",
"0.52363527",
"0.52233034",
"0.5217229",
"0.5214086",
"0.52113736",
"0.52077377",
"0.5180938",
"0.5178462",
"0.5171626",
"0.51693404",
"0.51531297",
"0.51507217",
"0.5141212",
"0.51391965",
"0.5136895",
"0.5136438",
"0.51224405",
"0.5110056",
"0.51036423",
"0.5103456",
"0.50894654",
"0.50819546",
"0.5080891",
"0.5076945",
"0.507275",
"0.5066779",
"0.50662845",
"0.5059788",
"0.5052503",
"0.5052183",
"0.5049141",
"0.504333",
"0.5043074",
"0.5040949",
"0.5037946",
"0.50343555",
"0.50325966",
"0.50320303",
"0.5031374",
"0.50254434",
"0.50254434",
"0.50214845",
"0.50190115",
"0.5018146",
"0.50151724",
"0.500609",
"0.5001991"
] |
0.77920645
|
0
|
returns all the rules defined for that set
|
def get_rules
@rules
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def all\n @rules\n end",
"def rules\n return @rules\n end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def ruleset_rules\n @rulesets.collect do |r|\n [\"# Begin [#{r.name}]\",\n r.firewall_rules,\n \"# End [#{r.name}]\",\n \"\"]\n end\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def all_defined_rules\n if @group\n @defined_rules.merge(@group.all_defined_rules)\n else\n @defined_rules\n end\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules\n self.class.rules\n end",
"def rules\n @rules=get_endpoint('rule').keys\n end",
"def rule_set\n @rule_set ||= Rules::RuleSet.build_for(calendar: calendar, kind: kind)\n end",
"def rules\n rule_applier.rules\n end",
"def rules\n @rules ||= {}\n end",
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def rules\n @rules.dup.freeze\n end",
"def rules\n #\n # This is called first in case any preable needs to be declared (chains, specifically)\n #\n _ruleset_rules = ruleset_rules\n\n [\n Asbestos.firewall.preamble(self),\n _ruleset_rules,\n Asbestos.firewall.postamble(self)\n ].flatten\n end",
"def rules_by_name; end",
"def rules\n return [] if @rules.empty?\n @rules.sort_by { |k| k['priority'] }.map { |h| h['rule_name'] }\n end",
"def all\n @rules ||= raw.values.flatten.map { |rule| Accessibility::Rule.new(rule) }\n end",
"def known_rules\n @table.keys\n end",
"def rules\n @rules ||= begin\n @rules = []\n resolve_permissions\n @rules\n end\n end",
"def rules\n return @rules unless @rules.nil?\n\n # this initialization code runs only once\n @rules = {}\n 7.downto(0).each do |rule_key|\n key = rule_key.to_s(2).rjust(3, '0') # convert to binary, pad left with 0\n @rules[key.to_sym] = RULE_NAME >> rule_key & 1 # just the one bit\n end\n\n @rules\n end",
"def patterns\n #@rules.every.pattern\n @rules.map {|r| r.pattern }\n end",
"def rules( *new_values )\n\t\tself.rules = new_values unless new_values.empty?\n\t\treturn @rules\n\tend",
"def defined_rules\n @defined_rules ||= {}\n end",
"def to_a\n @rules.keys\n end",
"def rules\n cluster.configurationEx.rule\n end",
"def rules\n cluster.configurationEx.rule\n end",
"def get_all_config_rules\n config_rules = []\n\n # Fetch all rules with pagination\n response = @client.describe_config_rules\n config_rules += response.config_rules\n while response.next_token\n response = @client.describe_config_rules(next_token: response.next_token)\n config_rules += response.config_rules\n end\n config_rules = config_rules.map(&:to_h)\n\n # Add necessary data to rules using helpers\n add_compliance_to_config_rules(config_rules)\n add_results_to_config_rules(config_rules)\n end",
"def get_staging_rule_sets\n get(\"#{url_base}/staging/rule_sets?#{dc}\")[\"data\"]\n end",
"def rulelist(ruleset, ctx)\r\n\r\n outlist = \"\"\r\n\r\n ruleset.rules.each do |ralias|\r\n rname = ctx.rules[ralias].name\r\n outlist += reference(\"rule\", rname)\r\n\r\n end # rules.each\r\n\r\n return outlist\r\n\r\n end",
"def extended_grammar(sets)\n rules = []\n sets.each do |set|\n set.items.each do |item|\n if item.dot == 0\n rule = [item]\n next_item = item.next_item\n while next_item != nil\n rule << next_item\n next_item = next_item.next_item\n end\n rules << rule\n end\n end\n end\n rules\n end",
"def get_candidates(rules)\n candidates = []\n rules.each { |rule| candidates << rule if rule.ever_matched? && rule.time_to_report? }\n candidates\n end",
"def rules=(value)\n @rules = value\n end",
"def validation_rules\n []\n end",
"def all\n rules = []\n\n raw.each do |type, details|\n # Add general rules\n Array(details['prefix']).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type\n })\n end\n\n # Process each country\n Array(details['countries']).each do |country, prefixes|\n # Add a rule for each prefix\n Array(prefixes).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type,\n country: country,\n })\n end\n end\n\n end\n\n # Sort by prefix length\n rules.sort { |x, y| y[:prefix].length <=> x[:prefix].length }\n end",
"def to_list\n rules.map do |rule|\n object = { actions: rule.actions, subject: rule.subjects.map{ |s| s.is_a?(Symbol) ? s : s.name } }\n object[:conditions] = rule.conditions unless rule.conditions.blank?\n object[:inverted] = true unless rule.base_behavior\n object\n end\n end",
"def rules_ids\n @rules_registry.rules.map(&:id)\n end",
"def available_rules\n\t\tif @rules.nil?\n\t\t\t@rules = []\n\t\t\tDir.glob(File.join(@rule_directory,\"**\",\"*.yar*\")).each do |yara_rule_file|\n\t\t\t\trule = YaraRule.new\n\t\t\t\trule.file_path = yara_rule_file.gsub(\"/\",\"\\\\\\\\\")\n\t\t\t\t@rules << rule\n\t\t\tend\n\t\tend\n\t\treturn @rules\n\tend",
"def rules_as_hash\n\t\tunless @rules_as_hash\n\t\t\t@rules_as_hash = self.rules.each_with_object( {} ) do |rule, hash|\n\t\t\t\tpred, succ = self.parse_rule( rule )\n\t\t\t\thash[ pred ] = succ\n\t\t\tend\n\n\t\t\tself.alphabet.each do |char|\n\t\t\t\t@rules_as_hash[ char ] = char unless @rules_as_hash.key?( char )\n\t\t\tend\n\t\tend\n\n\t\treturn @rules_as_hash\n\tend",
"def rules # :nodoc:\n # Rules should always be returned sorted with oldest first.\n @rules.sort! { |a, b| b[:age] <=> a[:age] }\n end",
"def rules_for(path)\n @rules.reverse.select do |rule| path.match(rule.pattern) end\n end",
"def rules(rule_name:, kind:)\n Rules::RuleSet.build_for(calendar: calendar, kind: kind).rules_with_name(rule_name)\n end",
"def to_rules\n Array.new.tap do |rules|\n new_rule = Rule.new(rule.chain)\n new_rule.description = \"#{rule.description} (#{self.description})\"\n new_rule.rule = rule.rule.gsub(/\\{\\{(\\w+)\\}\\}/) do\n if value = self.options[$1.to_sym]\n value\n else\n \"{{#{$1}}}\"\n end\n end\n new_rule.action = rule.action\n new_rule.conditions = rule.conditions | self.conditions\n if self.version\n new_rule.versions = [self.version]\n end\n\n if has_host_group?\n host_group = @rule.chain.table.base.host_groups[self.options[:ip]]\n host_group.hosts.each do |key, host|\n host.ips.each do |v, ip|\n hg_rule = new_rule.dup\n hg_rule.description += \" (#{host.name} via #{host_group.name})\"\n hg_rule.rule.gsub!(host_group.name.to_s, ip)\n hg_rule.versions = [v]\n rules << hg_rule\n end\n end\n else\n rules << new_rule\n end\n end\n end",
"def rules_for(state, char)\n rules.select { |rule| rule.applies_to?(state, char) }\n end",
"def list\n @driver.getRuleNames\n end",
"def rules_with_epsilon()\n rules = []\n @rules.each do |rule|\n rules << rule if rule.epsilon?\n end\n rules\n end",
"def rules_for(table)\n by_string, ages = rules_by_string(table, [])\n by_regexp, ages = rules_by_regexp(table, ages)\n for_all, ages = rules_for_all(table, ages)\n\n valid_rules = by_string + by_regexp + for_all\n valid_rules.sort { |a, b| b[:age] <=> a[:age] }\n end",
"def rules_at(keys, *rest)\n if defined?(keys.exclude_end?)\n return @rules[keys]\n end\n ([keys]+rest).flatten.map{ |i| rule_at(i) }\n end",
"def get_all(provider = :aws)\n @@_rule_set_registry.fetch(provider, {}).values\n end",
"def rules_for(configuration, character)\n # note that it is select (filter), not detect (find)\n rules.select {|rule| rule.applies_to?(configuration, character)}\n end",
"def rule_names\n @rule_names ||= []\n end",
"def rule_names\n @rule_names ||= []\n end",
"def rules_containing(production)\n rules = []\n @rules.each do |rule|\n rules << rule if rule.productions.include?(production)\n end\n rules\n end",
"def find_possibilities\n (0..@field_count-1).reduce({}) do |acc, i|\n acc[i] = @rules\n .select do |rule|\n ticket_values_at(i).all? { |v| rule.valid?(v) }\n end\n .map(&:name)\n\n acc\n end\n end",
"def rules1\n @rules1\nend",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def then_rules\n @then_rules ||= []\n end",
"def external_rules\n @external_rules ||= rules.dup.external\n end",
"def sets\n return [EscholSet.new({name: \"everything\", spec: \"everything\"})]\n end",
"def rule_set_artifacts\n @rule_set_artifacts ||= []\n end",
"def dumpRulesets()\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULESET DUMP\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n if(@rulesets.length > 0)\r\n rulesets = @rulesets.sort\r\n rulesets.each do |key, ruleset|\r\n\r\n 40.times {print \"-\"}\r\n puts\r\n puts \"#{ruleset.name}\\t(#{ruleset.alias}) : #{ruleset.type} : #{ruleset.execType}\"\r\n ruleset.rules.each do |ruleAlias|\r\n puts \"\\t#{ruleAlias}\"\r\n end # rules.each\r\n puts \"\"\r\n\r\n end # rulesets.each\r\n\r\n else\r\n puts \"No rulesets to dump.\"\r\n end\r\n\r\n puts \"\"\r\n end",
"def load_rules; end",
"def each(&block)\n @rules.each(&block)\n end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def get_rules\n rules = Array.new\n\n RULE_TYPES.each do |reg|\n ebtables_exit = `#{CONF[:ebtables]} -L FORWARD`\n\n rules << ebtables_exit.split(\"\\n\")[3..-1].collect do |l|\n line = l.strip\n m = line.match(reg)\n\n if m\n interface=m[1]\n {\n :interface => interface, \n :rule => line\n }\n else\n nil\n end\n end.compact\n end\n\n rules.flatten\nend",
"def each\n @rules.each { |h,ds| ds.each { |d| yield [h, d] } }\n end",
"def rules(section_id = @one_section_id)\n url = @url_sections + '/' + section_id + '/rules'\n @nsx_client.get(url)\n end",
"def get_modifying_rules(agent, opponent)\n modified_by = Hash.new { [[],[]] }\n track = lambda do |set, index|\n set.each_with_index do |rule, rule_i|\n rule.alternatives.each do |alt|\n alt.modifiers.each do |mod|\n arr = modified_by[mod.predicate]\n arr[index] << [rule_i, mod.type]\n modified_by[mod.predicate] = arr\n end\n end\n end\n end\n track.call(agent.actions, 0)\n track.call(opponent.rules, 1)\n return modified_by\n end",
"def print_rules(*names)\n names = nil if names.empty?\n puts \"(#{runner.root})\"\n runner.rulesets.each do |name, set|\n next unless names.member?(name.to_s) if names\n print \"#{name}\"\n print \" (#{set.chain.join(' ')})\" unless set.chain.empty?\n puts\n set.docs.each_with_index do |d, i|\n puts \" * #{d}\"\n end\n end\n\n #exit\n end",
"def predicates\n @set\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def closure(rules)\n\t\tj = rules.map{|x| x.clone};\n\t\tall_rules = [];\n\t\t@rules .each{ |x,y| y.each{ |z| all_rules += [[x, z, 0]] }}\n\t\tj .each{ | x| all_rules -= [ x ] }\n\t\t#p all_rules\n\t\tbegin\n\t\t\tis_added = false;\n\t\t\tj.each do |c_rule|\n\t\t\t\tif c_rule[1].size >= c_rule[2] then\n\t\t\t\t\tnonterm_to_add = c_rule[1][c_rule[2]]\n\t\t\t\t\t#p nonterm_to_add\n\t\t\t\t\tif nonterm_to_add.class == Symbol then\n\t\t\t\t\t\ttemp = [];\n\t\t\t\t\t\tall_rules.each do |rule_to_add|\n\t\t\t\t\t\t\t#p rule_to_add\n\t\t\t\t\t\t\tif nonterm_to_add == rule_to_add[0] then\n\t\t\t\t\t\t\t\ttemp += [rule_to_add];\n\t\t\t\t\t\t\t\tis_added = true;\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\t\tall_rules -= temp;\n\t\t\t\t\t\tj += temp;\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend while is_added\n\t\treturn j;\n\tend",
"def boolean_rule_test_sets\n {\n 'not set': 'fail',\n 'set': 'pass'\n }\nend",
"def construct_rules rules\n parsed_rules = {:rules => []}\n rules.each do |rule|\n parsed_rules[:rules] << rule.attributes\n end\n parsed_rules.to_json\n end",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def included_rules\n @included_rules ||= {}\n end",
"def relevant_rules(action, subject)\n return [] unless @rules\n\n relevant = possible_relevant_rules(subject).select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n relevant.reverse!.uniq!\n optimize_order! relevant\n relevant\n end",
"def inferred_truths_all\n inferred_truths_all = []\n validsyllogisms = self.valid_syllogisms\n validsyllogisms.each do |syllogism|\n inferred_truths_all << syllogism.conclusion\n end\n return inferred_truths_all\n end",
"def risk_rules\n @risk.rules.map { |rule| Item.new(resolve(rule)) }.compact.reject { |i| i.disabled? }\n end",
"def valid_sets; end",
"def add_relevant_rules_for_fact fact\r\n @rules.values.select { |rule| \r\n if !@relevant_rules.include?( rule)\r\n if rule.parameters_match?(fact.value) \r\n @relevant_rules << rule \r\n logger.debug \"#{rule} is relevant\" if logger\r\n else\r\n logger.debug \"#{rule} is not relevant\" if logger \r\n end \r\n end\r\n } \r\n end",
"def rules_by_name(rule_name, section_id = @one_section_id)\n rules = []\n return rules unless section_id\n\n all_rules = rules(section_id)\n return rules unless all_rules\n\n all_rules['results'].each do |rule|\n rules << rule if rule['display_name'] == rule_name\n end\n rules\n end",
"def get_bre_rules(opts = {})\n data, _status_code, _headers = get_bre_rules_with_http_info(opts)\n return data\n end",
"def properties\n properties = []\n\n rules.values.each do |declarations|\n declarations.each {|property, value| properties << [property, value] }\n end\n \n properties\n end",
"def ruleset(ruleset, ctx)\r\n rulelist = rulelist(ruleset, ctx)\r\n\r\n cmtSuffix = \"\"\r\n ruleParams = \"#{ruleset.execType}\" # Build the ruleset parameter list.\r\n\r\n if (ruleset.type == \"PL\")\r\n ruleParams += \", PL\"\r\n cmtSuffix += \"(PowerLookup)\"\r\n end # if ruleset.type\r\n\r\n aliasStmt = \"\" # Don't create an alias statement if it is not needed.\r\n\r\n if (ruleset.name != ruleset.alias)\r\n aliasStmt = <<EOF\r\nalias(ruleset, #{ruleset.name}, \"#{ruleset.alias}\");\r\nEOF\r\n end # if ruleset.name...\r\n\r\n\r\n out = <<EOF\r\n#{aliasStmt}\r\n/* ==========================================================================\r\n * #{ruleset.name} #{cmtSuffix}\r\n *\r\n *\r\n */\r\nruleset #{ruleset.name}(#{ruleParams})\r\n#{rulelist}\r\nend // ruleset #{ruleset.name}(#{ruleParams})\r\n\r\n\r\n\r\n\r\nEOF\r\n\r\n return out\r\n\r\n end",
"def rules_for(aNonTerm)\n rules.select { |a_rule| a_rule.lhs == aNonTerm }\n end",
"def result\n\n # start the matching of the ruleby engine if not yet called\n unless @engine_has_matched\n @engine.match\n @engine_has_matched = true\n end\n\n # return the result array\n @result_rules\n\n end",
"def rules_config\n @squeezed_rules_config\n end",
"def GetRules\n Builtins.y2milestone(\"Getting Rules: %1\", @tomerge)\n\n scheme = AutoinstConfig.scheme\n host = AutoinstConfig.host\n filepath = AutoinstConfig.filepath\n directory = AutoinstConfig.directory\n\n valid = []\n stop = false\n Builtins.foreach(@tomerge) do |file|\n if !stop\n dir = dirname(file)\n if dir != \"\"\n SCR.Execute(\n path(\".target.mkdir\"),\n Ops.add(Ops.add(AutoinstConfig.local_rules_location, \"/\"), dir)\n )\n end\n\n localfile = Ops.add(\n Ops.add(AutoinstConfig.local_rules_location, \"/\"),\n file\n )\n if !Get(\n scheme,\n host,\n Ops.add(Ops.add(directory, \"/\"), file),\n localfile\n )\n Builtins.y2error(\n \"Error while fetching file: %1\",\n Ops.add(Ops.add(directory, \"/\"), file)\n )\n else\n stop = true if @Behaviour == :one\n valid = Builtins.add(valid, file)\n end\n end\n end\n @tomerge = deep_copy(valid)\n if Builtins.size(@tomerge) == 0\n Builtins.y2milestone(\"No files from rules found\")\n return false\n else\n return true\n end\n end",
"def dumpRules()\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULE DUMP\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n if(@rules.length > 0)\r\n rules = @rules.sort\r\n rules.each do |key, rule|\r\n puts \"#{rule.name}\\t(#{rule.alias})\"\r\n puts \"#{rule.xml}\"\r\n 40.times {print \"-\"}\r\n puts\r\n end\r\n\r\n else\r\n puts \"No rules to dump.\"\r\n end\r\n\r\n puts \"\"\r\n end"
] |
[
"0.7793942",
"0.7636718",
"0.7592193",
"0.75142276",
"0.75142276",
"0.7487639",
"0.72660935",
"0.72660935",
"0.72660935",
"0.72629726",
"0.72176915",
"0.72176915",
"0.72176915",
"0.72176915",
"0.72176915",
"0.72176915",
"0.72176915",
"0.71722114",
"0.7149962",
"0.7121508",
"0.71063304",
"0.7075539",
"0.70746666",
"0.7050963",
"0.7014852",
"0.69961506",
"0.69696486",
"0.6923729",
"0.68502235",
"0.66902816",
"0.66578346",
"0.6613756",
"0.66032904",
"0.65545636",
"0.6542671",
"0.6480273",
"0.6480273",
"0.64513135",
"0.64220774",
"0.6367984",
"0.63511",
"0.6348886",
"0.6314774",
"0.62982154",
"0.6292023",
"0.6283072",
"0.6268179",
"0.6252327",
"0.6250165",
"0.6226561",
"0.6220968",
"0.6203644",
"0.61759424",
"0.615429",
"0.6112755",
"0.611064",
"0.6109834",
"0.6107061",
"0.6092154",
"0.6076863",
"0.6059756",
"0.6059756",
"0.60508144",
"0.60386515",
"0.6031707",
"0.6014631",
"0.6002316",
"0.599644",
"0.5988529",
"0.5980723",
"0.59501934",
"0.5943203",
"0.5921539",
"0.5903162",
"0.5897827",
"0.58950365",
"0.5892128",
"0.58893234",
"0.5872852",
"0.58725274",
"0.5855125",
"0.58377206",
"0.5820163",
"0.580532",
"0.58004713",
"0.5789826",
"0.5784506",
"0.5777151",
"0.576525",
"0.57275873",
"0.5720757",
"0.5717965",
"0.56918156",
"0.5649596",
"0.56436753",
"0.56417906",
"0.563718",
"0.5627997",
"0.5598",
"0.55979675"
] |
0.7439468
|
6
|
A single fact can be an single object of a particular class type or a collection of objects of a particular type
|
def fact( obj )
#begin
# check if facts already exist for that class
# if so, we need to add it to the existing list
cls = obj.class.to_s.downcase
cls.gsub!(/:/, '_')
if @facts.key? cls
logger.debug( "adding to facts: #{cls}") if logger
@facts[cls].fact_value << obj
else
logger.debug( "creating facts: #{cls}") if logger
arr = Array.new
arr << obj
proc = Proc.new { arr }
@facts[cls] = Facts.new(self, cls, proc )
end
#rescue Exception=> e
# logger.error e if logger
#end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def fact_class\r\n owning_class\r\n end",
"def fact_class\n cube.class.fact_class\n end",
"def extract_feature_object_types(doc, feature)\n # Tie this feature to a FeatureObjectType and through it an ObjectType\n admin_thesaurus_term = doc.at(\"/feature/fheader/fclass\")['term']\n\n # Does an object type exist for this code yet? \n ot = ObjectType.find_or_create_by_code(admin_thesaurus_term.downcase)\n\n # Create a FeatureObjectType to tie this feature to an ObjectType\n fot = FeatureObjectType.new\n fot.feature_id = feature.id\n fot.category_id = ot.id\n fot.perspective = @current_perspective#Perspective.find_or_create_by_code(@current_perspective_code)\n raise \"FeatureObjectType not saved!\" unless fot.save\n\n set_timespan(doc, fot)\n\n extract_citations(doc.at(\"/feature/fheader/fclass\"), fot)\n\n\n end",
"def filter(object)\n @id_by == :is_a? ? is(object) : kind(object)\n end",
"def object_types\n feature_object_types.collect(&:category).select{|c| c}\n end",
"def is_collection?(obj)\n obj && data_object(obj).respond_to?(:map) && data_object(obj).respond_to?(:each) &&\n (KNOWN_OBJECT_CLASSES & obj.class.ancestors.map(&:name)).empty?\n end",
"def know_it_all(object)\n object.class\nend",
"def objects_of_type(name)\n find_all { |r| name === r['type'] }\n end",
"def object_class object_type\n object_type.classify.constantize\n end",
"def define_fact(fact)\n case fact\n when Fact\n fact\n when String, Regexp\n @watchlist.accept(fact)\n FileFact.new(fact)\n when Symbol\n Fact.new{ send(fact) }\n when true, false, nil\n Fact.new{ fact }\n else #when Proc\n Fact.new(&fact)\n end\n end",
"def test_multiples_non_objectable_types_with_default_new_method\n cat1 = 'Amelia'\n cat2 = 'Gorbypuff'\n cats = [cat1, cat2]\n test_object = ObjTestClasses::TestObject.new(menagerie: cats)\n\n test_object.menagerie.each do |animal|\n assert_instance_of(ObjTestClasses::Cat, animal)\n end\n\n cats.each do |cat|\n assert_includes(test_object.menagerie, ObjTestClasses::Cat.new(cat))\n end\n end",
"def objects_of_class(name)\n find_all { |r| name === r['class'] }\n end",
"def match(klass); end",
"def collection_klass(collection)\n if collection.respond_to?(:proxy_association)\n collection.proxy_association.klass\n elsif collection.respond_to?(:proxy_reflection)\n collection.proxy_reflection.klass\n elsif defined?(::ActiveRecord::Relation) && collection.is_a?(::ActiveRecord::Relation)\n collection.klass\n elsif collection.respond_to?(:first) && collection.first\n collection.first.class\n end\n end",
"def contains?(klass)\n\t\tmap { |obj| obj.class }.include? klass\n\tend",
"def ensure_class(obj, types, msg)\n if types.class == Array\n if not types.member?(obj.class)\n return msg\n else\n return true\n end\n\n else\n if not types == obj.class\n return msg\n else\n return true\n end\n end\n end",
"def will_be?(type)\n single_class <= type\n end",
"def get(predicate)\n predicate = class_of predicate\n @set.find {|item| item.is_a? predicate}\n end",
"def is_a?(klass)\n return true if klass == Set\n super\n end",
"def identify_class(obj)\n case obj\n when Hacker,Submission,TestCase,Contest\n puts \"It's a #{obj.class}!\"\n else\n puts \"It's an unknown model\"\n end\nend",
"def collection\n klass.collection\n end",
"def is_collection_object\n return self.resource_type == Resource::COLLECTION_OBJECT;\n end",
"def is_a?(klass)\n __getobj__.class.object_id == klass.object_id\n end",
"def is_a?(klass)\n __getobj__.class.object_id == klass.object_id\n end",
"def add_fact(fact)\n @facts[fact.entity] = {} unless @facts.has_key?(fact.entity)\n @facts[fact.entity][fact.property] = [] unless @facts[fact.entity].has_key?(fact.property)\n @facts[fact.entity][fact.property].each do |existing|\n if (fact.comparator == Fact::EQUAL && existing.comparator == Fact::EQUAL && fact.property_value != existing.property_value) ||\n (existing.comparator != fact.comparator && existing.property_value == fact.property_value)\n raise \"Adding a contradictory fact!\"\n end\n end\n @facts[fact.entity][fact.property] << fact\n LOGGER.info \"Adding fact: #{fact.readable}\"\n end",
"def fact_type_dump(fact_type, name)\n @fact_types_dumped[fact_type] = true\n return objectified_fact_type_dump(fact_type.entity_type) if fact_type.entity_type\n\n puts fact_type.scala_definition\n\n @metamodel << fact_type.scala_metamodel\n end",
"def select_by_class(klass)\n scoped = @project.objects_hash.select { |_, attr| attr['isa'] == klass.isa }\n PBXObjectList.new(klass, @project, scoped)\n end",
"def test_lazy_fetch\n with_a_collection do\n \n # using the __class__ instance variable this looks like a Promise.\n assert_equal Lazy::Promise, @coll.last.__class__\n\n # once we check the class using #class, the result is fetched and now it's a Page.\n assert_equal QualityCenter::Defect::Page, @coll.last.class\n end\n end",
"def know_it_all(object)\n if object.class == String\n String\n elsif object.class == Fixnum\n Fixnum\n elsif object.class == Array\n Array\n elsif object.class == Hash\n Hash\n end\nend",
"def collection\n klass.collection\n end",
"def child_class\n Objekt\n end",
"def object_type\n first(FIELD_OBJECT_TYPE)\n end",
"def has_fact?(fact)\n get_fact(nil).include?(fact)\n end",
"def class\n @object.class\n end",
"def can_get_class?(klass); true; end",
"def precursors\n case body = embodied_as\n when ActiveFacts::Metamodel::ValueType\n [ body.supertype, body.unit ] +\n body.all_value_type_parameter.map{|f| f.facet_value_type } +\n body.all_value_type_parameter_restriction.map{|vr| vr.value.unit}\n when ActiveFacts::Metamodel::EntityType\n if body.fact_type\n body.fact_type.all_role.map{|r| r.object_type}\n else\n []\n end +\n # You can't define the preferred_identifier fact types until you define the entity type,\n # but the objects which play the identifying roles must be defined:\n body.preferred_identifier.role_sequence.all_role_ref.map {|rr| rr.role.object_type } +\n # You can't define the objectified fact type until you define the entity type:\n # [ body.fact_type ] # If it's an objectification\n body.all_type_inheritance_as_subtype.map{|ti| ti.supertype} # If it's a subtype\n when FactType\n body.all_role.map(&:object_type)\n when Role # We don't consider roles as they cannot be separately defined\n []\n when ActiveFacts::Metamodel::PresenceConstraint\n body.role_sequence.all_role_ref.map do |rr|\n rr.role.fact_type\n end\n when ActiveFacts::Metamodel::ValueConstraint\n [ body.role_as_role_value_constraint ? body.role_as_role_value_constraint.fact_type : nil, body.value_type ] +\n body.all_allowed_range.map do |ar|\n [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].compact.map{|b| b.value.unit}\n end\n when ActiveFacts::Metamodel::SubsetConstraint\n body.subset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type } +\n body.superset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }\n when ActiveFacts::Metamodel::SetComparisonConstraint\n body.all_set_comparison_roles.map{|scr| scr.role_sequence.all_role_ref.map{|rr| rr.role.fact_type } }\n when ActiveFacts::Metamodel::RingConstraint\n [ body.role.fact_type, body.other_role.fact_type ]\n when Instance\n [ body.population, body.object_type, body.value ? body.value.unit : nil ]\n when Fact\n [ body.population, body.fact_type ]\n when Query\n body.all_variable.map do |v|\n [ v.object_type,\n v.value ? v.value.unit : nil,\n v.step ? v.step.fact_type : nil\n ] +\n v.all_play.map{|p| p.role.fact_type }\n end\n when ContextNote\n []\n when Unit\n body.all_derivation_as_derived_unit.map{|d| d.base_unit }\n when Population\n []\n else\n raise \"ROGUE CONCEPT OF NO TYPE\"\n end.flatten.compact.uniq.map{|c| c.concept }\n end",
"def <<(stuff)\n if stuff.respond_to?(:to_ary)\n stuff.each do |thing|\n @fish << thing if thing.is_a?(SalmonObject)\n @food << thing if thing.is_a?(FishFood)\n @bubbles << thing if thing.is_a?(BubbleObject)\n @eggs << thing if thing.is_a?(EggObject)\n end\n else\n @fish << stuff if stuff.is_a?(SalmonObject)\n @food << stuff if stuff.is_a?(FishFood)\n @bubbles << stuff if stuff.is_a?(BubbleObject)\n @eggs << stuff if stuff.is_a?(EggObject)\n end\n end",
"def object_class\n @object_class\n end",
"def validate_klass!\n raise \"type can't be blank\" unless type.present?\n raise 'type must be a mergable type' unless EffectiveMergery.mergables.map(&:name).include?(type)\n raise \"invalid ActiveRecord klass\" unless klass\n raise \"invalid ActiveRecord collection\" unless collection.kind_of?(ActiveRecord::Relation)\n true\n end",
"def fact(name)\n name = canonicalize(name)\n\n # Try to load the fact if necessary\n load(name) unless @facts[name]\n\n # Try HARDER\n load_all unless @facts[name]\n\n if @facts.empty?\n logger.warnonce(\"No facts loaded from #{@internal_loader.search_path.join(File::PATH_SEPARATOR)}\")\n end\n\n @facts[name]\n end",
"def class\n object.class\n end",
"def fact(name)\n name = canonicalize(name)\n\n # Try to load the fact if necessary\n load(name) unless @facts[name]\n\n # Try HARDER\n internal_loader.load_all unless @facts[name]\n\n log.warnonce(\"No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}\") if @facts.empty?\n\n @facts[name]\n end",
"def make_object?(element)\n element && !HappyMapper::Item::Types.include?(element.type)\n end",
"def one?\n [Referenced::HasOne, Embedded::EmbedsOne].any? { |a| self.is_a?(a) }\n end",
"def test_multiples_of_other_objectable_types\n book1 = { title: 'Foobar', author: 'Mr. Foobar' }\n book2 = { title: 'Fiizbang', author: 'Miss Fizzbang' }\n books = [book1, book2]\n test_object = ObjTestClasses::TestObject.new(library: books)\n\n test_object.library.each do |library_book|\n assert_instance_of(ObjTestClasses::Book, library_book)\n end\n\n books.each do |book|\n assert_includes(test_object.library, ObjTestClasses::Book.new(book))\n end\n end",
"def __object_type \n @object_type \n end",
"def __object_type \n @object_type \n end",
"def find_cat_fact\n @fact = @cat.facts.find_by!(id: params[:id]) if @cat\n end",
"def infer_set_Object(o)\n infer(o)\n end",
"def matches?(klass); end",
"def retrieve_fact(fact_name)\n\n facts = engine.retrieve Fact\n\n facts = facts.select { |fact| fact.name == fact_name }\n\n raise \"Fact with name #{fact_name} is unknown or not yet asserted.\" if facts.empty?\n\n raise \"There is more than 1 fact (#{facts.count} total) with name #{fact_name}\" if facts.count > 1\n\n # return single fact\n facts.first\n\n end",
"def collection include_object_type=false, &block\n ASObj.generate :collection, !include_object_type, &block\n end",
"def assert_kind(expected_class, actual_object)\n expected_class = expected_class.to_s.camelize # turn the expected class into a camelized string\n actual_object = actual_object.first if actual_object.respond_to? \"each\" # check first item\n assert_equal expected_class, actual_object.class.to_s, \"expected object to be class '#{expected_class}' but was '#{actual_object.class}'\"\n end",
"def present_singular(object); nil; end",
"def isa? classname\n\t\t\tinit_classlist\n\t\t\t@cf.classlist.isa? classname\n\t\tend",
"def instance_of?(klass)\n super || object.instance_of?(klass)\n end",
"def single_vm_facts(vm, facts)\n fields = Hash[facts.collect { |fact| [fact.to_sym, 1] }]\n collection = connection[vms_collection]\n result = collection.find(_id: vm).limit(1).batch_size(1).projection(fields).to_a.first\n result.delete(\"_id\") if result\n result\n end",
"def is_fact?\n false\n end",
"def resource_class\n if any?\n first.class\n else\n raise ArgumentError, 'Cannot determine resource class on empty collection'\n end\n end",
"def determine_class(obj)\n case obj\n when Hacker\n puts \"It's a Hacker!\"\n when Submission\n puts \"It's a Submission!\"\n when TestCase\n puts \"It's a TestCase!\"\n when Contest\n puts \"It's a Contest!\"\n else\n puts \"It's an unknown model\"\n end\nend",
"def facts\n @facts ||= {}\n end",
"def obj\n return if obj_type.blank?\n return obj_type.constantize.find(obj_id) if obj_id.present?\n obj_type[/[A-Z]/] ? obj_type.constantize : obj_type.to_sym\n end",
"def collection_class\n OneToMany::Collection\n end",
"def collection_class\n OneToMany::Collection\n end",
"def value_in_class(clazz) value end",
"def cast\n Kernel.const_get(objeto_classe).find(objeto_id)\n end",
"def initialize(fact_class)\r\n @fact_class = fact_class\r\n end",
"def make_fact_type vocabulary\n fact_type = vocabulary.constellation.FactType(:new)\n trace :matching, \"Making new fact type for #{@phrases.inspect}\" do\n @phrases.each do |phrase|\n next unless phrase.respond_to?(:player)\n phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :object_type => phrase.player, :concept => :new)\n phrase.role.role_name = phrase.role_name if phrase.role_name && phrase.role_name.is_a?(String)\n end\n end\n fact_type\n end",
"def has_any? klass\n not find_all(\"class\", klass).empty?\n end",
"def is_one_of?(*classes)\n !!classes.find{|c| is_a?(c)}\n end",
"def starting_objects_class\n starting_objects.first.class rescue nil\n end",
"def same_type(obj_one, obj_two)\n\n if obj_one.class == obj_two.class\n return true\n else\n return false\n end\n\nend",
"def get_class_for_fedora_object(fobj)\n if fobj.datastreams['DC'] && fobj.datastreams['DC'].dc_type\n obj_dc_type = fobj.datastreams['DC'].dc_type # returned dc_type is an array\n\n # These methods defined in DigitalObject::Fedora::Detect\n # Ultimately should be moved to the subclasses themselves.\n type_map = {\n DigitalObject::Item => method_as_proc(:detect_item),\n DigitalObject::Asset => method_as_proc(:detect_asset),\n DigitalObject::Group => method_as_proc(:detect_group),\n DigitalObject::FileSystem => method_as_proc(:detect_file_system),\n DigitalObject::PublishTarget => method_as_proc(:detect_publish_target)\n }\n mapped_type = type_map.detect { |_candidate, detector| detector.call(fobj, obj_dc_type) }\n return mapped_type.first if mapped_type\n end\n\n raise \"Cannot determine Hyacinth type for fedora object #{fobj.pid} with class #{fobj.class} and dc_type: #{fobj.datastreams['DC'].dc_type}\"\n end",
"def type\n return self.class.type # all instances of a class have the same type\n end",
"def object_type object\n object.class.to_s.underscore\n end",
"def supports?(another_object)\n another_object.class.ancestors.include?(ActivityFeed::Serializable) &&\n instance[another_object.class.af_type_id.to_sym]\n end",
"def load_commentable_collection\n if @commentable.is_a?(Kata)\n @commentable_collection = @commentable.reviews\n else\n @commentable_collection = @commentable.comments\n end\n end",
"def find_and_cast_into_type(klass, data)\n return if data.nil?\n\n case klass.to_s\n when 'Boolean'\n return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)\n when 'Float'\n return data if data.instance_of?(Float)\n when 'Integer'\n return data if data.instance_of?(Integer)\n when 'Time'\n return Time.parse(data)\n when 'Date'\n return Date.parse(data)\n when 'String'\n return data if data.instance_of?(String)\n when 'Object' # \"type: object\"\n return data if data.instance_of?(Hash)\n when /\\AArray<(?<sub_type>.+)>\\z/ # \"type: array\"\n if data.instance_of?(Array)\n sub_type = Regexp.last_match[:sub_type]\n return data.map { |item| find_and_cast_into_type(sub_type, item) }\n end\n when /\\AHash<String, (?<sub_type>.+)>\\z/ # \"type: object\" with \"additionalProperties: { ... }\"\n if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }\n sub_type = Regexp.last_match[:sub_type]\n return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }\n end\n else # model\n const = Fastly.const_get(klass)\n if const\n if const.respond_to?(:fastly_one_of) # nested oneOf model\n model = const.build(data)\n return model if model\n else\n # raise if data contains keys that are not known to the model\n raise unless (data.keys - const.acceptable_attributes).empty?\n model = const.build_from_hash(data)\n return model if model && model.valid?\n end\n end\n end\n\n raise # if no match by now, raise\n rescue\n raise SchemaMismatchError, \"#{data} doesn't match the #{klass} type\"\n end",
"def subfield_x_object_type\n return { code: 'x', value: 'item' } if cocina_object.dro?\n\n { code: 'x', value: 'collection' } if cocina_object.collection?\n end",
"def association?(object, associations); end",
"def classify(obj=[])\n if obj.is_a? Airtable::Record\n [self.new(obj.fields)]\n elsif obj.respond_to? :map\n obj.map{|r| self.new(r.fields) }\n else\n raise AlienObject.new(\"Object is neither an array nor an Airtable::Model\")\n end\n end",
"def klass\n case type\n when :integer then Fixnum\n when :float then Float\n when :decimal then BigDecimal\n when :datetime then Time\n when :date then Date\n when :timestamp then Time\n when :time then Time\n when :text, :string then String\n when :binary then String\n when :boolean then Object\n end\n end",
"def test_item_should_be_of_proper_type\n assert_kind_of Product, items(:uranium_portion)\n assert_kind_of Product, items(:lightsaber)\n assert_kind_of Product, items(:holy_grenade)\n assert_kind_of Product, items(:chinchilla_coat)\n assert_kind_of Product, items(:towel)\n assert_kind_of Product, items(:the_stuff)\n end",
"def cats\n #loop through .all class method for the class Cat\n #select the value for variable cat and return it to a new array\n #every time cat.owner == self is true\n Cat.all.select do |cat|\n #block determines true value\n cat.owner == self #returns if true\n end\n end",
"def collection?\n @object.is_a?(Enumerable) && !@object.is_a?(Struct)\n end",
"def find_and_cast_into_type(klass, data)\n return if data.nil?\n\n case klass.to_s\n when 'Boolean'\n return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)\n when 'Float'\n return data if data.instance_of?(Float)\n when 'Integer'\n return data if data.instance_of?(Integer)\n when 'Time'\n return Time.parse(data)\n when 'Date'\n return Date.parse(data)\n when 'String'\n return data if data.instance_of?(String)\n when 'Object' # \"type: object\"\n return data if data.instance_of?(Hash)\n when /\\AArray<(?<sub_type>.+)>\\z/ # \"type: array\"\n if data.instance_of?(Array)\n sub_type = Regexp.last_match[:sub_type]\n return data.map { |item| find_and_cast_into_type(sub_type, item) }\n end\n when /\\AHash<String, (?<sub_type>.+)>\\z/ # \"type: object\" with \"additionalProperties: { ... }\"\n if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }\n sub_type = Regexp.last_match[:sub_type]\n return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }\n end\n else # model\n const = EgoiRubyClient.const_get(klass)\n if const\n if const.respond_to?(:openapi_one_of) # nested oneOf model\n model = const.build(data)\n return model if model\n else\n # raise if data contains keys that are not known to the model\n raise unless (data.keys - const.acceptable_attributes).empty?\n model = const.build_from_hash(data)\n return model if model && model.valid?\n end\n end\n end\n\n raise # if no match by now, raise\n rescue\n raise SchemaMismatchError, \"#{data} doesn't match the #{klass} type\"\n end",
"def correct_type?(object)\n object.type == type\n end",
"def case_type\n object\n end",
"def new_collection\n primitive.new\n end",
"def identify_class(obj)\n puts case obj.class\n when Hacker\n \"It's a Hacker!\"\n when Submission\n \"It's a Submission!\"\n when TestCase\n \"It's a TestCase!\"\n when Contest\n \"It's a Contest!\"\n else\n \"It's an unknown model\"\n end\nend",
"def have_one(model)\n HasOneReflection.new model\nend",
"def type\n @type ||= if model.column_names.include?(@name)\n TYPES[:degenerate]\n elsif association\n TYPES[:standard]\n else\n raise UnknownDimension, \"Dimension '#{@name}' not found on fact model '#{@fact_model}'\"\n end\n end",
"def get_facts\r\n @facts\r\n end",
"def test_truth\r\n assert_kind_of FaqCategory, @faq_category\r\n end",
"def is_a?(thing)\n kind_of?(thing)\n end",
"def objects; end",
"def collection\n feature_id = nil\n if params[:feature_id]\n feature_id = params[:feature_id]\n elsif params[:id]\n feature_id = object.feature_id\n end\n if params[:filter].blank? && !feature_id.blank?\n search_results = parent_object.definitions\n elsif !params[:filter].blank?\n search_results = Definition.search(params[:filter])\n search_results = search_results.where(:feature_id => feature_id) if feature_id\n else\n search_results = []\n end\n @collection = search_results.empty? ? search_results : search_results.page(params[:page])\n end",
"def object_class\n self.class.object_class\n end",
"def coerce(value)\n coerced = super\n return coerced unless coerced.respond_to?(:each_with_object)\n coerced.each_with_object(new_collection) do |entry, collection|\n coerce_and_append_member(collection, entry)\n end\n end",
"def first; self.objects.first end"
] |
[
"0.61535436",
"0.6050221",
"0.57339996",
"0.5546405",
"0.5408621",
"0.53951824",
"0.53747165",
"0.5359557",
"0.53043044",
"0.5302296",
"0.5268773",
"0.52346116",
"0.51863056",
"0.51644444",
"0.5158612",
"0.5130518",
"0.51115173",
"0.510841",
"0.51074904",
"0.5098112",
"0.5089162",
"0.5078384",
"0.50769234",
"0.50769234",
"0.5037874",
"0.5036765",
"0.50332695",
"0.5032428",
"0.50204164",
"0.50178635",
"0.50161296",
"0.5012494",
"0.500831",
"0.50054574",
"0.4995983",
"0.49825084",
"0.49815148",
"0.4979575",
"0.49785876",
"0.49646083",
"0.49638996",
"0.495449",
"0.49510065",
"0.49486926",
"0.49418384",
"0.49373144",
"0.49373144",
"0.49352255",
"0.49330914",
"0.49081838",
"0.49032092",
"0.49003136",
"0.48973635",
"0.4893045",
"0.48859408",
"0.48814726",
"0.48793766",
"0.48759344",
"0.487511",
"0.48708233",
"0.4870277",
"0.48690993",
"0.48655334",
"0.48655334",
"0.4864168",
"0.48588702",
"0.48573586",
"0.48537838",
"0.48527575",
"0.48481312",
"0.48434138",
"0.4832356",
"0.48263317",
"0.4823796",
"0.4821376",
"0.4813088",
"0.4810754",
"0.4807916",
"0.48065633",
"0.48057422",
"0.47987482",
"0.47980645",
"0.479225",
"0.47863317",
"0.47814253",
"0.4775489",
"0.47721916",
"0.47708666",
"0.47701913",
"0.47589347",
"0.47554603",
"0.47553745",
"0.47508287",
"0.4747035",
"0.4730954",
"0.4730688",
"0.47304806",
"0.47299084",
"0.4727761",
"0.47144285"
] |
0.6582
|
0
|
Delete all existing facts
|
def delete_facts
@facts = {}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def delete_all\n @configuration = nil\n end",
"def delete_all\n @configuration = nil\n end",
"def delete_all\n target.clear\n end",
"def destroy_all\n all.each(&:destroy)\n end",
"def delete_all\n self.store.delete_keys(find_keys)\n end",
"def destroy_all\n all.each do |n|\n n.destroy\n end\n end",
"def destroy_all\n all.each(&:destroy)\n end",
"def flush\n @facts.each { |name, fact| fact.flush }\n end",
"def remove_facts(data)\n record_id = assert_record_id(data)\n delete_facts_record record_id, data\n end",
"def delete_all\n self.destroy\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each {|x| x.delete_all}\n end",
"def delete_all\n records.clear\n end",
"def delete_all!\n delete(query: \"*:*\")\n end",
"def clear_all()\n User.destroy_all\n Hashtag.destroy_all\n Mention.destroy_all\n Tweet.destroy_all\n Follow.destroy_all\n # Hashtag_tweets.destroy_all\nend",
"def flush\n @facts.each { |_name, fact| fact.flush }\n @external_facts_loaded = nil\n end",
"def delete_all\n @reflection.through_reflection.klass.delete_all(@reflection.through_reflection.primary_key_name => @owner.id)\n reload\n end",
"def clear_all_in_database\n Tweet.destroy_all\n User.destroy_all\n Follow.destroy_all\n end",
"def clear_all_in_database\n Tweet.destroy_all\n User.destroy_all\n Follow.destroy_all\n end",
"def delete_existing\n Answer.delete_all\n Question.delete_all\n Knock.delete_all\n Door.delete_all\n Canvasser.delete_all\nend",
"def delete_all(name); end",
"def delete_all\n @objects.each do |o|\n o.delete \n end\n\n @objects.clear\n end",
"def delete_all(table)\n\t\t\t\ttable.clear\n\t\t\tend",
"def destroy_all\n each(&:destroy_all)\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each(&:delete_all)\n end",
"def purge_associations\n EspRulesList.where(list_type: type, list_id: id).delete_all\n ExportedLead.where(list_type: type, list_id: id).delete_all\n MessageAutoResponse.where(esp_list_type: type, esp_list_id: id).delete_all\n end",
"def clear_database\n User.destroy_all\n Animal.destroy_all\n Report.destroy_all\nend",
"def delete_all\n klass.delete_all(:conditions => selector)\n end",
"def wipe!\n resource_factory.orm_class.delete_all\n end",
"def clean_cached_facts(node)\n Puppet::Node::Facts.indirection.destroy(node)\n Puppet.info \"#{node}'s facts removed\"\n end",
"def clean_database\n [Entry, Room, User].each do |model|\n model.delete_all\n end\nend",
"def destroy_all\n destroy_users\n puts \"Destroyed users\"\n destroy_comments\n puts \"Destroyed comments\"\n destroy_costs\n puts \"Destroyed costs\"\n destroy_service_locations\n puts \"Destroyed service locations\"\n destroy_service_contacts\n puts \"Destroyed service contacts\"\n destroy_services\n puts \"Destroyed services\"\n destroy_service_types\n puts \"Destroyed service types\"\n destroy_locations\n puts \"Destroyed locations\"\n destroy_contacts\n puts \"Destroyed contacts\"\n destroy_categories\n puts \"Destroyed categories\"\n end",
"def delete_all(session=nil)\n start_kvs_session(session) do |kvs|\n kvs.delete_all\n end\n end",
"def clean!\n FAKEABLE.map(&:constantize).map(&:destroy_all)\n end",
"def delete_all(attributes = {})\n raise NotImplementedError.new\n end",
"def delete_all\n sum(&:delete_all)\n end",
"def clear_db\n DB.from(\"mentees\").delete\n DB.from(\"mentors\").delete\n DB.from(\"admins\").delete\n DB.from(\"users\").delete\n DB.from(\"codes\").delete\n DB.from(\"requests\").delete\n DB.from(\"questions_answers\").delete\nend",
"def destroy_all\n klass.destroy_all(:conditions => selector)\n end",
"def destroy_everything\n Event.destroy_all\n Hotel.destroy_all\n Amenity.destroy_all\n Article.destroy_all\n User.destroy_all\nend",
"def delete_all\n delete_if { |b| true }\n end",
"def delete_all\n store.delete(KEY)\n self\n end",
"def clear_db\n users = User.all\n users.delete_all\n companies = Company.all\n companies.delete_all\n feedbacks = Feedback.all\n feedbacks.delete_all\n co_emp = CompanyEmployee.all\n co_emp.delete_all\n projects = Project.all\n projects.delete_all\n proj_fb = ProjectFeedback.all\n proj_fb.delete_all\nend",
"def delete_all\n\t\t\t@@driver.delete_all\n\t\tend",
"def delete_all(klass)\n sql = \"DELETE FROM #{klass.table}\"\n sql << \" WHERE ogtype='#{klass}'\" if klass.schema_inheritance? and not klass.schema_inheritance_root?\n exec sql\n end",
"def delete_all(klass)\n raise \"Not implemented\"\n end",
"def deleteAll(xs)\n xs.each do |x|\n x.destroy\n end\n end",
"def destroy_everything\n destroy_user_key_columns\n destroy_user_key_organizations\n destroy_whitelists\n destroy_approvals\n destroy_user_keys\n destroy_users\n destroy_comments\n destroy_filters\n destroy_columns\n destroy_organizations\n end",
"def delete_all\n Nvmkv.kv_delete_all(@kv_id)\n end",
"def clear_rdf\n ActiveRDF::FederationManager.delete_all(self)\n end",
"def destoy_old_factors\r\n User_factor.all.each do |factor|\r\n factor.destroy\r\n end\r\n\r\n Film_factor.all.each do |factor|\r\n factor.destroy\r\n end\r\n\r\n Factor.all.each do |factor|\r\n factor.destroy\r\n end\r\n end",
"def delete_all_attributes\n model = Sketchup.active_model\n model.definitions.each { |d|\n delete_attributes(d.instances)\n }\n dicts = model.attribute_dictionaries\n if dicts\n dicts.delete('MSPhysics')\n dicts.delete('MSPhysics Sounds')\n dicts.delete('MSPhysics Replay')\n end\n end",
"def delete_all\n begin\n db.execute \"TRUNCATE TABLE #{table}\"\n\n rescue SQLite3::Exception => e\n puts \"Database Exception occured\"\n puts e\n \n ensure\n db.close if db\n end\n end",
"def purge\n\n DataMapper.repository(@dm_repository) {\n\n DmExpression.all.each { |de| de.destroy }\n #\n # TODO : find simpler way to do that\n }\n end",
"def clear_all\n data.delete_all\n self\n end",
"def delete_all_targets\n\t\tTarget.delete_all\n\tend",
"def incomplete_delete\n incomplete.delete_all\n end",
"def clear_all_fixtures\n Company.destroy_all\n end",
"def teardown\n Allergy.destroy_all\n Recipe.destroy_all\n Ingredient.destroy_all\n end",
"def delete_all_recipes(db)\n q = \"DELETE FROM recipes;\"\n return db.execute(q)\nend",
"def clear_all_tags()\n puts \"Deleting Tags...\"\n Tag.delete_all()\n puts \"Finished deleting all tags.\"\nend",
"def delete_all\n solr.delete_by_query('*:*')\n solr.commit\n end",
"def delete_all\n ActiveRecord::Base.send( :subclasses ).each do |subclass|\n if subclass.table_exists? && subclass.respond_to?(:delete_all)\n subclass.delete_all\n end\n end\n end",
"def clear_all_training_data\n @redis.flushdb\n end",
"def destroy_all\n destroy(load_target).tap do\n reset\n loaded!\n end\n end",
"def delete_all\n\t Bill.delete_all\n\t Cosponsorship.delete_all\n\t Representative.delete_all\n\t Event.delete_all\n\t RollCall.delete_all\n\t redirect_to :action => \"index\"\n\tend",
"def delete_all(conditions = \"\")\n collection.remove(XGen::SQL::Parser.parse_where(conditions, true) || {})\n end",
"def purge!\n Document.delete_all\n end",
"def delete\n\t\tcurrent_user\n\t\tcurrent_user.regexpressions.destroy_all\n\t\tcurrent_user.tasks.destroy_all\n\t\tcurrent_user.clouds.destroy_all\n\t\tcurrent_user.platforms.destroy_all\n\t\tcurrent_user.demos.destroy_all\n\t\tcurrent_user.favorites.destroy_all\n\tend",
"def delete_all\n refresh_index!\n Elasticsearch::Persistence.client.delete_by_query(\n index: alias_name,\n conflicts: :proceed,\n body: { query: { match_all: {} } }\n )\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def destroy_all(conditions = nil)\n find_all(conditions).each { |object| object.destroy }\n end",
"def clear_all\n Test.all.each do |test|\n test.clear_all\n test.save\n end\n \n redirect_to admin_root_path\n end",
"def delete_all\n neo4j_query(\"MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r\")\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find_by_id(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def delete_all\n Neo.db.execute_query(\"#{initial_match} OPTIONAL MATCH (n0)-[r]-() DELETE n0,r\")\n end",
"def truncate_all\n Content::Version.all.map(&:destroy)\n ContentKey::Version.all.map(&:destroy)\n Content.all.map(&:destroy)\n ContentKey.all.map(&:destroy)\n end",
"def clear\n @already_searched = {}\n Facter.clear_messages\n LegacyFacter.clear\n Options[:custom_dir] = []\n LegacyFacter.collection.invalidate_custom_facts\n LegacyFacter.collection.reload_custom_facts\n SessionCache.invalidate_all_caches\n nil\n end",
"def cleanup\n self.objectives.destroy_all\n end",
"def destroy_all\n begin\n Location.destroy_all\n Affiliation.destroy_all\n Person.destroy_all\n\n render json: {\n success: 'Deleted all data successfully'\n }\n rescue => e\n render json: {\n error: e\n }\n end\n end",
"def delete_all\n objs = target\n source.update_attribute(source_attribute, nil)\n objs.each(&:delete)\n end",
"def erase_all\n entities_to_erase = []\n for entity in Sketchup.active_model.entities\n entities_to_erase.push entity\n end\n\n for entity in entities_to_erase\n if entity.valid?\n entity.erase!\n end\n end\n end",
"def finalize\n Pez.destroy_all\n Comida.destroy_all\n Tiburon.destroy_all\n end",
"def delete_all_statements!\n delete_statements!({}, false)\n end",
"def clear_database_table\n <%= class_name %>.delete_all\n end",
"def destroy\n has_many_columns.each do |col|\n delete_candidates = self.send(col.name)\n\n delete_candidates.each do |candidate|\n candidate.delete if col.destroy == :delete\n candidate.destroy if col.destroy == :destroy\n end\n end\n delete\n end",
"def purge_db\n\tUser.delete_all\n\tSubscription.delete_all\n\tDorkus.delete_all\nend",
"def destroy_simple_game\n Zone.destroy_all\n ZoneHolder.destroy_all\n User.destroy_all\n Team.destroy_all\n Task.destroy_all\n Hint.destroy_all\n Code.destroy_all\n CodeString.destroy_all\n TeamCode.destroy_all\n TeamHint.destroy_all\n Log.destroy_all\n Game.destroy_all\nend",
"def delete_all(condition=nil)\n if condition\n query(\"DELETE FROM #{SmartSession::SqlSession.table_name} WHERE #{condition}\")\n else\n query(\"DELETE FROM #{SmartSession::SqlSession.table_name}\")\n end\n end",
"def clean_database\n models = [Comment, Article, Admin, User]\n if ENV['AN_USE_EXISTING_DYNAMODB_TABLE']\n ActivityNotification::Notification.where('id.not_null': true).delete_all\n ActivityNotification::Subscription.where('id.not_null': true).delete_all\n else\n models.concat([ActivityNotification::Notification, ActivityNotification::Subscription])\n end\n models.each do |model|\n model.delete_all\n end\nend",
"def destroy\n all.each { |file| FileUtils.rm_f(file) }\n end",
"def destroy; delete end",
"def clean\n\t\t\n\t\t@db.del 'twitter'\n\t\t@db.del 'rpg'\n\t\n\tend",
"def clear\n if namespace\n keys.each do |key|\n delete(key)\n end\n delete(KEYS_ADDRESS)\n else\n database.clear\n end\n end",
"def delete_all_targets\n\t\tWmapTarget.delete_all\n\tend",
"def delete_amorts\n self.amortizations.delete_all\n end",
"def delete_all\n @owner.transaction do\n self.each { |obj| obj.delete }\n end\n @members.clear\n end",
"def clear(collection)\n blk = Proc.new {}\n query(collection, blk).each { |entity| delete(collection, entity) }\n end",
"def destroy\n save_graph = RDF::Graph.new\n fill_save_graph save_graph\n save_graph.each do |s|\n puts s.inspect\n end\n Db.delete_data( save_graph, :graph => klass.object_graph )\n end",
"def delete_all(xpath); end",
"def delete_all\n User.delete_all\nend",
"def nuke\n self.open_graph_event.destroy unless self.open_graph_event.nil?\n self.teamsheet_entries.destroy_all\n self.messages.destroy_all\n self.activity_items.destroy_all\n self.result.destroy unless self.result.nil?\n self.destroy\n end"
] |
[
"0.72164387",
"0.72164387",
"0.7179863",
"0.7125613",
"0.7121009",
"0.71049255",
"0.7014218",
"0.6972486",
"0.6937076",
"0.6912945",
"0.6873016",
"0.68672895",
"0.6845922",
"0.6832502",
"0.6822878",
"0.68077195",
"0.6805079",
"0.6805079",
"0.6787817",
"0.67664945",
"0.6731538",
"0.67246234",
"0.66813475",
"0.66802037",
"0.6676212",
"0.66504383",
"0.663215",
"0.6619185",
"0.66034496",
"0.6596408",
"0.6591365",
"0.65816164",
"0.65617204",
"0.65345144",
"0.6519367",
"0.65186036",
"0.65161467",
"0.64996016",
"0.6497617",
"0.6491761",
"0.64873767",
"0.64692986",
"0.64648086",
"0.6437639",
"0.6431491",
"0.64280325",
"0.6417078",
"0.64127755",
"0.639353",
"0.6389073",
"0.6365358",
"0.6342558",
"0.63416845",
"0.63327104",
"0.63315773",
"0.63207626",
"0.6307203",
"0.6307002",
"0.6304101",
"0.6299858",
"0.6295324",
"0.62909204",
"0.6286056",
"0.6274828",
"0.62730634",
"0.62698776",
"0.6268689",
"0.62529165",
"0.62441427",
"0.6229455",
"0.62212586",
"0.6220779",
"0.62189317",
"0.6216065",
"0.62134635",
"0.6209847",
"0.6206978",
"0.62042606",
"0.6200072",
"0.6196326",
"0.6195496",
"0.6194611",
"0.61644256",
"0.6156438",
"0.6149169",
"0.6139698",
"0.61297673",
"0.61284363",
"0.6125276",
"0.6124861",
"0.6119403",
"0.61052376",
"0.6105179",
"0.61032665",
"0.6101607",
"0.6096168",
"0.6092528",
"0.6067904",
"0.6060885",
"0.60557973"
] |
0.84084576
|
0
|
Use in conjunction with Rools::RuleSetwith to create a Rools::Rule dependent on another. Dependencies are created through names (converted to strings and downcased), so lax naming can get you into trouble with creating dependencies or overwriting rules you didn't mean to.
|
def extend(name, &b)
name.to_s.downcase!
@extend_rule_name = name
instance_eval(&b) if block_given?
return self
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def rule!(name, opts = {}, &definition)\n rule(name, opts) { self.instance_eval(&definition).as(name) }\n end",
"def set_dependency(res_name1, res_name2)\n check_freeze\n validate_arg = proc {|o|\n o = Util.build_const(o) if o.is_a? String\n raise ArgumentError unless o.is_a?(Class) && o <= Resource\n raise \"This is not a member of this cluster \\\"#{self.class}\\\": #{o}\" unless resources.member?(o.id)\n raise \"Unknown resource object: #{o}\" unless Resource.exists?(o.id)\n o\n }\n \n res_name1 = validate_arg.call(res_name1)\n res_name2 = validate_arg.call(res_name2)\n \n return if res_name1.id == res_name2.id\n\n self.dg.set_dependency(res_name1, res_name2)\n end",
"def rule_set(ref, val)\n rule_table.set(setup_package_id(ref), val)\n end",
"def make_reference(package_id, name)\n RuleExpr.new(name, package_id)\n end",
"def rule(name, *productions)\n registry.define_rule(name, caller_locations.first, productions)\n end",
"def add(rule); end",
"def rule(pattern, *dependencies, &block)\n if block.nil?\n Rule.new(pattern, *dependencies)\n else\n Rule.new(pattern, *dependencies) do |rule|\n rule.define(&block)\n end\n end\n end",
"def add_rule( rule )\n type_check( rule, Elements::Rule )\n assert( !name_defined?(rule.name), \"name [#{rule.name}] is already in use\" )\n \n @rules[rule.name] = rule\n end",
"def add_dependencies(dependent, source)\n source.each do |dependency|\n dependents = @dependencies.fetch(dependency, [])\n # some fields may point at the same dependency,\n # to avoid duplicate validation the dependency\n # becomes the pointer to any dependent fields\n # e.g., dependency => [ dependent, dependent, ... ]\n @dependencies[dependency] = dependents.push(dependent)\n end\n end",
"def subrule(aRulename)\n\t\treturn ApplySubrule.new(aRulename)\n\tend",
"def add(name:, depends_on:, **kwargs)\n check_for_missing_dependencies!(depends_on)\n graph[name] = dependency_class.new(kwargs.merge(name: name, depends_on: depends_on))\n end",
"def rule(name, *productions)\n define_rule(name, caller_locations.first, productions)\n end",
"def rule(name, obj=nil)\n sym = name.to_sym\n obj = Proc.new.call if block_given?\n\n if obj\n rule_names << sym unless has_rule?(sym)\n\n rule = Rule.create(obj)\n rule.name = name\n setup_super(rule, name)\n rule.grammar = self\n\n rules[sym] = rule\n end\n\n rules[sym] || super_rule(sym)\n rescue => e\n raise \"Cannot create rule \\\"#{name}\\\": \" + e.message\n end",
"def rules_by_name; end",
"def dependent; end",
"def dependent; end",
"def add_dependency(dependency)\n unless has_dependency?(dependency.name, dependency.constraint)\n @dependencies[Graph.key_for(dependency)] = dependency\n end\n\n get_dependency(dependency.name, dependency.constraint)\n end",
"def rule(name, &definition)\n r = DSL::Rule.new name\n r.instance_eval(&definition)\n @rules << r\n r\n end",
"def define_rule(name, trace, productions)\n symbol = name.to_sym\n\n # TODO: this could be tidied up by consolidating parsing in a single class\n branch = Rule.build_ast(productions, self)\n\n # If the static rule is a map of k=>v pairs then add it to the lookup dict\n if branch.is_a?(Production::AffixTable)\n dicts[symbol] = branch\n else\n rules[symbol] = Rule.new(symbol, branch, trace)\n end\n end",
"def dependent=(_arg0); end",
"def dependent=(_arg0); end",
"def depends(name, constraint = \">= 0\")\n if name.nil?\n raise ArgumentError, \"A name must be specified. You gave: #{args}.\"\n end\n\n dependency = Dependency.new(self, name, constraint)\n add_dependency(dependency)\n\n self\n end",
"def rule(val); @rule = val; self; end",
"def define_rule(key, *required_object_types, &block)\n if all_defined_rules[key.to_sym]\n raise Checken::Error, \"Rule #{key} has already been defined\"\n else\n rule = Rule.new(key, &block)\n required_object_types.each { |rot| rule.required_object_types << rot }\n @defined_rules[key.to_sym] = rule\n rule\n end\n end",
"def name_rule( base_name, subrule = false )\n name = base_name.is_a?(Name) ? base_name.name : base_name\n \n if subrule then\n attempt = [\"#{name}__subrule_\", 1]\n attempt[1] += 1 while @rule_defs.member?(attempt.join(\"\"))\n \n name = attempt.join(\"\")\n end\n \n return create_name(name)\n end",
"def dependency_constraint(attribute_name, dependent_attribute_names, options = {}, &block)\n constraint = DependencyConstraint.new(self, attribute_name, dependent_attribute_names, options, &block)\n error(\"Dependency constraint #{constraint.name} on #{self.name} has an illegal non nullable attribute\") if !attribute_by_name(attribute_name).nullable?\n dependent_attribute_names.collect { |a| attribute_by_name(a) }.each do |a|\n error(\"Dependency constraint #{constraint.name} on #{self.name} has an illegal non nullable dependent attribute\") if !a.nullable?\n end\n add_unique_to_set(\"dependency\", constraint, @dependency_constraints)\n end",
"def dependencies(ctx)\n @i_name ||= ctx.lookup(name).i_name\n s = Set.new\n s << i_name\n s\n end",
"def set_rule_name(opts)\n opts = check_params(opts,[:rule_names])\n super(opts)\n end",
"def rule\n ['$(LD)', flags, '$(LDFLAGS)', @objects, sorted_ldadd, '$(LDADD)'].flatten.join(' ')\n end",
"def node_rule rule:\n label = make_label rule.values\n attrs = rule # assign all rule attributes\n\n add_node :Rule, label, attrs\n end",
"def rule(aName, aBeforeAction = nil, &aBlock)\n\t\tnew_rule = StandardRule.new(aName, aBeforeAction)\n\t\tprocess_rule(new_rule, &aBlock)\n\tend",
"def new_rule(rule)\n Rule.new(rule)\n end",
"def required_by(dependency, dependent_name)\n dependencies_by_requirer_name[dependent_name] ||= []\n dependencies_by_requirer_name[dependent_name] << dependency\n dependencies << dependency\n\n if acceptable_versions.empty?\n message = \"Unable to satisfy the following requirements:\\n\\n\"\n dependencies_by_requirer_name.each do |name, dependencies|\n dependencies.each do |dep|\n message << \"- `#{dep}` required by `#{name}`\\n\"\n end\n end\n raise Informative, message\n end\n end",
"def define(*args, &block)\n NamedRules.new(*args, &block)\n end",
"def add_rule(rhs)\n nonterm = '~[' + @nonterm.succ! + ']'\n @rules[nonterm] = rhs\n nonterm\n end",
"def add_dependencies\n self.extra_deps = normalize_deps extra_deps\n self.extra_dev_deps = normalize_deps extra_dev_deps\n\n case name\n when \"hoe\" then\n # do nothing? these deps are already in the hoe spec in the Rakefile\n else\n version = VERSION.split(/\\./).first(2).join(\".\")\n dependency \"hoe\", \"~> #{version}\", :development\n end\n\n seen = {}\n\n extra_deps.each do |dep|\n next if seen[dep.first]\n seen[dep.first] = true\n\n spec.add_dependency(*dep)\n end\n\n extra_dev_deps.each do |dep|\n next if seen[dep.first]\n seen[dep.first] = true\n\n spec.add_development_dependency(*dep)\n end\n end",
"def add_dependency(source, dependency)\n unless same_file? dependency, source\n dependencies << [dependency, source]\n end\n end",
"def dependency_name\n name.to_s.sub(/_factory$/, '').to_sym\n end",
"def depends_on( other_dependency )\n namespace name do\n task :build => \"#{other_dependency}:done\"\n end\n end",
"def add_dependency(path, dependency); end",
"def depends_on(*depends)\n new_dependencies = depends.map { |obj| obj.dependency? ? obj.links : Set[obj] }\n .reduce(&:merge)\n\n new_dependencies.select! { |obj| obj.root == root } unless root.nil?\n dependencies.merge(new_dependencies)\n self\n end",
"def rule; end",
"def rule; end",
"def rule; end",
"def add_dependent obj\n $log.debug \" ADDING DEPENDE #{obj}\"\n @dependents ||= []\n @dependents << obj\n end",
"def add_dependency(dependency)\n unrealize\n dependencies.push(dependency)\n dependency.dependents.push(self)\n dependency\n end",
"def rule(name, obj=nil, &block)\n sym = name.to_sym\n obj = block.call if block\n\n if obj\n rule_names << sym unless has_rule?(sym)\n\n rule = Rule.for(obj)\n rule.name = name\n setup_super(rule, name)\n rule.grammar = self\n\n rules[sym] = rule\n end\n\n rules[sym] || super_rule(sym)\n rescue => e\n e.message.replace(\"Cannot create rule \\\"#{name}\\\": #{e.message}\")\n raise e\n end",
"def add_dependency(name)\n dependencies[name]\n end",
"def add_rule(rule)\n @rulebook.add_rule rule\n end",
"def add_dependency(depender, dependency)\n if using_rake?\n if !task_defined?(depender)\n fail \"Could not locate a Rake task named '#{depender.to_s}' to add a dependency of '#{dependency.to_s}' to\"\n elsif !task_defined?(dependency)\n fail \"Could not locate a Rake task named '#{dependency.to_s}' to add as a dependency of '#{depender.to_s}'\"\n else\n depender_task = Rake::Task[depender]\n depender_task.enhance([dependency])\n end\n end\n end",
"def depend_upon(match_name) #, constraint)\n $LOAD_MANAGER.depend_upon(match_name) #, constraint)\n end",
"def depends *syms\n syms.each { |sym| raise ArgumentError, \"unknown option '#{sym}'\" unless @specs[sym] }\n @constraints << [:depends, syms]\n end",
"def setFromRule(r)\n @amp_rule = AmpRule.new\n # Set the coherence\n dummy = \"\"\n r.coherenceRule.split('.').each do |x|\n foundOne = false\n dumname = name.sub('.amps', '')\n dumname.scan(ampRe).each do |i|\n if i[0] == x\n dummy += i[1] + \".\"\n foundOne = true\n end\n end\n if !foundOne\n dummy += x + \".\"\n end\n end\n @amp_rule.coherenceRuleSet(dummy.chop)\n\n # Set the pars\n count = 0\n while count < r.parRules.size \n dummy = \"\"\n # Loop over the par rules terms\n r.parRules[count].terms[\"definition\"].split('.').each do |x|\n foundOne = false\n # Loop over the amp name and grab what we will\n dumname = name.sub('.amps', '')\n dumname.scan(ampRe).each do |i|\n if i[0] == x\n dummy += i[1] + \".\"\n foundOne = true\n end\n end\n if !foundOne\n dummy += x + \".\"\n end\n end\n # Set the new names\n @amp_rule.parRuleAdd(\"definition\"=>dummy.chop, \n \"free?\"=>r.parRules[count].terms[\"free?\"], \n \"range\"=>r.parRules[count].terms[\"range\"], \n \"step\"=>r.parRules[count].terms[\"step\"], \n \"par\"=>r.parRules[count].terms[\"par\"], \n \"dpar\"=>r.parRules[count].terms[\"dpar\"] )\n count+=1\n end\n end",
"def resolve!\n rule = grammar.rule(rule_name)\n\n unless rule\n raise Error, \"No rule named \\\"#{rule_name}\\\" in grammar #{grammar}\"\n end\n\n rule\n end",
"def reverse_dependencies()\n\n a = LineTree.new(@s, root: @root).to_doc.root.xpath('//' + @name)\n\n s = a.select {|x| x.has_elements? }\\\n .map{|x| XmlToSliml.new(x).to_s }.join(\"\\n\")\n\n return DepViz.new if s.empty?\n\n dv3 = DepViz.new(root: nil)\n dv3.read s\n dv3\n\n end",
"def add_dependency_condition(dc_obj)\n dc_obj.dependency_id = self.id\n self.dependency_conditions << dc_obj\n end",
"def diffeq_depends_on()\n unless @diffeq_deps\n my_deps = depends_on # calculate @depends_on\n\n d1_name = Variable.derivative_of_name(@name)\n my_d1 = @parent.variable_by_name(d1_name)\n d1_deps = my_d1.depends_on\n\n @diffeq_deps = my_deps | d1_deps\n end\n @diffeq_deps\n end",
"def expand_rule_definition definition\r\n\t\t@rules.reverse_each do |r|\r\n definition = definition.gsub \"[:#{r.type.to_s}]\", \"(#{r.definition})\"\r\n\t\tend\r\n\t\tdefinition\r\n\tend",
"def resolve!\n rule = grammar.rule(rule_name)\n raise RuntimeError, 'No rule named \"%s\" in grammar %s' %\n [rule_name, grammar.name] unless rule\n rule\n end",
"def dependency(val)\n dependencies << val\n dependencies.dup\n end",
"def create_dependencies(con)\n @resolving_dependencies = true\n dependencies.each do |_, d|\n fail CircularDependencyError.new(name, d.name) if d.resolving_dependencies\n d.create_dependencies(con)\n d.create_or_update!(con)\n end\n @resolving_dependencies = false\n end",
"def rule_by_id; end",
"def rel!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 33 )\n\n type = REL\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 167:7: 'rel'\n match( \"rel\" )\n\n \n @state.type = type\n @state.channel = channel\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 33 )\n\n end",
"def simple_ruby_dep name, *other_deps\n debug __LINE__, \"other_deps\", other_deps\n other_deps_string = other_deps.inject(\"\") do | a, e |\n debug __LINE__, \"a\", a\n debug __LINE__, \"e\", e\n a + \" \" + e\n end\n new_entry \"../public/#{name}: #{name}.rb#{other_deps_string}\"\n tab \"ruby $(RUBYOPT) #{name}.rb >$@.t\"\n commit\n end",
"def nested_model_dependency(args = {})\n unless args.include?(:from) && args.include?(:to)\n raise ArgumentError, \":from and :to hash keys must be included.\"\n end\n \n from = symbolize(args[:from])\n tos = args[:to].is_a?(Array) ? args[:to] : [symbolize(args[:to])]\n \n tos.each do |to|\n if dependency_introduces_cycle?(from, to)\n raise ModelOrchestration::DependencyCycleError, \"#{from} is already a dependency of #{to}\"\n else\n add_dependency(from, to)\n end\n end\n end",
"def dependency(*dep_names, &block)\n self.dep_name = dep_names\n @block = block\n end",
"def requires *deps\n return unless @dependency_lib\n\n @parents.concat(deps).uniq!\n deps.each do |dep|\n @dependency_lib.dependencies[dep].each{|d| d.add_child(@name) }\n end\n end",
"def add_dependency(task_from, task_to)\n unless task_from.is_a? Deployment::Task\n task_from = get_task task_from\n raise Deployment::NoSuchTask.new self, 'There is no such task in the graph!', task_from unless task_from\n end\n unless task_to.is_a? Deployment::Task\n task_to = get_task task_to\n raise Deployment::NoSuchTask.new self, 'There is no such task in the graph!', task_to unless task_to\n end\n task_to.dependency_backward_add task_from\n end",
"def rule_name\n super\n end",
"def task_add_new_with_dependencies(task_name, data=nil, backward_deps=[], forward_deps=[])\n task = task_create task_name, data\n backward_deps = [backward_deps] unless backward_deps.is_a? Array\n forward_deps = [forward_deps] unless forward_deps.is_a? Array\n backward_deps.each do |dependency|\n dependency = task_create dependency\n add_dependency dependency, task\n end\n forward_deps.each do |dependency|\n dependency = task_create dependency\n add_dependency task, dependency\n end\n task\n end",
"def resolve!\n rule = grammar.super_rule(rule_name)\n\n unless rule\n raise Error,\n \"No rule named \\\"#{rule_name}\\\" in hierarchy of grammar #{grammar}\"\n end\n\n rule\n end",
"def rule_name=(rule_name)\n @rule_name = rule_name.to_sym\n end",
"def rule_name=(rule_name)\n @rule_name = rule_name.to_sym\n end",
"def use(*specs)\n named = specs.flatten.inject({}) do |seen, spec|\n if Hash === spec && (spec.keys & ActsAsArtifact::ARTIFACT_ATTRIBUTES).empty?\n spec.each_pair do |name, spec|\n if ArtifactNamespace === spec # create as subnamespace\n raise ArgumentError.new(\"Circular reference\") if self == spec\n registry[name.to_sym] = spec\n elsif Numeric === spec || (String === spec && VersionRequirement.version?(spec))\n artifact = ArtifactRequirement.allocate\n artifact.name = name\n artifact.version = spec.to_s\n seen[artifact.name] ||= artifact\n elsif Symbol === spec\n self.alias name, spec\n elsif Array === spec # a group\n seen[name] ||= spec.map { |s| ArtifactRequirement.new(s) }\n else\n artifact = ArtifactRequirement.new(spec)\n artifact.name = name\n seen[artifact.name] ||= artifact\n end\n end\n else\n if Symbol === spec\n artifact = get(spec).dclone\n else\n artifact = ArtifactRequirement.new(spec)\n end\n seen[artifact.name] ||= artifact\n end\n seen\n end\n named.each_pair do |name, artifact|\n is_group = Array === artifact\n artifact = [artifact].flatten.map do |artifact|\n unvers = artifact.unversioned_spec\n previous = get(unvers, false) || get(name, false)\n if previous # have previous on current namespace\n if previous.requirement # we must satisfy the requirement\n if unvers\n satisfied = previous.satisfied_by?(artifact)\n else # we only have the version\n satisfied = previous.requirement.satisfied_by?(artifact.version)\n end\n raise \"Unsatisfied dependency #{previous} \" +\n \"not satisfied by #{artifact}\" unless satisfied\n previous.version = artifact.version # OK, set new version\n artifact = previous # use the same object for aliases\n else # not a requirement, set the new values\n unless artifact.id == previous.id && name != previous.name\n previous.copy_attrs(artifact)\n artifact = previous\n end\n end\n else\n if unvers.nil? && # we only have the version\n (previous = get(unvers, true, false, false))\n version = artifact.version\n artifact.copy_attrs(previous)\n artifact.version = version\n end\n artifact.requirement = nil\n end\n artifact.selected!\n end\n artifact = artifact.first unless is_group\n if is_group\n names = artifact.map do |art|\n unv = art.unversioned_spec\n registry[unv] = art\n unv\n end\n group(name, *(names + [{:namespace => self}]))\n elsif artifact.id\n unvers = artifact.unversioned_spec\n registry[name] = artifact\n registry.alias unvers, name\n else\n registry[name] = artifact\n end\n end\n self\n end",
"def method_missing(name, *productions)\n registry.define_rule(name, caller_locations.first, productions)\n end",
"def create_style_rule(rule); end",
"def resolve!\n rule = grammar.super_rule(rule_name)\n raise RuntimeError, 'No rule named \"%s\" in hierarchy of grammar %s' %\n [rule_name, grammar.name] unless rule\n rule\n end",
"def rule\n @rule ||= resolve!\n end",
"def rule\n @rule ||= resolve!\n end",
"def add_rule(rule, keys, options, callback)\n @rules[rule] = Rule.new(rule, keys, options, callback) \n end",
"def initialize(*args)\r\n super\r\n @by_name = {}\r\n children.each {|rule| @by_name[rule.name] = rule }\r\n end",
"def rule_set\n @rule_set ||= Rules::RuleSet.build_for(calendar: calendar, kind: kind)\n end",
"def depends_on(*depends)\n @depends = depends.dup\n\n # Increment dependent references\n @depends.each { |b| b.ref }\n end",
"def initialize(name) #initializing new instances with one argument\n @name = name #setting instance variable @name equal to name argument, which will be a string\n @rule = \"Law of Demeter\" #instance variable @rule set eql to string\n end",
"def depends(name)\n @dependencies << name unless @dependencies.include?(name)\n end",
"def create_rule(*args, &block)\n @ProjectFileLoader.CurrentlyLoadedProjectFile().create_rule(*args, &block)\n end",
"def << rule\n rules << rule\n nil\n end",
"def add_rule(name, *param_types, &func)\n rule = { name: name.to_s.dup.freeze,\n param_types: param_types.dup.freeze }.freeze\n regexp = mk_regexp_from_rule(rule)\n @rules.push([regexp, rule, func])\n return self\n end",
"def depend_on(dependant, env = environment.name, requirement = nil)\n fail('Dependant cannot be nil') if dependant.nil? || dependant.eql?('')\n fail('Environment cannot be nil') if env.nil? || env.eql?('')\n dep = if dependant == :all\n if env == :all\n Stacks::Dependencies::MultiServiceDependency.new(self,\n Stacks::Dependencies::AllKubernetesSelector.new(requirement),\n requirement)\n else\n fail('Selection by a specific environment not yet support for :all dependency')\n end\n elsif dependant.is_a?(Array)\n selectors = dependant.map { |d| Stacks::Dependencies::ServiceSelector.new(d, env) }\n Stacks::Dependencies::SingleServiceDependency.new(self,\n Stacks::Dependencies::MultiSelector.new(selectors),\n requirement)\n else\n Stacks::Dependencies::SingleServiceDependency.new(self,\n Stacks::Dependencies::ServiceSelector.new(dependant, env),\n requirement)\n end\n\n @depends_on << dep unless @depends_on.include? dep\n end",
"def _consume_rule seq\n # rule = rulename defined-as elements c-nl\n\n rulename = seq.shift\n raise \"BUG: bad rulename #{rulename.inspect}\" if rulename.nil? || rulename.type != :name\n\n raise \"truncated rule for #{rulename.value}\" if seq.empty?\n\n defined_as = nil\n case (op = seq.shift).type\n when :EQ, :EQ_ALT\n defined_as = op\n else\n raise \"unexpected #{op.type.inspect}, expected :EQ or :EQ_ALT\"\n end\n\n definition = _alternation(seq)\n raise \"unexpected #{seq.first.type.inspect} after rule\" unless seq.empty? || seq.first.type == :endline\n [rulename, defined_as, definition]\n end",
"def rules(rule_name:, kind:)\n Rules::RuleSet.build_for(calendar: calendar, kind: kind).rules_with_name(rule_name)\n end",
"def rule(error: :rule_failed, &predicate)\n Rule.new error: error, predicate: predicate\n end",
"def local_ruby_dep name, *other_deps\n other_deps_string = other_deps.inject(\"\") do | a, e |\n a + \" \" + e\n end\n new_entry \"#{name}: #{name}.rb#{other_deps_string}\"\n tab \"ruby $(RUBYOPT) #{name}.rb >$@.t\"\n commit\n end",
"def <<(dependency)\n if @dependencies.key? dependency.name\n @dependencies[dependency.name].merge!(dependency)\n else\n @dependencies[dependency.name] = dependency\n end\n end",
"def dependency=(value)\n self[:dependency] = \". #{value} .\".gsub(/ +/,' ')\n end",
"def apply rule\n run((String===rule) ? @rules[rule].consequence : rule.consequence)\n end",
"def add_generated_directed_dependency(parent, child, label=nil)\n if parent.depthfirst?\n source = child\n target = parent\n else\n source = parent\n target = child\n end\n\n # For each potential relationship metaparam, check if parent or\n # child references the other. If there are none, we should add our\n # edge.\n edge_exists = Puppet::Type.relationship_params.any? { |param|\n param_sym = param.name.to_sym\n\n if parent[param_sym]\n parent_contains = parent[param_sym].any? { |res|\n res.ref == child.ref\n }\n else\n parent_contains = false\n end\n\n if child[param_sym]\n child_contains = child[param_sym].any? { |res|\n res.ref == parent.ref\n }\n else\n child_contains = false\n end\n\n parent_contains || child_contains\n }\n\n if not edge_exists\n # We *cannot* use target.to_resource here!\n #\n # For reasons that are beyond my (and, perhaps, human)\n # comprehension, to_resource will call retrieve. This is\n # problematic if a generated resource needs the system to be\n # changed by a previous resource (think a file on a path\n # controlled by a mount resource).\n #\n # Instead of using to_resource, we just construct a resource as\n # if the arguments to the Type instance had been passed to a\n # Resource instead.\n resource = ::Puppet::Resource.new(target.class, target.title,\n :parameters => target.original_parameters)\n\n source[:before] ||= []\n source[:before] << resource\n end\n end",
"def initialize(question, args, options)\n self.parser = question.parser\n self.id = parser.new_dependency_id\n self.question_id = question.id\n self.rule = (args[0] || {})[:rule]\n self.dependency_conditions = []\n self.default_options().merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set(\"@#{key}\", value)}\n end",
"def initialize(rule_set, name, priority, b)\r\n @rule_set = rule_set\r\n @name = name\r\n @priority = priority\r\n @conditions = []\r\n @consequences = []\r\n @parameters = []\r\n \r\n begin\r\n instance_eval(&b) if b\r\n rescue Exception => e\r\n raise RuleCheckError.new( self, e)\r\n end\r\n end",
"def setup_super(rule, name) # :nodoc:\n if Nonterminal === rule\n rule.rules.each {|r| setup_super(r, name) }\n elsif Super === rule\n rule.rule_name = name\n end\n end",
"def setup_super(rule, name) # :nodoc:\n if Nonterminal === rule\n rule.rules.each {|r| setup_super(r, name) }\n elsif Super === rule\n rule.rule_name = name\n end\n end"
] |
[
"0.58839417",
"0.57827204",
"0.5732911",
"0.5719083",
"0.5440427",
"0.5427264",
"0.5355852",
"0.5355065",
"0.53180116",
"0.5304991",
"0.53002656",
"0.52963644",
"0.5271722",
"0.52603656",
"0.5222042",
"0.5222042",
"0.5214741",
"0.5207046",
"0.5179739",
"0.51741356",
"0.51741356",
"0.51479524",
"0.5138281",
"0.51152885",
"0.5098387",
"0.50973785",
"0.5060755",
"0.5055774",
"0.5054867",
"0.5041592",
"0.5035453",
"0.49904022",
"0.49860907",
"0.49739164",
"0.49607444",
"0.4958609",
"0.4944745",
"0.4937897",
"0.49282908",
"0.49237028",
"0.4922565",
"0.49199373",
"0.49199373",
"0.49199373",
"0.4919761",
"0.491957",
"0.491899",
"0.4917659",
"0.4911122",
"0.48953533",
"0.489479",
"0.48942938",
"0.48770282",
"0.48613945",
"0.48586008",
"0.4853834",
"0.48459187",
"0.48394126",
"0.48332787",
"0.482888",
"0.48264617",
"0.48250696",
"0.48248625",
"0.48118454",
"0.4806723",
"0.48014012",
"0.4796606",
"0.479429",
"0.47917366",
"0.47872448",
"0.47825453",
"0.47742164",
"0.47742164",
"0.47735322",
"0.4763342",
"0.4748914",
"0.47365537",
"0.4736184",
"0.4736184",
"0.47300676",
"0.4727387",
"0.47254348",
"0.47242343",
"0.4706683",
"0.47032633",
"0.46997556",
"0.46963",
"0.46947253",
"0.46933246",
"0.46898037",
"0.4688174",
"0.46875235",
"0.46853903",
"0.46790114",
"0.46782774",
"0.46747613",
"0.46567056",
"0.46399772",
"0.46398428",
"0.4636077",
"0.4636077"
] |
0.0
|
-1
|
Stops the current assertion. Does not indicate failure.
|
def stop(message = nil)
@assert = false
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def stop\n msg = \"guard-self_test is stopped...\"\n UI.info msg\n Notifier.notify(msg)\n end",
"def stop_test(test)\n puts \"Test was stopped mid execution: #{test.uri}\"\n end",
"def stop_test_case\n return logger.error { \"Could not stop test case, no test case is running\" } unless @current_test_case\n\n logger.debug { \"Stopping test case: #{@current_test_case.name}\" }\n @current_test_case.stop = ResultUtils.timestamp\n @current_test_case.stage = Stage::FINISHED\n file_writer.write_test_result(@current_test_case)\n clear_current_test_case\n clear_step_context\n end",
"def stop_fixture\n return logger.error { \"Could not stop fixture, fixture is not started\" } unless @current_fixture\n\n logger.debug { \"Stopping fixture: #{@current_fixture.name}\" }\n @current_fixture.stop = ResultUtils.timestamp\n @current_fixture.stage = Stage::FINISHED\n clear_current_fixture\n clear_step_context\n end",
"def stop\n @runner.stop\n end",
"def stop\n throw @context.stop\n end",
"def stop_test_step\n return logger.error { \"Could not stop test step, no step is running\" } unless current_test_step\n\n logger.debug { \"Stopping test step: #{current_test_step.name}\" }\n current_test_step.stop = ResultUtils.timestamp\n current_test_step.stage = Stage::FINISHED\n clear_last_test_step\n end",
"def abort(reason)\n puts \"Test failed: #{reason}\"\n if EventMachine.reactor_running?\n EventMachine.stop()\n end\n exit(FAILURE_EXIT_STATUS)\n end",
"def teardown\r\n\r\n if self.passed?\r\n @reportiumClient.testStop(TestResultFactory.createSuccess)\r\n else\r\n @reportiumClient.testStop(TestResultFactory.createFailure(@exception.message, @exception))\r\n end\r\n\r\n puts '========================================================================================================================'\r\n puts 'report url: ' + @reportiumClient.getReportUrl\r\n puts '========================================================================================================================'\r\n\r\n @driver.close\r\n @driver.quit\r\n end",
"def end_test(test_status)\n # Abstract\n end",
"def end_test(test_status)\n # Abstract\n end",
"def stop!\n throw :return, 1\n end",
"def halt\n StepResult.new(false)\n end",
"def stop\n begin\n pre_stop\n ensure\n begin\n stop_impl\n ensure\n post_stop\n end\n end\n end",
"def halt!\n @running = false\n @audio.stop_audio\n @hardware_interface.teardown\n end",
"def testStop(testResult)\n\n params = {\n :success => testResult.isSuccessful\n }\n\n if !testResult.isSuccessful\n params['failureDescription'] = testResult.message\n params['failureReason'] = testResult.failureReason\n end\n\n executeScript($END_TEST_COMMAND, params)\n return true\n end",
"def stop_test_run(test_run)\n puts \"Test Run Stopped.\"\n end",
"def cancel\n self.break_condition = 1\n end",
"def stop\n raise \"NotImplemented\"\n end",
"def abort_test!\n throw 'abort_test!'\n end",
"def stop\n\t\t\tContext::wait if @options[:wait]\n\t\t\tbegin\n\t\t\t\t@logger.finalize(self)\n\t\t\trescue StandardError => e\n\t\t\t\tprint_error(e)\n\t\t\t\traise\n\t\t\tensure\n\t\t\t\t@driver.quit if @driver\n\t\t\tend\n\t\tend",
"def test_end_fail\r\n \t@test_prospector.move_count = 1\r\n \tassert_equal false, @test_prospector.end?\r\n end",
"def stop\n raise NotImplementedError.new(\"Implement stop() in your Invoker. \")\n end",
"def stop\n @run = false\n end",
"def stop\n tempfile = ARGV.first\n system(\"#{MOCK_EXECUTABLE} #{tempfile} --stop --example -y\")\n end",
"def helper_stop_test(message, encoded_message = nil)\n post '/start', { message: '' }, session # to avoid stop twice error\n post '/stop', { message: message }, session\n\n assert_equal 302, last_response.status\n assert_flash 'Time stopped.'\n assert_time_stop(encoded_message || message)\n\n # follow redirect back to actions page\n get last_response['Location']\n\n assert_all_actions\n assert_displayed_flash 'Time stopped.'\n end",
"def abort\n unless @finished\n do_abort\n end\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def test_stop_stopped_job\n job 'job'\n assert_message(\"Timeclock tried to stop job 'job'.\n But 'job' is already stopped.\",\n stop('job'))\n end",
"def halt!\n @running = false\n return nil\n end",
"def stop\n exit\n end",
"def teardown\n assertGreaterThan @@assertions, @assertions, 'Test should make assertions'\n end",
"def teardown\n @suite.p \"\\n:: [TEARDOWN]\\n\"\n end",
"def halt\n end",
"def stop_for_testing?(stop_point)\n if stop_for_testing = R8::Config[:stop_for_testing]\n if stop_for_testing[stop_point]\n fail Error.new(\"stop for testing at #{stop_point}\")\n end\n end\n end",
"def test_03()\n\t\tputs \"Inside test 3\"\n\t\t$browser.stop\n\t\t\n\tend",
"def stop\n Thread.new { log \"Exiting...\" }\n @exit = true\n end",
"def stop\n Thread.new { log \"Exiting...\" }\n @exit = true\n end",
"def stop\n Thread.new { log \"Exiting...\" }\n @exit = true\n end",
"def halt; end",
"def halt; end",
"def teardown\r\n # Do nothing\r\n @driver.quit()\r\n @verification_errors\r\n end",
"def fail_now\n fail\n raise TestFail\n end",
"def teardown\n signout\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def stop\n @actor.finalize if @actor\n nil\n end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def exit\n case @status\n when :sleep\n wake_resume(:exit)\n when :run\n throw :exit\n end\n end",
"def stop\n @stop = true\n end",
"def teardown\n #@driver.quit\n assert_equal [], @verification_errors\n end",
"def stop\n unless Thread.current == @thread\n @thread.kill\n end\n end",
"def stop\n # no-op\n end",
"def teardown\r\n\r\n puts2(\"\\nTestcase finished in \" + calc_elapsed_time(@@tTestCase_StartTime) + \" seconds.\")\r\n\r\n # Restore the Global variable's original settings\r\n $VERBOSE = @@VERBOSE_ORIG\r\n $DEBUG = @@DEBUG_ORIG\r\n $FAST_SPEED = @@FAST_SPEED_ORIG\r\n $HIDE_IE = @@HIDE_IE_ORIG\r\n\r\n end",
"def fail(message = nil)\n if @__assert_pending__ == 0\n if halt_on_fail?\n raise Result::TestFailure, message || \"\"\n else\n capture_result(Assert::Result::Fail, message || \"\")\n end\n elsif halt_on_fail?\n raise Result::TestSkipped, \"Pending fail: #{message || \"\"}\"\n else\n capture_result(Assert::Result::Skip, \"Pending fail: #{message || \"\"}\")\n end\n end",
"def stop?(*) end",
"def stop\n check_alive! if options(:strict)\n self << Stop.new\n @strategy.stop\n raise @exception if @exception\n end",
"def stop_trace\n if @trace_thread\n @trace_thread.kill\n @trace_thread = nil\n end\n end",
"def terminate\n @state = :terminating\n cancel_timer\n true\n end",
"def teardown\n\n puts2(\"\\nTestcase finished in \" + calc_elapsed_time(@@tTestCase_StartTime) + \" seconds.\")\n\n # Restore the Global variable's original settings\n $VERBOSE = @@VERBOSE_ORIG\n $DEBUG = @@DEBUG_ORIG\n $FAST_SPEED = @@FAST_SPEED_ORIG\n $HIDE_IE = @@HIDE_IE_ORIG\n\n # Flag indicating if a browser was started\n $bBrowserStarted = false\n\n end",
"def stop_simulating\n logger.info \"Being told to stop! #{name}\"\n @please_stop_simulating = true\n end",
"def stop\n rpc(:stop).key?(:success)\n end",
"def terminate\n @should_terminate = true\n end",
"def stop!; end",
"def stop\n @actions << :stop\n end",
"def stop()\n @state = STOPPED\n end",
"def stop\n @mutex.synchronize{ @do_stop = true }\n end",
"def stop\n if working\n @stop = true\n else\n exit\n end\n end",
"def abort ; conclude(false) ; end",
"def fail(message = nil)\r\n @status = FAIL\r\n @assert = false\r\n end",
"def test_more_than_one_pause_when_stopping\n stqe = @session.jobs['stqe']\n mail = @session.jobs['misc. email']\n\n stqe_start = @now\n start(stqe)\n assert_states([stqe], [])\n assert_new_record 1, stqe, stqe_start\n mail_start = @now\n start(mail)\n assert_states([mail], [stqe])\n assert_new_record 2, mail, mail_start\n pause\n assert_states([], [mail, stqe])\n stop(stqe)\n assert_states([], [mail])\n assert_stopped_with(1, 1.minute)\n stop(mail)\n assert_states([], [])\n assert_stopped_with(2, 1.minute)\n end",
"def stop\n true\n end",
"def stop\n true\n end",
"def stop\n true\n end",
"def stop\n true\n end",
"def stop!\n @stop = true\n end",
"def stop!\n @stop = true\n end",
"def test_on_error_cancel\n\n pdef = Ruote.define do\n sequence :on_error => 'cancel' do\n echo 'n'\n error 'nada'\n end\n end\n\n wfid = @dashboard.launch(pdef)\n r = @dashboard.wait_for(wfid)\n\n assert_equal 'terminated', r['action']\n assert_equal %w[ n ], @tracer.to_a\n end",
"def stop\n Agent.stop\n end",
"def teardown\r\n\r\n # Calculate and record the elapsed time for the current test case\r\n puts2(\"\\nTestcase finished in \" + calc_elapsed_time(@@tTestCase_StartTime, true))\r\n\r\n # Check for any Errors\r\n #$browser.recover_from_error()\r\n\r\n # Check if the $browser needs to be closed\r\n # NOTE: RAutomation currently only runs on Windows\r\n if(@@bCloseBrowser == true)\r\n\r\n puts2(\"Attempting to close the current browser...\")\r\n if(($browser.link(:href => \"/logout\").exists?) and ($browser.link(:href => \"/logout\").visible?))\r\n puts2(\"Logging out...\")\r\n $browser.link(:href => \"/logout\").click\r\n sleep($iNetDelay) # Short delay before closing the browser\r\n end\r\n\r\n puts2(\"\\t Attempting to stop: \" + $sDefaultBrowser.downcase.strip)\r\n\r\n # Force any open $browsers to exit\r\n case $sDefaultBrowser.downcase.strip\r\n when /ie/\r\n $browser.exit_browsers(\"ie\")\r\n sleep($iNetDelay)\r\n when /firefox/\r\n $browser.exit_browsers(\"ff\")\r\n sleep($iNetDelay)\r\n when /safari/\r\n $browser.exit_browsers(\"safari\")\r\n sleep($iNetDelay)\r\n end\r\n\r\n if(@@bClearCache == true)\r\n puts2(\"Clear the $browser cache...\")\r\n clear_cache()\r\n\r\n # Turn it off again\r\n @@bClearCache == false\r\n end\r\n\r\n # Turn it off again\r\n @@bCloseBrowser = false\r\n\r\n end # Check if the $browser needs to be closed\r\n\r\n\r\n # Restore the Global variable's original settings\r\n $VERBOSE = @@VERBOSE_ORIG\r\n $DEBUG = @@DEBUG_ORIG\r\n $FAST_SPEED = @@FAST_SPEED_ORIG\r\n $HIDE_IE = @@HIDE_IE_ORIG\r\n\r\n puts2(\"#\"*40)\r\n\r\n end",
"def ole_stop\n @ole.quit\n end",
"def stop!\n @stop_mutex.synchronize { @stop = true }\n end",
"def stop_runner!\n @running = false\n end",
"def stop(&blk)\n if blk\n Smith.stop(true, &blk)\n else\n Smith.stop(true)\n end\n end",
"def stop\n @running = false\n end",
"def stop\n @running = false\n end",
"def stop\n @running = false\n end"
] |
[
"0.67832035",
"0.6547782",
"0.651686",
"0.63943756",
"0.63706154",
"0.6355129",
"0.6264343",
"0.6263689",
"0.6251894",
"0.6166021",
"0.6166021",
"0.6126806",
"0.61249775",
"0.61223114",
"0.61156374",
"0.6082949",
"0.60592645",
"0.60485375",
"0.6011075",
"0.600784",
"0.5971989",
"0.5928432",
"0.59178895",
"0.5911871",
"0.5910186",
"0.59086156",
"0.58940417",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.5882289",
"0.58579147",
"0.58558893",
"0.5854673",
"0.5846835",
"0.5819209",
"0.5809442",
"0.5809044",
"0.58003956",
"0.5795564",
"0.5795564",
"0.5795564",
"0.5784547",
"0.5784547",
"0.5771256",
"0.57661045",
"0.5747398",
"0.5731273",
"0.57228476",
"0.57228476",
"0.57228476",
"0.57228476",
"0.57228476",
"0.57228476",
"0.57228476",
"0.57088035",
"0.570698",
"0.5705162",
"0.56954765",
"0.5689404",
"0.5686095",
"0.5682467",
"0.56799704",
"0.5679237",
"0.5677946",
"0.5675765",
"0.56743157",
"0.56733114",
"0.5666832",
"0.5656517",
"0.5654563",
"0.56494087",
"0.56488866",
"0.56415576",
"0.5636139",
"0.5636041",
"0.5623253",
"0.56229496",
"0.56181866",
"0.56181866",
"0.56181866",
"0.56181866",
"0.56141627",
"0.56141627",
"0.5613692",
"0.56133264",
"0.5608961",
"0.5603719",
"0.55889827",
"0.55829674",
"0.55781794",
"0.55717283",
"0.55717283",
"0.55717283"
] |
0.7875146
|
0
|
Stops the current assertion and change status to :fail
|
def fail(message = nil)
@status = FAIL
@assert = false
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def stop(message = nil)\r\n @assert = false\r\n end",
"def fail_now\n fail\n raise TestFail\n end",
"def fail(message = nil)\n if @__assert_pending__ == 0\n if halt_on_fail?\n raise Result::TestFailure, message || \"\"\n else\n capture_result(Assert::Result::Fail, message || \"\")\n end\n elsif halt_on_fail?\n raise Result::TestSkipped, \"Pending fail: #{message || \"\"}\"\n else\n capture_result(Assert::Result::Skip, \"Pending fail: #{message || \"\"}\")\n end\n end",
"def fail\n @failed = true\n end",
"def fail!\n @success = false\n end",
"def fail!\n @failed = true\n end",
"def test_end_fail\r\n \t@test_prospector.move_count = 1\r\n \tassert_equal false, @test_prospector.end?\r\n end",
"def fail!\n @success = false\n end",
"def fail!\n @success = false\n end",
"def abort(reason)\n puts \"Test failed: #{reason}\"\n if EventMachine.reactor_running?\n EventMachine.stop()\n end\n exit(FAILURE_EXIT_STATUS)\n end",
"def fail(check)\n update_check_status(check, 'fail')\n end",
"def defaultFailTest\n rescue_assertion /#{FAILING}/ do\n fail\n end\n end",
"def end_test(test_status)\n # Abstract\n end",
"def end_test(test_status)\n # Abstract\n end",
"def failure\n @status = FAILURE_FLAG if @status == SUCCESS_FLAG\n end",
"def failed!\n @success = false\n end",
"def assertFailTest value\n rescue_assertion /#{ASSERT_ERROR}/ do\n assert value\n end\n end",
"def abort_test!\n throw 'abort_test!'\n end",
"def fail\n @counts.fails += 1\n puts_failure_data(header: FAIL_HEADER)\n end",
"def fail message = nil, data = {}\n __assert_block FAILING, message, data\n end",
"def failWithMessageTest message\n rescue_assertion /#{FAILING}/, message do\n fail message\n end\n end",
"def report_failure\n @report.fail\n end",
"def report_failure\n @report.fail\n end",
"def fail(message=nil)\n halt(message, 1)\n end",
"def fail(reason = 'Test case called fail!')\n raise Bcpm::Tests::AssertionError, reason\n end",
"def testStop(testResult)\n\n params = {\n :success => testResult.isSuccessful\n }\n\n if !testResult.isSuccessful\n params['failureDescription'] = testResult.message\n params['failureReason'] = testResult.failureReason\n end\n\n executeScript($END_TEST_COMMAND, params)\n return true\n end",
"def failure\n !success\n end",
"def teardown\r\n\r\n if self.passed?\r\n @reportiumClient.testStop(TestResultFactory.createSuccess)\r\n else\r\n @reportiumClient.testStop(TestResultFactory.createFailure(@exception.message, @exception))\r\n end\r\n\r\n puts '========================================================================================================================'\r\n puts 'report url: ' + @reportiumClient.getReportUrl\r\n puts '========================================================================================================================'\r\n\r\n @driver.close\r\n @driver.quit\r\n end",
"def mark_failure\n self.failure_occurred = true\n end",
"def mark_failure\n self.failure_occurred = true\n end",
"def do_failure; end",
"def stop_test(test)\n puts \"Test was stopped mid execution: #{test.uri}\"\n end",
"def halt\n StepResult.new(false)\n end",
"def fail!\n return if state == 'FAILED'\n JobTracker.transaction do\n update_attribute(:state, 'FAILED')\n Delayed::Job.destroy_failed_jobs ? delayed_jobs.each(&:destroy) : delayed_jobs.each do |dj|\n dj.update_attribute(:failed_at, Time.now)\n end\n end\n end",
"def test_on_error_cancel\n\n pdef = Ruote.define do\n sequence :on_error => 'cancel' do\n echo 'n'\n error 'nada'\n end\n end\n\n wfid = @dashboard.launch(pdef)\n r = @dashboard.wait_for(wfid)\n\n assert_equal 'terminated', r['action']\n assert_equal %w[ n ], @tracer.to_a\n end",
"def failure!\n @count += 1\n end",
"def stop\n msg = \"guard-self_test is stopped...\"\n UI.info msg\n Notifier.notify(msg)\n end",
"def stop_test_step\n return logger.error { \"Could not stop test step, no step is running\" } unless current_test_step\n\n logger.debug { \"Stopping test step: #{current_test_step.name}\" }\n current_test_step.stop = ResultUtils.timestamp\n current_test_step.stage = Stage::FINISHED\n clear_last_test_step\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def teardown\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def fail\n now = Time.now\n update_attributes(failed_at: now, completed_at: now)\n end",
"def abort_on_failure(value = true)\n @abort_on_failure = value\n end",
"def failure(err_msg)\n @fail = true\n @err_msg = err_msg\n end",
"def failure(err_msg)\n @fail = true\n @err_msg = err_msg\n end",
"def failure(err_msg)\n @fail = true\n @err_msg = err_msg\n end",
"def failure(err_msg)\n @fail = true\n @err_msg = err_msg\n end",
"def fail_after(y, m, d, msg); end",
"def stop_test_case\n return logger.error { \"Could not stop test case, no test case is running\" } unless @current_test_case\n\n logger.debug { \"Stopping test case: #{@current_test_case.name}\" }\n @current_test_case.stop = ResultUtils.timestamp\n @current_test_case.stage = Stage::FINISHED\n file_writer.write_test_result(@current_test_case)\n clear_current_test_case\n clear_step_context\n end",
"def fail!\n @__result.fail!\n throw :fail\n end",
"def failure(message)\n $stderr.puts \"#{name}: #{message}\"\n exit 1\n end",
"def fail(description, message, line, file)\n print yellow(\"F\")\n @details << \"FAILURE - #{test_detail(description, message)} #{line_info(line, file)}\".strip\n end",
"def teardown\n #@driver.quit\n assert_equal [], @verification_errors\n end",
"def failure(message = '')\n FailureAssertion.new(message)\n end",
"def assert_error_occurred\n assert_not_exit_status 0\n end",
"def assertFalseFailTest value\n rescue_assertion /#{ASSERT_FALSE_ERROR}/ do\n assertFalse value\n end\n end",
"def fail!\n @__result.fail!\n throw :fail\n end",
"def failure\n end",
"def custom_failure!\n @custom_failure = true\n end",
"def stop_test_run(test_run)\n puts \"Test Run Stopped.\"\n end",
"def teardown\n assertGreaterThan @@assertions, @assertions, 'Test should make assertions'\n end",
"def fail(msg)\n $stderr.puts msg\n Kernel.exit 1\nend",
"def failure!\n end",
"def failures; end",
"def failures; end",
"def failures; end",
"def fail(message)\n self.failures << message\n puts \"fail #{message}\"\n end",
"def fail_unexpectedly(message)\n log \"An unexpected error occurred: #{message}\"\n @ticket.request_error! @last_log_message\n end",
"def fail!(**arguments)\n context.fail!(**arguments)\n end",
"def is_failed\n @status == Status::FAILURE\n end",
"def assert_failure(response)\n clean_backtrace do\n assert_false response.success?, \"Response expected to fail: #{response.inspect}\"\n end\n end",
"def assertTrueFailTest value\n rescue_assertion /#{ASSERT_TRUE_ERROR}/ do\n assertTrue value\n end\n end",
"def signal_failure\n __send_signal(:failure)\n end",
"def assert_timed_out\n assert avatar.lights[-1].output.start_with?('Unable to complete')\n assert_equal :timed_out, avatar.lights[-1].colour\n end",
"def assert_error_occurred\n @status.wont_equal 0\n end",
"def failed?; state == 'failed'; end",
"def failed?; state == 'failed'; end",
"def failure?; terminal_flag == :failure end",
"def failure?; terminal_flag == :failure end",
"def assert_clean_exit\n assert(0 == exit_status)\n end",
"def fail(task, error)\n @failure = error\n @complete = true\n end",
"def assertFailWithMessageTest value, message\n rescue_assertion /#{ASSERT_ERROR}/, message do\n assert value, message\n end\n end",
"def assertNotFailTest value\n rescue_assertion /#{ASSERT_NOT_ERROR}/ do\n assertNot value\n end\n end",
"def fail(message = nil)\r\n @rule_set.fail(message)\r\n end",
"def failed(message)\n log << \"[FAILURE] #{message}\"\n @failed = true\n end",
"def assertFalseFailWithMessageTest value, message\n rescue_assertion /#{ASSERT_FALSE_ERROR}/, message do\n assertFalse value, message\n end\n end",
"def fail(reason)\n end",
"def teardown\n signout\n @driver.quit\n assert_equal [], @verification_errors\n end",
"def failure\n if $DEBUG\n @__num_of_tries ||= 1\n @__num_of_tries += 1\n end\n back_amb.pop.call\n end",
"def teardown\n time = Time.new\n\n if passed?\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: PASS\\n\"\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: PASS\\n\".green\n puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: \" + \"PASS\\n\".green\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.to_s}.#{__method__.to_s}: PASS\\n\"\n else\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: FAIL\\n\"\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: FAIL\\n\".red\n puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.#{__method__.to_s}: \" + \"FAIL\\n\".red\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.to_s}.#{__method__.to_s}: FAIL\\n\"\n\n # take screenshot at end of test, useful for failures/errors\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/Screenshots/' + @method_name + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + self.inspect.to_s + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + __callee__.to_s + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + __method__.to_s + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.name}\" + '#' + \"#{__method__.to_s}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.to_s}\" + '#' + \"#{__method__.to_s}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #time += 1\n #@@b.screenshot.save(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.name}\" + '#' + \"#{__method__.to_s}]\" + '_' + (Time.new + 1).strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.screenshot.save(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.to_s}\" + '#' + \"#{__method__.to_s}]\" + '_' + (Time.new + 1).strftime('%Y%m%d_%H%M%S') + '.png');\n\n#=begin\n @@b.driver.save_screenshot(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.name}\" + '#' + \"#{method_name}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n #@@b.driver.save_screenshot(File.dirname(__FILE__) + '/Screenshots/' + \"[#{self.class.to_s}\" + '#' + \"#{method_name}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png');\n#=end\n\n #puts File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + \"[#{self.class.name}\" + '#' + \"#{__method__.to_s}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png\\n'\n #puts File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + \"[#{self.class.to_s}\" + '#' + \"#{__method__.to_s}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png\\n'\n puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.name}.teardown: Screenshot saved to \" + File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + \"[#{self.class.name}\" + '#' + \"#{method_name}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png' + \"\\n\"\n #puts \"#{time.strftime('%Y.%m.%d %H:%M:%S')} - #{self.class.to_s}.teardown: Screenshot saved to \" + File.dirname(__FILE__) + '/' + 'Screenshot' + '_' + \"[#{self.class.to_s}\" + '#' + \"#{method_name}]\" + '_' + time.strftime('%Y%m%d_%H%M%S') + '.png' + \"\\n\"\n end\n\n time = Time.new\n File.open(File.dirname(__FILE__) + '/' + 'Results' + '/' + 'results.csv', 'a+'){|f|\n f << time.strftime('%Y%m%d') + \";\"\n f << time.strftime('%H%M%S') + \";\"\n f << \"#{self.class.to_s}\" + '#' + \"#{method_name}\" + \";\"\n f << (passed? ? \";\" : \"#{@message};\")\n f << (passed? ? \"PASS;\" : \"FAIL;\")\n f << \"\\n\"\n }\n end",
"def on_failure(message)\n @status.update_attributes(:failures=>(@status.failures+1) )\n @logger.error message\n end",
"def fail(message)\n growl \"Failure!\", message\n exit\nend",
"def report_failure(title, msg)\n @ok = false\n @failure_title = title\n @failure_message = msg\n # note that the errback handler is expected to audit the message based on\n # the preserved title and message and so we don't audit it here.\n EM.next_tick { fail }\n true\n end"
] |
[
"0.72820985",
"0.7252399",
"0.6899079",
"0.6854849",
"0.67692125",
"0.67598766",
"0.67290473",
"0.67276686",
"0.67276686",
"0.6621376",
"0.6612223",
"0.6586547",
"0.6563205",
"0.6563205",
"0.65092444",
"0.648474",
"0.6470521",
"0.64400804",
"0.641346",
"0.6382244",
"0.6360785",
"0.634643",
"0.634643",
"0.632493",
"0.63131803",
"0.63125604",
"0.6299537",
"0.62605983",
"0.62301654",
"0.62301654",
"0.6219872",
"0.6212012",
"0.6187003",
"0.61692923",
"0.61670876",
"0.6166417",
"0.6162057",
"0.6139627",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.6113671",
"0.60985494",
"0.60942453",
"0.60779893",
"0.60779893",
"0.60779893",
"0.60779893",
"0.6073544",
"0.60728234",
"0.60713303",
"0.606688",
"0.60515887",
"0.6046573",
"0.60460263",
"0.602599",
"0.60124964",
"0.601153",
"0.6007313",
"0.60071725",
"0.6001598",
"0.59987485",
"0.5994432",
"0.5990718",
"0.59906244",
"0.59906244",
"0.59906244",
"0.59884644",
"0.5985411",
"0.5979369",
"0.5971672",
"0.5947557",
"0.59435296",
"0.5938199",
"0.59370273",
"0.5917742",
"0.5907118",
"0.5907118",
"0.59035945",
"0.59035945",
"0.58794826",
"0.5874797",
"0.5874523",
"0.5869238",
"0.5857052",
"0.5850508",
"0.5824125",
"0.5819729",
"0.5818016",
"0.5817431",
"0.5816653",
"0.581252",
"0.5790863",
"0.57897717"
] |
0.7579891
|
0
|
an assert has been made within a rule
|
def rule_assert( obj )
# add object as a new fact
f = fact(obj)
# get_relevant_rules
logger.debug( "Check if we need to add more rules") if logger
add_relevant_rules_for_fact(f)
sort_relevant_rules
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def assert(obj)\r\n @rule_set.rule_assert(obj)\r\n end",
"def assertions; end",
"def assertions; end",
"def assert(expr)\n fail 'Assertion failed' unless expr\n end",
"def assert(expr)\n raise 'Assertion failed' unless (expr)\n end",
"def assert\n\tyield\nend",
"def assert\n\tyield\nend",
"def assert\n\traise \"Assertion failed!\" unless \n\t yield\nend",
"def assert\n\traise ArgumentError.new(\"assertion error\") unless yield\nend",
"def assert \n\traise \"Assertion failed\" unless yield\nend",
"def assert\n \t raise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed\" unless yield\nend",
"def assert\n\traise \"Assertion failed\" unless yield\nend",
"def __assert__(pass, error=nil)\n Assertor.assert(pass, error, @negated, @backtrace)\n end",
"def assert _args\n \"assert _args;\" \n end",
"def assert\n\traise ArgumentError.new(\"Assertion failed!\") unless yield\nend",
"def assert(predicate, message='failed assertion')\n @assertions += 1\n return if predicate\n fail message\n end",
"def assert(predicate, message='failed assertion')\n @assertions += 1\n return if predicate\n fail message\n end",
"def assert name\n TetCore.group(name) do\n TetCore.assert\n\n yield ? TetCore.pass : TetCore.fail\n end\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n\tputs \"Assertion Failed!\" unless yield\nend",
"def assert \n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion Failed\" unless yield\nend",
"def assert\n\traise \"Assertion error!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\traise \"Assertion failed!\" unless yield\nend",
"def assert\n\t\tif yield\n\t\t\tputs \"Passes assert\"\n\t\telse\n\t\t\tputs \"Fails assert\"\n\t\tend\n\tend",
"def assert\n\traise \"Assertion Failed!\" unless yield\nend",
"def assert\n\traise \"Assertion Failed!\" unless yield\nend",
"def assert\n\traise \"Assertion Raised!\" unless yield\nend",
"def assert\n \n raise \"Assertion failed\" unless yield \nend",
"def before_assert\n end",
"def assertions=(_arg0); end",
"def assertions=(_arg0); end",
"def assert\n raise \"Assertion failed!\" unless yield\n\nend",
"def assert \t\t\t\t\t\t\t\t\t\n raise \"Assertion failed!\" unless yield \t\nend",
"def assert\n raise \"Assertion failed!\" unless yield\n end",
"def assert(cond)\n failure unless cond\n end",
"def assert\n \"Assertion failed!\" unless yield\nend",
"def assert\n puts \"Processing...\"\n raise \"Assertion failed!\" unless yield \n puts \"True!\"\nend",
"def assert\r\n raise \"Assert Faild\" unless yield\r\nend",
"def assert\n raise \"Assertion failed!\" unless yield\n puts yield\nend",
"def assert\n# puts \"Processing...\"\n raise \"Assertion failed!\" unless yield \n puts \"True!\"\nend",
"def assert\n raise \"Assertion failed\" unless yield\nend",
"def assert\n raise \"Assertion failed\" unless yield\nend",
"def assert\n raise \"Assertion failed\" unless yield\nend",
"def assert\n raise \"Assertion failed\" unless yield\nend",
"def assert\n raise \"Assertion Failed!\" unless yield\n end",
"def assert\n\traise \"Assert failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\n puts \"Test passed\"\nend",
"def assert\n\t# if yield\n\t# \tputs \"true\"\n\traise \"Assertion failed\" unless yield \n# end \nend",
"def assert(msg, condition)\n if condition\n puts \"PASS: #{msg}\".green\n else\n puts \"FAIL: #{msg}\".red\n end\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend",
"def assert\n raise \"Assertion failed!\" unless yield\nend"
] |
[
"0.74538875",
"0.71891856",
"0.71891856",
"0.66735715",
"0.66657466",
"0.6636732",
"0.6636732",
"0.6584969",
"0.6566555",
"0.65412253",
"0.6539189",
"0.65313923",
"0.65313923",
"0.6529663",
"0.6525103",
"0.6520264",
"0.6517361",
"0.6517361",
"0.6514503",
"0.6506171",
"0.6489673",
"0.6485897",
"0.64826274",
"0.6482188",
"0.6475485",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.647521",
"0.6448404",
"0.64342225",
"0.64342225",
"0.6432243",
"0.64287764",
"0.64079726",
"0.6407329",
"0.6407329",
"0.6395126",
"0.6392982",
"0.63756704",
"0.6369068",
"0.6363666",
"0.63526356",
"0.6345982",
"0.6341957",
"0.6341602",
"0.6336561",
"0.6336561",
"0.6336561",
"0.6336561",
"0.63314307",
"0.6323162",
"0.63186455",
"0.63169265",
"0.63093734",
"0.62961036",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264",
"0.62953264"
] |
0.7101034
|
3
|
Turn passed object into facts and evaluate all relevant rules Previous facts of same type are removed
|
def assert( *objs )
objs.each { |obj|
fact(obj)
}
return evaluate()
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def rule_assert( obj )\r\n # add object as a new fact\r\n f = fact(obj)\r\n # get_relevant_rules\r\n logger.debug( \"Check if we need to add more rules\") if logger\r\n add_relevant_rules_for_fact(f)\r\n sort_relevant_rules\r\n end",
"def assert_facts_from_rule(rule_object)\n\n # get the facts from the rule\n facts = rule_object.facts\n\n # iterate all the facts\n facts.each do |fact|\n\n # evaluate fact value\n # TODO: ONLY evaluate fact when trigger is called on a top level rule fact\n fact.value = evaluate_fact_value fact.value\n\n # let the ruleby engine assert the fact\n @engine.assert fact\n\n end\n\n end",
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def evaluate\r\n @status = PASS\r\n @assert = true\r\n @num_executed = 0;\r\n @num_evaluated = 0;\r\n \r\n get_relevant_rules()\r\n logger.debug(\"no relevant rules\") if logger && @relevant_rules.size==0\r\n \r\n #begin #rescue\r\n \r\n # loop through the available_rules, evaluating each one,\r\n # until there are no more matching rules available\r\n begin # loop\r\n \r\n # the loop condition is reset to break by default after every iteration\r\n matches = false\r\n obj = nil #deprecated\r\n \r\n #logger.debug(\"available rules: #{available_rules.size.to_s}\") if logger\r\n @relevant_rules.each do |rule|\r\n # RuleCheckErrors are caught and swallowed and the rule that\r\n # raised the error is removed from the working-set.\r\n logger.debug(\"evaluating: #{rule}\") if logger\r\n begin\r\n @num_evaluated += 1\r\n if rule.conditions_match?(obj)\r\n logger.debug(\"rule #{rule} matched\") if logger\r\n matches = true\r\n \r\n # remove the rule from the working-set so it's not re-evaluated\r\n @relevant_rules.delete(rule)\r\n \r\n # find all parameter-matching dependencies of this rule and\r\n # add them to the working-set.\r\n if @dependencies.has_key?(rule.name)\r\n logger.debug( \"found dependant rules to #{rule}\") if logger\r\n @relevant_rules += @dependencies[rule.name].select do |dependency|\r\n dependency.parameters_match?(obj)\r\n end\r\n end\r\n \r\n # execute this rule\r\n logger.debug(\"executing rule #{rule}\") if logger\r\n rule.call(obj)\r\n @num_executed += 1\r\n \r\n # break the current iteration and start back from the first rule defined.\r\n break\r\n end # if rule.conditions_match?(obj)\r\n \r\n rescue RuleConsequenceError\r\n fail\r\n rescue RuleCheckError => e\r\n fail\r\n end # begin/rescue\r\n \r\n end # available_rules.each\r\n \r\n end while(matches && @assert)\r\n \r\n #rescue RuleConsequenceError => rce\r\n # RuleConsequenceErrors are allowed to break out of the current assertion,\r\n # then the inner error is bubbled-up to the asserting code.\r\n # @status = FAIL\r\n # raise rce.inner_error\r\n #end\r\n \r\n @assert = false\r\n \r\n return @status\r\n end",
"def process_rules\n @rules.each do |rule|\n rule.process(@commands, @vars)\n end\n\n @commands.uniq!\n end",
"def process_rules *args, &block\n Shotshare::ProcessRuleContainer.instance.rules = \\\n Docile.dsl_eval(Shotshare::Dsl::ProcessRuleBuilder.new, &block).build\nend",
"def remove_predicate_and_its_object_statements(predicate)\n predicate_stmts = @graph.query([nil, predicate, nil])\n predicate_stmts.each { |pstmt|\n pred_obj = pstmt.object\n OA::Graph.subject_statements(pred_obj, @graph).each { |s|\n @graph.delete s\n } if OA::Graph.subject_statements(pred_obj, @graph)\n @graph.delete pstmt\n }\n end",
"def apply_filters(o)\n @filters.keys.find_all{|type| Splib.type_of?(o, type)}.each do |type|\n @filters[type].each_pair do |k,v|\n begin\n case k\n when :filters\n v.each{|f|o = f.filter(o)}\n when :procs\n v.each{|pr|o = pr.call(o)}\n end\n rescue ArgumentError\n # ignore this\n end\n end\n end\n o\n end",
"def rule_handler(rule_object)\n\n # only rules that are not yet triggered should be processed\n unless triggered? rule_object\n\n case\n\n # when there are no questions and no goals\n when rule_object.questions.empty? && rule_object.goal.nil?\n\n # trigger the rule, thus asserting facts and storing in triggered rules\n trigger rule_object\n\n # when the goal is NOT nil\n when !rule_object.goal.nil?\n\n # add to the result rules\n @result_rules << rule_object\n\n # otherwise add to the question rules\n else\n\n # add to the possible questions\n @question_rules << rule_object\n\n end\n\n end\n\n end",
"def clear_rules!\n @rules = []\n end",
"def filter_rule_classes(cfn_model, violations)\n discover_rule_classes(@rule_directory).each do |rule_class|\n begin\n filtered_cfn_model = cfn_model_with_suppressed_resources_removed(\n cfn_model: cfn_model,\n rule_id: rule_class.new.rule_id,\n allow_suppression: @allow_suppression\n )\n audit_result = rule_class.new.audit(filtered_cfn_model)\n violations << audit_result unless audit_result.nil?\n rescue ScriptError, StandardError => rule_error\n raise rule_error unless @isolate_custom_rule_exceptions\n\n STDERR.puts rule_error\n end\n end\n end",
"def apply_rules(rules, obj, status = Nanoc::Core::OutdatednessStatus.new)\n rules.inject(status) do |acc, rule|\n if acc.useful_to_apply?(rule)\n reason = rule.instance.call(obj, @outdatedness_checker)\n if reason\n acc.update(reason)\n else\n acc\n end\n else\n acc\n end\n end\n end",
"def sanitize\n return @conditions if @conditions\n merge_conditions(*(objects.collect { |object| object.sanitize } << {:any => any}))\n end",
"def destroy_old_objs(obj, to_save)\n if obj.respond_to?(:stix_id) && !obj.stix_id.nil?\n obj_to_destroy = obj.class.find_by_stix_id(obj.stix_id)\n if obj_to_destroy.present?\n # Get rid of old indicator things\n obj_to_destroy.stix_markings.destroy_all\n if obj.class == Indicator\n obj_to_destroy.observables.destroy_all\n obj_to_destroy.indicators_course_of_actions.destroy_all\n obj_to_destroy.confidences.destroy_all\n obj_to_destroy.indicator_ttps.destroy_all\n obj_to_destroy.sightings.destroy_all\n # get rid of old stix package things\n elsif obj.class == StixPackage\n obj_to_destroy.indicators_packages.destroy_all\n obj_to_destroy.exploit_target_packages.destroy_all\n obj_to_destroy.packages_course_of_actions.destroy_all\n obj_to_destroy.contributing_sources.destroy_all\n obj_to_destroy.ttp_packages.destroy_all\n # get rid of old COA things\n elsif obj.class == CourseOfAction\n obj_to_destroy.parameter_observables.destroy_all\n # Exploit Targets \n elsif obj.class == ExploitTarget\n obj_to_destroy.exploit_target_vulnerabilities.destroy_all\n obj_to_destroy.exploit_target_course_of_actions.destroy_all\n # Vulnerabilities dont need anything because we just destroy stix markings\n elsif obj.class == Vulnerability\n elsif obj.class == Ttp\n obj_to_destroy.ttp_attack_patterns.destroy_all\n obj_to_destroy.ttp_exploit_targets.destroy_all\n # Attack Patterns dont need anything because we just destroy stix markings\n elsif obj.class == AttackPattern\n end\n end\n # Get rid of old cybox object things\n elsif obj.respond_to?(:cybox_object_id) && !obj.cybox_object_id.nil?\n obj_to_destroy = obj.class.find_by_cybox_object_id(obj.cybox_object_id)\n if obj_to_destroy.present?\n obj_to_destroy.stix_markings.destroy_all\n end\n end\n\n if obj_to_destroy.present? && obj.id != obj_to_destroy.id\n to_save -= [obj_to_destroy]\n obj_to_destroy.destroy\n end\n\n to_save\n end",
"def remove_all_rules\n super\n end",
"def process_rules(state)\n raise(\"No rules have been loaded into engine %s\" % self) if empty?\n\n rules_by_priority do |rule|\n state.mutable = !rule.concurrent?\n result = rule.process_state(state)\n state.mutable = true\n\n state.store_result(result) if result\n end\n\n state.results\n end",
"def apply!(env)\n @rules.each do |rule|\n rule.apply!(env)\n end\n end",
"def clean(classn)\n if classn.is_a?(Array)\n classn.each do |realclassn|\n self.clean(realclassn)\n end\n\n return nil\n end\n\n if @args[:cache] == :weak\n @objects[classn].clean\n elsif @args[:cache] == :none\n return false\n else\n return false if !@objects.key?(classn)\n @objects[classn] = {}\n GC.start\n\n @objects.keys.each do |classn|\n data = @objects[classn]\n classobj = @args[:module].const_get(classn)\n ObjectSpace.each_object(classobj) do |obj|\n begin\n data[obj.id.to_i] = obj\n rescue => e\n if e.message == \"No data on object.\"\n #Object has been unset - skip it.\n next\n end\n\n raise e\n end\n end\n end\n end\n end",
"def prune(obj)\n case obj\n when Array\n return if obj.is_a?(PrunableObject)\n a = obj.map do |i|\n next if i.is_a?(PrunableObject)\n prune(i)\n end.compact.flatten\n a unless a.empty?\n when Hash\n return if obj.is_a?(PrunableObject)\n return obj if obj.empty?\n h = {}\n obj.each do |k, v|\n pruned = prune(v)\n next if pruned.is_a?(PrunableObject)\n h[k] = pruned\n end\n h unless h.empty?\n else\n obj\n end\n end",
"def generate_objects!\n if custom_query?\n results = eval(custom_query)\n else\n objects = any? ? [] : starting_objects.clone\n objects_to_delete = []\n puts \"Evaluating #{starting_objects.size} objects and #{conditions.size} condition(s)...\"\n for obj in starting_objects\n # print \"\\n #{obj.id}: \"\n for condition in conditions\n # print \" [C#{condition.id}:\"\n if condition.passes?(obj)\n # print \"PASS]\"\n objects << obj and break if any?\n else\n # print \"FAIL]\"\n objects_to_delete << obj and break if all?\n end\n end\n end\n results = objects - objects_to_delete\n unless result_variant.blank?\n results = results.collect{|r| r.instance_eval(result_variant)}.flatten\n end\n end\n update_object_ids(results)\n update_attribute(:objects_generated_at, Time.now)\n update_attribute(:objects_count, self.object_ids.values.flatten.uniq.size)\n results\n end",
"def clean_all\n self.clean(@objects.keys)\n end",
"def apply_rules(json, type, rules)\n rules.each do |rule|\n next unless rule.function.call(json)\n rule.metadata = json\n rule.type = type\n\n case rule.modifier\n when :warning\n warnings << rule\n when :error\n errors << rule\n end\n end\n end",
"def retract_rules(rules)\n rules = QL.to_rules(rules)\n GRel::Debugger.debug \"REMOVING FROM SCHEMA #{@schema_graph}\"\n GRel::Debugger.debug rules\n GRel::Debugger.debug \"IN\"\n GRel::Debugger.debug @db_name\n @connection.remove(@db_name, rules, @schema_graph, \"text/turtle\")\n self\n end",
"def unstore_fact(object) \n @bot.debug \"Unstoring #{object}\"\n query = config[:dbh].prepare \"DELETE FROM facts WHERE object=?\"\n query.execute object\n\n query = config[:dbh].prepare \"DELETE FROM aliases WHERE original=?\"\n query.execute object\n return \"Forgetting #{object}\"\n end",
"def delete_facts\r\n @facts = {}\r\n end",
"def postprocess_healthchecks(value)\n value.is_a?(Hash) ? value.prune : value\n end",
"def clean!\n FAKEABLE.map(&:constantize).map(&:destroy_all)\n end",
"def apply_rules(record)\n rules.each do |rule|\n if record.note =~ Regexp.new(rule.trigger)\n rule.effects.each do |effect|\n if effect.change_kind?\n record.kind = effect.value if effect.value.to_i.in? Record.kinds\n elsif effect.change_source_account?\n record.source_account = Account.find(effect.value)\n elsif effect.change_target_account?\n record.target_account = Account.find(effect.value)\n record.target_currency = record.source_currency\n record.kind = Record::KIND_TRANSFER\n record.target_amount = record.source_amount\n elsif effect.add_tag?\n record.tags << Tag.find(effect.value)\n elsif effect.change_party?\n record.party = Party.find(effect.value)\n elsif effect.change_group?\n record.group = Group.find(effect.value)\n elsif effect.change_source_sign?\n record.source_amount *= -1\n elsif effect.change_target_sign?\n record.target_amount *= -1\n elsif effect.remove_record?\n record.destroy\n end\n end\n end\n end\n end",
"def add_relevant_rules_for_fact fact\r\n @rules.values.select { |rule| \r\n if !@relevant_rules.include?( rule)\r\n if rule.parameters_match?(fact.value) \r\n @relevant_rules << rule \r\n logger.debug \"#{rule} is relevant\" if logger\r\n else\r\n logger.debug \"#{rule} is not relevant\" if logger \r\n end \r\n end\r\n } \r\n end",
"def untaint_values( obj )\n\t\tself.log.debug \"Untainting a result %s\" % [ obj.class.name ]\n\t\treturn obj unless obj.tainted?\n\t\tnewobj = nil\n\n\t\tcase obj\n\t\twhen Hash\n\t\t\tnewobj = {}\n\t\t\tobj.each do |key,val|\n\t\t\t\tnewobj[ key ] = untaint_values( val )\n\t\t\tend\n\n\t\twhen Array\n\t\t\t# Arrow::Logger[ self ].debug \"Untainting array %p\" % val\n\t\t\tnewobj = obj.collect {|v| v.dup.untaint}\n\n\t\telse\n\t\t\t# Arrow::Logger[ self ].debug \"Untainting %p\" % val\n\t\t\tnewobj = obj.dup\n\t\t\tnewobj.untaint\n\t\tend\n\n\t\treturn newobj\n\tend",
"def filter(objects) objects end",
"def prepare_rules(rules)\n prepared_rules = rules.each_with_object({}) do |(attribute, rule), copy|\n rule = copy[attribute] = safe_dup(rule)\n\n if rule[:type]\n puts 'Rule key `:type` is deprecated. Use `:calculator` instead.'\n rule[:calculator] = rule[:type]\n end\n\n rule[:calculator] = get_calculator(rule[:calculator])\n\n copy\n end\n prepared_rules = normalize_weights(prepared_rules)\n\n prepared_rules\n end",
"def apply(text)\n raw = process_text(text)\n rule_stack = []\n str = ''\n rule_names = @rules.keys\n raw.each do |r|\n if r.is_a?(Symbol)\n # Part is a rule\n dprint \"\\tRule Symbol #{r}\\n\"\n if r == :close && rule_stack.length >= 1\n # Rule close with 1+ opened rules\n opened = rule_stack.pop\n opened_after = @rules[opened].codes(Rule::Parts[:after])\n dprint \"\\t\\tClose, opened rule '#{opened}'\\n\"\n dprint \"\\t\\t\\tClosing rule '#{opened}' with After\\n\"\n dprint 4,\"After: #{opened_after.inspect}\\n\"\n str.concat(opened_after)\n unless rule_stack.length == 0\n rule_stack.each do |outer|\n outer_inside = @rules[outer].codes(Rule::Parts[:inside])\n # Closed rule was nested in another open rule\n dprint 3, \"Outer rule '#{outer}' still open. Restoring Inside\\n\"\n dprint 4, \"Inside: #{outer_inside.inspect}\\n}\"\n str.concat(outer_inside)\n end\n end\n # binding.pry\n # outer = rule_stack[-1]\n # outer_inside = @rules[outer].codes(Rule::Parts[:inside])\n # # Closed rule was nested in another open rule\n # dprint 3, \"Outer rule '#{outer}' still open. Restoring Inside\\n\"\n # dprint 4, \"Inside: #{outer_inside.inspect}\\n}\"\n # str.concat(outer_inside)\n # # binding.pry\n # end\n elsif r == :reset && rule_stack.length == 0\n # no opened outer rules, reset symbol given\n dprint \"\\t\\tReset, no opened rule\\n\"\n str.concat(@rules[r].codes(Rule::Parts[:after]))\n elsif rule_names.include?(r)\n # New rule to apply\n dprint \"\\t\\tApplying new rule '#{r}'\\n\"\n dprint 3, \"Previous active rule `#{rule_stack[-1]}`\\n\"\n rule_stack.push r\n str.concat(@rules[r].codes(Rule::Parts[:inside]))\n end\n else\n # Part is text\n str.concat(r)\n end\n end\n str\n end",
"def apply(hash)\n raise ArgumentError, \"Hash expected (did you invoked an action without a Hash?)\" unless Hash===hash\n converted, failures = hash.dup, []\n failures = @rules.collect{|rule| rule.convert_and_validate(converted)}.compact\n failures.empty? ? [true, converted] : [false, failures]\n end",
"def evaluate\n results = {}\n traits.each do |trait|\n results[trait] = trait.new(@strokes ).trait.to_a.sort\n end\n results\n end",
"def passes?(obj)\n method_key = valid_criteria[attribute_name][\"operators\"] rescue nil\n if method_key.nil?\n return false unless DEFAULT_EVAL_METHODS.include?(eval_method)\n t_eval_method = (eval_method == \"match\" || eval_method == \"include?\") ? \".#{eval_method}\" : \" #{eval_method}\"\n eval_string = \"obj.instance_eval(\\\"#{attribute_name}\\\")#{t_eval_method} \\\"#{value.to_s}\\\"\"\n # puts eval_string\n eval eval_string, binding\n else\n eval_string = method_key[eval_method]\n eval_string.gsub!(\"$1\", \"obj\")\n eval_string.gsub!(\"$2\", (values == \"boolean\" ? value : \"\\\"#{value}\\\"\"))\n # puts eval_string\n eval eval_string, binding\n end\n end",
"def each_typed_rule_match(type, rule, subject, match, permissive, &b)\n if rule.atom?\n process_rule_atom(type, rule, subject, match, permissive, &b)\n elsif rule.s_exp?\n process_typed_rule_s_exp(type, rule, subject, match, &b)\n else\n raise RuleException, \"Internal error\"\n end\n end",
"def convert_obj(obj)\n if obj.kind_of? Basic_class\n return obj.eval\n elsif obj.instance_of? Variable_class\n return obj.eval\n elsif obj.kind_of? Basic_container\n return obj\n elsif obj.instance_of? Call_Func\n return obj.eval\n elsif obj.instance_of? Func_class\n return obj.eval\n elsif obj.instance_of? Return_class\n return obj.value\n elsif obj.instance_of? Comp_not_class\n return obj.value.eval\n else\n return obj\n end\n Bool_class.new('bool', 'FALSE')\nend",
"def remove_policies(_sec, _ptype, _rules); end",
"def delete_all_rules(rules)\n return if rules.nil?\n\n @ids = rules['data'].map { |rule| rule['id'] }\n @payload = { delete: { ids: @ids } }\n @options = {\n headers: {\n \"User-Agent\": 'v2FilteredStreamRuby',\n \"Authorization\": \"Bearer #{@bearer_token}\",\n \"Content-type\": 'application/json'\n },\n body: JSON.dump(@payload)\n }\n @response = Typhoeus.post(@rules_url, @options)\n raise \"An error occurred while deleting your rules: #{@response.status_message}\" unless @response.success?\nend",
"def discardAllTreasures\n \n end",
"def evaluate\n made_discovery = true\n while made_discovery do\n made_discovery = self.rules.any? do |rule|\n if rule.fired?\n false\n else\n rule.evaluate\n rule.fired?\n end\n end\n end\n end",
"def clear_summative_task_criterions\n if (objectives.empty?) # if objectives are clear, then clear out summative_task_criterions\n summative_tasks.each do |x|\n x.criterions.clear\n end\n else # delete criterions from summative_tasks that are not not contained by objectives\n summative_tasks.each do |task|\n task.criterions.each do |criterion|\n task.criterions.delete(criterion) unless objectives.collect(&:criterion).include?(criterion)\n end\n end\n end\n end",
"def process(object, options={})\n object = unstring(object)\n return object unless has_filter?\n filtered = !filter.flatten.uniq.index(options[:row]).nil?\n pattern.each do |p|\n filtered = (filtered or !(object =~ Regexp.new(p)).nil?)\n end\n filtered = (filtered or match_boolean_filter?(object.split(';')))\n filtered ? object : nil\n end",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def run(model, runner, user_arguments)\n super(model, runner, user_arguments)\n\n # use the built-in error checking\n if !runner.validateUserArguments(arguments(model), user_arguments)\n return false\n end\n\n # assign the user inputs to variables\n remove_unused_space_types = runner.getBoolArgumentValue(\"remove_unused_space_types\",user_arguments)\n remove_unused_load_defs = runner.getBoolArgumentValue(\"remove_unused_load_defs\",user_arguments)\n remove_unused_schedules = runner.getBoolArgumentValue(\"remove_unused_schedules\",user_arguments)\n remove_unused_constructions = runner.getBoolArgumentValue(\"remove_unused_constructions\",user_arguments)\n\n # report initial condition of model\n runner.registerInitialCondition(\"The model started with #{model.numObjects.to_s} objects.\")\n\n # remove orphan space infiltration objects\n orphan_flag = false\n model.getSpaceInfiltrationDesignFlowRates.sort.each do |instance|\n if instance.spaceType.is_initialized == false and instance.space.is_initialized == false\n runner.registerInfo(\"Removing orphan space infiltration object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan space infiltration objects were found\")\n end\n\n # todo - add section to remove orphan effective leakage\n\n # remove orphan design spec oa objects\n orphan_flag = false\n model.getDesignSpecificationOutdoorAirs.sort.each do |instance|\n if instance.directUseCount == 0\n runner.registerInfo(\"Removing orphan design specification outdoor air object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan design specification outdoor air objects were found\")\n end\n\n # remove orphan load instances\n orphan_flag = false\n model.getSpaceLoadInstances.sort.each do |instance|\n if instance.spaceType.is_initialized == false and instance.space.is_initialized == false\n\n # extra check for water use equipment. They may or may not have space. But they should have a water use connection\n if instance.to_WaterUseEquipment.is_initialized and instance.to_WaterUseEquipment.get.waterUseConnections.is_initialized\n next\n end\n\n runner.registerInfo(\"Removing orphan load instance object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan load instance objects were found\")\n end\n\n # remove orphan surfaces\n orphan_flag = false\n model.getSurfaces.sort.each do |surface|\n if not surface.space.is_initialized\n runner.registerInfo(\"Removing orphan base surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan base surfaces were found\")\n end\n\n # remove orphan subsurfaces\n orphan_flag = false\n model.getSubSurfaces.sort.each do |subsurface|\n if not subsurface.surface.is_initialized\n runner.registerInfo(\"Removing orphan sub surface named #{subsurface.name}\")\n subsurface.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan sub surfaces were found\")\n end\n\n # remove orphan shading surfaces\n orphan_flag = false\n model.getShadingSurfaces.sort.each do |surface|\n if not surface.shadingSurfaceGroup.is_initialized\n runner.registerInfo(\"Removing orphan shading surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan shading surfaces were found\")\n end\n\n # remove orphan interior partition surfaces\n orphan_flag = false\n model.getInteriorPartitionSurfaces.sort.each do |surface|\n if not surface.interiorPartitionSurfaceGroup.is_initialized\n runner.registerInfo(\"Removing orphan interior partition surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if not orphan_flag\n runner.registerInfo(\"No orphan interior partition surfaces were found\")\n end\n\n # find and remove orphan LifeCycleCost objects\n lcc_objects = model.getObjectsByType(\"OS:LifeCycleCost\".to_IddObjectType)\n #make an array to store the names of the orphan LifeCycleCost objects\n orphaned_lcc_objects = Array.new\n #loop through all LifeCycleCost objects, checking for missing Item Name\n lcc_objects.each do |lcc_object|\n if lcc_object.isEmpty(4)\n orphaned_lcc_objects << lcc_object.handle\n puts \"**(removing object)#{lcc_object.name} is not connected to any model object\"\n runner.registerInfo(\"Removing orphan lifecycle cost named #{lcc_object.name}\")\n lcc_object.remove\n end\n end\n #summarize the results\n if not orphaned_lcc_objects.length > 0\n runner.registerInfo(\"no orphaned LifeCycleCost objects were found\")\n end\n\n # todo - remove surfaces that would trigger error in E+ (less than 3 vertices or too small.)\n\n\n # todo - remove empty shading and interior partition groups. Don't think we would want to do this to spaces, since they may contain space types or loads\n\n\n # remove unused space types\n if remove_unused_space_types\n unused_flag_counter = 0\n model.getSpaceTypes.sort.each do |resource|\n if resource.spaces.size == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused space types\")\n end\n\n # remove unused load defs\n if remove_unused_load_defs\n unused_flag_counter = 0\n model.getSpaceLoadDefinitions.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused load definitions\")\n end\n\n # remove unused default schedule sets\n if remove_unused_schedules\n unused_flag_counter = 0\n model.getDefaultScheduleSets.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused default schedules sets\")\n end\n\n # remove unused default schedules\n if remove_unused_schedules\n unused_flag_counter = 0\n model.getSchedules.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused schedules\")\n end\n\n # remove unused default schedule sets\n if remove_unused_constructions\n\n unused_flag_counter = 0\n model.getDefaultConstructionSets.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused default construction sets\")\n\n # remove default surface and sub surface constructions, but dont' report\n # these are typically hidden from users and reporting it may be more confusing that helpful\n unused_flag_counter = 0\n model.getDefaultSurfaceConstructionss.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n #runner.registerInfo(\"Removed #{unused_flag_counter} unused default surface constructions\")\n\n unused_flag_counter = 0\n model.getDefaultSubSurfaceConstructionss.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n #runner.registerInfo(\"Removed #{unused_flag_counter} unused default sub surface constructions\")\n\n # remove default constructions\n unused_flag_counter = 0\n model.getConstructions.sort.each do |resource|\n if resource.directUseCount == 1 # still don't understand why this is 1 not 0\n unused_flag_counter += 1\n resource.remove\n else # this was just put in for testing ot understand why directUseCount isn't 0\n #puts \"\"\n #puts \"Name #{resource.name}\"\n #puts \"directUseCount = #{resource.nonResourceObjectUseCount}\"\n #puts \"nonResourceObjectUseCount = #{resource.nonResourceObjectUseCount}\"\n #puts \"targets.size = #{resource.targets.size}\"\n #puts \"sources.size = #{resource.sources.size}\"\n\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused constructions\")\n\n # remove unused materials\n unused_flag_counter = 0\n model.getMaterials.sort.each do |resource|\n if resource.directUseCount == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused materials\")\n\n end\n\n # report final condition of model\n runner.registerFinalCondition(\"The model finished with #{model.numObjects.to_s} objects.\")\n\n return true\n\n end",
"def assert(predicate, object, type=nil, lang=nil)\n if predicate.could_be_a_safe_curie?\n uri = URI.parse(Curie.parse predicate)\n else\n uri = URI.parse(predicate)\n end\n ns = nil\n elem = nil\n if uri.fragment\n ns, elem = uri.to_s.split('#')\n ns << '#'\n else\n elem = uri.path.split('/').last\n ns = uri.to_s.sub(/#{elem}$/, '')\n end\n attr_name = ''\n if i = @namespaces.index(ns)\n attr_name = \"n#{i}_#{elem}\"\n else\n @namespaces << ns\n attr_name = \"n#{@namespaces.index(ns)}_#{elem}\"\n end\n \n # if type is not given, value is same as object\n unless type\n val = object\n # if type is given, object is converted according to type\n else\n \n @modifiers[object.object_id] ||={}\n @modifiers[object.object_id][:type] = type # fallback to ...\n val = case type\n when 'http://www.w3.org/2001/XMLSchema#dateTime' then DateTime.parse(object)\n when 'http://www.w3.org/2001/XMLSchema#date' then Date.parse(object)\n when 'http://www.w3.org/2001/XMLSchema#int' then object.to_i\n when 'http://www.w3.org/2001/XMLSchema#string' then object.to_s\n when 'http://www.w3.org/2001/XMLSchema#boolean'\n if object.downcase == 'true' || object == '1'\n true\n else\n false\n end\n else\n object\n end\n end\n\n # if lang is given, object is converted according to type\n if lang\n @modifiers[object.object_id] ||={}\n @modifiers[val.object_id][:language] = lang \n end\n if self.instance_variable_defined?(\"@#{attr_name}\")\n unless self.instance_variable_get(\"@#{attr_name}\").is_a?(Array)\n att = self.instance_variable_get(\"@#{attr_name}\")\n self.instance_variable_set(\"@#{attr_name}\", [att])\n end\n self.instance_variable_get(\"@#{attr_name}\") << val\n else\n self.instance_variable_set(\"@#{attr_name}\", val)\n end\n end",
"def run(model, runner, user_arguments)\n super(model, runner, user_arguments)\n\n # use the built-in error checking\n if !runner.validateUserArguments(arguments(model), user_arguments)\n return false\n end\n\n # assign the user inputs to variables\n remove_unused_space_types = runner.getBoolArgumentValue('remove_unused_space_types', user_arguments)\n remove_unused_load_defs = runner.getBoolArgumentValue('remove_unused_load_defs', user_arguments)\n remove_unused_schedules = runner.getBoolArgumentValue('remove_unused_schedules', user_arguments)\n remove_unused_curves = runner.getBoolArgumentValue('remove_unused_curves', user_arguments)\n remove_unused_constructions = runner.getBoolArgumentValue('remove_unused_constructions', user_arguments)\n\n # report initial condition of model\n runner.registerInitialCondition(\"The model started with #{model.numObjects} objects.\")\n\n # remove orphan space infiltration objects\n orphan_flag = false\n model.getSpaceInfiltrationDesignFlowRates.sort.each do |instance|\n if (instance.spaceType.is_initialized == false) && (instance.space.is_initialized == false)\n runner.registerInfo(\"Removing orphan space infiltration object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan space infiltration objects were found')\n end\n\n # TODO: - add section to remove orphan effective leakage\n\n # remove orphan design spec oa objects\n orphan_flag = false\n model.getDesignSpecificationOutdoorAirs.sort.each do |instance|\n if instance.directUseCount(excludeChildren=true) == 0\n runner.registerInfo(\"Removing orphan design specification outdoor air object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan design specification outdoor air objects were found')\n end\n\n # remove orphan load instances\n orphan_flag = false\n model.getSpaceLoadInstances.sort.each do |instance|\n if (instance.spaceType.is_initialized == false) && (instance.space.is_initialized == false)\n\n # extra check for water use equipment. They may or may not have space. But they should have a water use connection\n if instance.to_WaterUseEquipment.is_initialized && instance.to_WaterUseEquipment.get.waterUseConnections.is_initialized\n next\n end\n\n runner.registerInfo(\"Removing orphan load instance object named #{instance.name}\")\n instance.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan load instance objects were found')\n end\n\n # remove orphan surfaces\n orphan_flag = false\n model.getSurfaces.sort.each do |surface|\n if !surface.space.is_initialized\n runner.registerInfo(\"Removing orphan base surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan base surfaces were found')\n end\n\n # remove orphan subsurfaces\n orphan_flag = false\n model.getSubSurfaces.sort.each do |subsurface|\n if !subsurface.surface.is_initialized\n runner.registerInfo(\"Removing orphan sub surface named #{subsurface.name}\")\n subsurface.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan sub surfaces were found')\n end\n\n # remove orphan shading surfaces\n orphan_flag = false\n model.getShadingSurfaces.sort.each do |surface|\n if !surface.shadingSurfaceGroup.is_initialized\n runner.registerInfo(\"Removing orphan shading surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan shading surfaces were found')\n end\n\n # remove orphan interior partition surfaces\n orphan_flag = false\n model.getInteriorPartitionSurfaces.sort.each do |surface|\n if !surface.interiorPartitionSurfaceGroup.is_initialized\n runner.registerInfo(\"Removing orphan interior partition surface named #{surface.name}\")\n surface.remove\n orphan_flag = true\n end\n end\n if !orphan_flag\n runner.registerInfo('No orphan interior partition surfaces were found')\n end\n\n # find and remove orphan LifeCycleCost objects\n lcc_objects = model.getObjectsByType('OS:LifeCycleCost'.to_IddObjectType)\n # make an array to store the names of the orphan LifeCycleCost objects\n orphaned_lcc_objects = []\n # loop through all LifeCycleCost objects, checking for missing Item Name\n lcc_objects.each do |lcc_object|\n if lcc_object.isEmpty(4)\n orphaned_lcc_objects << lcc_object.handle\n puts \"**(removing object)#{lcc_object.name} is not connected to any model object\"\n runner.registerInfo(\"Removing orphan lifecycle cost named #{lcc_object.name}\")\n lcc_object.remove\n end\n end\n # summarize the results\n if orphaned_lcc_objects.length <= 0\n runner.registerInfo('no orphaned LifeCycleCost objects were found')\n end\n\n # TODO: - remove surfaces that would trigger error in E+ (less than 3 vertices or too small.)\n\n # TODO: - remove empty shading and interior partition groups. Don't think we would want to do this to spaces, since they may contain space types or loads\n\n # remove unused space types\n if remove_unused_space_types\n unused_flag_counter = 0\n model.getSpaceTypes.sort.each do |resource|\n if resource.spaces.empty?\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused space types\")\n end\n\n # remove unused load defs\n if remove_unused_load_defs\n unused_flag_counter = 0\n model.getSpaceLoadDefinitions.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused load definitions\")\n end\n\n # remove unused default schedule sets\n if remove_unused_schedules\n unused_flag_counter = 0\n model.getDefaultScheduleSets.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused default schedules sets\")\n end\n\n # remove unused default schedules\n if remove_unused_schedules\n unused_flag_counter = 0\n model.getSchedules.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused schedules\")\n end\n\n # remove unused curves\n if remove_unused_curves\n unused_flag_counter = 0\n model.getCurves.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n # work-around logic since <OpenStudio::Model::Curve>.remove doesn't work\n model.removeObject(resource.handle)\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused curves\")\n end\n\n # remove unused default schedule sets\n if remove_unused_constructions\n\n unused_flag_counter = 0\n model.getDefaultConstructionSets.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused default construction sets\")\n\n # remove default surface and sub surface constructions, but dont' report\n # these are typically hidden from users and reporting it may be more confusing that helpful\n unused_flag_counter = 0\n model.getDefaultSurfaceConstructionss.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n # runner.registerInfo(\"Removed #{unused_flag_counter} unused default surface constructions\")\n\n unused_flag_counter = 0\n model.getDefaultSubSurfaceConstructionss.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n # runner.registerInfo(\"Removed #{unused_flag_counter} unused default sub surface constructions\")\n\n # remove default constructions\n unused_flag_counter = 0\n model.getConstructions.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused constructions\")\n\n # remove unused materials\n unused_flag_counter = 0\n model.getMaterials.sort.each do |resource|\n if resource.directUseCount(excludeChildren=true) == 0\n unused_flag_counter += 1\n resource.remove\n end\n end\n runner.registerInfo(\"Removed #{unused_flag_counter} unused materials\")\n\n end\n\n # report final condition of model\n runner.registerFinalCondition(\"The model finished with #{model.numObjects} objects.\")\n\n return true\n end",
"def unclear(object)\n toys = object[0]\n toys.each do |toy|\n add_toy(toy)\n end\n strokes = object[1]\n strokes.each do |stroke|\n add_stroke(stroke)\n end\n end",
"def fact( obj )\r\n #begin\r\n # check if facts already exist for that class\r\n # if so, we need to add it to the existing list\r\n cls = obj.class.to_s.downcase\r\n cls.gsub!(/:/, '_')\r\n if @facts.key? cls\r\n logger.debug( \"adding to facts: #{cls}\") if logger\r\n @facts[cls].fact_value << obj\r\n else\r\n logger.debug( \"creating facts: #{cls}\") if logger\r\n arr = Array.new\r\n arr << obj\r\n proc = Proc.new { arr }\r\n @facts[cls] = Facts.new(self, cls, proc ) \r\n end\r\n #rescue Exception=> e\r\n # logger.error e if logger\r\n #end\r\n end",
"def fact!\n @predicate << Rule.new(self, true)\n self\n end",
"def __clean__!(object=self)\n format = DataCleaner::Formats.formats[object.class.name]\n \n format.attributes.each do |attribute, arguments|\n object.send(:\"#{attribute}=\", __replacement__(arguments, object))\n end\n object\n end",
"def get_modifying_rules(agent, opponent)\n modified_by = Hash.new { [[],[]] }\n track = lambda do |set, index|\n set.each_with_index do |rule, rule_i|\n rule.alternatives.each do |alt|\n alt.modifiers.each do |mod|\n arr = modified_by[mod.predicate]\n arr[index] << [rule_i, mod.type]\n modified_by[mod.predicate] = arr\n end\n end\n end\n end\n track.call(agent.actions, 0)\n track.call(opponent.rules, 1)\n return modified_by\n end",
"def method_missing(name,*args,&block)\n # NoMethodError should be raised on this object\n super unless rules.respond_to?(name)\n rules.send(name,*args,&block)\n end",
"def >>(*object)\n object = object.flatten\n \n # Convert any IDs (strings) into their correct objects.\n object.map! { |o| o.kind_of?(String) && PublicEarth::Db::Base.find_in_general(o) || o }\n object.compact!\n\n places = object.select { |o| o.kind_of?(Atlas::Place) }\n remove_place(*places) unless places.blank?\n\n categories = object.select { |o| o.kind_of?(PublicEarth::Db::Category) || o.kind_of?(Atlas::Category) }\n remove_category(*categories) unless categories.blank?\n \n sources = object.select { |o| o.kind_of?(PublicEarth::Db::Source) || o.kind_of?(Atlas::Source)}\n remove_source(*sources) unless sources.blank?\n \n self\n end",
"def machinize(attr, obj)\n self.semantic_attributes[attr].predicates.inject(obj) { |val, predicate| val = predicate.from_human(val) }\n end",
"def triggered_rules_from_encrypted(encrypted)\n\n # TODO: add decryption\n\n # create a new rules array\n rules = Array.new\n\n # decrypt the data\n string = encrypted\n\n # get the array back\n array = JSON.parse string\n\n # iterate the array\n array.each do |hash|\n\n # get the rule back\n rule = retrieve_rule hash['name']\n\n # create a new facts array\n facts = []\n\n # retrieve each of the facts\n hash['facts'].each do |fact|\n\n # create a new fact for each\n facts << create_fact(fact['name'], fact['value'])\n\n end\n\n # replace the facts on the rule\n rule.facts = facts\n\n # add to the array\n rules << rule\n\n end\n\n # return the rules array\n rules\n\n end",
"def remove_inherited_rules\n new_list = self.class.new({})\n\n rules.keys.sort.each do |name|\n new_rule = Permissions::Rule.new(resource: name)\n parent = new_rule.parent\n\n rules[name].privileges.each do |k, v|\n new_rule.privileges[k] = v if v && !new_list.authorized?(k, parent)\n end\n\n new_list << new_rule unless new_rule.empty?\n end\n\n new_list\n end",
"def __clean__(object=self)\n __clean__!(object.dup)\n end",
"def finalize\n # sort rules by alphabetical order, grouped by chain, else they arrive in\n # random order and cause puppet to reload iptables rules.\n @@rules.each_key {|key|\n @@rules[key] = @@rules[key].sort_by {|rule| [rule[\"chain_prio\"], rule[\"name\"]] }\n }\n\n # load pre and post rules\n load_rules_from_file(@@rules, @@pre_file, :prepend)\n load_rules_from_file(@@rules, @@post_file, :append)\n\n # add numbered version to each rule\n @@table_counters.each_key { |table|\n rules_to_set = @@rules[table]\n if rules_to_set\n counter = 1\n rules_to_set.each { |rule|\n rule['numbered rule'] = counter.to_s + \" \"+rule[\"full rule\"]\n rule['altned rule'] = counter.to_s + \" \"+rule[\"alt rule\"]\n counter += 1\n }\n end\n }\n\n # On the first round we delete rules which do not match what\n # we want to set. We have to do it in the loop until we\n # exhaust all rules, as some of them may appear as multiple times\n while self.delete_not_matched_rules > 0\n end\n\n # Now we need to take care of rules which are new or out of order.\n # The way we do it is that if we find any difference with the\n # current rules, we add all new ones and remove all old ones.\n if self.rules_are_different\n # load new new rules\n benchmark(:notice, self.noop ? \"rules would have changed... (noop)\" : \"rules have changed...\") do\n # load new rules\n @@table_counters.each { |table, total_do_delete|\n rules_to_set = @@rules[table]\n if rules_to_set\n rules_to_set.each { |rule_to_set|\n if self.noop\n debug(\"Would have run 'iptables -t #{table} #{rule_to_set['alt rule']}' (noop)\")\n next\n else\n debug(\"Running 'iptables -t #{table} #{rule_to_set['alt rule']}'\")\n `#{@@iptables_dir}/iptables -t #{table} #{rule_to_set['alt rule']}`\n end\n }\n end\n }\n\n # delete old rules\n @@table_counters.each { |table, total_do_delete|\n current_table_rules = @@current_rules[table]\n if current_table_rules\n current_table_rules.each { |rule, data|\n if self.noop\n debug(\"Would have run 'iptables -t #{table} -D #{data['chain']} 1' (noop)\")\n next\n else\n debug(\"Running 'iptables -t #{table} -D #{data['chain']} 1'\")\n `#{@@iptables_dir}/iptables -t #{table} -D #{data['chain']} 1`\n end\n }\n end\n }\n # Run iptables save to persist rules. The behaviour is to do nothing\n # if we no nothing of the operating system.\n persist_cmd = case Facter.value(:operatingsystem).downcase\n when /(fedora|redhat|centos)/ then \"/sbin/service iptables save\"\n when /(ubuntu|debian)/ then \"/sbin/iptables-save > /etc/iptables.rules\"\n else nil\n end\n debug(\"Saving iptables with: #{persist_cmd}\")\n unless(persist_cmd == nil) then\n\t system(persist_cmd)\n end\n end\n\n @@rules = {}\n end\n\n @@finalized = true\n end",
"def add_rule(rule_object)\n\n # store the rule\n @rules[rule_object.name] = rule_object\n\n case\n\n # rule which asserts facts without conditions or questions\n when rule_object.matcher.nil? && rule_object.questions.empty?\n\n # add the rule to the fact rules array, contains rules with only facts\n @fact_rules << rule_object\n\n when rule_object.matcher.nil? && rule_object.questions.count > 0\n\n # rules can be triggered directly\n @start_rules << rule_object\n\n else\n\n # get the matcher\n matcher = rule_object.matcher\n\n # get the matcher type (any / all)\n matcher_type = matcher.type\n\n # generate the ruleby conditions based on the matcher conditions\n conditions = create_conditions matcher.conditions\n\n # switch statement for the matcher type\n case matcher_type\n\n # all the conditions must match\n when :all\n\n # star to convert array to arguments\n rule AND *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n # one of the conditions must match\n when :any\n\n # star to convert array to arguments\n rule OR *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n else\n raise \"Unknown matcher type #{matcher.type}\"\n\n end\n\n end\n\n end",
"def update_from_object(obj)\n\t\tfor to_type,fields in [[\"to_block_length\",%w{x y z stance}],[\"to_rotation_in_degrees\",%w{yaw pitch}],[\"to_i\",[\"is_on_ground\"]]]\n\t\t\tfor field in fields do\n\t\t\t\t#puts \"checking field #{field}\"\n\t\t\t\tif obj.respond_to?(field)\n\t\t\t\t\tinstance_variable_set(\"@\"+field,obj.send(field).send(to_type))\n\t\t\t\t#\tputs \"\\tset field #{field} to value #{obj.send(field)} enforcing type #{to_type}\"\n\t\t\t\tend\n\t\t\t\t\n\t\t\tend\n\t\tend\n\tend",
"def remove( *ruleses )\n self.dup.remove!( *ruleses )\n end",
"def trim_objectives\n return if objectives.empty? # do nothing\n\n if unit_planner.objectives.empty?\n objectives.clear\n else\n self.objectives = (unit_planner.objectives & self.objectives)\n end\n end",
"def convert(obj)\n ret = convert_proc.call(obj)\n filters.execute(ret)\n end",
"def object_def!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 91 )\n\n type = OBJECT_DEF\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 212:14: 'object'\n match( \"object\" )\n\n \n @state.type = type\n @state.channel = channel\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 91 )\n\n end",
"def calculate\n candidates = []\n\n generalized_cause = NLU::Generalization.new(symbols: @symbols).generalize(@cause)\n\n #ap \"sentence: #{cause_sentence}\"\n #ap \"learned: #{@learned.inspect}\"\n\n # We go through everything that was learned before\n @learned.each do |function_name, criteria|\n criteria[:generalizations].each do |generalization|\n\n # We generate a pre-candidate for this generalization. It starts\n # with score zero because we don't know yet whether this criteria\n # fits the sentence or not.\n local_candidate = {\n fn: function_name,\n attrs: { },\n score: 0.0\n }\n\n #ap \"generalized_cause #{generalized_cause}\"\n\n # We then generalize the cause sentence and go through it.\n # We will match *each* learned generalization against the cause\n # generalization.\n generalized_cause.each_with_index do |cause_rule, cause_index|\n\n\n # Wildcard\n #\n # Matches these:\n #\n # > i want a [type:wildcard:some_name_for_this_wildcard]\n # > i want a ford\n #\n wildcard = \"[#{NLU::Generalization::RESERVED_TYPES[:wildcard]}]\"\n #ap \"wildcard: #{wildcard}\"\n wildcard_regex = Regexp.escape(wildcard)\n if generalization =~ /wildcard/i\n wildcard_generalization = generalization\n .gsub(/\\[(type:wildcard)(.+)\\]/i, '[\\1]')\n end\n #ap \"wildcard_generalization(#{wildcard_generalization}) =~ cause_rule(#{wildcard_regex})\"\n if wildcard_generalization.to_s =~ Regexp.new(wildcard_regex, Regexp::IGNORECASE)\n #ap \"true -> #{wildcard_generalization} =~ /#{Regexp.new(wildcard_regex, Regexp::IGNORECASE)}/i\"\n\n rule = wildcard_generalization.gsub(\"#{wildcard}\", \"(.+)\")\n #ap \"rule #{rule}\"\n #binding.pry\n if value = cause_sentence.join(\" \").match(Regexp.new(rule, Regexp::IGNORECASE))\n value = value[-1]\n prop = attr_name_from_type_param(generalization)\n\n local_candidate = local_candidate.merge({\n attrs: {\n prop => value\n },\n score: 0.75\n })\n end\n\n # If we find a learned generalization that matches the generalized\n # sentence, we will save it.\n elsif generalization == cause_rule\n cause_rule.split(\" \").each_with_index do |typed_string, index|\n\n # If the learned generalization has a type anywhere, we will\n # check what is the corresponding word in the cause sentence.\n #\n # For example, consider the following sentence:\n #\n # [type:subject] want a [type:make]\n #\n # and the sentence\n #\n # I want a ford\n #\n # Finding `[type:make]` at position 3 of the array, we will\n # get `ford` at the position 3 of the cause sentence. With\n # that we can come up with `{make: 'ford'}`.\n #\n if typed_string =~ /\\[type/i\n local_candidate[:score] += 1\n type = attr_name_from_type_param(typed_string)\n prop = type_properties(type)\n type_token_length = prop[:token_length]\n\n # In `i want a car`, this will get the `i`. If the type\n # says instead that it's formed by two symbols (e.g\n # `i want`), then it will take `i want`.\n #\n # The -1 in the brackets is because otherwise it would be\n # translated to the following if the type had 1 symbol\n #\n # cause_sentence[1..1+1]\n #\n # That would take 2 words (`[1..2]`). We want one word, so\n #\n # cause_sentence[1..1+1-1]\n #\n word_for_type = cause_sentence[index..index+(type_token_length-1)]\n #ap \"> type: #{type} - #{index} #{cause_sentence[index..index+type_token_length]}\"\n\n local_candidate[:attrs][type] = word_for_type.join(\" \")\n\n # When it's just the same sentence as one seen before, no\n # generalizations\n else\n local_candidate[:score] = 1\n end\n end\n\n end\n end\n\n if local_candidate[:score] > 0\n candidates << local_candidate\n end\n end\n end\n\n # TODO - normalization is taking out some elements that are good.\n #candidates = normalize_scores(candidates)\n candidates = pick_candidates(candidates)\n candidates = merge_attributes(candidates)\n\n candidates\n end",
"def deconvert\n # release magic!\n eval(abstract_object[:_magic])\n end",
"def apply_rules_multi(rules, objs)\n objs.inject(Nanoc::Core::OutdatednessStatus.new) { |acc, elem| apply_rules(rules, elem, acc) }\n end",
"def rules_by_name; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def flush\n @facts.each { |_name, fact| fact.flush }\n @external_facts_loaded = nil\n end",
"def rule_member_ids\n results = []\n\n # Step One: Build groups out of each 'is' rule,\n # grouping rules of similar type together via OR\n # Note: we ignore the 'loginid' column as it is calculated separately\n # Produce an array of arrays: outer array items represent each column type used, inner arrays are all group rule IDs for that specific column type\n # e.g. id: 1 \"organization is\", id: 2 \"organization is\", id: 3 \"department is\" produces: [ [1,2] , [3] ]\n GroupRule.select(:group_rule_result_set_id, :column)\n .where(group_id: id)\n .where(condition: 'is')\n .where.not(column: 'loginid')\n .group_by(&:column)\n .map { |set| set[1].map(&:group_rule_result_set_id) }.each do |rule_set_ids|\n rule_set_results = GroupRuleResult.select(:entity_id)\n .joins(:group_rule_result_set)\n .where(group_rule_result_set_id: rule_set_ids)\n .map(&:entity_id)\n results << rule_set_results\n end\n\n # Step Two: AND all groups from step one together\n results = results.inject(results.first) { |sum, n| sum &= n }\n results ||= [] # reduce/inject may return nil\n\n # Step Three: Pass over the result from step two and\n # remove anybody who violates an 'is not' rule\n negative_results = []\n GroupRule.select(:group_rule_result_set_id, :column)\n .where(group_id: id)\n .where(condition: 'is not')\n .group_by(&:column)\n .map { |set| set[1].map(&:group_rule_result_set_id) }.each do |rule_set_ids|\n negative_results << GroupRuleResult.select(:entity_id)\n .joins(:group_rule_result_set)\n .where(group_rule_result_set_id: rule_set_ids)\n .map(&:entity_id)\n end\n\n results -= negative_results.flatten.uniq\n\n # Step Four: Process any 'loginid is' rules\n rules.select { |r| r.condition == 'is' && r.column == 'loginid' }.each do |rule|\n # Rails.logger.debug \"Processing loginid is rule #{rule.value}...\"\n results << rule.result_set.results.map(&:entity_id)\n end\n\n results.flatten!\n\n return results # rubocop:disable Style/RedundantReturn\n end",
"def each\n @rules.each {|rule, obj| yield obj }\n end",
"def subsequent_rules(*args); end",
"def subsequent_rules(*args); end",
"def apply_rules\n @matrix.each(&:apply_rules!)\n end",
"def update_from_params(params)\n\n if params.has_key? :triggered_rules\n\n # all the posted triggered rules\n posted_triggered_rules = triggered_rules_from_encrypted(params[:triggered_rules])\n\n # trigger all the triggered rules?\n posted_triggered_rules.each do |rule|\n\n # trigger all the previous triggered rules\n trigger rule\n\n end\n\n end\n\n # do some checks for stuff needed in the params\n if params.has_key? :current_rule\n\n # get the posted rule\n posted_rule = retrieve_rule(params[:current_rule])\n\n # get the posted facts\n posted_facts = facts_from_params params\n\n # add the facts to the posted rule\n posted_rule.facts.concat posted_facts\n\n # trigger the posted rule\n trigger posted_rule\n\n end\n\n # TODO: set the engine_match boolean to false??\n\n end",
"def remove_rule(opts)\n opts = check_params(opts,[:rules])\n super(opts)\n end",
"def remove_facts(data)\n record_id = assert_record_id(data)\n delete_facts_record record_id, data\n end",
"def purge_associations\n EspRulesList.where(list_type: type, list_id: id).delete_all\n ExportedLead.where(list_type: type, list_id: id).delete_all\n MessageAutoResponse.where(esp_list_type: type, esp_list_id: id).delete_all\n end",
"def match_existing_fact_type context, options = {}\n raise \"Cannot match a clause that contains no object types for #{self.inspect}\" if nps.size == 0\n raise \"Internal error, clause already matched, should not match again\" if @fact_type\n\n if is_naked_object_type\n np = nps[0] # \"There can be only one\"\n return true unless np.nested_clauses\n np.nested_clauses.each do |nested|\n ft = nested.match_existing_fact_type(context)\n raise \"Unrecognised fact type #{nested.display} nested under #{inspect}\" unless ft\n if (ft.entity_type == np.player)\n np.objectification_of = ft\n nested.objectified_as = np\n end\n end\n raise \"#{np.inspect} contains objectification steps that do not objectify it\" unless np.objectification_of\n return true\n end\n\n # If we fail to match, try a left contraction (or save this for a subsequent left contraction):\n left_contract_this_onto = context.left_contractable_clause\n new_conjunction = (conjunction == nil || conjunction == ',')\n changed_conjunction = (lcc = context.left_contraction_conjunction) && lcc != conjunction\n if context.left_contraction_allowed && (new_conjunction || changed_conjunction)\n # Conjunctions are that/who, where, comparison-operator, ','\n trace :matching, \"A left contraction will be against #{self.inspect}, conjunction is #{conjunction.inspect}\"\n context.left_contractable_clause = self\n left_contract_this_onto = nil # Can't left-contract this clause\n end\n context.left_contraction_conjunction = new_conjunction ? nil : @conjunction\n\n phrases = @phrases\n vrs = []+nps\n\n # A left contraction is where the first player in the previous clause continues as first player of this clause\n contracted_left = false\n can_contract_right = false\n left_insertion = nil\n right_insertion = nil\n supposed_roles = [] # Arrange to unbind incorrect noun_phrases supposed due to contraction\n contract_left = proc do\n contracted_from = left_contract_this_onto.nps[0]\n contraction_player = contracted_from.player\n contracted_role = NounPhrase.new(\n term: contraction_player.name,\n leading_adjective: contracted_from.leading_adjective,\n trailing_adjective: contracted_from.trailing_adjective,\n role_name: contracted_from.role_name\n )\n supposed_roles << contracted_role\n left_insertion = contracted_role.inspect+' '\n contracted_role.player = contracted_from.player\n contracted_role.role_name = contracted_from.role_name\n contracted_role.bind(context)\n vrs.unshift contracted_role\n contracted_left = true\n phrases = [contracted_role]+phrases\n trace :matching, \"Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}\"\n end\n\n contract_right = proc do\n contracted_from = left_contract_this_onto.nps[-1]\n contraction_player = contracted_from.player\n contracted_role = NounPhrase.new(\n term: contraction_player.name,\n leading_adjective: contracted_from.leading_adjective,\n trailing_adjective: contracted_from.trailing_adjective,\n role_name: contracted_from.role_name\n )\n supposed_roles << contracted_role\n right_insertion = ' '+contracted_role.inspect\n contracted_role.player = contracted_from.player\n contracted_role.role_name = contracted_from.role_name\n contracted_role.bind(context)\n vrs.push contracted_role\n phrases = phrases+[contracted_role]\n trace :matching, \"Failed to match #{inspect}. Trying again using right contraction onto #{contraction_player.name}\"\n end\n\n begin\n players = vrs.map{|vr| vr.player}\n\n if players.size == 0\n can_contract_right = left_contract_this_onto.nps.size == 2\n contract_left.call\n redo\n end\n\n raise \"Must identify players before matching fact types\" if players.include? nil\n raise \"A fact type must involve at least one object type, but there are none in '#{inspect}'\" if players.size == 0 && !left_contract_this_onto\n\n player_names = players.map{|p| p.name}\n\n trace :matching, \"Looking for existing #{players.size}-ary fact types matching '#{inspect}'\" do\n trace :matching, \"Players are '#{player_names.inspect}'\"\n\n # Match existing fact types in nested clauses first:\n # (not for contractions) REVISIT: Why not?\n if !contracted_left\n vrs.each do |np|\n next if np.is_a?(Operation)\n next unless steps = np.nested_clauses and !steps.empty?\n np.nested_clauses.each do |nested|\n ft = nested.match_existing_fact_type(context)\n raise \"Unrecognised fact type #{nested.display}\" unless ft\n if (ft && ft.entity_type == np.player)\n np.objectification_of = ft\n nested.objectified_as = np\n end\n end\n raise \"#{np.inspect} contains objectification steps that do not objectify it\" unless np.objectification_of\n end\n end\n\n # For each role player, find the compatible types (the set of all subtypes and supertypes).\n # For a player that's an objectification, we don't allow implicit supertype steps\n player_related_types =\n vrs.zip(players).map do |np, player|\n disallow_subtyping = np && np.objectification_of || options[:exact_type]\n ((disallow_subtyping ? [] : player.supertypes_transitive) +\n player.subtypes_transitive).uniq\n end\n\n trace :matching, \"Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'\"\n\n start_obj = player_related_types[0] || [left_contract_this_onto.nps[-1].player]\n # The candidate fact types have the right number of role players of related types.\n # If any role is played by a supertype or subtype of the required type, there's an implicit subtyping steps\n # REVISIT: A double contraction results in player_related_types being empty here\n candidate_fact_types =\n start_obj.map do |related_type|\n related_type.all_role.select do |role|\n # next if role.fact_type.all_reading.size == 0\n next if role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)\n next if role.fact_type.all_role.size != players.size # Wrong number of players\n\n compatible_readings = role.fact_type.compatible_readings(player_related_types)\n next unless compatible_readings.size > 0\n trace :matching_fails, \"These readings are compatible: #{compatible_readings.map(&:expand).inspect}\"\n true\n end.\n map{ |role| role.fact_type}\n end.flatten.uniq\n\n # If there is more than one possible exact match (same adjectives) with different subyping, the implicit query is ambiguous and is not allowed\n\n trace :matching, \"Looking amongst #{candidate_fact_types.size} existing fact types for one matching #{left_insertion}'#{inspect}'#{right_insertion}\" do\n matches = {}\n candidate_fact_types.map do |fact_type|\n fact_type.all_reading.map do |reading|\n next unless side_effects = clause_matches(fact_type, reading, phrases)\n matches[reading] = side_effects if side_effects\n end\n end\n\n # REVISIT: Side effects that leave extra adjectives should only be allowed if the\n # same extra adjectives exist in some other clause in the same declaration.\n # The extra adjectives are then necessary to associate the two role players\n # when consumed adjectives were required to bind to the underlying fact types.\n # This requires the final decision on fact type matching to be postponed until\n # the whole declaration has been processed and the extra adjectives can be matched.\n\n best_matches = matches.keys.sort_by{|match|\n # Between equivalents, prefer the one without steps on the first role\n (m = matches[match]).cost*2 + ((!(e = m.role_side_effects[0]) || e.cost) == 0 ? 0 : 1)\n }\n trace :matching_fails, \"Found #{matches.size} valid matches#{matches.size > 0 ? ', best is '+best_matches[0].expand : ''}\"\n\n if matches.size > 1\n first = matches[best_matches[0]]\n cost = first.cost\n equal_best = matches.select{|k,m| m.cost == cost}\n\n if equal_best.size > 1 and equal_best.detect{|k,m| !m.fact_type.is_a?(Metamodel::TypeInheritance)}\n # Complain if there's more than one equivalent cost match (unless all are TypeInheritance):\n trace :matching_fails, \"#{@phrases.inspect} could match any of the following:\\n\\t\"+\n best_matches.map { |reading| reading.expand + \" with \" + matches[reading].describe } * \"\\n\\t\"\n end\n end\n\n if matches.size >= 1\n @reading = best_matches[0]\n @side_effects = matches[@reading]\n @fact_type = @side_effects.fact_type\n trace :matching, \"Matched '#{@fact_type.default_reading}'\"\n @phrases = phrases\n\n # REVISIT: Drop handling side-effects because roles are still required for processing conditions in transformation logic\n # apply_side_effects(context, @side_effects)\n @side_effects.role_side_effects.each do |side_effect|\n phrase = side_effect.phrase\n phrase.role_ref = side_effect.role_ref\n end\n\n return @fact_type\n end\n\n end\n trace :matching, \"No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*\"', '\"}'\"\n end\n if left_contract_this_onto\n if !contracted_left\n contract_left.call\n redo\n elsif can_contract_right\n contract_right.call\n can_contract_right = false\n redo\n end\n end\n end until true # Once through, unless we hit a redo\n supposed_roles.each do |role|\n role.unbind context\n end\n @fact_type = nil\n end",
"def rdl_do_typecheck(sym)\n if RDL.to_do_at[sym]\n RDL.to_do_at[sym].each { |blk| blk.call(sym) }\n end\n RDL.to_do_at[sym] = Array.new\n return unless RDL.to_typecheck[sym]\n RDL.to_typecheck[sym].each { |klass, meth|\n RDL::Typecheck.typecheck(klass, meth)\n }\n RDL.to_typecheck[sym] = Set.new\n nil\n end",
"def build_entity_dependencies\n @vocabulary.all_object_type.inject([{},{}]) { |a, o|\n if o.is_a?(ActiveFacts::Metamodel::EntityType)\n precursor = a[0]\n follower = a[1]\n blocked = false\n pi = o.preferred_identifier\n if pi\n pi.role_sequence.all_role_ref.each{|rr|\n role = rr.role\n player = role.object_type\n # REVISIT: If we decide to emit value types on demand, need to remove this:\n next unless player.is_a?(ActiveFacts::Metamodel::EntityType)\n # player is a precursor of o\n (precursor[o] ||= []) << player if (player != o)\n (follower[player] ||= []) << o if (player != o)\n }\n end\n if o.fact_type\n o.fact_type.all_role.each do |role|\n next unless role.object_type.is_a?(ActiveFacts::Metamodel::EntityType)\n (precursor[o] ||= []) << role.object_type\n (follower[role.object_type] ||= []) << o\n end\n end\n\n # Supertypes are precursors too:\n subtyping = o.all_type_inheritance_as_supertype\n next a if subtyping.size == 0\n subtyping.each{|ti|\n # debug ti.class.roles.verbalise; trace \"all_type_inheritance_as_supertype\"; exit\n s = ti.subtype\n (precursor[s] ||= []) << o\n (follower[o] ||= []) << s\n }\n # REVISIT: Need to use this to order ValueTypes after their supertypes\n # else\n # o.all_value_type_as_supertype.each { |s|\n # (precursor[s] ||= []) << o\n # (follower[o] ||= []) << s\n # }\n end\n a\n }\n end",
"def sort_if_needed\n @rules.sort! unless @sorted\n @sorted = true\n end",
"def do_housecleaning\n puts \"\\n********** Entering do_housecleaning() **********\"\n\n round_ids = (@@prev_round + @@curr_round + @@next_round).compact.uniq\n rounds_to_ignore = round_ids.map{|id| Round.find(id)} if !round_ids.nil?\n qo_to_ignore = QuestionOccurrence.select{|qo| rounds_to_ignore.include?(qo.round)}\n results_to_ignore = Result.select{|rt| rounds_to_ignore.include?(rt.round)}\n\n oldNumQO = QuestionOccurrence.count\n oldNumRd = Round.count\n oldNumRt = Result.count\n edRd = edRt = []\n\n # Only keep QuestionOccurrences that have Questions\n QuestionOccurrence.prune_question_orphans(qo_to_ignore)\n \n # Only keep QuestionOccurrences that have Rounds\n QuestionOccurrence.prune_round_orphans(qo_to_ignore)\n\n # Only keep Results that have at least 1 corr/skip/incorr\n Result.prune_unanswered(results_to_ignore)\n\n # Only keep Results that have Users\n Result.prune_user_orphans(results_to_ignore)\n\n # Only keep Results that have Rounds\n Result.prune_round_orphans(results_to_ignore)\n\n # Only keep Rounds that have QuestionOccurrences\n Round.prune_question_occurrence_orphans(rounds_to_ignore)\n\n # Only keep Rounds that have Results\n Round.prune_result_orphans(rounds_to_ignore)\n\n # Recalculate any clearly erroneous num_correct, num_skipped, num_incorrect\n edRt += Result.recalculate_incorrect_num_answers(results_to_ignore)\n\n # Recalculate any clearly incorrect Round.num_participants\n edRd += Round.recalculate_incorrect_num_participants(rounds_to_ignore)\n\n # Recalculate any clearly incorrect Round.max_qo_index\n edRd += Round.recalculate_incorrect_max_qo_index(rounds_to_ignore)\n\n # Only keep QuestionOccurrences reached in that Round \n QuestionOccurrence.prune_unreached_questions(qo_to_ignore)\n \n # For Results, clear the rank if it is not round_complete\n edRt += Result.unrank_incompletes\n\n # Recalculate any clearly incorrrect ranks\n edRt += Result.recalculate_outlier_ranks(results_to_ignore)\n\n edNumRt = edRt.uniq.length\n edNumRd = edRd.uniq.length\n\n newNumQO = QuestionOccurrence.count\n newNumRd = Round.count\n newNumRt = Result.count\n puts \"Deleted #{oldNumQO-newNumQO} QuestionOccurrences, #{oldNumRd-newNumRd} Rounds, #{oldNumRt-newNumRt} Results\"\n puts \"Performed #{edNumRd} updates on Rounds, #{edNumRt} updates on Results\"\n puts \"********** Exiting do_housecleaning() **********\\n\"\n end",
"def clean_cached_facts(node)\n Puppet::Node::Facts.indirection.destroy(node)\n Puppet.info \"#{node}'s facts removed\"\n end",
"def demongoize(object)\n object\n end",
"def reprocess\n #rt = rem_type.downcase\n\n @rems = nil\n @fus = nil\n\n case rem_type\n when 'Agent Monthly'\n @rems = AgentReminder.find_all_by_rem_type_and_month_and_sent('monthly', month, false)\n set_ar_fields\n when 'Agent Six-monthly'\n @rems = AgentReminder.find_all_by_rem_type_and_month_and_sent('six-monthly', month, false)\n set_ar_fields\n when 'Customer Monthly'\n @fus = CustomerFu.find_all_by_fu_type_and_month_and_sent('monthly', month, false)\n set_fu_fields\n end\n end",
"def evaluate_behaviors(text)\n modified_text = text\n if @behavior_objects\n @behavior_objects.each do |b|\n modified_text = b.evaluate(modified_text)\n end\n end\n modified_text\n end",
"def eval\n return if self.children.empty?\n \n # Remove parenthesis\n if self.children.first.val.class == LeftParen\n self.children = self.children[1..-2]\n end\n \n return if self.children.empty?\n \n # Ensure all children have types, so we can evaluate with semantics\n # There are special cases for conditionals, where we delay evaluation.\n if [While, If].include?(self.children[0].val.class)\n # Use stupid serialization/deserialization because of GODAMN SHALLOW COPYING!!!!!!!!\n children_copy = Marshal.load(Marshal.dump(self.children))\n children[1].val = self.children[1].eval unless self.children[1].val\n else\n self.children.each do |child|\n child.val = child.eval unless child.val\n end\n end\n \n \n child_vals = self.children.map{|c|c.val}\n child_classes = child_vals.map{|c|c.class}\n first_child_val = child_vals[0]\n first_child_class = child_classes[0]\n last_child_vals = child_vals[1..-1]\n last_child_classes = child_classes[1..-1]\n \n \n # Go through and evaluate each child to ensure that IDs become something we can work with\n unless [Assign].include?(first_child_class)\n last_child_classes.each_with_index do |child, index|\n if child == Id\n var = last_child_vals[index].val\n type = $var_table.get_type(var)\n val = $var_table.get_val(var)\n last_child_vals[index] = val\n last_child_classes[index] = type\n self.children[index + 1].val = type.new(val)\n end\n end\n end\n \n \n \n case\n # TRIG\n when first_child_val.kind_of?(Trig)\n if last_child_classes != [MReal]\n throw SemanticException.new(first_child_val, last_child_vals)\n else\n return send 'float'\n end\n \n \n # LOGIC\n when first_child_val.kind_of?(Logic)\n if last_child_classes == [MReal, MInteger] || last_child_classes == [MReal, MReal] || last_child_classes == [MInteger, MReal]\n return send 'float', true\n elsif last_child_classes == [MInteger, MInteger]\n return send 'integer', true\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # NEGATION / SUBTRACTION\n when first_child_class == Minus\n if last_child_classes == [MReal]\n return negation_send 'float'\n elsif last_child_classes == [MInteger]\n return negation_send 'integer'\n elsif last_child_classes == [MReal, MInteger] || last_child_classes == [MReal, MReal] || last_child_classes == [MInteger, MReal]\n return send 'float'\n elsif last_child_classes == [MInteger, MInteger]\n return send 'integer'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # All other number operators except addition\n when [Multiply, Divide, Modulo, Exponent].include?(first_child_class)\n if last_child_classes == [MReal, MInteger] || last_child_classes == [MReal, MReal] || last_child_classes == [MInteger, MReal]\n return send 'float'\n elsif last_child_classes == [MInteger, MInteger]\n return send 'integer'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # Addition / Concatenation\n when first_child_class == Plus\n if last_child_classes == [MReal, MInteger] || last_child_classes == [MReal, MReal] || last_child_classes == [MInteger, MReal]\n return send 'float'\n elsif last_child_classes == [MInteger, MInteger]\n return send 'integer'\n elsif last_child_classes == [MString, MString]\n return concat_send\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # And / Or\n when [And, Or].include?(first_child_class)\n if last_child_classes == [MBoolean, MBoolean] \n return send 'boolean', true\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # Negation\n when first_child_class == Not\n if last_child_classes == [MBoolean] \n return send 'boolean', true\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # Variable ssignment\n when first_child_class == Assign\n if last_child_classes[0] == Id \n var = last_child_vals[0].val\n $var_table.assign(var, last_child_vals[1])\n return 'assignment'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n \n # Let statement\n # Records pop count for current level. Resets pop count. Leaves flag to free variables.\n when first_child_class == Let\n if last_child_vals == ['varlist']\n $pop_count_stack << $pop_count\n $pop_count = 0\n return 'free_variables'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # Declare variables.\n # Need to track the variable for when we free it later.\n when first_child_class == Id\n if last_child_classes == [Type]\n $var_table.declare(first_child_val.val, last_child_vals[0].val)\n $scope_stack.push(first_child_val.val)\n $pop_count += 1\n return 'declaration'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # Varlists\n when first_child_val == 'declaration'\n last_child_vals.each do |val|\n if val != 'declaration'\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n end\n return 'varlist'\n \n \n # Releasing variables when we rise above their scope\n when first_child_val == 'free_variables'\n times_to_pop = $pop_count_stack.pop\n times_to_pop.times do\n variable = $scope_stack.pop\n $var_table.pop(variable)\n end\n return 'ignore'\n\n\n # While loop\n # keeps evaluating subsequent stuff so long as the first expression is true\n when first_child_class == While\n if last_child_vals[0].val == 'true'\n self.children[2..-1].each { |c| c.eval }\n self.children = children_copy\n self.eval\n return 'ignore'\n elsif last_child_vals[0].val == 'false'\n return 'ignore'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n # If branch\n # Given two expressions, evaluates the second only if the first evaluates to true\n # Given three expressions, evaluates the second if the first evaluates to true, otherwise\n # evaluates the third.\n when first_child_class == If\n if last_child_classes[0] == MBoolean\n if last_child_vals.length == 2 && last_child_vals[0].val == 'true'\n self.children[2].val = self.children[2].eval\n elsif last_child_vals.length == 3\n if last_child_vals[0].val == 'true'\n self.children[2].val = self.children[2].eval\n else\n self.children[3].val = self.children[3].eval\n end\n end\n return 'ignore'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n when first_child_class == Print\n if last_child_vals[0].kind_of?(Token)\n puts last_child_vals[0].val\n return 'ignore'\n else\n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n \n when first_child_val.kind_of?(Type)\n return self.children[0].val\n \n \n # For things where we shouldn't evaluate a return value, like stdout or assignment.\n when first_child_val == 'ignore'\n # Do nothing\n \n \n # Undefined semantics\n else \n throw SemanticException.new(first_child_val, last_child_vals)\n end\n \n end",
"def clean\r\n if @conns\r\n @conns.objects.each do |data|\r\n data[:object].clean if data[:object].respond_to?(\"clean\")\r\n end\r\n elsif @conn\r\n @conn.clean if @conn.respond_to?(\"clean\")\r\n end\r\n end",
"def validate\n\t\t\t# time always exists\n\t\t\tsyms = { 't' => Parameter.new('t', 0) }\n\t\t\tidents = []\n\t\t\t@species.each {|k, v| syms[k] = v}\n\t\t\t@parameters.each do |k, v| \n\t\t\t\traise \"Parameter and species share id: #{k}\" if syms[k]\n\t\t\t\tsyms[k] = v\n\t\t\tend\n\t\t\tsyms.each do |k, v|\n\t\t\t\traise \"Symbol #{v.to_s} mapped to wrong id: #{k}\" if v.name != k\n\t\t\tend\n\n\t\t\trule_output_names = {}\n\n\t\t\t@rules.each do |rule|\n\t\t\t\tif rule_output_names.key? (rule.output.name)\n\t\t\t\t\traise \"Two rules for one output (#{rule.output.name})\"\n\t\t\t\tend\n\t\t\t\trule_output_names[rule.output.name] = 1\n\n\t\t\t\tif !syms.key?(rule.output.name)\n\t\t\t\t\traise \"rule #{rule.to_s} has undefined output: #{rule.output.name}\"\n\t\t\t\tend\n\n\t\t\t\tif syms[rule.output.name] != rule.output\n\t\t\t\t\traise \"Inconsistent model: rule #{rule.to_s} does not output to the correct variable #{syms[rule.output.name]}\"\n\t\t\t\tend\n\n\t\t\t\trule.equation.all_idents.each do |id|\n\t\t\t\t\tidents = idents | [id]\n\t\t\t\t\tif !syms.key?(id)\n\t\t\t\t\t\traise \"rule #{rule.to_s} has undefined input: #{id}\"\n\t\t\t\t\t# else\n\t\t\t\t\t# \tputs \"#{id} used in #{rule.to_s}\\n\"\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\n\t\t\tunused = idents.reject { |e| syms.key?(e) }\n\t\t\tunused = unused | (syms.keys.reject { |e| idents.index(e) })\n\t\t\t# dawn dusk and force are in every model (at least after sassy opens it)\n\t\t\tunused = unused.reject { |e| e == 't' || e == 'dawn' || e == 'dusk' || e == 'force' \\\n\t\t\t\t|| rule_output_names.key?(e) || @species.key?(e) }\n\t\t\tif unused.length > 0\n\t\t\t\tputs \"[W] Model has unused symbols: #{unused}\\n\"\n\t\t\tend\n\t\t\tself\n\t\tend",
"def demongoize(object)\n new(value_of(object))\n end",
"def rules_from_step_content\n @rules_from_step_content ||= content_items.each_with_object({}) do |content_item, items|\n items[content_item[\"content_id\"]] = build_rule(content_item)\n end\n end"
] |
[
"0.60669965",
"0.5695625",
"0.5545631",
"0.53663915",
"0.53335416",
"0.5318605",
"0.53155166",
"0.5298187",
"0.52801955",
"0.5274887",
"0.5251812",
"0.523486",
"0.5233228",
"0.52292717",
"0.52231187",
"0.5217648",
"0.5211928",
"0.5203749",
"0.5196249",
"0.51700497",
"0.5169679",
"0.51409465",
"0.5097984",
"0.509008",
"0.5082812",
"0.506791",
"0.50659126",
"0.5053662",
"0.50317734",
"0.50305355",
"0.5025795",
"0.5015416",
"0.5003311",
"0.4986555",
"0.49858516",
"0.4975697",
"0.49692905",
"0.4965472",
"0.49396956",
"0.48896086",
"0.48788556",
"0.48680583",
"0.48659834",
"0.48521164",
"0.4852108",
"0.48310047",
"0.4828048",
"0.4800014",
"0.47949368",
"0.47933775",
"0.47854653",
"0.4783107",
"0.47717535",
"0.476574",
"0.47614792",
"0.47600898",
"0.47581506",
"0.475513",
"0.4738274",
"0.4729462",
"0.47288865",
"0.47083333",
"0.47071573",
"0.47047207",
"0.4702326",
"0.46763143",
"0.46619955",
"0.4661303",
"0.4660007",
"0.46563238",
"0.46446693",
"0.46446693",
"0.46446693",
"0.46446693",
"0.46446693",
"0.46446693",
"0.46446693",
"0.46446678",
"0.46312737",
"0.4622782",
"0.46165487",
"0.46165487",
"0.4615522",
"0.46116045",
"0.46087492",
"0.46030003",
"0.45937622",
"0.4586308",
"0.45798442",
"0.4570247",
"0.45687667",
"0.4567245",
"0.45609248",
"0.45590433",
"0.45562282",
"0.45503455",
"0.45445815",
"0.45445585",
"0.45422035",
"0.45304707",
"0.45300362"
] |
0.0
|
-1
|
for a particular fact, we need to retrieve the relevant rules and add them to the relevant list
|
def add_relevant_rules_for_fact fact
@rules.values.select { |rule|
if !@relevant_rules.include?( rule)
if rule.parameters_match?(fact.value)
@relevant_rules << rule
logger.debug "#{rule} is relevant" if logger
else
logger.debug "#{rule} is not relevant" if logger
end
end
}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def rules_by_name; end",
"def rules_from_step_content\n @rules_from_step_content ||= content_items.each_with_object({}) do |content_item, items|\n items[content_item[\"content_id\"]] = build_rule(content_item)\n end\n end",
"def rule_assert( obj )\r\n # add object as a new fact\r\n f = fact(obj)\r\n # get_relevant_rules\r\n logger.debug( \"Check if we need to add more rules\") if logger\r\n add_relevant_rules_for_fact(f)\r\n sort_relevant_rules\r\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rule_by_id; end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def add(rule); end",
"def add_rule(rule_object)\n\n # store the rule\n @rules[rule_object.name] = rule_object\n\n case\n\n # rule which asserts facts without conditions or questions\n when rule_object.matcher.nil? && rule_object.questions.empty?\n\n # add the rule to the fact rules array, contains rules with only facts\n @fact_rules << rule_object\n\n when rule_object.matcher.nil? && rule_object.questions.count > 0\n\n # rules can be triggered directly\n @start_rules << rule_object\n\n else\n\n # get the matcher\n matcher = rule_object.matcher\n\n # get the matcher type (any / all)\n matcher_type = matcher.type\n\n # generate the ruleby conditions based on the matcher conditions\n conditions = create_conditions matcher.conditions\n\n # switch statement for the matcher type\n case matcher_type\n\n # all the conditions must match\n when :all\n\n # star to convert array to arguments\n rule AND *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n # one of the conditions must match\n when :any\n\n # star to convert array to arguments\n rule OR *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n else\n raise \"Unknown matcher type #{matcher.type}\"\n\n end\n\n end\n\n end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def get_rules\r\n @rules\r\n end",
"def load_rules; end",
"def rules\n @rules ||= begin\n @rules = []\n resolve_permissions\n @rules\n end\n end",
"def add_rules(rules)\n rules.each do |rule|\n add_rule rule\n end\n end",
"def rules\n rule_applier.rules\n end",
"def rules\n @rules=get_endpoint('rule').keys\n end",
"def rule(expression, &block)\n case expression\n when Hash\n expression.each do |fact, task|\n fact = define_fact(fact)\n task = define_task(task)\n @rules << Rule.new(fact, &task)\n end\n else\n fact = define_fact(expression)\n @rules << Rule.new(fact, &block)\n end\n\n #rule = Rule.new(@_facts, get_rule_options, &procedure)\n #@rules << rule\n #clear_rule_options\n\n return @rules\n end",
"def fact!\n @predicate << Rule.new(self, true)\n self\n end",
"def rules_by_name(rule_name, section_id = @one_section_id)\n rules = []\n return rules unless section_id\n\n all_rules = rules(section_id)\n return rules unless all_rules\n\n all_rules['results'].each do |rule|\n rules << rule if rule['display_name'] == rule_name\n end\n rules\n end",
"def rules(rule_name:, kind:)\n Rules::RuleSet.build_for(calendar: calendar, kind: kind).rules_with_name(rule_name)\n end",
"def rule; end",
"def rule; end",
"def rule; end",
"def rules_for(configuration, character)\n # note that it is select (filter), not detect (find)\n rules.select {|rule| rule.applies_to?(configuration, character)}\n end",
"def add_fact(fact)\n @facts[fact.entity] = {} unless @facts.has_key?(fact.entity)\n @facts[fact.entity][fact.property] = [] unless @facts[fact.entity].has_key?(fact.property)\n @facts[fact.entity][fact.property].each do |existing|\n if (fact.comparator == Fact::EQUAL && existing.comparator == Fact::EQUAL && fact.property_value != existing.property_value) ||\n (existing.comparator != fact.comparator && existing.property_value == fact.property_value)\n raise \"Adding a contradictory fact!\"\n end\n end\n @facts[fact.entity][fact.property] << fact\n LOGGER.info \"Adding fact: #{fact.readable}\"\n end",
"def process_rules\n @rules.each do |rule|\n rule.process(@commands, @vars)\n end\n\n @commands.uniq!\n end",
"def rules\n return @rules\n end",
"def process_rules *args, &block\n Shotshare::ProcessRuleContainer.instance.rules = \\\n Docile.dsl_eval(Shotshare::Dsl::ProcessRuleBuilder.new, &block).build\nend",
"def rules\n cluster.configurationEx.rule\n end",
"def rules\n cluster.configurationEx.rule\n end",
"def << rule\n rules << rule\n nil\n end",
"def load_cop_rules(rules); end",
"def process_rules(state)\n raise(\"No rules have been loaded into engine %s\" % self) if empty?\n\n rules_by_priority do |rule|\n state.mutable = !rule.concurrent?\n result = rule.process_state(state)\n state.mutable = true\n\n state.store_result(result) if result\n end\n\n state.results\n end",
"def get_rule(rule)\n @rules[rule]\n end",
"def then_rules\n @then_rules ||= []\n end",
"def rules\n self.class.rules\n end",
"def rulelist(ruleset, ctx)\r\n\r\n outlist = \"\"\r\n\r\n ruleset.rules.each do |ralias|\r\n rname = ctx.rules[ralias].name\r\n outlist += reference(\"rule\", rname)\r\n\r\n end # rules.each\r\n\r\n return outlist\r\n\r\n end",
"def load_parameter_rules(rules); end",
"def get_modifying_rules(agent, opponent)\n modified_by = Hash.new { [[],[]] }\n track = lambda do |set, index|\n set.each_with_index do |rule, rule_i|\n rule.alternatives.each do |alt|\n alt.modifiers.each do |mod|\n arr = modified_by[mod.predicate]\n arr[index] << [rule_i, mod.type]\n modified_by[mod.predicate] = arr\n end\n end\n end\n end\n track.call(agent.actions, 0)\n track.call(opponent.rules, 1)\n return modified_by\n end",
"def rule_set\n @rule_set ||= Rules::RuleSet.build_for(calendar: calendar, kind: kind)\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def external_rules\n @external_rules ||= rules.dup.external\n end",
"def rules=(value)\n @rules = value\n end",
"def construct_rules rules\n parsed_rules = {:rules => []}\n rules.each do |rule|\n parsed_rules[:rules] << rule.attributes\n end\n parsed_rules.to_json\n end",
"def for_rule(rule_name)\n @rules.fetch(rule_name.to_sym, {})\n end",
"def passing_rules\n @passing_rules ||= rules.dup.passing\n end",
"def add_rule(rule)\n @rulebook.add_rule rule\n end",
"def ruleset_rules\n @rulesets.collect do |r|\n [\"# Begin [#{r.name}]\",\n r.firewall_rules,\n \"# End [#{r.name}]\",\n \"\"]\n end\n end",
"def to_list\n rules.map do |rule|\n object = { actions: rule.actions, subject: rule.subjects.map{ |s| s.is_a?(Symbol) ? s : s.name } }\n object[:conditions] = rule.conditions unless rule.conditions.blank?\n object[:inverted] = true unless rule.base_behavior\n object\n end\n end",
"def rules\n #\n # This is called first in case any preable needs to be declared (chains, specifically)\n #\n _ruleset_rules = ruleset_rules\n\n [\n Asbestos.firewall.preamble(self),\n _ruleset_rules,\n Asbestos.firewall.postamble(self)\n ].flatten\n end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def to_rules\n Array.new.tap do |rules|\n new_rule = Rule.new(rule.chain)\n new_rule.description = \"#{rule.description} (#{self.description})\"\n new_rule.rule = rule.rule.gsub(/\\{\\{(\\w+)\\}\\}/) do\n if value = self.options[$1.to_sym]\n value\n else\n \"{{#{$1}}}\"\n end\n end\n new_rule.action = rule.action\n new_rule.conditions = rule.conditions | self.conditions\n if self.version\n new_rule.versions = [self.version]\n end\n\n if has_host_group?\n host_group = @rule.chain.table.base.host_groups[self.options[:ip]]\n host_group.hosts.each do |key, host|\n host.ips.each do |v, ip|\n hg_rule = new_rule.dup\n hg_rule.description += \" (#{host.name} via #{host_group.name})\"\n hg_rule.rule.gsub!(host_group.name.to_s, ip)\n hg_rule.versions = [v]\n rules << hg_rule\n end\n end\n else\n rules << new_rule\n end\n end\n end",
"def rule\n @rule ||= resolve!\n end",
"def rule\n @rule ||= resolve!\n end",
"def rule(name)\n begin\n @name=name\n @content=get_rest \"rules/#{@name}\"\n rescue Stingray::NotFoundError \n nil\n end\n end",
"def set_rule\n @rule = Rule.find_by id: params[:id], user: current_user\n end",
"def current_rule\n\n # start the matching of the ruleby engine if not yet called\n unless @engine_has_matched\n\n # first assert all the facts from the fact rules\n # these are rules without conditions and only facts\n # when doing this while adding the rules something weird happens and instead of 1 match, stuff matches 22+ times\n @fact_rules.each do |rule|\n\n trigger rule\n\n end\n\n # add start rules to the question rules when they are not yet handled\n @start_rules.each do |rule|\n\n # when rule not yet triggered\n unless triggered? rule\n\n # add to the possible questions\n @question_rules << rule\n\n end\n\n end\n\n # match the rules using the ruleby engine\n @engine.match\n\n # set the matched flag\n @engine_has_matched = true\n\n end\n\n # get the first of the question rules\n @question_rules.first\n\n end",
"def add_rule(rule)\n new_rules = rules.dup\n new_rules << rule\n @rules = new_rules.uniq.freeze\n validate_rules!\n self\n end",
"def rules(event)\n @rules[event]\n end",
"def rules1\n @rules1\nend",
"def assert_facts_from_rule(rule_object)\n\n # get the facts from the rule\n facts = rule_object.facts\n\n # iterate all the facts\n facts.each do |fact|\n\n # evaluate fact value\n # TODO: ONLY evaluate fact when trigger is called on a top level rule fact\n fact.value = evaluate_fact_value fact.value\n\n # let the ruleby engine assert the fact\n @engine.assert fact\n\n end\n\n end",
"def find_rule(aRuleName) abstract_method\n end",
"def migrate_rules\n contact_counts_by_id = {}\n check_counts_by_id = {}\n\n source_keys_matching('contact_notification_rules:?*').each do |rules_key|\n\n rules_key =~ /\\Acontact_notification_rules:(#{ID_PATTERN_FRAGMENT})\\z/\n contact_id = $1\n raise \"Bad regex for '#{rules_key}'\" if contact_id.nil?\n\n contact = find_contact(contact_id)\n\n contact_num = contact_counts_by_id[contact.id]\n if contact_num.nil?\n contact_num = contact_counts_by_id.size + 1\n contact_counts_by_id[contact.id] = contact_num\n end\n\n check_ids = @check_ids_by_contact_id_cache[contact.id]\n\n rules = {\n Flapjack::Data::Acceptor => [],\n Flapjack::Data::Rejector => []\n }\n\n rule_ids = @source_redis.smembers(rules_key)\n rule_ids.each do |rule_id|\n rule_data = @source_redis.hgetall(\"notification_rule:#{rule_id}\")\n\n time_restrictions = Flapjack.load_json(rule_data['time_restrictions'])\n\n entities = Set.new( Flapjack.load_json(rule_data['entities']))\n regex_entities = Set.new( Flapjack.load_json(rule_data['regex_entities']))\n\n tags = Set.new( Flapjack.load_json(rule_data['tags']))\n regex_tags = Set.new( Flapjack.load_json(rule_data['regex_tags']))\n\n # collect specific matches together with regexes\n regex_entities = regex_entities.collect {|re| Regexp.new(re) } +\n entities.to_a.collect {|entity| /\\A#{Regexp.escape(entity)}\\z/}\n regex_tags = regex_tags.collect {|re| Regexp.new(re) } +\n tags.to_a.collect {|tag| /\\A#{Regexp.escape(tag)}\\z/}\n\n acceptor_conditions_by_media = {}\n rejector_conditions_by_media = {}\n\n Flapjack::Data::Condition.unhealthy.keys.each do |fail_state|\n media_types = Flapjack.load_json(rule_data[\"#{fail_state}_media\"])\n next if media_types.nil? || media_types.empty?\n\n media_types_str = media_types.sort.join(\"|\")\n blackhole = !!Flapjack.load_json(rule_data[\"#{fail_state}_blackhole\"])\n cond_by_media = blackhole ? rejector_conditions_by_media : acceptor_conditions_by_media\n cond_by_media[media_types_str] ||= []\n cond_by_media[media_types_str] << fail_state\n end\n\n checks_and_tags_for_rule = proc do |rule_klass, cond_by_media|\n\n rule_klass.lock(Flapjack::Data::Check, Flapjack::Data::Tag,\n Flapjack::Data::Contact, Flapjack::Data::Medium) do\n\n cond_by_media.each_pair do |media_types_str, fail_states|\n rule = rule_klass.new\n rule.conditions_list = fail_states.sort.join(\"|\")\n rule.all = regex_entities.empty? && regex_tags.empty?\n rule.time_restrictions = time_restrictions\n rule.save\n raise rule.errors.full_messages.join(\", \") unless rule.persisted?\n\n media_transports = media_types_str.split('|')\n media = contact.media.intersect(:transport => media_transports)\n rule.media.add_ids(*media.ids) unless media.empty?\n\n unless rule.all\n # apply the entities/tag regexes as a filter\n checks = Flapjack::Data::Check.intersect(:id => check_ids).select do |check|\n entity_name = check.name.split(':', 2).first\n if regex_entities.all? {|re| re === entity_name }\n # copying logic from https://github.com/flapjack/flapjack/blob/68a3fd1144a0aa516cf53e8ae5cb83916f78dd94/lib/flapjack/data/notification_rule.rb\n # not sure if this does what we want, but it's how it currently works\n matching_re = []\n check.tags.each do |tag|\n matching_re += regex_tags.select {|re| re === tag.name }\n end\n matching_re.size >= regex_tags.size\n else\n false\n end\n end\n\n tags = checks.collect do |check|\n check_num = check_counts_by_id[check.id]\n if check_num.nil?\n check_num = check_counts_by_id.size + 1\n check_counts_by_id[check.id] = check_num\n end\n\n tag = Flapjack::Data::Tag.new(:name => \"migrated-contact_#{contact_num}-check_#{check_num}\")\n tag.save\n check.tags << tag\n tag\n end\n\n rule.tags.add(*tags) unless tags.empty?\n end\n rules[rule_klass] << rule\n end\n end\n end\n\n checks_and_tags_for_rule.call(Flapjack::Data::Rejector, rejector_conditions_by_media)\n checks_and_tags_for_rule.call(Flapjack::Data::Acceptor, acceptor_conditions_by_media)\n end\n\n rejectors = rules[Flapjack::Data::Rejector]\n contact.rejectors.add(*rejectors) unless rejectors.empty?\n\n acceptors = rules[Flapjack::Data::Acceptor]\n contact.acceptors.add(*acceptors) unless acceptors.empty?\n end\n end",
"def rules\n return [] if @rules.empty?\n @rules.sort_by { |k| k['priority'] }.map { |h| h['rule_name'] }\n end",
"def get_candidates(rules)\n candidates = []\n rules.each { |rule| candidates << rule if rule.ever_matched? && rule.time_to_report? }\n candidates\n end",
"def check_rule(rule)\n\n\t if rule.include? 'twitter_lang'\n\t\t rule = handle_lang_operators rule\n\t end\n\n\t if rule.include? 'has:lang'\n\t\t rule = handle_has_lang rule\n\t end\n\n\t if rule.include? '_contains:'\n\t\t rule = handle_contains_operators rule\n\t end\n\n\n\t if rule.include? 'country_code:'\n\t\t rule = handle_country_code_operators rule\n\t end\n\n\t rule\n\n end",
"def relevant_rules(action, subject)\n return [] unless @rules\n\n relevant = possible_relevant_rules(subject).select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n relevant.reverse!.uniq!\n optimize_order! relevant\n relevant\n end",
"def fact( obj )\r\n #begin\r\n # check if facts already exist for that class\r\n # if so, we need to add it to the existing list\r\n cls = obj.class.to_s.downcase\r\n cls.gsub!(/:/, '_')\r\n if @facts.key? cls\r\n logger.debug( \"adding to facts: #{cls}\") if logger\r\n @facts[cls].fact_value << obj\r\n else\r\n logger.debug( \"creating facts: #{cls}\") if logger\r\n arr = Array.new\r\n arr << obj\r\n proc = Proc.new { arr }\r\n @facts[cls] = Facts.new(self, cls, proc ) \r\n end\r\n #rescue Exception=> e\r\n # logger.error e if logger\r\n #end\r\n end",
"def rules\n @rules.dup.freeze\n end",
"def all\n @rules\n end",
"def apply_rules(json, type, rules)\n rules.each do |rule|\n next unless rule.function.call(json)\n rule.metadata = json\n rule.type = type\n\n case rule.modifier\n when :warning\n warnings << rule\n when :error\n errors << rule\n end\n end\n end",
"def add_rules(rules)\n rules.each {|a_rule| @l.addToken(a_rule.tokID,a_rule.re)}\n end",
"def rules( *new_values )\n\t\tself.rules = new_values unless new_values.empty?\n\t\treturn @rules\n\tend",
"def update_rules(list, params)\n params[:taxa].each do |taxon_params|\n taxon = Taxon.find_by_id(taxon_params[:taxon_id].to_i)\n next unless taxon\n list.build_taxon_rule(taxon)\n end\n list\n end",
"def failing_rules\n @failing_rules ||= rules.dup.failing\n end",
"def subsequent_rules(*args); end",
"def subsequent_rules(*args); end",
"def run(rule)\n end",
"def rules(rules)\n rules = QL.to_rules(rules)\n GRel::Debugger.debug \"STORING IN SCHEMA #{@schema_graph}\"\n GRel::Debugger.debug rules\n GRel::Debugger.debug \"IN\"\n GRel::Debugger.debug @db_name\n @connection.add(@db_name, rules, @schema_graph, \"application/rdf+xml\")\n self\n end",
"def fact_readings_with_constraints(verbaliser, fact_type)\n fact_constraints = @presence_constraints_by_fact[fact_type]\n readings = []\n define_role_names = true\n fact_type.all_reading_by_ordinal.each do |reading|\n readings << expanded_reading(verbaliser, reading, fact_constraints, define_role_names)\n define_role_names = false # No need to define role names in subsequent readings\n end\n readings\n end",
"def rules(section_id = @one_section_id)\n url = @url_sections + '/' + section_id + '/rules'\n @nsx_client.get(url)\n end",
"def rule_handler(rule_object)\n\n # only rules that are not yet triggered should be processed\n unless triggered? rule_object\n\n case\n\n # when there are no questions and no goals\n when rule_object.questions.empty? && rule_object.goal.nil?\n\n # trigger the rule, thus asserting facts and storing in triggered rules\n trigger rule_object\n\n # when the goal is NOT nil\n when !rule_object.goal.nil?\n\n # add to the result rules\n @result_rules << rule_object\n\n # otherwise add to the question rules\n else\n\n # add to the possible questions\n @question_rules << rule_object\n\n end\n\n end\n\n end",
"def rules\n return @rules unless @rules.nil?\n\n # this initialization code runs only once\n @rules = {}\n 7.downto(0).each do |rule_key|\n key = rule_key.to_s(2).rjust(3, '0') # convert to binary, pad left with 0\n @rules[key.to_sym] = RULE_NAME >> rule_key & 1 # just the one bit\n end\n\n @rules\n end",
"def visit_rule(node)\n rules = node.rule[0].split(',')\n\n rules.each do |rule|\n append_child_rules(node, rule.strip)\n end\n end",
"def applied_by_rule=(rule_id)\n\t\t\t@dict.set_attribute 'IterativeSG', 'applied_by_rule', rule_id\n\t\t\t@applied_by_rule = rule_id\n\t\tend",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def defined_rules\n @defined_rules ||= {}\n end",
"def do_rule_builds\n @rule.execution_trigger_rules.build if @rule.execution_trigger_rules.size == 0\n @rule.actions.build if @rule.actions.size == 0\n @rule.criteria.build if @rule.criteria.size == 0\n end",
"def add_rule(opts)\n opts = check_params(opts,[:rules])\n super(opts)\n end"
] |
[
"0.7580315",
"0.6833116",
"0.677695",
"0.67665654",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6519024",
"0.64688337",
"0.64688337",
"0.6444558",
"0.6444558",
"0.6444558",
"0.6357586",
"0.6325273",
"0.62844115",
"0.6251636",
"0.62373185",
"0.6216572",
"0.62035334",
"0.6171375",
"0.6141448",
"0.6124327",
"0.603575",
"0.6035517",
"0.60293907",
"0.59801465",
"0.5924443",
"0.5924443",
"0.5924443",
"0.592291",
"0.590607",
"0.5904208",
"0.58998704",
"0.5883155",
"0.58824044",
"0.58824044",
"0.5868249",
"0.5855295",
"0.5854674",
"0.5849943",
"0.5844795",
"0.5842397",
"0.581316",
"0.5800913",
"0.5796954",
"0.57930213",
"0.578987",
"0.5780286",
"0.5768211",
"0.57551074",
"0.575085",
"0.5745009",
"0.57191503",
"0.5716361",
"0.57092553",
"0.5686275",
"0.56736445",
"0.56696",
"0.56513536",
"0.56513536",
"0.56474787",
"0.56459886",
"0.5640805",
"0.5637166",
"0.56238574",
"0.56174827",
"0.5616147",
"0.5614379",
"0.5613615",
"0.56114835",
"0.5610502",
"0.5607007",
"0.55984163",
"0.5587454",
"0.55800563",
"0.5571838",
"0.55676496",
"0.55582094",
"0.55448914",
"0.5529635",
"0.5524713",
"0.5515688",
"0.5515688",
"0.55125755",
"0.5510261",
"0.54989624",
"0.54971135",
"0.549531",
"0.5492029",
"0.54911053",
"0.54870594",
"0.5479281",
"0.54739386",
"0.5472713",
"0.5464304"
] |
0.7809773
|
0
|
relevant rules need to be sorted in priority order
|
def sort_relevant_rules
# sort array in rule priority order
@relevant_rules = @relevant_rules.sort do |r1, r2|
r2.priority <=> r1.priority
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def sort_if_needed\n @rules.sort! unless @sorted\n @sorted = true\n end",
"def optimize_order!(rules)\n first_can_in_group = -1\n rules.each_with_index do |rule, i|\n (first_can_in_group = -1) && next unless rule.base_behavior\n (first_can_in_group = i) && next if first_can_in_group == -1\n next unless rule.subjects == [:all]\n\n rules[i] = rules[first_can_in_group]\n rules[first_can_in_group] = rule\n first_can_in_group += 1\n end\n end",
"def by_priority\n rules.sort_by(&:priority).each do |rule|\n yield(rule)\n end\n end",
"def prioritize_rules()\n \n #\n # Process all :reorder_specs. The top row of each table form roots of the DAG.\n # We test for cycles as we go -- there can't be any. \n \n root_sets = []\n hierarchy = Util::DirectedAcyclicGraph.new( false )\n @reorder_specs.each do |spec|\n previous_level = []\n spec.reorder_levels.each do |level|\n \n #\n # Collect rule reference TO RULES IN THIS GRAMMAR ONLY. Rule priority is about\n # rule production. A grammar can use rules from other grammars, but can't PRODUCE\n # rules from other grammars, so local rules only need apply. This is only an issue\n # for groups, where we'll just skip anything that isn't a local Rule.\n \n current_level = []\n level.references.each do |name_token|\n name = name_token.text\n if @rule_defs.member?(name) then\n current_level << name\n elsif @group_defs.member?(name) then\n @group_defs[name].member_references.each do |reference|\n if reference.is_a?(RuleReference) then\n unless (reference.symbol_name.grammar.exists? and reference.symbol_name.grammar != @name)\n current_level << reference.symbol_name.name\n end\n end\n end\n end\n end\n \n #\n # Everything in the current_level is linked to everything in the previous_level. If \n # there is no previous_level, then we'll register the names as points.\n \n if previous_level.empty? then\n root_sets << current_level\n current_level.each do |name|\n hierarchy.register_point( name )\n end\n else\n previous_level.each do |parent_name|\n current_level.each do |child_name|\n if hierarchy.would_cycle?(parent_name, child_name) then\n nyi( \"error handling for precedence cycle [#{parent_name}] to [#{child_name}]\" )\n else\n hierarchy.register( parent_name, child_name )\n end\n end\n end\n end\n \n previous_level = current_level\n end\n end\n \n \n #\n # Now, we want to integrate the prioritized rules back into the overall hierarchy, and we\n # want to preserve as much of the original ordering as possible. We do this by looking\n # within the prioritized rules at each layer and picking the highest priority for each\n # subtree, then inserting that layer at that index, shifting all the unprioritized rules \n # down.\n #\n # I think some examples might help explain what I mean.\n #\n # Rules: a, b, c, d, e, f, g, h | Rules: a, b, c, d, e, f\n # Order: 1, 2, 3, 4, 5, 6, 7, 8 | Order: 1, 2, 3, 4, 5, 6\n # |\n # Prec table 1: | Prec table 1:\n # d | b c\n # e g | e f\n # Prec table 2: | \n # h | \n # d | \n # g | \n # |\n # DAG layers and original order: | DAG layers and original order:\n # h 8 | b c 2 3\n # d 4 | e f 5 6\n # e g 5 7 |\n #\n # So, with these two examples, we want to reinsert the DAG elements back into the order\n # so that the DAG's hierarchy is respected, while -- as much as possible -- not disturbing \n # the original order. At each layer of the DAG, we look down the tree and find the highest\n # priority original position, and that is where we insert that layer. So\n #\n # insertion_points: | insertion_points:\n # 4, 4, 5 | 2, 5\n #\n # Now, obviously we can't insert two layers at the same point, so for the left example,\n # we'll need to adjust the second layer down a level, which will then cascade to the third\n # layer. And as there is no room between those insertion points, any rules originally at\n # levels 4, 5, or 6 must be shifted down as well.\n #\n # For the right example, notice that rule 4 doesn't need to be disturbed by the\n # the prioritization of either layer, as there is space between insertion points 2 and 5.\n # So we leave it in that position.\n #\n # insertion_points: | insertion_points:\n # 4, 5, 6 | 2, 5\n #\n # Finally, after integrating the default and prioritized rules, we get:\n # 1: a | 1: a\n # 2: b | 2: b c\n # 3: c | 3: d\n # 4: h | 4: e f\n # 5: d |\n # 6: e g |\n # 7: f |\n \n all_rules = []\n default_rules = []\n \n @rule_defs.each do |name, element|\n name = name.to_s\n \n if element.is_a?(Rule) then\n all_rules << name\n default_rules << name unless hierarchy.node?(name)\n end\n end\n\n\n #\n # Next we collect the raw insertion point data for the precedence data. But there's another \n # wrinkle. Up top, we merged all the precedence tables into one DAG, so we could find loops\n # and inter-relationships between the precedence tables. However, if some elements don't link\n # up, we don't want to prioritize all the independent trees to the same level -- we want to\n # preserve as much of the original ordering as possible. So we have to process each tree separately,\n # then interleave the data back together.\n \n insertion_point_sets = []\n insertion_layer_sets = []\n \n hierarchy.independent_trees(root_sets).each do |tree|\n insertion_points = []\n insertion_layers = []\n \n tree.each_layer_reverse do |layer|\n insertion_point = all_rules.length\n layer.each do |name|\n insertion_point = min( insertion_point, all_rules.index(name) )\n end\n \n insertion_points.unshift min(insertion_point, insertion_points.empty? ? insertion_point : insertion_points[0])\n insertion_layers.unshift layer\n end\n \n insertion_point_sets << insertion_points\n insertion_layer_sets << insertion_layers\n end\n \n \n #\n # We interleave the data sets back together. We want to do the interleaving by insertion_point.\n \n insertion_points = []\n insertion_layers = []\n\n until insertion_point_sets.empty? \n tops = insertion_point_sets.collect{|set| set[0]}\n min = tops.inject(all_rules.length){|current, aggregate| min(current, aggregate)}\n index = tops.index( min )\n \n insertion_points << insertion_point_sets[index].shift\n insertion_layers << insertion_layer_sets[index].shift\n \n if insertion_point_sets[index].empty? then\n insertion_point_sets.delete_at(index)\n insertion_layer_sets.delete_at(index)\n end\n end\n \n \n #\n # Next, we need to adjust the insertion points so that every one is unique.\n \n last_insertion_point = -1\n insertion_points.each_index do |index|\n insertion_points[index] = last_insertion_point + 1 if insertion_points[index] <= last_insertion_point\n last_insertion_point = insertion_points[index]\n end\n \n \n #\n # Finally, we have to integrate the two systems by setting the priority on each Rule. \n # We proceed one priority level at a time: if it is in the insertion_points list, we set \n # the priority for all rules on that level to that number; otherwise, we shift a name off\n # the default_rules list and set its priority instead.\n \n (default_rules.length + insertion_layers.length).times do |i|\n if insertion_points.member?(i) then\n insertion_layers[insertion_points.index(i)].each do |name|\n @rule_defs[name].priority = i\n end\n else\n default_rules.shift.each do |rule_name|\n @rule_defs[rule_name].priority = i\n end\n end\n end\n end",
"def rules\n return [] if @rules.empty?\n @rules.sort_by { |k| k['priority'] }.map { |h| h['rule_name'] }\n end",
"def by_priority; end",
"def rules # :nodoc:\n # Rules should always be returned sorted with oldest first.\n @rules.sort! { |a, b| b[:age] <=> a[:age] }\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def tsort_each_child(elem)\n if elem == TopRule then\n @rules.each_value do |e|\n yield e unless e == TopRule or \n e.lower_priority_elements.index(TopRule)\n end\n elsif elem == BottomRule then\n @rules.each_value do |e|\n yield e if e.higher_priority_elements.index(BottomRule)\n end\n else\n elem.lower_priority_elements.each do |e|\n yield e if e != BottomRule\n end\n unless elem.higher_priority_elements.index(BottomRule)\n yield BottomRule\n end\n end\n end",
"def rules_by_name; end",
"def check_rank_rules\n defined_rules.each do |scoped_model, level_and_rules|\n level_and_rules.sort.each do |level, rule|\n grant_when_applies(scoped_model, rule, level)\n end\n end\n end",
"def priority(*) end",
"def priority=(*) end",
"def output_priority\n priority = Hash.new # where priority[id] = block id's priority \n error_set = Hash.new # where error_set[id] = block id's error set\n \n # init error_set to contain all the blocks\n @validations.values.each do |validation|\n for i in 0..validation.blocks.size-1\n unless validation.blocks[i].class != Set \n id = validation.id.to_s + \"~\" + i.to_s \n error_set.merge!(id => validation.blocks[i])\n priority.merge!(id => 1)\n end\n end\n end\n\n error_set.keys.each do |key| \n error_set.keys.each do |other| # QUADRATIC\n unless key == other\n if error_set[key].difference(error_set[other]).empty? then priority[other] = priority[other] + 1 end # key is a subest of other so other's priority increases\n end\n end\n end\n\n sorted = priority.sort{|key, value| -1*(key[1] <=> value[1]) } \n\n i = 0\n puts \"========= Priority by block-error-set ========\"\n puts sorted[i].class\n while i < LIMIT and sorted[i]\n id = sorted[i][0]\n print sorted[i][1].to_s + \" blocks will be successful if you fix: \"\n puts id.to_s\n error_set[id].each do |error|\n print \" \" + error.to_s.delete(\"[\").delete(\"]\")\n puts \"\"\n end\n i = i + 1\n\n \n end\n end",
"def subsequent_rules(*args); end",
"def subsequent_rules(*args); end",
"def tsort_each_node(&x)\n @rules.each_value(&x)\n end",
"def test_sorting\n # Make sure declarations with no length sort first.\n host_exact = Declaration.new(:allow, \"host.com\")\n host_range = Declaration.new(:allow, \"*.host.com\")\n\n ip_exact = Declaration.new(:allow, \"192.168.0.1\")\n ip_range = Declaration.new(:allow, \"192.168.0.*\")\n\n\n assert_equal(\n -1, host_exact <=> host_range,\n\n \"exact name match did not sort first\")\n\n\n assert_equal(\n -1, ip_exact <=> ip_range,\n\n \"exact ip match did not sort first\")\n\n # Next make sure we sort by length\n ip_long = Declaration.new(:allow, \"192.168.*\")\n assert_equal(-1, ip_range <=> ip_long, \"/16 sorted before /24 in ip\")\n\n # Now try it using masks\n ip24 = Declaration.new(:allow, \"192.168.0.0/24\")\n ip16 = Declaration.new(:allow, \"192.168.0.0/16\")\n\n assert_equal(-1, ip24 <=> ip16, \"/16 sorted before /24 in ip with masks\")\n\n # Make sure ip checks sort before host checks\n assert_equal(-1, ip_exact <=> host_exact, \"IP exact did not sort before host exact\")\n\n\n assert_equal(\n -1, ip_range <=> host_range,\n\n \"IP range did not sort before host range\")\n\n host_long = Declaration.new(:allow, \"*.domain.host.com\")\n\n assert_equal(-1, host_long <=> host_range, \"did not sort by domain length\")\n\n # Now make sure denies sort before allows, for equivalent\n # declarations.\n host_deny = Declaration.new(:deny, \"host.com\")\n assert_equal(-1, host_deny <=> host_exact, \"deny did not sort before allow when exact\")\n\n host_range_deny = Declaration.new(:deny, \"*.host.com\")\n assert_equal(-1, host_range_deny <=> host_range, \"deny did not sort before allow when ranged\")\n\n ip_allow = Declaration.new(:allow, \"192.168.0.0/16\")\n ip_deny = Declaration.new(:deny, \"192.168.0.0/16\")\n\n\n assert_equal(\n -1, ip_deny <=> ip_allow,\n\n \"deny did not sort before allow in ip range\")\n\n %w{host.com *.domain.com 192.168.0.1 192.168.0.1/24}.each do |decl|\n assert_equal(0, Declaration.new(:allow, decl) <=>\n Declaration.new(:allow, decl),\n \"Equivalent declarations for #{decl} were considered different\"\n )\n end\n end",
"def priority\n @rule_details.priority\n end",
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def package_rules\n {\n 1 => %w( p1 p2 ),\n 2 => %w( p1 p2 ),\n 3 => %w( p1 ),\n }.fetch(level)\n end",
"def criterions\n objectives.collect(&:criterion).uniq.sort{|a,b| a.category <=> b.category}\n end",
"def process_rules\n @rules.each do |rule|\n rule.process(@commands, @vars)\n end\n\n @commands.uniq!\n end",
"def priority() nil end",
"def priority_sort(result_list, free_bandwidth)\n priority_list = result_list.sort\n new_results = []\n priority_index = 0\n priority_list.each_index do |i|\n result = \"PASSED\"\n priority_index = priority_list[i].slice!(/^\\d+/).to_i\n bc = priority_list[i].split(\"|\")[0].unpack(\"a2a2a2\")\n if bc[2] == \"BF\"\n # fails if minimum failed and it's the top priority stream\n result = \"FAILED\" if bc[0] == \"YM\" && i == 0\n # fails if minimum failed and there was free bandwidth\n result = \"FAILED\" if bc[0] == \"YM\" && free_bandwidth > 0\n # fails if the bandwidth is over maximum specified\n result = \"FAILED\" if bc[1] == \"YN\"\n end\n new_results << priority_list[i].split(\"|\")[1].insert(0, \"[#{priority_index >= 0 ? sprintf(\"%d\", priority_index) : \"NONE\"}] [#{result}] \")\n end\n return new_results\nend",
"def rules\n #\n # This is called first in case any preable needs to be declared (chains, specifically)\n #\n _ruleset_rules = ruleset_rules\n\n [\n Asbestos.firewall.preamble(self),\n _ruleset_rules,\n Asbestos.firewall.postamble(self)\n ].flatten\n end",
"def pbArrangeByTier(pokemonlist,rule)\n tiers=[\n withRestr(rule,0,500,0),\n withRestr(rule,380,500,0),\n withRestr(rule,400,555,0),\n withRestr(rule,400,555,0),\n withRestr(rule,400,555,0),\n withRestr(rule,400,555,0),\n withRestr(rule,580,680,1),\n withRestr(rule,500,680,0),\n withRestr(rule,580,680,2)\n ]\n tierPokemon=[]\n for i in 0...tiers.length\n tierPokemon.push([])\n end\n for i in 0...pokemonlist.length\n next if !rule.ruleset.isPokemonValid?(pokemonlist[i])\n validtiers=[]\n for j in 0...tiers.length\n tier=tiers[j]\n if tier.ruleset.isPokemonValid?(pokemonlist[i])\n validtiers.push(j)\n end\n end\n if validtiers.length>0\n vt=validtiers.length*i/pokemonlist.length\n tierPokemon[validtiers[vt]].push(pokemonlist[i])\n end\n end\n # Now for each tier, sort the Pokemon in that tier\n ret=[]\n for i in 0...tiers.length\n tierPokemon[i].sort!{|a,b|\n bstA=baseStatTotal(a.species)\n bstB=baseStatTotal(b.species)\n if bstA==bstB\n a.species<=>b.species\n else\n bstA<=>bstB\n end\n }\n ret.concat(tierPokemon[i])\n end\n return ret\nend",
"def then_rules\n @then_rules ||= []\n end",
"def rule; end",
"def rule; end",
"def rule; end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def relevant_rules(action, subject)\n return [] unless @rules\n\n relevant = possible_relevant_rules(subject).select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n relevant.reverse!.uniq!\n optimize_order! relevant\n relevant\n end",
"def add_relevant_rules_for_fact fact\r\n @rules.values.select { |rule| \r\n if !@relevant_rules.include?( rule)\r\n if rule.parameters_match?(fact.value) \r\n @relevant_rules << rule \r\n logger.debug \"#{rule} is relevant\" if logger\r\n else\r\n logger.debug \"#{rule} is not relevant\" if logger \r\n end \r\n end\r\n } \r\n end",
"def sorted(tasks)\n tasks.sort_by {|task| task[:priority]}\nend",
"def rules_for(table)\n by_string, ages = rules_by_string(table, [])\n by_regexp, ages = rules_by_regexp(table, ages)\n for_all, ages = rules_for_all(table, ages)\n\n valid_rules = by_string + by_regexp + for_all\n valid_rules.sort { |a, b| b[:age] <=> a[:age] }\n end",
"def rules\n @rules ||= {}\n end",
"def rule_priority_text\n severity\n end",
"def order\n order = \"#{@rules[:s]}\".split(' ')\n @resource = order.blank? ? @resource : @resource.order_by(order)\n end",
"def order; end",
"def order; end",
"def compute!\n class_def = /^\\[[\\w;\\?|=!]*?\\]$/\n inheritance = /\\[(.*?)\\]\\^\\[(.*?)\\]/\n association = /\\[.*\\]-.*>\\[.*\\]/\n\n @statements.sort! do |x, y|\n\n if x =~ class_def and y =~ inheritance\n -1\n elsif x =~ class_def and y =~ association\n -1\n elsif x =~ inheritance and y =~ association\n -1\n elsif x =~ class_def and y =~ class_def\n 0\n elsif x =~ inheritance and y =~ inheritance\n 0\n elsif x =~ association and y =~ association\n 0\n else\n 1\n end\n\n end\n end",
"def skip_rule_targets\n targets = skip_rules.map { |r| r.dest_item || :end }.uniq\n targets.sort_by! { |t| t == :end ? [1e9] : t.full_rank }\n targets.map { |t| t == :end ? h.t(\"skip_rule.end\") : \"##{t.full_dotted_rank}\" }\n end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def order\n if terminal?\n 0\n elsif self_referential?\n 1\n else\n r = 0\n @rules.each do |rule|\n # Only interested in rule with recursion\n if rule.size > 1\n rule.each do |elem|\n # Only interested in references\n if elem.is_a? String\n b = @klass.defs.find_all {|i| i.name == elem}[0].order + 1\n r = b if b > r # swap if higher\n end\n end\n end\n end\n r\n end\n end",
"def process_rules(state)\n raise(\"No rules have been loaded into engine %s\" % self) if empty?\n\n rules_by_priority do |rule|\n state.mutable = !rule.concurrent?\n result = rule.process_state(state)\n state.mutable = true\n\n state.store_result(result) if result\n end\n\n state.results\n end",
"def load_rules; end",
"def sorted(tasks)\r\n tasks.sort_by {|task| task[\"priority\"]}\r\nend",
"def priority_order(action_by_priority)\n action_by_priority.keys.sort\n end",
"def test_retuns_ordered_jobs_considering_all_dependecies\n sequence = Sequence.new()\n sequence.add(\"a =>\n b => c\n c => f\n d => a\n e => b\n f =>\")\n sequence.ordered.each do |job|\n assert (%w[a b c d e f].include?(job))\n end\n assert sequence.ordered.index(\"f\") < sequence.ordered.index(\"c\")\n assert sequence.ordered.index(\"c\") < sequence.ordered.index(\"b\")\n assert sequence.ordered.index(\"b\") < sequence.ordered.index(\"e\")\n assert sequence.ordered.index(\"a\") < sequence.ordered.index(\"d\")\n end",
"def sort_action_in_priority(actions)\n actions.sort! do |a, b|\n # @type [PFM::PokemonBattler]\n pokemon_a = a[:launcher] || a[:target] || a[:who]\n # @type [PFM::PokemonBattler]\n pokemon_b = b[:launcher] || b[:target] || b[:who]\n next(pokemon_a.spd <=> pokemon_b.spd)\n end\n actions.reverse! if global_trick_room?\n check_priority_item_trigger(actions)\n end",
"def collect_compare_priority\n @compare_quque = []\n @compare_quque = ComparisonTable.sort_by{|k, dar|\n DisplayOrder[StringTable[dar.first]] ? DisplayOrder[StringTable[dar.first]] : DisplayOrder[MISC_text]\n }.collect{|p| p[0]}\n end",
"def dumpRules()\r\n 79.times {print \"=\"}\r\n puts\r\n puts \"RULE DUMP\".center(80)\r\n 79.times {print \"=\"}\r\n puts\r\n\r\n if(@rules.length > 0)\r\n rules = @rules.sort\r\n rules.each do |key, rule|\r\n puts \"#{rule.name}\\t(#{rule.alias})\"\r\n puts \"#{rule.xml}\"\r\n 40.times {print \"-\"}\r\n puts\r\n end\r\n\r\n else\r\n puts \"No rules to dump.\"\r\n end\r\n\r\n puts \"\"\r\n end",
"def predicate_order\n [\n RDF.type,\n RDF::RDFS.label,\n RDF::RDFS.comment,\n RDF::URI(\"http://purl.org/dc/terms/title\"),\n RDF::URI(\"http://purl.org/dc/terms/description\"),\n RDF::OWL.sameAs,\n RDF::N3::Log.implies\n ]\n end",
"def e5115_sublinear_sort(values)\n end",
"def rule_assert( obj )\r\n # add object as a new fact\r\n f = fact(obj)\r\n # get_relevant_rules\r\n logger.debug( \"Check if we need to add more rules\") if logger\r\n add_relevant_rules_for_fact(f)\r\n sort_relevant_rules\r\n end",
"def priority\n 0\n end",
"def matching_rules(number, rules)\n result = []\n rules.each do |rule, ranges|\n ranges.each do |range|\n next if number < range[0] || number > range[1]\n\n result.append(rule)\n break\n end\n end\n result\nend",
"def critical_risks_unique_sorted\n\t\t\t\t\t#Item.select(\"items.*\").select(\"count(*) as count_all\").where(:severity => 4).group(:plugin_id).order(\"count_all DESC\")\n\t\t\t\t\tItem.where(:severity => 4).group(:plugin_id).order(Arel.sql('COUNT(*) DESC'))\n\t\t\t\tend",
"def sorted_threshold_problems\n # if there are no threshold problems, return nil\n threshold_problems = self.threshold_problems.all\n if threshold_problems.empty?\n return nil\n end\n sorted_problems = {}\n problem_types = ProblemType.all.map{|type| type.name}\n puts problem_types\n problem_count = 0\n # for each type\n problem_types.each do |type|\n puts type\n # get all the problems of that type and put the problems into an array\n types_problems = []\n problems_for_type = self.threshold_problems.select{|problem| problem.problem_type.name == type}\n problems_for_type.each do |prob|\n types_problems << prob.problem\n end\n # then make a key in the problems hash that maps to the array or problems\n sorted_problems[type] = types_problems\n end \n return sorted_problems\n end",
"def k_ordenar!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 49 )\n\n\n\n type = K_ORDENAR\n channel = ANTLR3::DEFAULT_CHANNEL\n # - - - - label initialization - - - -\n\n\n # - - - - main rule block - - - -\n # at line 449:3: 'sort'\n match( \"sort\" )\n\n\n\n @state.type = type\n @state.channel = channel\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 49 )\n\n\n end",
"def sort_dependencies!(params)\n params.each do |x|\n next unless [:require, :before, :notify, :subscribe].include?(x[0])\n if x[1].class == Array\n x[1].sort!\n end\n end\n end",
"def apply_sorting(chain)\n chain\n end",
"def finalize\n # sort rules by alphabetical order, grouped by chain, else they arrive in\n # random order and cause puppet to reload iptables rules.\n @@rules.each_key {|key|\n @@rules[key] = @@rules[key].sort_by {|rule| [rule[\"chain_prio\"], rule[\"name\"]] }\n }\n\n # load pre and post rules\n load_rules_from_file(@@rules, @@pre_file, :prepend)\n load_rules_from_file(@@rules, @@post_file, :append)\n\n # add numbered version to each rule\n @@table_counters.each_key { |table|\n rules_to_set = @@rules[table]\n if rules_to_set\n counter = 1\n rules_to_set.each { |rule|\n rule['numbered rule'] = counter.to_s + \" \"+rule[\"full rule\"]\n rule['altned rule'] = counter.to_s + \" \"+rule[\"alt rule\"]\n counter += 1\n }\n end\n }\n\n # On the first round we delete rules which do not match what\n # we want to set. We have to do it in the loop until we\n # exhaust all rules, as some of them may appear as multiple times\n while self.delete_not_matched_rules > 0\n end\n\n # Now we need to take care of rules which are new or out of order.\n # The way we do it is that if we find any difference with the\n # current rules, we add all new ones and remove all old ones.\n if self.rules_are_different\n # load new new rules\n benchmark(:notice, self.noop ? \"rules would have changed... (noop)\" : \"rules have changed...\") do\n # load new rules\n @@table_counters.each { |table, total_do_delete|\n rules_to_set = @@rules[table]\n if rules_to_set\n rules_to_set.each { |rule_to_set|\n if self.noop\n debug(\"Would have run 'iptables -t #{table} #{rule_to_set['alt rule']}' (noop)\")\n next\n else\n debug(\"Running 'iptables -t #{table} #{rule_to_set['alt rule']}'\")\n `#{@@iptables_dir}/iptables -t #{table} #{rule_to_set['alt rule']}`\n end\n }\n end\n }\n\n # delete old rules\n @@table_counters.each { |table, total_do_delete|\n current_table_rules = @@current_rules[table]\n if current_table_rules\n current_table_rules.each { |rule, data|\n if self.noop\n debug(\"Would have run 'iptables -t #{table} -D #{data['chain']} 1' (noop)\")\n next\n else\n debug(\"Running 'iptables -t #{table} -D #{data['chain']} 1'\")\n `#{@@iptables_dir}/iptables -t #{table} -D #{data['chain']} 1`\n end\n }\n end\n }\n # Run iptables save to persist rules. The behaviour is to do nothing\n # if we no nothing of the operating system.\n persist_cmd = case Facter.value(:operatingsystem).downcase\n when /(fedora|redhat|centos)/ then \"/sbin/service iptables save\"\n when /(ubuntu|debian)/ then \"/sbin/iptables-save > /etc/iptables.rules\"\n else nil\n end\n debug(\"Saving iptables with: #{persist_cmd}\")\n unless(persist_cmd == nil) then\n\t system(persist_cmd)\n end\n end\n\n @@rules = {}\n end\n\n @@finalized = true\n end",
"def priorities\n @priorities ||= [:highest, :high, :normal, :low, :lowest]\n end",
"def sort_by_algo(state_list)\n state_list.sort_by(&:algie_check)\n end",
"def placings\n score_ordering = low? ? :asc : :desc\n\n scores.order(disqualified: :asc)\n .order(participated: :desc)\n .order(tier: :asc)\n .order(score: score_ordering)\n .order(tiebreaker_place: :asc)\n end",
"def sort_conditions\n @sort_conditions ||= SimpleTypedList.new SortCondition\n end",
"def relevant_rules(action, subject)\n rules.reverse.select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n end",
"def apply_rules\n match_reduce(\n ->((rhs1, rhs1_s), (_, rhs2_s)) {\n rhs1.size >= 2 and rhs2_s.include? rhs1_s\n },\n ->(lhs1, lhs2, _) { @cfg.factor! lhs2, lhs1 }\n )\n end",
"def all\n rules = []\n\n raw.each do |type, details|\n # Add general rules\n Array(details['prefix']).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type\n })\n end\n\n # Process each country\n Array(details['countries']).each do |country, prefixes|\n # Add a rule for each prefix\n Array(prefixes).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type,\n country: country,\n })\n end\n end\n\n end\n\n # Sort by prefix length\n rules.sort { |x, y| y[:prefix].length <=> x[:prefix].length }\n end",
"def tie_breaking_sort\n { \"content_id\" => { order: \"asc\" } }\n end",
"def rules\n @rules ||= begin\n @rules = []\n resolve_permissions\n @rules\n end\n end",
"def sort_input(input, property, order); end",
"def priority\r\n 25\r\n end",
"def default_priority\n 0\n end",
"def lower_priority_elements\n []\n end",
"def each_rule_pair\n rules = @cfg.rules.dup\n rules_s = @cfg.rules_s\n sizes = Hash[rules.map { |lhs, rhs| [lhs, rhs.size] }]\n\n rules.each_with_index do |(lhs1, rhs1), i|\n rules.each_with_index do |(lhs2, rhs2), j|\n next unless j < i\n\n rule1 = [lhs1, [rhs1, rules_s[lhs1]]]\n rule2 = [lhs2, [rhs2, rules_s[lhs2]]]\n\n yield [rule1, rule2].sort_by { |lhs, _| sizes[lhs] }\n end\n end\n end",
"def sort_by_dependencies\n visited = Hash[dependencies.keys.map {|k| [k, false]}]\n in_call_stack = {}\n dependencies.each_pair do |job, dependency|\n return if error\n helper(visited, in_call_stack, job) unless visited[job]\n end\n result\n end",
"def sort_option\n ['Best match', 'Level', 'Provider(s)']\n end",
"def [](*args)\n sort_if_needed\n @rules[*args]\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def to_list\n rules.map do |rule|\n object = { actions: rule.actions, subject: rule.subjects.map{ |s| s.is_a?(Symbol) ? s : s.name } }\n object[:conditions] = rule.conditions unless rule.conditions.blank?\n object[:inverted] = true unless rule.base_behavior\n object\n end\n end",
"def score_priority(x)\n priority = 0\n 0.upto(x.size-1) { |i|\n if x[i] == @instance.final_capacities[i]\n priority += 7\n elsif @instance.final_capacities.include?(x[i])\n priority += 5\n elsif x[i] > 0 && x[i] != @instance.capacities[i]\n priority += 2\n end\n }\n return priority\n end",
"def closure(rules)\n\t\tj = rules.map{|x| x.clone};\n\t\tall_rules = [];\n\t\t@rules .each{ |x,y| y.each{ |z| all_rules += [[x, z, 0]] }}\n\t\tj .each{ | x| all_rules -= [ x ] }\n\t\t#p all_rules\n\t\tbegin\n\t\t\tis_added = false;\n\t\t\tj.each do |c_rule|\n\t\t\t\tif c_rule[1].size >= c_rule[2] then\n\t\t\t\t\tnonterm_to_add = c_rule[1][c_rule[2]]\n\t\t\t\t\t#p nonterm_to_add\n\t\t\t\t\tif nonterm_to_add.class == Symbol then\n\t\t\t\t\t\ttemp = [];\n\t\t\t\t\t\tall_rules.each do |rule_to_add|\n\t\t\t\t\t\t\t#p rule_to_add\n\t\t\t\t\t\t\tif nonterm_to_add == rule_to_add[0] then\n\t\t\t\t\t\t\t\ttemp += [rule_to_add];\n\t\t\t\t\t\t\t\tis_added = true;\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\t\tall_rules -= temp;\n\t\t\t\t\t\tj += temp;\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend while is_added\n\t\treturn j;\n\tend",
"def order_by_cached_appeal_priority_clause\n Arel.sql(<<-SQL)\n (CASE\n WHEN cached_appeal_attributes.case_type = 'Court Remand' THEN 1\n ELSE 0\n END) DESC,\n cached_appeal_attributes.is_aod DESC,\n cached_appeal_attributes.docket_number ASC\n SQL\n end",
"def priority\n self.stylesheet_or_javascript? ? 100 : 0\n end",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def sort_criteria\n @sort_criteria ||=\n sort_params.reduce('') do |sum, (key, value)|\n comparables = [\"a[:#{key}]\", \"b[:#{key}]\"]\n comparables.reverse! if value == :desc\n sum + \"comp = comp == 0 ? #{comparables.join(' <=> ')} : comp; \"\n end\n end"
] |
[
"0.77348995",
"0.7692838",
"0.71726584",
"0.70538974",
"0.6967807",
"0.6660927",
"0.66408473",
"0.66164094",
"0.66164094",
"0.66164094",
"0.66164094",
"0.66164094",
"0.66164094",
"0.66164094",
"0.6531411",
"0.64810646",
"0.6457969",
"0.6288312",
"0.6256381",
"0.62449473",
"0.62296355",
"0.619401",
"0.619401",
"0.6133487",
"0.610542",
"0.6105395",
"0.6079934",
"0.60108244",
"0.60031295",
"0.59380424",
"0.5890196",
"0.5864804",
"0.5842358",
"0.58273554",
"0.582571",
"0.5813103",
"0.5813103",
"0.5813103",
"0.58120066",
"0.5801324",
"0.5801324",
"0.5801324",
"0.5800249",
"0.5772467",
"0.5771632",
"0.5759132",
"0.5756042",
"0.57538486",
"0.5744682",
"0.5743157",
"0.5743157",
"0.57404584",
"0.5738233",
"0.5720138",
"0.5720138",
"0.5718349",
"0.57179785",
"0.5702814",
"0.56989473",
"0.5668088",
"0.5665083",
"0.565975",
"0.5633212",
"0.5618793",
"0.5565101",
"0.55621433",
"0.5536896",
"0.55357367",
"0.5511485",
"0.5510453",
"0.55037665",
"0.54959804",
"0.54951966",
"0.54794043",
"0.54751074",
"0.5470074",
"0.54692245",
"0.54634005",
"0.5461253",
"0.5454696",
"0.5437981",
"0.54253405",
"0.5388116",
"0.53826886",
"0.53790665",
"0.53777444",
"0.53722644",
"0.53407073",
"0.53242695",
"0.5312884",
"0.5312673",
"0.53080964",
"0.53052324",
"0.5301167",
"0.5285903",
"0.52848196",
"0.5272204",
"0.52720267",
"0.5265942",
"0.52625126"
] |
0.8185103
|
0
|
get all relevant rules for all specified facts
|
def get_relevant_rules
@relevant_rules = Array.new
@facts.each { |k,f|
add_relevant_rules_for_fact f
}
sort_relevant_rules
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def all\n @rules\n end",
"def rules_by_name; end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def add_relevant_rules_for_fact fact\r\n @rules.values.select { |rule| \r\n if !@relevant_rules.include?( rule)\r\n if rule.parameters_match?(fact.value) \r\n @relevant_rules << rule \r\n logger.debug \"#{rule} is relevant\" if logger\r\n else\r\n logger.debug \"#{rule} is not relevant\" if logger \r\n end \r\n end\r\n } \r\n end",
"def rules\n @rules=get_endpoint('rule').keys\n end",
"def matches(facts)\n rules.values.map {|rule|\n rule.matches(facts).map { |bindings| Match.new(rule,bindings) }\n }.reduce(:+).uniq\n end",
"def get_candidates(rules)\n candidates = []\n rules.each { |rule| candidates << rule if rule.ever_matched? && rule.time_to_report? }\n candidates\n end",
"def get_rules\r\n @rules\r\n end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def relevant_rules(action, subject)\n return [] unless @rules\n\n relevant = possible_relevant_rules(subject).select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n relevant.reverse!.uniq!\n optimize_order! relevant\n relevant\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n return [] if @rules.empty?\n @rules.sort_by { |k| k['priority'] }.map { |h| h['rule_name'] }\n end",
"def rules\n return @rules\n end",
"def rules_for(configuration, character)\n # note that it is select (filter), not detect (find)\n rules.select {|rule| rule.applies_to?(configuration, character)}\n end",
"def get_all_config_rules\n config_rules = []\n\n # Fetch all rules with pagination\n response = @client.describe_config_rules\n config_rules += response.config_rules\n while response.next_token\n response = @client.describe_config_rules(next_token: response.next_token)\n config_rules += response.config_rules\n end\n config_rules = config_rules.map(&:to_h)\n\n # Add necessary data to rules using helpers\n add_compliance_to_config_rules(config_rules)\n add_results_to_config_rules(config_rules)\n end",
"def rules\n @rules ||= {}\n end",
"def all_defined_rules\n if @group\n @defined_rules.merge(@group.all_defined_rules)\n else\n @defined_rules\n end\n end",
"def to_list\n rules.map do |rule|\n object = { actions: rule.actions, subject: rule.subjects.map{ |s| s.is_a?(Symbol) ? s : s.name } }\n object[:conditions] = rule.conditions unless rule.conditions.blank?\n object[:inverted] = true unless rule.base_behavior\n object\n end\n end",
"def all\n @rules ||= raw.values.flatten.map { |rule| Accessibility::Rule.new(rule) }\n end",
"def relevant_rules(action, subject)\n rules.reverse.select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n end",
"def get_modifying_rules(agent, opponent)\n modified_by = Hash.new { [[],[]] }\n track = lambda do |set, index|\n set.each_with_index do |rule, rule_i|\n rule.alternatives.each do |alt|\n alt.modifiers.each do |mod|\n arr = modified_by[mod.predicate]\n arr[index] << [rule_i, mod.type]\n modified_by[mod.predicate] = arr\n end\n end\n end\n end\n track.call(agent.actions, 0)\n track.call(opponent.rules, 1)\n return modified_by\n end",
"def rules\n cluster.configurationEx.rule\n end",
"def rules\n cluster.configurationEx.rule\n end",
"def rules\n @rules ||= begin\n @rules = []\n resolve_permissions\n @rules\n end\n end",
"def all\n rules = []\n\n raw.each do |type, details|\n # Add general rules\n Array(details['prefix']).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type\n })\n end\n\n # Process each country\n Array(details['countries']).each do |country, prefixes|\n # Add a rule for each prefix\n Array(prefixes).each do |prefix|\n rules.push({\n prefix: prefix.to_s,\n length: details['length'],\n type: type,\n country: country,\n })\n end\n end\n\n end\n\n # Sort by prefix length\n rules.sort { |x, y| y[:prefix].length <=> x[:prefix].length }\n end",
"def ruleset_rules\n @rulesets.collect do |r|\n [\"# Begin [#{r.name}]\",\n r.firewall_rules,\n \"# End [#{r.name}]\",\n \"\"]\n end\n end",
"def rules_by_name(rule_name, section_id = @one_section_id)\n rules = []\n return rules unless section_id\n\n all_rules = rules(section_id)\n return rules unless all_rules\n\n all_rules['results'].each do |rule|\n rules << rule if rule['display_name'] == rule_name\n end\n rules\n end",
"def rules # :nodoc:\n # Rules should always be returned sorted with oldest first.\n @rules.sort! { |a, b| b[:age] <=> a[:age] }\n end",
"def rules_for(table)\n by_string, ages = rules_by_string(table, [])\n by_regexp, ages = rules_by_regexp(table, ages)\n for_all, ages = rules_for_all(table, ages)\n\n valid_rules = by_string + by_regexp + for_all\n valid_rules.sort { |a, b| b[:age] <=> a[:age] }\n end",
"def known_rules\n @table.keys\n end",
"def rules\n self.class.rules\n end",
"def get_rules\n rules = Array.new\n\n RULE_TYPES.each do |reg|\n ebtables_exit = `#{CONF[:ebtables]} -L FORWARD`\n\n rules << ebtables_exit.split(\"\\n\")[3..-1].collect do |l|\n line = l.strip\n m = line.match(reg)\n\n if m\n interface=m[1]\n {\n :interface => interface, \n :rule => line\n }\n else\n nil\n end\n end.compact\n end\n\n rules.flatten\nend",
"def rules(rule_name:, kind:)\n Rules::RuleSet.build_for(calendar: calendar, kind: kind).rules_with_name(rule_name)\n end",
"def rules\n return @rules unless @rules.nil?\n\n # this initialization code runs only once\n @rules = {}\n 7.downto(0).each do |rule_key|\n key = rule_key.to_s(2).rjust(3, '0') # convert to binary, pad left with 0\n @rules[key.to_sym] = RULE_NAME >> rule_key & 1 # just the one bit\n end\n\n @rules\n end",
"def all_facts\n @facts.values.collect { |property_facts| property_facts.values }.flatten\n end",
"def each\n @rules.each { |h,ds| ds.each { |d| yield [h, d] } }\n end",
"def rules\n rule_applier.rules\n end",
"def search(*rules); end",
"def search(*rules); end",
"def consume_rules(flags = {})\n rules = []\n\n while token = @tokens.consume\n case token[:node]\n when :comment, :whitespace\n rules << token\n\n when :cdc, :cdo\n unless flags[:top_level]\n @tokens.reconsume\n rule = consume_qualified_rule\n rules << rule if rule\n end\n\n when :at_keyword\n @tokens.reconsume\n rule = consume_at_rule\n rules << rule if rule\n\n else\n @tokens.reconsume\n rule = consume_qualified_rule\n rules << rule if rule\n end\n end\n\n rules\n end",
"def rules\n #\n # This is called first in case any preable needs to be declared (chains, specifically)\n #\n _ruleset_rules = ruleset_rules\n\n [\n Asbestos.firewall.preamble(self),\n _ruleset_rules,\n Asbestos.firewall.postamble(self)\n ].flatten\n end",
"def rule_by_id; end",
"def rulelist(ruleset, ctx)\r\n\r\n outlist = \"\"\r\n\r\n ruleset.rules.each do |ralias|\r\n rname = ctx.rules[ralias].name\r\n outlist += reference(\"rule\", rname)\r\n\r\n end # rules.each\r\n\r\n return outlist\r\n\r\n end",
"def readable\n \"Rules:\\n#{rules.collect {|r| r.readable }.join('\\n')}\\nFacts:\\n#{all_facts.collect {|f| f.readable }.join('\\n')}\"\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def rules(section_id = @one_section_id)\n url = @url_sections + '/' + section_id + '/rules'\n @nsx_client.get(url)\n end",
"def construct_rules rules\n parsed_rules = {:rules => []}\n rules.each do |rule|\n parsed_rules[:rules] << rule.attributes\n end\n parsed_rules.to_json\n end",
"def rule_set\n @rule_set ||= Rules::RuleSet.build_for(calendar: calendar, kind: kind)\n end",
"def process_rules\n @rules.each do |rule|\n rule.process(@commands, @vars)\n end\n\n @commands.uniq!\n end",
"def find_possibilities\n (0..@field_count-1).reduce({}) do |acc, i|\n acc[i] = @rules\n .select do |rule|\n ticket_values_at(i).all? { |v| rule.valid?(v) }\n end\n .map(&:name)\n\n acc\n end\n end",
"def patterns\n #@rules.every.pattern\n @rules.map {|r| r.pattern }\n end",
"def rules_from_step_content\n @rules_from_step_content ||= content_items.each_with_object({}) do |content_item, items|\n items[content_item[\"content_id\"]] = build_rule(content_item)\n end\n end",
"def rules_at(keys, *rest)\n if defined?(keys.exclude_end?)\n return @rules[keys]\n end\n ([keys]+rest).flatten.map{ |i| rule_at(i) }\n end",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def defined_rules\n @defined_rules ||= {}\n end",
"def process_rules(state)\n raise(\"No rules have been loaded into engine %s\" % self) if empty?\n\n rules_by_priority do |rule|\n state.mutable = !rule.concurrent?\n result = rule.process_state(state)\n state.mutable = true\n\n state.store_result(result) if result\n end\n\n state.results\n end",
"def load_rules; end",
"def rules_for(state, char)\n rules.select { |rule| rule.applies_to?(state, char) }\n end",
"def rules\n @rules.dup.freeze\n end",
"def fact_readings_with_constraints(verbaliser, fact_type)\n fact_constraints = @presence_constraints_by_fact[fact_type]\n readings = []\n define_role_names = true\n fact_type.all_reading_by_ordinal.each do |reading|\n readings << expanded_reading(verbaliser, reading, fact_constraints, define_role_names)\n define_role_names = false # No need to define role names in subsequent readings\n end\n readings\n end",
"def available_rules\n\t\tif @rules.nil?\n\t\t\t@rules = []\n\t\t\tDir.glob(File.join(@rule_directory,\"**\",\"*.yar*\")).each do |yara_rule_file|\n\t\t\t\trule = YaraRule.new\n\t\t\t\trule.file_path = yara_rule_file.gsub(\"/\",\"\\\\\\\\\")\n\t\t\t\t@rules << rule\n\t\t\tend\n\t\tend\n\t\treturn @rules\n\tend",
"def rule_assert( obj )\r\n # add object as a new fact\r\n f = fact(obj)\r\n # get_relevant_rules\r\n logger.debug( \"Check if we need to add more rules\") if logger\r\n add_relevant_rules_for_fact(f)\r\n sort_relevant_rules\r\n end",
"def rules_with_epsilon()\n rules = []\n @rules.each do |rule|\n rules << rule if rule.epsilon?\n end\n rules\n end",
"def predicates\n @graphs.inject([]) {|memo, g| memo += g.predicates}\n end",
"def to_rules\n Array.new.tap do |rules|\n new_rule = Rule.new(rule.chain)\n new_rule.description = \"#{rule.description} (#{self.description})\"\n new_rule.rule = rule.rule.gsub(/\\{\\{(\\w+)\\}\\}/) do\n if value = self.options[$1.to_sym]\n value\n else\n \"{{#{$1}}}\"\n end\n end\n new_rule.action = rule.action\n new_rule.conditions = rule.conditions | self.conditions\n if self.version\n new_rule.versions = [self.version]\n end\n\n if has_host_group?\n host_group = @rule.chain.table.base.host_groups[self.options[:ip]]\n host_group.hosts.each do |key, host|\n host.ips.each do |v, ip|\n hg_rule = new_rule.dup\n hg_rule.description += \" (#{host.name} via #{host_group.name})\"\n hg_rule.rule.gsub!(host_group.name.to_s, ip)\n hg_rule.versions = [v]\n rules << hg_rule\n end\n end\n else\n rules << new_rule\n end\n end\n end",
"def get_all_rules\n @options = {\n headers: {\n \"User-Agent\": 'v2FilteredStreamRuby',\n \"Authorization\": \"Bearer #{@bearer_token}\"\n }\n }\n @response = Typhoeus.get(@rules_url, @options)\n raise \"An error occurred while retrieving active rules from your stream: #{@response.body}\" unless @response.success?\n\n @body = JSON.parse(@response.body)\nend",
"def each(&block)\n @rules.each(&block)\n end",
"def facts\n @facts ||= {}\n end",
"def then_rules\n @then_rules ||= []\n end",
"def rules_containing(production)\n rules = []\n @rules.each do |rule|\n rules << rule if rule.productions.include?(production)\n end\n rules\n end",
"def rules( *new_values )\n\t\tself.rules = new_values unless new_values.empty?\n\t\treturn @rules\n\tend",
"def list\n @driver.getRuleNames\n end",
"def evaluate\r\n @status = PASS\r\n @assert = true\r\n @num_executed = 0;\r\n @num_evaluated = 0;\r\n \r\n get_relevant_rules()\r\n logger.debug(\"no relevant rules\") if logger && @relevant_rules.size==0\r\n \r\n #begin #rescue\r\n \r\n # loop through the available_rules, evaluating each one,\r\n # until there are no more matching rules available\r\n begin # loop\r\n \r\n # the loop condition is reset to break by default after every iteration\r\n matches = false\r\n obj = nil #deprecated\r\n \r\n #logger.debug(\"available rules: #{available_rules.size.to_s}\") if logger\r\n @relevant_rules.each do |rule|\r\n # RuleCheckErrors are caught and swallowed and the rule that\r\n # raised the error is removed from the working-set.\r\n logger.debug(\"evaluating: #{rule}\") if logger\r\n begin\r\n @num_evaluated += 1\r\n if rule.conditions_match?(obj)\r\n logger.debug(\"rule #{rule} matched\") if logger\r\n matches = true\r\n \r\n # remove the rule from the working-set so it's not re-evaluated\r\n @relevant_rules.delete(rule)\r\n \r\n # find all parameter-matching dependencies of this rule and\r\n # add them to the working-set.\r\n if @dependencies.has_key?(rule.name)\r\n logger.debug( \"found dependant rules to #{rule}\") if logger\r\n @relevant_rules += @dependencies[rule.name].select do |dependency|\r\n dependency.parameters_match?(obj)\r\n end\r\n end\r\n \r\n # execute this rule\r\n logger.debug(\"executing rule #{rule}\") if logger\r\n rule.call(obj)\r\n @num_executed += 1\r\n \r\n # break the current iteration and start back from the first rule defined.\r\n break\r\n end # if rule.conditions_match?(obj)\r\n \r\n rescue RuleConsequenceError\r\n fail\r\n rescue RuleCheckError => e\r\n fail\r\n end # begin/rescue\r\n \r\n end # available_rules.each\r\n \r\n end while(matches && @assert)\r\n \r\n #rescue RuleConsequenceError => rce\r\n # RuleConsequenceErrors are allowed to break out of the current assertion,\r\n # then the inner error is bubbled-up to the asserting code.\r\n # @status = FAIL\r\n # raise rce.inner_error\r\n #end\r\n \r\n @assert = false\r\n \r\n return @status\r\n end",
"def each\n @rules.each {|rule, obj| yield obj }\n end",
"def result\n\n # start the matching of the ruleby engine if not yet called\n unless @engine_has_matched\n @engine.match\n @engine_has_matched = true\n end\n\n # return the result array\n @result_rules\n\n end",
"def parse_firewall_rules\n script_code = 'netsh advfirewall firewall show rule name=all verbose'\n cmd = powershell_out(script_code) # Not logged because it makes too much noise\n\n retval = parse_firewall_paragraphs(cmd)\n\n raise 'Could not parse firewall rules' if retval.empty?\n return retval\n end",
"def closure(rules)\n\t\tj = rules.map{|x| x.clone};\n\t\tall_rules = [];\n\t\t@rules .each{ |x,y| y.each{ |z| all_rules += [[x, z, 0]] }}\n\t\tj .each{ | x| all_rules -= [ x ] }\n\t\t#p all_rules\n\t\tbegin\n\t\t\tis_added = false;\n\t\t\tj.each do |c_rule|\n\t\t\t\tif c_rule[1].size >= c_rule[2] then\n\t\t\t\t\tnonterm_to_add = c_rule[1][c_rule[2]]\n\t\t\t\t\t#p nonterm_to_add\n\t\t\t\t\tif nonterm_to_add.class == Symbol then\n\t\t\t\t\t\ttemp = [];\n\t\t\t\t\t\tall_rules.each do |rule_to_add|\n\t\t\t\t\t\t\t#p rule_to_add\n\t\t\t\t\t\t\tif nonterm_to_add == rule_to_add[0] then\n\t\t\t\t\t\t\t\ttemp += [rule_to_add];\n\t\t\t\t\t\t\t\tis_added = true;\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\t\tall_rules -= temp;\n\t\t\t\t\t\tj += temp;\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend while is_added\n\t\treturn j;\n\tend",
"def triggered_rules_from_encrypted(encrypted)\n\n # TODO: add decryption\n\n # create a new rules array\n rules = Array.new\n\n # decrypt the data\n string = encrypted\n\n # get the array back\n array = JSON.parse string\n\n # iterate the array\n array.each do |hash|\n\n # get the rule back\n rule = retrieve_rule hash['name']\n\n # create a new facts array\n facts = []\n\n # retrieve each of the facts\n hash['facts'].each do |fact|\n\n # create a new fact for each\n facts << create_fact(fact['name'], fact['value'])\n\n end\n\n # replace the facts on the rule\n rule.facts = facts\n\n # add to the array\n rules << rule\n\n end\n\n # return the rules array\n rules\n\n end",
"def rules(event)\n @rules[event]\n end",
"def rules_by_regex(regex, section_id = @one_section_id)\n rules = []\n return rules unless section_id\n\n all_rules = rules(section_id)\n return rules unless all_rules\n\n all_rules['results'].each do |rule|\n rules << rule if rule['display_name'].match(regex)\n end\n rules\n end",
"def rules_for(path)\n @rules.reverse.select do |rule| path.match(rule.pattern) end\n end",
"def rules\n @rules ||= Rules.new(path, logger)\n end",
"def get_facts\r\n @facts\r\n end",
"def rule(expression, &block)\n case expression\n when Hash\n expression.each do |fact, task|\n fact = define_fact(fact)\n task = define_task(task)\n @rules << Rule.new(fact, &task)\n end\n else\n fact = define_fact(expression)\n @rules << Rule.new(fact, &block)\n end\n\n #rule = Rule.new(@_facts, get_rule_options, &procedure)\n #@rules << rule\n #clear_rule_options\n\n return @rules\n end",
"def parse_matching_rules( descriptions )\n\t\tdescriptions ||= []\n\t\treturn descriptions.inject( Treequel::Schema::Table.new ) do |table, desc|\n\t\t\tbegin\n\t\t\t\trule = Treequel::Schema::MatchingRule.parse( self, desc )\n\t\t\t\ttable[ rule.oid ] = rule\n\t\t\t\trule.names.inject( table ) {|h, name| h[name] = rule; h }\n\t\t\trescue Treequel::ParseError => err\n\t\t\t\tif self.class.strict_parse_mode?\n\t\t\t\t\traise\n\t\t\t\telse\n\t\t\t\t\tself.log.warn( err.message )\n\t\t\t\tend\n\t\t\tend\n\n\t\t\ttable\n\t\tend\n\tend",
"def rules_ids\n @rules_registry.rules.map(&:id)\n end",
"def inferred_truths_all\n inferred_truths_all = []\n validsyllogisms = self.valid_syllogisms\n validsyllogisms.each do |syllogism|\n inferred_truths_all << syllogism.conclusion\n end\n return inferred_truths_all\n end",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def rules_as_hash\n\t\tunless @rules_as_hash\n\t\t\t@rules_as_hash = self.rules.each_with_object( {} ) do |rule, hash|\n\t\t\t\tpred, succ = self.parse_rule( rule )\n\t\t\t\thash[ pred ] = succ\n\t\t\tend\n\n\t\t\tself.alphabet.each do |char|\n\t\t\t\t@rules_as_hash[ char ] = char unless @rules_as_hash.key?( char )\n\t\t\tend\n\t\tend\n\n\t\treturn @rules_as_hash\n\tend",
"def external_rules\n @external_rules ||= rules.dup.external\n end"
] |
[
"0.7097032",
"0.6890875",
"0.6853133",
"0.6829951",
"0.6672312",
"0.6652536",
"0.66160196",
"0.6602752",
"0.65246457",
"0.65246457",
"0.650818",
"0.6499943",
"0.6499943",
"0.6499943",
"0.6499943",
"0.6499943",
"0.6499943",
"0.6499943",
"0.6449105",
"0.6449105",
"0.6449105",
"0.64484274",
"0.6438313",
"0.63906085",
"0.6332024",
"0.63249254",
"0.63050747",
"0.6268109",
"0.62623227",
"0.62505484",
"0.62341493",
"0.62195176",
"0.62195176",
"0.6183637",
"0.61803913",
"0.6153411",
"0.61265594",
"0.61200935",
"0.6088033",
"0.6071581",
"0.6052808",
"0.6048408",
"0.60292524",
"0.6027058",
"0.6019763",
"0.601546",
"0.60060674",
"0.5999135",
"0.5999135",
"0.5946101",
"0.59163725",
"0.59116775",
"0.5910901",
"0.5893737",
"0.5888118",
"0.58728844",
"0.58339703",
"0.5810917",
"0.5806141",
"0.58052856",
"0.58015054",
"0.5761949",
"0.5747583",
"0.57394105",
"0.57383317",
"0.5722465",
"0.57152057",
"0.57030714",
"0.56978303",
"0.56644046",
"0.56406355",
"0.56396353",
"0.5633685",
"0.5624897",
"0.5620581",
"0.5613709",
"0.5602739",
"0.55880255",
"0.558565",
"0.55770874",
"0.55574775",
"0.5546108",
"0.553445",
"0.5533142",
"0.5527663",
"0.55241793",
"0.5517051",
"0.55076873",
"0.5502266",
"0.54969734",
"0.5489079",
"0.5488256",
"0.5487149",
"0.5485951",
"0.5473254",
"0.5432689",
"0.54266375",
"0.5426006",
"0.542021",
"0.5409351"
] |
0.8081455
|
0
|
evaluate all relevant rules for specified facts
|
def evaluate
@status = PASS
@assert = true
@num_executed = 0;
@num_evaluated = 0;
get_relevant_rules()
logger.debug("no relevant rules") if logger && @relevant_rules.size==0
#begin #rescue
# loop through the available_rules, evaluating each one,
# until there are no more matching rules available
begin # loop
# the loop condition is reset to break by default after every iteration
matches = false
obj = nil #deprecated
#logger.debug("available rules: #{available_rules.size.to_s}") if logger
@relevant_rules.each do |rule|
# RuleCheckErrors are caught and swallowed and the rule that
# raised the error is removed from the working-set.
logger.debug("evaluating: #{rule}") if logger
begin
@num_evaluated += 1
if rule.conditions_match?(obj)
logger.debug("rule #{rule} matched") if logger
matches = true
# remove the rule from the working-set so it's not re-evaluated
@relevant_rules.delete(rule)
# find all parameter-matching dependencies of this rule and
# add them to the working-set.
if @dependencies.has_key?(rule.name)
logger.debug( "found dependant rules to #{rule}") if logger
@relevant_rules += @dependencies[rule.name].select do |dependency|
dependency.parameters_match?(obj)
end
end
# execute this rule
logger.debug("executing rule #{rule}") if logger
rule.call(obj)
@num_executed += 1
# break the current iteration and start back from the first rule defined.
break
end # if rule.conditions_match?(obj)
rescue RuleConsequenceError
fail
rescue RuleCheckError => e
fail
end # begin/rescue
end # available_rules.each
end while(matches && @assert)
#rescue RuleConsequenceError => rce
# RuleConsequenceErrors are allowed to break out of the current assertion,
# then the inner error is bubbled-up to the asserting code.
# @status = FAIL
# raise rce.inner_error
#end
@assert = false
return @status
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_relevant_rules\r\n @relevant_rules = Array.new\r\n @facts.each { |k,f| \r\n add_relevant_rules_for_fact f\r\n }\r\n sort_relevant_rules\r\n end",
"def add_relevant_rules_for_fact fact\r\n @rules.values.select { |rule| \r\n if !@relevant_rules.include?( rule)\r\n if rule.parameters_match?(fact.value) \r\n @relevant_rules << rule \r\n logger.debug \"#{rule} is relevant\" if logger\r\n else\r\n logger.debug \"#{rule} is not relevant\" if logger \r\n end \r\n end\r\n } \r\n end",
"def evaluate\n made_discovery = true\n while made_discovery do\n made_discovery = self.rules.any? do |rule|\n if rule.fired?\n false\n else\n rule.evaluate\n rule.fired?\n end\n end\n end\n end",
"def process_rules(state)\n raise(\"No rules have been loaded into engine %s\" % self) if empty?\n\n rules_by_priority do |rule|\n state.mutable = !rule.concurrent?\n result = rule.process_state(state)\n state.mutable = true\n\n state.store_result(result) if result\n end\n\n state.results\n end",
"def subsequent_rules(*args); end",
"def subsequent_rules(*args); end",
"def process_rules\n @rules.each do |rule|\n rule.process(@commands, @vars)\n end\n\n @commands.uniq!\n end",
"def search(*rules); end",
"def search(*rules); end",
"def matches(facts)\n rules.values.map {|rule|\n rule.matches(facts).map { |bindings| Match.new(rule,bindings) }\n }.reduce(:+).uniq\n end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def rules; end",
"def apply!(env)\n @rules.each do |rule|\n rule.apply!(env)\n end\n end",
"def rules_by_name; end",
"def process_rules *args, &block\n Shotshare::ProcessRuleContainer.instance.rules = \\\n Docile.dsl_eval(Shotshare::Dsl::ProcessRuleBuilder.new, &block).build\nend",
"def each(&block)\n @rules.each(&block)\n end",
"def assert_facts_from_rule(rule_object)\n\n # get the facts from the rule\n facts = rule_object.facts\n\n # iterate all the facts\n facts.each do |fact|\n\n # evaluate fact value\n # TODO: ONLY evaluate fact when trigger is called on a top level rule fact\n fact.value = evaluate_fact_value fact.value\n\n # let the ruleby engine assert the fact\n @engine.assert fact\n\n end\n\n end",
"def rule_assert( obj )\r\n # add object as a new fact\r\n f = fact(obj)\r\n # get_relevant_rules\r\n logger.debug( \"Check if we need to add more rules\") if logger\r\n add_relevant_rules_for_fact(f)\r\n sort_relevant_rules\r\n end",
"def each\n @rules.each {|rule, obj| yield obj }\n end",
"def each\n @rules.each { |h,ds| ds.each { |d| yield [h, d] } }\n end",
"def calculate\n candidates = []\n\n generalized_cause = NLU::Generalization.new(symbols: @symbols).generalize(@cause)\n\n #ap \"sentence: #{cause_sentence}\"\n #ap \"learned: #{@learned.inspect}\"\n\n # We go through everything that was learned before\n @learned.each do |function_name, criteria|\n criteria[:generalizations].each do |generalization|\n\n # We generate a pre-candidate for this generalization. It starts\n # with score zero because we don't know yet whether this criteria\n # fits the sentence or not.\n local_candidate = {\n fn: function_name,\n attrs: { },\n score: 0.0\n }\n\n #ap \"generalized_cause #{generalized_cause}\"\n\n # We then generalize the cause sentence and go through it.\n # We will match *each* learned generalization against the cause\n # generalization.\n generalized_cause.each_with_index do |cause_rule, cause_index|\n\n\n # Wildcard\n #\n # Matches these:\n #\n # > i want a [type:wildcard:some_name_for_this_wildcard]\n # > i want a ford\n #\n wildcard = \"[#{NLU::Generalization::RESERVED_TYPES[:wildcard]}]\"\n #ap \"wildcard: #{wildcard}\"\n wildcard_regex = Regexp.escape(wildcard)\n if generalization =~ /wildcard/i\n wildcard_generalization = generalization\n .gsub(/\\[(type:wildcard)(.+)\\]/i, '[\\1]')\n end\n #ap \"wildcard_generalization(#{wildcard_generalization}) =~ cause_rule(#{wildcard_regex})\"\n if wildcard_generalization.to_s =~ Regexp.new(wildcard_regex, Regexp::IGNORECASE)\n #ap \"true -> #{wildcard_generalization} =~ /#{Regexp.new(wildcard_regex, Regexp::IGNORECASE)}/i\"\n\n rule = wildcard_generalization.gsub(\"#{wildcard}\", \"(.+)\")\n #ap \"rule #{rule}\"\n #binding.pry\n if value = cause_sentence.join(\" \").match(Regexp.new(rule, Regexp::IGNORECASE))\n value = value[-1]\n prop = attr_name_from_type_param(generalization)\n\n local_candidate = local_candidate.merge({\n attrs: {\n prop => value\n },\n score: 0.75\n })\n end\n\n # If we find a learned generalization that matches the generalized\n # sentence, we will save it.\n elsif generalization == cause_rule\n cause_rule.split(\" \").each_with_index do |typed_string, index|\n\n # If the learned generalization has a type anywhere, we will\n # check what is the corresponding word in the cause sentence.\n #\n # For example, consider the following sentence:\n #\n # [type:subject] want a [type:make]\n #\n # and the sentence\n #\n # I want a ford\n #\n # Finding `[type:make]` at position 3 of the array, we will\n # get `ford` at the position 3 of the cause sentence. With\n # that we can come up with `{make: 'ford'}`.\n #\n if typed_string =~ /\\[type/i\n local_candidate[:score] += 1\n type = attr_name_from_type_param(typed_string)\n prop = type_properties(type)\n type_token_length = prop[:token_length]\n\n # In `i want a car`, this will get the `i`. If the type\n # says instead that it's formed by two symbols (e.g\n # `i want`), then it will take `i want`.\n #\n # The -1 in the brackets is because otherwise it would be\n # translated to the following if the type had 1 symbol\n #\n # cause_sentence[1..1+1]\n #\n # That would take 2 words (`[1..2]`). We want one word, so\n #\n # cause_sentence[1..1+1-1]\n #\n word_for_type = cause_sentence[index..index+(type_token_length-1)]\n #ap \"> type: #{type} - #{index} #{cause_sentence[index..index+type_token_length]}\"\n\n local_candidate[:attrs][type] = word_for_type.join(\" \")\n\n # When it's just the same sentence as one seen before, no\n # generalizations\n else\n local_candidate[:score] = 1\n end\n end\n\n end\n end\n\n if local_candidate[:score] > 0\n candidates << local_candidate\n end\n end\n end\n\n # TODO - normalization is taking out some elements that are good.\n #candidates = normalize_scores(candidates)\n candidates = pick_candidates(candidates)\n candidates = merge_attributes(candidates)\n\n candidates\n end",
"def apply_rules\n @matrix.each(&:apply_rules!)\n end",
"def each(&block)\n sort_if_needed\n @rules.each(&block)\n end",
"def each_typed_rule_match(type, rule, subject, match, permissive, &b)\n if rule.atom?\n process_rule_atom(type, rule, subject, match, permissive, &b)\n elsif rule.s_exp?\n process_typed_rule_s_exp(type, rule, subject, match, &b)\n else\n raise RuleException, \"Internal error\"\n end\n end",
"def each_rule\n vars.each do |var|\n productions[var].size.times do |i|\n yield productions[var][i]\n end\n end\n end",
"def rules_for(configuration, character)\n # note that it is select (filter), not detect (find)\n rules.select {|rule| rule.applies_to?(configuration, character)}\n end",
"def parse_rules(rules)\n rules.split(\"\\n\").each_with_object({}) do |rule, rule_hsh|\n mdata = /\\s{3}(\\w+)\\s/.match(rule)\n case mdata.nil? ? nil : mdata[1]\n when 'match'\n rule_hsh[:match] = [] unless rule_hsh.include?(:match)\n rule_hsh[:match] << rule.sub('match', '').strip\n when 'set'\n rule_hsh[:set] = [] unless rule_hsh.include?(:set)\n rule_hsh[:set] << rule.sub('set', '').strip\n when 'continue'\n rule_hsh[:continue] = nil unless rule_hsh.include?(:continue)\n rule_hsh[:continue] = rule.sub('continue', '').strip.to_i\n when 'description'\n rule_hsh[:description] = nil unless rule_hsh.include?(:description)\n rule_hsh[:description] = rule.sub('description', '').strip\n end\n end\n end",
"def get_candidates(rules)\n candidates = []\n rules.each { |rule| candidates << rule if rule.ever_matched? && rule.time_to_report? }\n candidates\n end",
"def apply_rules(json, type, rules)\n rules.each do |rule|\n next unless rule.function.call(json)\n rule.metadata = json\n rule.type = type\n\n case rule.modifier\n when :warning\n warnings << rule\n when :error\n errors << rule\n end\n end\n end",
"def update_from_params(params)\n\n if params.has_key? :triggered_rules\n\n # all the posted triggered rules\n posted_triggered_rules = triggered_rules_from_encrypted(params[:triggered_rules])\n\n # trigger all the triggered rules?\n posted_triggered_rules.each do |rule|\n\n # trigger all the previous triggered rules\n trigger rule\n\n end\n\n end\n\n # do some checks for stuff needed in the params\n if params.has_key? :current_rule\n\n # get the posted rule\n posted_rule = retrieve_rule(params[:current_rule])\n\n # get the posted facts\n posted_facts = facts_from_params params\n\n # add the facts to the posted rule\n posted_rule.facts.concat posted_facts\n\n # trigger the posted rule\n trigger posted_rule\n\n end\n\n # TODO: set the engine_match boolean to false??\n\n end",
"def all\n @rules\n end",
"def rule(expression, &block)\n case expression\n when Hash\n expression.each do |fact, task|\n fact = define_fact(fact)\n task = define_task(task)\n @rules << Rule.new(fact, &task)\n end\n else\n fact = define_fact(expression)\n @rules << Rule.new(fact, &block)\n end\n\n #rule = Rule.new(@_facts, get_rule_options, &procedure)\n #@rules << rule\n #clear_rule_options\n\n return @rules\n end",
"def add_rules(rules)\n rules.each do |rule|\n add_rule rule\n end\n end",
"def run(rule)\n end",
"def rule_handler(rule_object)\n\n # only rules that are not yet triggered should be processed\n unless triggered? rule_object\n\n case\n\n # when there are no questions and no goals\n when rule_object.questions.empty? && rule_object.goal.nil?\n\n # trigger the rule, thus asserting facts and storing in triggered rules\n trigger rule_object\n\n # when the goal is NOT nil\n when !rule_object.goal.nil?\n\n # add to the result rules\n @result_rules << rule_object\n\n # otherwise add to the question rules\n else\n\n # add to the possible questions\n @question_rules << rule_object\n\n end\n\n end\n\n end",
"def check_rule(rule)\n\n\t if rule.include? 'twitter_lang'\n\t\t rule = handle_lang_operators rule\n\t end\n\n\t if rule.include? 'has:lang'\n\t\t rule = handle_has_lang rule\n\t end\n\n\t if rule.include? '_contains:'\n\t\t rule = handle_contains_operators rule\n\t end\n\n\n\t if rule.include? 'country_code:'\n\t\t rule = handle_country_code_operators rule\n\t end\n\n\t rule\n\n end",
"def load_rules; end",
"def apply(text)\n raw = process_text(text)\n rule_stack = []\n str = ''\n rule_names = @rules.keys\n raw.each do |r|\n if r.is_a?(Symbol)\n # Part is a rule\n dprint \"\\tRule Symbol #{r}\\n\"\n if r == :close && rule_stack.length >= 1\n # Rule close with 1+ opened rules\n opened = rule_stack.pop\n opened_after = @rules[opened].codes(Rule::Parts[:after])\n dprint \"\\t\\tClose, opened rule '#{opened}'\\n\"\n dprint \"\\t\\t\\tClosing rule '#{opened}' with After\\n\"\n dprint 4,\"After: #{opened_after.inspect}\\n\"\n str.concat(opened_after)\n unless rule_stack.length == 0\n rule_stack.each do |outer|\n outer_inside = @rules[outer].codes(Rule::Parts[:inside])\n # Closed rule was nested in another open rule\n dprint 3, \"Outer rule '#{outer}' still open. Restoring Inside\\n\"\n dprint 4, \"Inside: #{outer_inside.inspect}\\n}\"\n str.concat(outer_inside)\n end\n end\n # binding.pry\n # outer = rule_stack[-1]\n # outer_inside = @rules[outer].codes(Rule::Parts[:inside])\n # # Closed rule was nested in another open rule\n # dprint 3, \"Outer rule '#{outer}' still open. Restoring Inside\\n\"\n # dprint 4, \"Inside: #{outer_inside.inspect}\\n}\"\n # str.concat(outer_inside)\n # # binding.pry\n # end\n elsif r == :reset && rule_stack.length == 0\n # no opened outer rules, reset symbol given\n dprint \"\\t\\tReset, no opened rule\\n\"\n str.concat(@rules[r].codes(Rule::Parts[:after]))\n elsif rule_names.include?(r)\n # New rule to apply\n dprint \"\\t\\tApplying new rule '#{r}'\\n\"\n dprint 3, \"Previous active rule `#{rule_stack[-1]}`\\n\"\n rule_stack.push r\n str.concat(@rules[r].codes(Rule::Parts[:inside]))\n end\n else\n # Part is text\n str.concat(r)\n end\n end\n str\n end",
"def closure(rules)\n\t\tj = rules.map{|x| x.clone};\n\t\tall_rules = [];\n\t\t@rules .each{ |x,y| y.each{ |z| all_rules += [[x, z, 0]] }}\n\t\tj .each{ | x| all_rules -= [ x ] }\n\t\t#p all_rules\n\t\tbegin\n\t\t\tis_added = false;\n\t\t\tj.each do |c_rule|\n\t\t\t\tif c_rule[1].size >= c_rule[2] then\n\t\t\t\t\tnonterm_to_add = c_rule[1][c_rule[2]]\n\t\t\t\t\t#p nonterm_to_add\n\t\t\t\t\tif nonterm_to_add.class == Symbol then\n\t\t\t\t\t\ttemp = [];\n\t\t\t\t\t\tall_rules.each do |rule_to_add|\n\t\t\t\t\t\t\t#p rule_to_add\n\t\t\t\t\t\t\tif nonterm_to_add == rule_to_add[0] then\n\t\t\t\t\t\t\t\ttemp += [rule_to_add];\n\t\t\t\t\t\t\t\tis_added = true;\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\t\tall_rules -= temp;\n\t\t\t\t\t\tj += temp;\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend while is_added\n\t\treturn j;\n\tend",
"def rules_for(table)\n by_string, ages = rules_by_string(table, [])\n by_regexp, ages = rules_by_regexp(table, ages)\n for_all, ages = rules_for_all(table, ages)\n\n valid_rules = by_string + by_regexp + for_all\n valid_rules.sort { |a, b| b[:age] <=> a[:age] }\n end",
"def evaluate(attributes = {})\n return true unless rules.any?\n\n attributes_to_evaluate = if !attributes || attributes.empty?\n collected_attributes\n else\n attributes\n end\n\n if evaluation_logic == 'any'\n !!rules.detect { |rule| rule.evaluate(attributes_to_evaluate) }\n else\n rules.each do |rule|\n return false unless rule.evaluate(attributes_to_evaluate)\n end\n true\n end\n end",
"def consume_rules(flags = {})\n rules = []\n\n while token = @tokens.consume\n case token[:node]\n when :comment, :whitespace\n rules << token\n\n when :cdc, :cdo\n unless flags[:top_level]\n @tokens.reconsume\n rule = consume_qualified_rule\n rules << rule if rule\n end\n\n when :at_keyword\n @tokens.reconsume\n rule = consume_at_rule\n rules << rule if rule\n\n else\n @tokens.reconsume\n rule = consume_qualified_rule\n rules << rule if rule\n end\n end\n\n rules\n end",
"def load_rules(rules)\n self.instance_eval(rules)\n end",
"def add_rule(rule_object)\n\n # store the rule\n @rules[rule_object.name] = rule_object\n\n case\n\n # rule which asserts facts without conditions or questions\n when rule_object.matcher.nil? && rule_object.questions.empty?\n\n # add the rule to the fact rules array, contains rules with only facts\n @fact_rules << rule_object\n\n when rule_object.matcher.nil? && rule_object.questions.count > 0\n\n # rules can be triggered directly\n @start_rules << rule_object\n\n else\n\n # get the matcher\n matcher = rule_object.matcher\n\n # get the matcher type (any / all)\n matcher_type = matcher.type\n\n # generate the ruleby conditions based on the matcher conditions\n conditions = create_conditions matcher.conditions\n\n # switch statement for the matcher type\n case matcher_type\n\n # all the conditions must match\n when :all\n\n # star to convert array to arguments\n rule AND *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n # one of the conditions must match\n when :any\n\n # star to convert array to arguments\n rule OR *conditions do |v|\n\n # when rule is applicable, add to possible rules\n rule_handler rule_object\n\n end\n\n else\n raise \"Unknown matcher type #{matcher.type}\"\n\n end\n\n end\n\n end",
"def check_rank_rules\n defined_rules.each do |scoped_model, level_and_rules|\n level_and_rules.sort.each do |level, rule|\n grant_when_applies(scoped_model, rule, level)\n end\n end\n end",
"def relevant_rules(action, subject)\n rules.reverse.select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n end",
"def load_parameter_rules(rules); end",
"def rule; end",
"def rule; end",
"def rule; end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def rules\n @rules ||= {}\n end",
"def matches(facts)\n @condition.matches(facts)\n end",
"def rules\n @rules ||= begin\n @rules = []\n resolve_permissions\n @rules\n end\n end",
"def define\n predicates = Object.new\n @conditions.each {|k, v| predicates.class.send(:define_method, \"#{k}?\") { v } }\n yield RuleMapper.new(self), @conditions, @context\n end",
"def result\n\n # start the matching of the ruleby engine if not yet called\n unless @engine_has_matched\n @engine.match\n @engine_has_matched = true\n end\n\n # return the result array\n @result_rules\n\n end",
"def perform_production(agent)\n condition_vals = evaluate_conditions(agent)\n\n @production_rules.each { |rule| rule.produce(agent, condition_vals) }\n end",
"def apply_rules(env)\n if match = find_match(env)\n match.__execute(env)\n elsif (parent and inherits)\n parent.apply_rules(env)\n else\n body = \"File not found: #{env['PATH_INFO']}\\n\"\n [404, {\"Content-Type\" => \"text/plain\",\n \"Content-Length\" => body.size.to_s,\n \"X-Cascade\" => \"pass\"},\n [body]]\n end\n end",
"def resolve_rule rule, node\n puts \" apply #{rule} at #{node}\"\n case rule\n when Optional\n rules = rule.rules.dup\n return true if rules.empty? # TODO warn about empty?\n context = nil\n callcc {|cc| context = cc}\n return false if rules.empty?\n add_backtrack context, \"#{rule} : #{rules}\"\n resolve_impl rules.shift, node\n when Concat\n rule.rules.each do |r_id|\n node = resolve_impl r_id, node\n return false if node == false\n end\n node\n when Repeat\n (0..rule.min-1).each do\n node = resolve_impl rule.rule, node\n return false if node == false\n end\n nodes = [node]\n (0..rule.max-1).each do\n node = resolve_impl rule.rule, node\n break if node == false\n nodes.push node\n # TODO warn if no consuming?\n end\n context = nil\n callcc {|cc| context = cc}\n return false if nodes.empty?\n add_backtrack context, \"#{rule} : #{nodes}\"\n nodes.pop\n=begin\nTODO add cardinality depending on number of candidates?\nTODO make that the node return is the next...\n when OnCandidates\n nodes = rule.generator.call node\n return false if nodes.empty?\n context = nil\n callcc {|cc| context = cc}\n return false if nodes.empty?\n add_backtrack context, \"#{rule} : #{nodes}\"\n resolve_impl rule.rule, nodes.shift\n=end\n when Empty\n node\n when FinalNode\n node == nil ? nil : false\n when String\n resolve_impl rule, node\n else\n raise ArgumentError, \"invalid rule #{rule}\"\n return false\n end\n end",
"def rules\n @rules=get_endpoint('rule').keys\n end",
"def deals_search_rules(target_rule, user)\n # if target_rule.end_date >= Time.zone.now and ((target_rule.male and user.gender == 'male') or(target_rule.female and user.gender == 'female')) and target_rule.attributes[target_rule.get_rule_colum_name(user.age.to_i)] and target_rule.attributes[:gift_or_seasonal]\n # puts \"ssssssssssssssssssssssssssss\", target_rule.end_date >= Time.zone.now\n # put\n if target_rule.end_date >= Time.zone.now \n return true\n else\n return false\n end\n end",
"def current_rule\n\n # start the matching of the ruleby engine if not yet called\n unless @engine_has_matched\n\n # first assert all the facts from the fact rules\n # these are rules without conditions and only facts\n # when doing this while adding the rules something weird happens and instead of 1 match, stuff matches 22+ times\n @fact_rules.each do |rule|\n\n trigger rule\n\n end\n\n # add start rules to the question rules when they are not yet handled\n @start_rules.each do |rule|\n\n # when rule not yet triggered\n unless triggered? rule\n\n # add to the possible questions\n @question_rules << rule\n\n end\n\n end\n\n # match the rules using the ruleby engine\n @engine.match\n\n # set the matched flag\n @engine_has_matched = true\n\n end\n\n # get the first of the question rules\n @question_rules.first\n\n end",
"def run_rules_engine \n #Rails.logger.info \"BURKLE ----- > Start RunRulesEngineService.run_rules_engine\"\n #Rails.logger.info \"BURKLE ----- > Character: #{@temp_character.inspect}\"\n \n # need another table to link which rules (under game) link to characters\n # hardcoding the link right now\n characterGameRule = GameRule.find_by(name: \"Character Sheet Rules\")\n #Rails.logger.info \"BURKLE ----- > GameRule.ID: #{characterGameRule.id}\"\n\n # LOOP ON - character.character_attributes [ca]\n @temp_character.character_attributes.each do |ca|\n if ca.value.present?\n #Rails.logger.info \"BURKLE ----- > Character.CharacterAttribute.GameAttribute.ID: #{ca.game_attribute_id}\"\n #Rails.logger.info \" Character.CharacterAttribute.Value: #{ca.value}\"\n \n # LOOP ON - characterGameRule.GameAttributeRules where AffectingGameAttributeID is the ca.GameAttribute.ID\n characterGameRule.game_attribute_rules.where(affecting_game_attribute_id: ca.game_attribute_id).each do |affectingGAR|\n #Rails.logger.info \"BURKLE ----- > AttributeRule.ID: #{affectingGAR.id}\"\n #Rails.logger.info \"BURKLE ----- > AttributeRule.RuleFunction: #{affectingGAR.rule_function}\"\n #Rails.logger.info \"BURKLE ----- > AttributeRule.AffectedGameAttribute.ID: #{affectingGAR.affected_game_attribute_id}\"\n\n if affectingGAR.rule_function == \"LookupValue\"\n if affectingGAR.lookup_table_id.present?\n #Rails.logger.info \"BURKLE ----- > AttributeRule.LookUpTable.ID: #{affectingGAR.lookup_table_id}\"\n \n # Look up VALUE from LookUpTable.LookUpValues based on CurrentValue and LookUpTableID\n outputLookupValue = affectingGAR.lookup_table.lookup_values.find_by(input_key: ca.value)\n if outputLookupValue.present?\n outputValue = outputLookupValue.output_value\n if outputValue.present?\n\n # Update the changing attribute on the character with the new output value\n changingAttribute = @temp_character.character_attribute_matching_game_attribute(affectingGAR.affected_game_attribute)\n #Rails.logger.info \"RESULT ----- > ChangingAttribute.PriorValue: #{changingAttribute.value}\"\n changingAttribute.value = outputValue\n #Rails.logger.info \"RESULT ----- > ChangingAttribute.NewValue: #{changingAttribute.value}\"\n end\n end\n end\n end\n end\n end\n end\n \n @temp_character\n #Rails.logger.info \"BURKLE ----- > End RunRulesEngineService.run_rules_engine\"\n end",
"def print_rules(*names)\n names = nil if names.empty?\n puts \"(#{runner.root})\"\n runner.rulesets.each do |name, set|\n next unless names.member?(name.to_s) if names\n print \"#{name}\"\n print \" (#{set.chain.join(' ')})\" unless set.chain.empty?\n puts\n set.docs.each_with_index do |d, i|\n puts \" * #{d}\"\n end\n end\n\n #exit\n end",
"def apply_rules(rules, obj, status = Nanoc::Core::OutdatednessStatus.new)\n rules.inject(status) do |acc, rule|\n if acc.useful_to_apply?(rule)\n reason = rule.instance.call(obj, @outdatedness_checker)\n if reason\n acc.update(reason)\n else\n acc\n end\n else\n acc\n end\n end\n end",
"def process(name, resource_class, *args)\n\t\t\t@logger.debug \"Searching for #{name} #{resource_class.name}\"\n\n\t\t\t@rules.each do |rule|\n\t\t\t\t@logger.debug \"Checking rule #{rule}...\"\n\n\t\t\t\tcatch (:next) do\n\t\t\t\t\t# If the rule returns true, we assume that it was successful and no further rules need to be evaluated.\n\t\t\t\t\treturn true if rule.call(self, name, resource_class, *args)\n\t\t\t\tend\n\t\t\tend\n\n\t\t\tif @otherwise\n\t\t\t\t@otherwise.call(*args)\n\t\t\telse\n\t\t\t\t@logger.warn \"Failed to handle #{name} #{resource_class.name}!\"\n\t\t\tend\n\t\tend",
"def rules\n @rules ||= {}\n end",
"def relevant_rules(action, subject)\n return [] unless @rules\n\n relevant = possible_relevant_rules(subject).select do |rule|\n rule.expanded_actions = expand_actions(rule.actions)\n rule.relevant? action, subject\n end\n relevant.reverse!.uniq!\n optimize_order! relevant\n relevant\n end",
"def load_cop_rules(rules); end",
"def apply_rules(record)\n rules.each do |rule|\n if record.note =~ Regexp.new(rule.trigger)\n rule.effects.each do |effect|\n if effect.change_kind?\n record.kind = effect.value if effect.value.to_i.in? Record.kinds\n elsif effect.change_source_account?\n record.source_account = Account.find(effect.value)\n elsif effect.change_target_account?\n record.target_account = Account.find(effect.value)\n record.target_currency = record.source_currency\n record.kind = Record::KIND_TRANSFER\n record.target_amount = record.source_amount\n elsif effect.add_tag?\n record.tags << Tag.find(effect.value)\n elsif effect.change_party?\n record.party = Party.find(effect.value)\n elsif effect.change_group?\n record.group = Group.find(effect.value)\n elsif effect.change_source_sign?\n record.source_amount *= -1\n elsif effect.change_target_sign?\n record.target_amount *= -1\n elsif effect.remove_record?\n record.destroy\n end\n end\n end\n end\n end",
"def fact!\n @predicate << Rule.new(self, true)\n self\n end",
"def check # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity\n no_errors = true\n no_warnings = true\n warn = lambda { |msg|\n @logger.warn(msg)\n no_warnings = false\n }\n error = lambda { |msg|\n @logger.error(msg)\n no_warnings = no_errors = false\n }\n\n @logger.info \"Checking profile in #{@path}\"\n @logger.info 'Metadata OK.' if @metadata.valid?\n\n no_warnings = true\n if @params[:rules].empty?\n warn.call('No controls or tests were defined.')\n else\n @logger.debug \"Found #{@params[:rules].length} rules.\"\n end\n\n # iterate over hash of groups\n @params[:rules].each do |group, rules_array|\n @logger.debug \"Verify all rules in #{group}\"\n rules_array.each do |id, rule|\n next if id.start_with? '(generated '\n error.call('Avoid rules with empty IDs') if id.nil? or id.empty?\n warn.call(\"Rule #{id} has no title\") if rule[:title].to_s.empty?\n warn.call(\"Rule #{id} has no description\") if rule[:desc].to_s.empty?\n warn.call(\"Rule #{id} has impact > 1.0\") if rule[:impact].to_f > 1.0\n warn.call(\"Rule #{id} has impact < 0.0\") if rule[:impact].to_f < 0.0\n warn.call(\"Rule #{id} has no tests defined\") if rule[:checks].nil? or rule[:checks].empty?\n end\n end\n\n @logger.info 'Rule definitions OK.' if no_warnings\n no_errors\n end",
"def apply_rules_multi(rules, objs)\n objs.inject(Nanoc::Core::OutdatednessStatus.new) { |acc, elem| apply_rules(rules, elem, acc) }\n end",
"def rules\n @rules ||= []\n end",
"def rules\n @rules ||= []\n end",
"def printRules\n\t\n\t@i = 1\n\t@@rulesArray.each do |rule|\n\t\tputs \"#{@i}-#{rule.fetch('src_ip')}/#{rule.fetch('src_netmask')}:#{rule.fetch('src_port')} #{rule.fetch('dest_ip')}/#{rule.fetch('dest_netmask')}:#{rule.fetch('dest_port')} #{rule.fetch('protocol')} #{rule.fetch('action')}\"\n\t\t@i += 1\n\tend\n\n\tif @i == 1\n\t\tputs \"No rules to print!\"\n\telse\n\t\tputs \"Rules Loaded!\"\n\tend\nend",
"def rules_from_step_content\n @rules_from_step_content ||= content_items.each_with_object({}) do |content_item, items|\n items[content_item[\"content_id\"]] = build_rule(content_item)\n end\n end",
"def rules\n @rules.map{|r| [r.name, r.rule]}.to_h\n end",
"def do_rule_builds\n @rule.execution_trigger_rules.build if @rule.execution_trigger_rules.size == 0\n @rule.actions.build if @rule.actions.size == 0\n @rule.criteria.build if @rule.criteria.size == 0\n end",
"def rules\n\t\tf = File.read(\"./rules.txt\")\n\t\tputs \"#{f}\"\n\t\tback_option = gets.chomp.to_i\n\t\trules_option(back_option)\n\tend",
"def apply_rules\n match_reduce(\n ->((rhs1, rhs1_s), (_, rhs2_s)) {\n rhs1.size >= 2 and rhs2_s.include? rhs1_s\n },\n ->(lhs1, lhs2, _) { @cfg.factor! lhs2, lhs1 }\n )\n end",
"def validate()\n\t\trules.values.each do |aRule|\n\t\t\tsubrule_invokations = aRule.all_actions.select { |act| act.kind_of?(ApplySubrule) }\n\t\t\tsubrule_invokations.each do |invokation|\n\t\t\t\traise LexerRuleError, \"Reference to unknown subrule '#{invokation.rulename}' in rule '#{aRule.name}'.\" unless rules.has_key? invokation.rulename\n\t\t\tend\n\t\tend\n\tend",
"def rules( *new_values )\n\t\tself.rules = new_values unless new_values.empty?\n\t\treturn @rules\n\tend",
"def evaluates(&block)\n @predicate << Rule.new(self, block)\n self\n end",
"def educate(elements)\n Rules.inject(elements) do |elems, rule|\n apply_one_rule!(rule, elems)\n end\n end",
"def migrate_rules\n contact_counts_by_id = {}\n check_counts_by_id = {}\n\n source_keys_matching('contact_notification_rules:?*').each do |rules_key|\n\n rules_key =~ /\\Acontact_notification_rules:(#{ID_PATTERN_FRAGMENT})\\z/\n contact_id = $1\n raise \"Bad regex for '#{rules_key}'\" if contact_id.nil?\n\n contact = find_contact(contact_id)\n\n contact_num = contact_counts_by_id[contact.id]\n if contact_num.nil?\n contact_num = contact_counts_by_id.size + 1\n contact_counts_by_id[contact.id] = contact_num\n end\n\n check_ids = @check_ids_by_contact_id_cache[contact.id]\n\n rules = {\n Flapjack::Data::Acceptor => [],\n Flapjack::Data::Rejector => []\n }\n\n rule_ids = @source_redis.smembers(rules_key)\n rule_ids.each do |rule_id|\n rule_data = @source_redis.hgetall(\"notification_rule:#{rule_id}\")\n\n time_restrictions = Flapjack.load_json(rule_data['time_restrictions'])\n\n entities = Set.new( Flapjack.load_json(rule_data['entities']))\n regex_entities = Set.new( Flapjack.load_json(rule_data['regex_entities']))\n\n tags = Set.new( Flapjack.load_json(rule_data['tags']))\n regex_tags = Set.new( Flapjack.load_json(rule_data['regex_tags']))\n\n # collect specific matches together with regexes\n regex_entities = regex_entities.collect {|re| Regexp.new(re) } +\n entities.to_a.collect {|entity| /\\A#{Regexp.escape(entity)}\\z/}\n regex_tags = regex_tags.collect {|re| Regexp.new(re) } +\n tags.to_a.collect {|tag| /\\A#{Regexp.escape(tag)}\\z/}\n\n acceptor_conditions_by_media = {}\n rejector_conditions_by_media = {}\n\n Flapjack::Data::Condition.unhealthy.keys.each do |fail_state|\n media_types = Flapjack.load_json(rule_data[\"#{fail_state}_media\"])\n next if media_types.nil? || media_types.empty?\n\n media_types_str = media_types.sort.join(\"|\")\n blackhole = !!Flapjack.load_json(rule_data[\"#{fail_state}_blackhole\"])\n cond_by_media = blackhole ? rejector_conditions_by_media : acceptor_conditions_by_media\n cond_by_media[media_types_str] ||= []\n cond_by_media[media_types_str] << fail_state\n end\n\n checks_and_tags_for_rule = proc do |rule_klass, cond_by_media|\n\n rule_klass.lock(Flapjack::Data::Check, Flapjack::Data::Tag,\n Flapjack::Data::Contact, Flapjack::Data::Medium) do\n\n cond_by_media.each_pair do |media_types_str, fail_states|\n rule = rule_klass.new\n rule.conditions_list = fail_states.sort.join(\"|\")\n rule.all = regex_entities.empty? && regex_tags.empty?\n rule.time_restrictions = time_restrictions\n rule.save\n raise rule.errors.full_messages.join(\", \") unless rule.persisted?\n\n media_transports = media_types_str.split('|')\n media = contact.media.intersect(:transport => media_transports)\n rule.media.add_ids(*media.ids) unless media.empty?\n\n unless rule.all\n # apply the entities/tag regexes as a filter\n checks = Flapjack::Data::Check.intersect(:id => check_ids).select do |check|\n entity_name = check.name.split(':', 2).first\n if regex_entities.all? {|re| re === entity_name }\n # copying logic from https://github.com/flapjack/flapjack/blob/68a3fd1144a0aa516cf53e8ae5cb83916f78dd94/lib/flapjack/data/notification_rule.rb\n # not sure if this does what we want, but it's how it currently works\n matching_re = []\n check.tags.each do |tag|\n matching_re += regex_tags.select {|re| re === tag.name }\n end\n matching_re.size >= regex_tags.size\n else\n false\n end\n end\n\n tags = checks.collect do |check|\n check_num = check_counts_by_id[check.id]\n if check_num.nil?\n check_num = check_counts_by_id.size + 1\n check_counts_by_id[check.id] = check_num\n end\n\n tag = Flapjack::Data::Tag.new(:name => \"migrated-contact_#{contact_num}-check_#{check_num}\")\n tag.save\n check.tags << tag\n tag\n end\n\n rule.tags.add(*tags) unless tags.empty?\n end\n rules[rule_klass] << rule\n end\n end\n end\n\n checks_and_tags_for_rule.call(Flapjack::Data::Rejector, rejector_conditions_by_media)\n checks_and_tags_for_rule.call(Flapjack::Data::Acceptor, acceptor_conditions_by_media)\n end\n\n rejectors = rules[Flapjack::Data::Rejector]\n contact.rejectors.add(*rejectors) unless rejectors.empty?\n\n acceptors = rules[Flapjack::Data::Acceptor]\n contact.acceptors.add(*acceptors) unless acceptors.empty?\n end\n end",
"def apply(nodes)\n node_manager.assert_known(nodes)\n for node in nodes\n node_manager.find(node).apply\n end\n end",
"def rules_by_name(rule_name, section_id = @one_section_id)\n rules = []\n return rules unless section_id\n\n all_rules = rules(section_id)\n return rules unless all_rules\n\n all_rules['results'].each do |rule|\n rules << rule if rule['display_name'] == rule_name\n end\n rules\n end",
"def [](*args)\n sort_if_needed\n @rules[*args]\n end",
"def rules_for(state, char)\n rules.select { |rule| rule.applies_to?(state, char) }\n end",
"def get_modifying_rules(agent, opponent)\n modified_by = Hash.new { [[],[]] }\n track = lambda do |set, index|\n set.each_with_index do |rule, rule_i|\n rule.alternatives.each do |alt|\n alt.modifiers.each do |mod|\n arr = modified_by[mod.predicate]\n arr[index] << [rule_i, mod.type]\n modified_by[mod.predicate] = arr\n end\n end\n end\n end\n track.call(agent.actions, 0)\n track.call(opponent.rules, 1)\n return modified_by\n end",
"def parse\n self.class.rules.each do |target, (selector, delegate, plural)|\n if plural\n @doc.search(selector).each do |node|\n send(target) << parse_result(node, delegate)\n end\n else\n send(\"#{target}=\", parse_result(@doc.at(selector), delegate))\n end\n end\n self\n end",
"def run( lines )\r\n # Check if this rule already evaluated to true\r\n return if self.result == true\r\n # Check if input is empty\r\n return if self.pattern == \"\"\r\n\r\n if lines.kind_of?(String)\r\n self.result = check_string( lines )\r\n elsif lines.kind_of?(Array)\r\n self.result = check_array( lines )\r\n else\r\n puts \"#{self.class}:run: Received invalid input of type: #{lines.class}\"\r\n return false\r\n end\r\n\r\n puts \"#{self.result.to_s.upcase}: #{self.class}: #{self.pattern}\" if @@DEBUG == true\r\n end",
"def apply(hash)\n raise ArgumentError, \"Hash expected (did you invoked an action without a Hash?)\" unless Hash===hash\n converted, failures = hash.dup, []\n failures = @rules.collect{|rule| rule.convert_and_validate(converted)}.compact\n failures.empty? ? [true, converted] : [false, failures]\n end"
] |
[
"0.6823999",
"0.67219603",
"0.6701946",
"0.6554284",
"0.650058",
"0.650058",
"0.632449",
"0.6275201",
"0.6275201",
"0.62481976",
"0.62459016",
"0.62459016",
"0.62459016",
"0.62459016",
"0.62459016",
"0.62459016",
"0.62459016",
"0.62030774",
"0.6162582",
"0.6126606",
"0.61061203",
"0.6071615",
"0.60178286",
"0.601753",
"0.60006523",
"0.59304166",
"0.5914203",
"0.5846047",
"0.5828507",
"0.581685",
"0.578343",
"0.5759128",
"0.57375497",
"0.5718825",
"0.57074344",
"0.5703624",
"0.56857276",
"0.56126845",
"0.559011",
"0.5575405",
"0.55501825",
"0.55314267",
"0.55280834",
"0.55079293",
"0.54910266",
"0.54909444",
"0.5476248",
"0.5471928",
"0.5463103",
"0.5456336",
"0.54516864",
"0.54337",
"0.5423554",
"0.5423554",
"0.5423554",
"0.5417118",
"0.5417118",
"0.5417118",
"0.54149693",
"0.54139674",
"0.5412745",
"0.5411378",
"0.5405527",
"0.53873867",
"0.5380255",
"0.5361335",
"0.53612596",
"0.53553987",
"0.5354637",
"0.5353014",
"0.53307956",
"0.5313839",
"0.53130245",
"0.5312238",
"0.5302536",
"0.530179",
"0.52972",
"0.52952546",
"0.52943474",
"0.52873194",
"0.52873194",
"0.52776986",
"0.5276706",
"0.52717304",
"0.52637553",
"0.52538425",
"0.52438354",
"0.524216",
"0.5229627",
"0.5229172",
"0.5222993",
"0.5215228",
"0.52054065",
"0.5201732",
"0.5197789",
"0.51965696",
"0.5193774",
"0.51702476",
"0.5151382",
"0.51487935"
] |
0.7222914
|
0
|
def test_round_has_feedback redundant end
|
def test_correct_number_user_answer_1
assert_equal @round.number_correct, 0
result = @round.record_guess("Juneau")
assert_equal @round.number_correct, 1
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def testing\n # ...\n end",
"def test_unranked_recall\n\n add_test_judgements \n add_unranked_query_result\n assert_equal(1.0, @query_result.statistics[:recall])\n \n end",
"def test_truth\n end",
"def test_guess_feedback_is_incorrect\n card_1 = Card.new(\"3\", \"Hearts\")\n card_2 = Card.new(\"4\", \"Clubs\")\n deck = Deck.new([card_1, card_2])\n round = Round.new(deck)\n new_guess_2 = round.record_guess({value: \"Jack\", suit: \"Diamonds\"})\n assert_equal \"Incorrect.\", round.guesses.last.feedback\nend",
"def test_method\n end",
"def tests; end",
"def tests; end",
"def message_for(test); end",
"def message_for(test); end",
"def test_cases; end",
"def feedback_can_be_given?\n !has_feedback? && !feedback_skipped?\n end",
"def running_test_case; end",
"def tested?\n @tested\n end",
"def test_lung_cancer\n @answers[0] = true\n @answers[2] = true\n assert_equal(Diagnosis.diagnose(@answers),\"Lung Cancer\")\n end",
"def my_tests\n end",
"def test_acknowledgement \n end",
"def test_tip_method\n assert_equal(0.15, @check_test.tip_calc)\n end",
"def test_guess_feedback_true\n card = Card.new(\"10\", \"Hearts\")\n guess = Guess.new(\"10 of Hearts\", card)\n\n assert_equal guess.feedback, \"Correct!\"\n end",
"def test_case; end",
"def test_guess_feedback_false\n card = Card.new(\"10\", \"Hearts\")\n guess = Guess.new(\"8 of Hearts\", card)\n\n assert_equal guess.feedback, \"Incorrect.\"\n end",
"def graffiti_test\n end",
"def test_espresso_more_effective\n hipster = Human.new \"Hipster\"\n espresso = Espresso.new \"Espresso\"\n\n hipster.buy espresso\n assert espresso.drinks_before_empty == 1\n\n hipster.drink!\n assert (hipster.alertness > 0.4)\n\n end",
"def test_relevant\n add_test_judgement\n assert(@gold_standard.relevant? :document => \"doc1\", :query => \"query1\")\n end",
"def test?\n false\n end",
"def correction_with_test(t)\n end",
"def default_test\r\n end",
"def assertions; end",
"def assertions; end",
"def self_test; end",
"def self_test; end",
"def stest_method_1(test); end",
"def test \n end",
"def test_marked\n end",
"def test?\n true\n end",
"def covered?; end",
"def test_acknowledgement\n\n end",
"def test_acknowledgement\n\n end",
"def test_acknowledgement\n\n end",
"def test_acknowledgement\n\n end",
"def test05_NoteTwoComments_TC_24319\n\t\tcommentNotePop\n\t\tcommentPopSubmit\n\tend",
"def default_test; end",
"def assert_test_warnings\n assert has_test_warnings?(@review)\n end",
"def test\n end",
"def test\n end",
"def test\n end",
"def feedback\n end",
"def _test_message ; process_test_case(\"message\") ; end",
"def tricks_taken \n \t\tself.score-(self.correct*10)\n \tend",
"def test_nothing\n end",
"def check_against(unit_test)\n grade_sheet = unit_test.execute(src_code) \n Feedback.on(grade_sheet)\n end",
"def test_step; end",
"def test_both_players_level_and_exceed_defcon\n scenario us: 4, ussr: 4, defcon: 3\n assert_no_award\n end",
"def test_hero_is_invincible\n end",
"def test_guest_cannot_buy_drink_if_they_have_insufficient_funds\n @room1.add_drinks_to_stock(@drink1)\n @room1.add_drinks_to_stock(@drink2)\n guest6=Guest.new(\"Kaka\", 1.00, \"Always look on the bright side of life.\")\n guest6.show_tab\n expected = \"You can't afford this drink.\"\n assert_equal(expected, @room1.refuse_guest_drink_if_they_cannot_afford_it(guest6, @drink1))\n end",
"def __dummy_test__\n end",
"def passed?\n return @test_passed\n end",
"def default_test\n end",
"def test_both_players_exceed_defcon\n scenario us: 4, ussr: 5, defcon: 3\n assert_no_award\n end",
"def test\n\n end",
"def test_results_sad\r\n assert_output(\"Going home sad.\\n\") { @g.results(9) }\r\n end",
"def test_nothing\n end",
"def test_participant_reject\n\n pdef = Ruote.process_definition do\n alpha\n end\n\n @dashboard.register_participant :alpha, DifficultParticipant\n\n assert_trace(%w[ diff diff ], pdef)\n end",
"def test_nothing; end",
"def test_magic_ball_silent_shake\n magic_ball = Predictor.new\n assert_silent { magic_ball.shake() }\n end",
"def passes; end",
"def passes; end",
"def test_judgement\n add_test_judgement\n assert(@gold_standard.contains_judgement? :document => \"doc1\", :query => \"query1\")\n end",
"def after_test(_test); end",
"def after_test(_test); end",
"def after_test(_test); end",
"def default_test\n end",
"def test_ut_diff_warning_02\n assert_equal 2,@diff_warning.diff_status_id\n assert_equal 1,@diff_warning.diff_file_id\n assert_equal 1,@diff_warning.rule_set\n assert_equal 1,@diff_warning.warning_id\n assert_equal 1,@diff_warning.original_file_id\n end",
"def ptest_method_1(test); end",
"def test_02_comment_on_post_as_guest\n end",
"def test?\n @test\n end",
"def test_total_turns_1\n \tpro = Prospector.new(1)\n \tpro.prospect_move(1)\n \tassert pro.total_rubies == 0\n \tassert pro.total_fake_rubies == 0\n end",
"def failure_message_when_negated; end",
"def failure_message_when_negated; end",
"def failure_message_when_negated; end",
"def test_contains_13_eachsuit\n assert true == false\n end",
"def test_percentage_home_wins\n assert_equal 0.44, @stat_tracker.percentage_home_wins\n end",
"def test_shouting_with_no_exclamation_mark\n remark = 'I HATE YOU' # => \"I HATE YOU\"\n assert_equal 'Whoa, chill out!', bob.hey(remark), feedback(remark) # => true\n end",
"def test_alcohol_level_of_drink\n assert_equal(5, @drink3.alcohol_level())\n end",
"def spec; end",
"def spec; end",
"def feedback\n # check to see if correct is true\n if correct?\n # if correct is true return \"Correct!\"\n \"Correct!\"\n # or else return \"Incorrect.\"\n else\n \"Incorrect.\"\n end\n end",
"def assert_silent; end",
"def report_test_result success, msg\n if(success)\n print_success msg\n else\n print_error msg\n end\nend",
"def running_test_step; end",
"def test_contains_four_eachface\n assert true == false\n end",
"def test_it_can_get_outcome\n assert_equal :home_win, @game_1.outcome\n end",
"def test02_FlagEventComment_TC_24319\n\t\tcommentEventPop\n\t\tsleep 4\n\t\tcommentPopSubmit\n\t\tsleep 4\n\t\tcommentFlag\n\t\t\n\t\tbegin \n\t\tassert $comment_flag_success.exists?\n\t\t\trescue => e\n\t\t\tputs \"IPS05T02: FAILED! User unable to flag comment!\"\n\t\t\tputs e\n\t\tend\n\tend",
"def feedback\n if correct?\n \"Correct!\"\n else\n \"Incorrect.\"\n end\n end",
"def example_passed(example)\n end",
"def test_returns_strength_value_halved\n skip\n end",
"def passed?; end",
"def passed?; end",
"def passed?; end",
"def testing_end\n end",
"def test_check_fish\n assert_equal(0, @river1.check_fish)\n end"
] |
[
"0.6857681",
"0.6695703",
"0.6685089",
"0.6537783",
"0.64951515",
"0.6463348",
"0.6463348",
"0.6459506",
"0.6459506",
"0.645235",
"0.6426935",
"0.6404251",
"0.6402619",
"0.639003",
"0.6372724",
"0.6367403",
"0.6343219",
"0.6342789",
"0.63336694",
"0.63307756",
"0.6317173",
"0.62990963",
"0.62885624",
"0.62732595",
"0.62683207",
"0.62653303",
"0.62298995",
"0.62298995",
"0.622631",
"0.622631",
"0.62153393",
"0.62082887",
"0.62068135",
"0.6193109",
"0.61665213",
"0.6146396",
"0.6146396",
"0.6146396",
"0.6146396",
"0.614177",
"0.6134007",
"0.611759",
"0.60909337",
"0.60909337",
"0.60909337",
"0.60894465",
"0.6085985",
"0.60793245",
"0.60761106",
"0.6072848",
"0.6064035",
"0.6059248",
"0.60480577",
"0.6047705",
"0.60427845",
"0.6036161",
"0.6030751",
"0.60280025",
"0.60245174",
"0.5995628",
"0.59924453",
"0.5990945",
"0.59837204",
"0.5976557",
"0.59747493",
"0.59747493",
"0.5967491",
"0.5963544",
"0.5963544",
"0.5963544",
"0.5961686",
"0.59567267",
"0.59552693",
"0.59548664",
"0.5947912",
"0.5946494",
"0.5946277",
"0.5946277",
"0.5946277",
"0.59422576",
"0.5940259",
"0.59284186",
"0.59238726",
"0.59237844",
"0.59237844",
"0.59233654",
"0.592284",
"0.5921044",
"0.5920896",
"0.5919651",
"0.5917129",
"0.59112704",
"0.58988774",
"0.5898658",
"0.58932894",
"0.5889542",
"0.5889542",
"0.5889542",
"0.58882666",
"0.5884393"
] |
0.59586006
|
71
|
lookup app name either in the file or if already cached look in the metadata variable
|
def lookup(app_name)
unless @metadata.key?(app_name)
data = YAML.load_file("./data/applications/#{app_name}.yaml")
@metadata[app_name] = data['cots::app_metadata']
end
@metadata[app_name]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_app_name(app_name)\n app_file = $pkg_dir+\"/\"+app_name.downcase.gsub(/ |-/,'_')+\".rb\"\n if File.exist?(app_file)\n app_name = eval(\"get_#{app_name.downcase.gsub(/ |-/,'_')}_app_name()\")\n else\n app_list = Dir.entries($pkg_dir)\n tmp_name = app_list.grep(/^#{app_name.downcase.gsub(/ |-/,'_')}/)[0]\n if tmp_name\n tmp_name = tmp_name.gsub(/\\.rb/,\"\")\n else\n puts\n end\n if tmp_name =~ /[A-z]/\n if $verbose == 1\n puts \"Application profile \"+app_name+\" not found\"\n puts \"Found profile \"+tmp_name\n end\n app_name = eval(\"get_#{tmp_name.downcase.gsub(/ |-/,'_')}_app_name()\")\n else\n puts \"Application \"+app_name+\" not found\"\n puts\n puts \"Available Applications:\"\n puts\n print_avail_pkgs()\n puts\n exit\n end\n end\n return app_name\nend",
"def metadata_any_app_get(name)\n app = node.apps.detect {|a| a.metadata?(name) } and app.metadata?(name)\n end",
"def fetch_app(name)\r\n return name if SAMPLES[name].nil?\r\n \"#{name}/#{SAMPLES[name]}\"\r\n end",
"def appname\n fetch(:appname) || script_name\n end",
"def get_app_url(app_name)\n app_file = $pkg_dir+\"/\"+app_name.downcase+\".rb\"\n if File.exist?(app_file)\n app_url = eval(\"get_#{app_name.downcase.gsub(/ |-/,'_')}_app_url()\")\n else\n puts \"Application \"+app_name+\" not found\"\n end\n return app_url\nend",
"def find_application_name(val_installpath)\n index_file = ['index.html','index.htm','index.php','index.jsp','index.asp']\n path = val_installpath + \"\\\\webapps\"\n if not directory?(path + \"\\\\ROOT\")\n print_error(\"\\t\\t! expected directory wasnt found\")\n return \"Unknown\"\n end\n\n index_file.each do |i|\n if not exist?(\"#{path}\\\\ROOT\\\\#{i}\")\n next\n end\n data = read_file(path + \"\\\\ROOT\\\\#{i}\")\n if data =~ /(?i)<title>([^<]+)<\\/title>/\n return $1\n else\n #look for redirect as name\n if data =~ /(?i)onload=\\\"?document\\.location\\=['\"]?([\\/\\w\\d]+)['\"]?\\\"?/\n return $1.gsub(\"/\",\"\")\n end\n end\n end\n return \"Unknown\"\n rescue\n print_error(\"\\t\\t! could not identify application name\")\n return \"Unknown\"\n end",
"def app_name\n @data['CFBundleExecutable'].to_s\n end",
"def find snippet\n apps.select do |app|\n app.filename.include? snippet\n end\n end",
"def find_application\n unless self.app_name.blank?\n self.app = App.active.by_short_or_long_name(self.app_name).try(:first)\n self.application_lookup_failed = self.app.blank?\n end\n # be sure the call back returns true or else the call will fail with no error message\n return true\n end",
"def app_name\n Rucola::InfoPlist.open((RUBYCOCOA_ROOT + 'config/Info.plist').to_s).app_name\n end",
"def select_app file_name\n ftype = file_type file_name\n @app_map[ftype]\n end",
"def app_name\n @app_name || Sapience.app_name\n end",
"def app_name\n return @app_name\n end",
"def app_name\n return @app_name\n end",
"def load_metadata\n begin\n load RAILS_ROOT + '/app/metadata/' + self.name.to_s.underscore + '.rb'\n rescue MissingSourceFile\n end\n end",
"def select_app file_name\n ftype = file_type( file_name ).downcase\n @app_map[ ftype ]\n end",
"def cb_local_lookup(cb_name)\n full_path = File.expand_path(\"#{$opts[:repo]}/#{cb_name}\")\n if File.exists?(\"#{full_path}/metadata.rb\")\n version = (`grep '^version' #{full_path}/metadata.rb`)\n else\n return -1\n end\n version.split(' ').last.gsub('\"','').gsub('\\'','').chomp\nend",
"def select_app file_name \n ftype = file_type( file_name ).downcase\n @app_map[ ftype ]\n end",
"def locate_app_file\n app_const = app_constant\n\n candidates = []\n candidates << app_const.app_file if app_const.respond_to?(:app_file)\n candidates << Padrino.first_caller if File.identical?(Padrino.first_caller.to_s, Padrino.called_from.to_s)\n candidates << Padrino.mounted_root(name.downcase, \"app.rb\")\n simple_name = name.split(\"::\").last.downcase\n mod_name = name.split(\"::\")[0..-2].join(\"::\")\n Padrino.modules.each do |mod|\n if mod.name == mod_name\n candidates << mod.root(simple_name, \"app.rb\")\n end\n end\n candidates << Padrino.root(\"app\", \"app.rb\")\n candidates.find { |candidate| File.exist?(candidate) }\n end",
"def select_app file_name \n\t\tftype = file_type( file_name ).downcase\n\t\t@app_map[ ftype ]\n\tend",
"def get_satellite_eyes_app_name()\n app_name = \"Satellite Eyes\"\n return app_name\nend",
"def application_name\n # It's important that we don't use ActionView::Helpers::CacheHelper#cache here\n # because it returns nil.\n Rails.cache.fetch 'blacklight/application_name' do\n t('blacklight.application_name',\n default: t('blacklight.application_name', locale: I18n.default_locale))\n end\n end",
"def app_name\n return File.basename(File.expand_path(root)).freeze\n end",
"def name\n if app_name = @args[:props][\"application_name\"].to_s.strip and !app_name.empty?\n return app_name\n else\n raise \"Could not figure out the input-name.\"\n end\n end",
"def app_name\n @app_name ||= defined_app_const_base? ? defined_app_name : File.basename(destination_root)\n end",
"def app(name=nil)\n if @app.nil? && name.nil? && Remotely.apps.size == 1\n name = Remotely.apps.first.first\n end\n\n (name and @app = name) or @app\n end",
"def find_manifest_entry(name)\n if dev_server_running?\n { 'file' => prefix_vite_asset(name.to_s) }\n else\n manifest[name.to_s]\n end\n end",
"def get_loc_ver(app_name)\n loc_ver = eval(\"get_#{app_name.downcase.gsub(/ |-/,'_')}_loc_ver(app_name)\")\n if loc_ver.to_s.match(/Installed/)\n loc_ver = \"Not Installed\"\n end\n return loc_ver\nend",
"def find_hook_point(amanifest)\n package = amanifest.xpath(\"//manifest\").first['package']\n application = amanifest.xpath('//application')\n application_name = application.attribute(\"name\")\n if application_name\n application_str = application_name.to_s\n unless application_str == 'android.app.Application'\n return application_str\n end\n end\n activities = amanifest.xpath(\"//activity|//activity-alias\")\n for activity in activities\n activityname = activity.attribute(\"targetActivity\")\n unless activityname\n activityname = activity.attribute(\"name\")\n end\n category = activity.search('category')\n unless category\n next\n end\n for cat in category\n categoryname = cat.attribute('name')\n if (categoryname.to_s == 'android.intent.category.LAUNCHER' || categoryname.to_s == 'android.intent.action.MAIN')\n name = activityname.to_s\n if name.start_with?('.')\n name = package + name\n end\n return name\n end\n end\n end\n end",
"def get_pdf_attributes_app_name()\n app_name = \"PDF Attributes\"\n return app_name\nend",
"def select_app(file_name)\n ftype = file_type(file_name)\n @app_map[ ftype ]\n end",
"def select_app( file_name )\n ftype = file_type( file_name )\n @app_map[ ftype ]\n end",
"def find_app(what, item, app)\n id = get_id(what, item)\n the_app = get_app(what, app, id)\n raise \"#{what} #{item['text']} app #{app} not found\" unless the_app\n the_app\n end",
"def app_display_name\n return @app_display_name\n end",
"def app_display_name\n return @app_display_name\n end",
"def app_display_name\n return @app_display_name\n end",
"def app_name\n @@app_name\n end",
"def app_info\n \"#{app_name} v#{app_version}\"\n end",
"def application_name\n @application_name || _application_name_from_namespace || _default_application_name\n end",
"def app_name\n c.application\n end",
"def app_name\n ApplicationService.application_name\n end",
"def get_app_name\n if ENV.key?('INSTANA_SERVICE_NAME')\n return ENV['INSTANA_SERVICE_NAME']\n end\n\n if defined?(::Resque)\n # Just because Resque is defined doesn't mean this is a resque process necessarily\n # Check arguments for a match\n if ($0 =~ /resque-#{Resque::Version}/)\n return \"Resque Worker\"\n elsif ($0 =~ /resque-pool-master/)\n return \"Resque Pool Master\"\n elsif ($0 =~ /resque-scheduler/)\n return \"Resque Scheduler\"\n end\n end\n\n if defined?(::RailsLts) || defined?(::Rails)\n return Rails.application.class.to_s.split('::')[0]\n end\n\n if $0.to_s.empty?\n return \"Ruby\"\n end\n\n exe = File.basename($0)\n if exe == \"rake\"\n return \"Rake\"\n end\n\n return exe\n rescue Exception => e\n Instana.logger.info \"#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}\"\n Instana.logger.debug { e.backtrace.join(\"\\r\\n\") }\n return \"Ruby\"\n end",
"def app_name\n Dir.pwd.split(\"/\").last.gsub(/\\./, \"_\")\n end",
"def find_application\n unless self.app_name.blank?\n my_apps = []\n # in the case of an array, the new finder will not work\n Array(self.app_name).each do |individual_name|\n new_apps = App.active.by_short_or_long_name(individual_name)\n logger.info \"new_apps\" + new_apps.inspect\n my_apps += new_apps unless new_apps.blank?\n logger.info \"my_apps\" + my_apps.inspect\n end\n unless my_apps.blank? || my_apps.length != Array(self.app_name).length\n self.apps << my_apps - self.apps\n else\n self.application_lookup_failed = true\n end\n end\n # be sure the call back returns true or else the call will fail with no error message\n # from the validation loop\n return true\n end",
"def appname\n @appname = \"Jazzify\"\n end",
"def crowd_app_name(name=nil)\r\n rw_config(:crowd_app_name, name, nil)\r\n end",
"def app_name\n @app_name ||= Rails.app_class.module_parent_name.demodulize.underscore.dasherize\n end",
"def app_name\n Rails.application.class.to_s.split(\"::\").first\n end",
"def resolve_app(application, sdfile=nil, params={})\n return @vespa.resolve_app(application, sdfile, params)\n end",
"def application_name\n return @application_name\n end",
"def get_app_ver(app_name)\n app_ver = \"\"\n app_dir = get_app_dir(app_name,app_ver)\n ver_file = app_dir+\"/Contents/Info.plist\"\n if File.exist?(ver_file)\n if app_name.match(/ServeToMe/)\n app_ver = %x[defaults read \"#{ver_file}\" CFBundleVersion].chomp\n else\n cf_check = %x[cat \"#{ver_file}\" | grep CFBundleGetInfoString]\n if cf_check.match(/CFBundleGetInfoString/)\n app_ver = %x[defaults read \"#{ver_file}\" CFBundleGetInfoString].chomp\n end\n if app_ver !~ /[0-9]\\.[0-9]/\n cf_check = %x[cat \"#{ver_file}\" | grep CFBundleShortVersionString]\n if cf_check.match(/CFBundleShortVersionString/)\n app_ver = %x[defaults read \"#{ver_file}\" CFBundleShortVersionString].chomp\n end\n end\n end\n app_ver = app_ver.gsub(/\\.$/,\"\")\n if app_name.match(/Spotify/) and app_ver.match(/g/)\n app_ver = app_ver.split(/\\./)[0..-2].join(\".\")\n end\n if !app_ver\n app_ver = get_min_ver(app_name)\n else\n if !app_ver.match(/[0-9]/)\n app_ver = get_min_ver(app_name)\n end\n end\n app_ver = app_ver.gsub(/#{app_name} /,\"\")\n else\n if $verbose == 1\n puts \"Application information file \"+ver_file+\" does not exist\"\n end\n app_ver = \"Not Installed\"\n end\n return app_ver\nend",
"def get_application_name\r\n root_info = get_rails_root_info\r\n root_info.split('/').last.capitalize\r\n end",
"def app_name=(value)\n @app_name = value\n end",
"def app_name=(value)\n @app_name = value\n end",
"def get_translation_info(app = nil)\r\n @@translation_info ||= {}\r\n\r\n unless @@translation_info[app].present?\r\n if app.present?\r\n location = File.join(app, info_file)\r\n else\r\n location = info_file\r\n end\r\n\r\n if File.exists?(location)\r\n @@translation_info[app] = YAML.load_file(location) || {}\r\n end\r\n end\r\n\r\n return @@translation_info[app] || {}\r\n end",
"def bapp_name\n bapp.try(:description)\n end",
"def appname\n fetch(:capnotify_appname, \"\")\n end",
"def app_name ; self.class.rootname.snake_case.to_sym ; end",
"def sexy_app_name\n # puts \"gml_application=#{gml_application.inspect} application=#{application.inspect}\"\n (!application.blank? && application) || (!gml_application.blank? && gml_application) || ''\n end",
"def get_radiant_player_app_name()\n app_name = \"Radiant Player\"\n return app_name\nend",
"def application_name\n Rails.root.to_s.split('/').last.underscore\n end",
"def app_name\n if CurrentUser.safe_mode?\n \"Safebooru\"\n else\n \"Danbooru\"\n end\n end",
"def get_min_ver(app_name)\n min_ver = \"\"\n app_ver = \"\"\n app_dir = get_app_dir(app_name,app_ver)\n ver_file = app_dir+\"/Contents/Info.plist\"\n if File.exist?(ver_file)\n cf_check = %x[cat \"#{ver_file}\" | grep CFBundleVersion]\n if cf_check.match(/CFBundleVersion/)\n min_ver = %x[defaults read \"#{ver_file}\" CFBundleVersion].chomp\n end\n else\n if $verbose == 1\n puts \"Application information file \"+ver_file+\" does not exist\"\n end\n min_ver = \"Not Installed\"\n end\n return min_ver\nend",
"def info(name)\n\t\tdoc = xml(get(\"/apps/#{name}\"))\n\t\tattrs = { :collaborators => list_collaborators(name) }\n\t\tdoc.elements.to_a('//app/*').inject(attrs) do |hash, element|\n\t\t\thash[element.name.to_sym] = element.text; hash\n\t\tend\n\tend",
"def get_opera_beta_app_name()\n app_name = \"Opera Beta\"\n return app_name\nend",
"def appname\n \"Application\"\n end",
"def get_app(what, app, id)\n apps = all(case what.keys[0]\n when :study\n %Q{div.app a[href*=\"/?study_id=#{id}\"]}\n when :study_group\n %Q{div.app a[href*=\"/?studygroup_id=#{id}\"]}\n when :site\n raise \"don't know how to search for site apps\"\n when :team\n raise \"don't know how to search for team apps\"\n else\n nil\n end)\n apps.detect { |a| a['text'] == app }\n end",
"def program_name\n @program_name || File.basename($0, '.*')\n end",
"def info(name_or_domain)\n\t\tname_or_domain = name_or_domain.gsub(/^(http:\\/\\/)?(www\\.)?/, '')\n\t\tdoc = xml(get(\"/apps/#{name_or_domain}\"))\n\t\tattrs = doc.elements.to_a('//app/*').inject({}) do |hash, element|\n\t\t\thash[element.name.gsub(/-/, '_').to_sym] = element.text; hash\n\t\tend\n\t\tattrs.merge!(:collaborators => list_collaborators(attrs[:name]))\n\t\tattrs.merge!(:addons => installed_addons(attrs[:name]))\n\tend",
"def app\n @app ||= Rack::Builder.parse_file(File.join(OpenRecipeApp.root,\"config.ru\"))[0]\n end",
"def get_app_type(app_name)\n app_type = eval(\"get_#{app_name.downcase.gsub(/ |-/,'_')}_app_type()\")\n return app_type\nend",
"def exists?(app_name)\n File.exists? File.join(path, app_name)\n end",
"def application_name\n @application_name ||= t('application.name')\n end",
"def apps_path\n Gym.cache[:apps_path] ||= File.join(temporary_output_path, \"Apps\")\n end",
"def app_for(name)\n app_name = app?(name) ? name : \"all\"\n\n @apps[name] ||= App.new(app_name, @roots)\n end",
"def current_application\n Wasko::Applescript.run do\n \"get name of (info for (path to frontmost application))\"\n end\n end",
"def app=(name)\n self.config[:app] = name\n end",
"def sync_app_information!(app_lookup)\n @name = app_lookup.try(:[],'trackName')\n @description = app_lookup.try(:[],'description')\n @small_icon_url = app_lookup.try(:[],'artworkUrl60')\n @publisher_name = app_lookup.try(:[],'sellerName')\n @price = app_lookup.try(:[],'price')\n @version = app_lookup.try(:[],'version')\n @average_user_rating = app_lookup.try(:[],'averageUserRatingForCurrentVersion')\n end",
"def cm_file_name\n @cm_file_name ||= assembly_item.path_finder.path_to_metadata_file(Settings.assembly.cm_file_name)\n end",
"def find_or_create_app(app_name)\n create_app(app_name)\n rescue\n @heroku.app.info(app_name)\n end",
"def app(id_or_name_or_package_id)\n all_available_apps.find do |app|\n [app.name, app.id, app.package_id].include?(id_or_name_or_package_id)\n end\n end",
"def get_google_drive_app_name()\n app_name = \"Google Drive\"\n return app_name\nend",
"def get_vapp_by_name(organization, vdcName, vAppName)\n result = nil\n\n get_vdc_by_name(organization, vdcName)[:vapps].each do |vapp|\n if vapp[0].downcase == vAppName.downcase\n result = get_vapp(vapp[1])\n end\n end\n\n result\n end",
"def app_const\n Module.const_get(app_name)\n end",
"def default_app_module\n # If set in app_state, use that.\n return app_state[:python_celery_module] if app_state[:python_celery_module]\n # If a Django settings module is set, use everything by the last\n # dotted component of it. to_s handles nil since that won't match.\n return $1 if app_state_environment[:DJANGO_SETTINGS_MODULE].to_s =~ /^(.+?)\\.[^.]+$/\n files = Dir.exist?(path) ? Dir.entries(path) : []\n # Try to find a known filename.\n candidate_file = %w{tasks.py task.py celery.py main.py app.py application.py}.find {|file| files.include?(file) }\n # Try the first Python file. Do I really want this?\n candidate_file ||= files.find {|file| file.end_with?('.py') }\n if candidate_file\n ::File.basename(candidate_file, '.py')\n else\n nil\n end\n end",
"def app_name\n \"ExampleApp#{$example_app_counter}\"\n end",
"def library_name(code)\n Mylibrary::Application.config.library_map[code] || code\n end",
"def module_app_name(name)\n name.split(\"_\").map!{|x| x.capitalize}.join\n end",
"def metadata_version_of(name)\n self.class.md_key_map.each do |md_name, var_name|\n return md_name if var_name.to_s == name\n end\n name # return input if no mapping was discovered\n end",
"def present?(arg)\n return PRESENT_CACHE[arg] if PRESENT_CACHE.key?(arg)\n\n prefixes = ENV['PATH'].split(File::PATH_SEPARATOR)\n\n bool = prefixes.any? do |prefix|\n File.exist?(prefix + File::SEPARATOR + arg)\n end\n\n bool = File.exist?(\"/Applications/#{arg}.app\") if !bool && mac?\n\n PRESENT_CACHE[arg] = bool\n\n bool\n end",
"def stub_cm_file_name\n @stub_cm_file_name ||= path_finder.path_to_metadata_file(Settings.assembly.stub_cm_file_name)\n end",
"def app_dir_for(type) self.app_paths[type].first end",
"def app_name\n to_s.underscore\n end",
"def app_with_name name\n AX::Application.new name\n end",
"def pkg_metadata_file\n @pkg_metadata_file ||= File.join(staging_dir, \"gen.manifestfile\")\n end",
"def find_app(title)\n @klass = Object.const_get(Object.constants.grep(/^#{title}$/i)[0]) rescue nil\n end",
"def application_path\n if environment.container?\n applications_path.join(application_name_as_snake_case)\n else\n Pathname.new('app')\n end\n end",
"def app_name_configured?\n names = Agent.config[:app_name]\n return names.respond_to?(:any?) && names.any?\n end",
"def get_heroku_app_name(name)\n if @args.empty?\n app_not_found = true\n while app_not_found\n app_case = @prompt.select(prompt_box(\"Please select whether you are creating a new app or updating an existing one:\"), %W[Create Update])\n if app_case == \"Create\"\n name_prompt = \"What would you like to name your app?\"\n command_case = \"create\"\n else\n name_prompt = \"What is your app's name?\"\n command_case = \"info\"\n end\n begin\n @config[\"config\"][\"app_name\"] = @prompt.ask(prompt_box(name_prompt), default: name, required: true) { |q| q.validate /^[a-z0-9]+$/m, \"Must be lowercase alphanumeric only\" }\n name = @config[\"config\"][\"app_name\"]\n @cmd.run(\"heroku #{command_case} #{name} #{command_case == \"create\" ? \"--stack heroku-18\" : \"\"}\")\n app_not_found = false\n rescue TTY::Command::ExitError\n error_box(\"App #{command_case} failed. Please try a different name.\")\n end\n end\n else\n command_case = get_argument_value(\"heroku_command\", true, \"info\")\n begin\n @config[\"config\"][\"app_name\"] = get_argument_value(\"heroku_app_name\", true, nil)\n name = @config[\"config\"][\"app_name\"]\n @cmd.run(\"heroku #{command_case} #{name} #{command_case == \"create\" ? \"--stack heroku-18\" : \"\"}\")\n rescue TTY::Command::ExitError\n error_box(\"App #{command_case} failed.\")\n raise ArgumentError\n end\n end\n name\nend",
"def app(*args)\n\t\tif args == []\n\t\t\treturn MRA_App\n\t\telse\n\t\t\treturn MRA_App.by_name(*args)\n\t\tend\n\tend"
] |
[
"0.72688407",
"0.6998888",
"0.6632529",
"0.66260004",
"0.6625991",
"0.6451284",
"0.6280447",
"0.6277652",
"0.6266911",
"0.6266208",
"0.6180625",
"0.6162862",
"0.6134059",
"0.6134059",
"0.6116541",
"0.6106713",
"0.60854656",
"0.6083655",
"0.607067",
"0.6051834",
"0.6045461",
"0.6000587",
"0.5995631",
"0.59822863",
"0.5980315",
"0.5940055",
"0.5928468",
"0.5901794",
"0.58971167",
"0.5885476",
"0.58792824",
"0.58627564",
"0.5851871",
"0.5851749",
"0.5851749",
"0.5851749",
"0.5836128",
"0.5822596",
"0.58106536",
"0.5774176",
"0.57647896",
"0.5750105",
"0.57416993",
"0.5739089",
"0.57313126",
"0.57309616",
"0.5725971",
"0.5723367",
"0.5714848",
"0.5710445",
"0.5693124",
"0.56357723",
"0.5609491",
"0.5609491",
"0.55676776",
"0.5553384",
"0.5530714",
"0.55038404",
"0.5484165",
"0.5468081",
"0.54664284",
"0.5461109",
"0.54605806",
"0.5452085",
"0.5450795",
"0.54445565",
"0.5439635",
"0.5432246",
"0.5425118",
"0.5421131",
"0.541963",
"0.5415464",
"0.54067695",
"0.54003996",
"0.540025",
"0.5394637",
"0.5393858",
"0.53927773",
"0.5372094",
"0.53696644",
"0.5350239",
"0.5349245",
"0.5340948",
"0.5329977",
"0.532826",
"0.5325704",
"0.5323935",
"0.5320339",
"0.52941835",
"0.52844006",
"0.52818173",
"0.5277475",
"0.5248015",
"0.52466637",
"0.52443796",
"0.5231035",
"0.5226476",
"0.5226121",
"0.5221944",
"0.5221076"
] |
0.81205225
|
0
|
Renders an with the given options
|
def share_button(options={})
%(
<fb:share-button class="meta">
#{SHARE_META_OPTIONS.select {|o| options.keys.include?(o) }.collect {|o| %(<meta name="#{o}" content="#{options[o]}" />)}.join("\n") }
#{SHARE_LINK_OPTIONS.select {|o| options.keys.include?(o) }.collect {|o| %(<link rel="#{o}" href="#{options[o]}" />)}.join("\n")}
</fb:share-button>
)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def render(context, options); end",
"def render(options = {})\n raise double_render! if rendered?\n @render_opts = options\n end",
"def render(opts={})\n opts\n end",
"def options\n render plain: ''\n end",
"def options\n render plain: ''\n end",
"def options\n render plain: ''\n end",
"def options\n render plain: ''\n end",
"def render options\n options.view_model = self\n \n determine_and_set_format options\n \n self.class.render view_instance, options\n end",
"def _render_template(options); end",
"def _render_template(options); end",
"def render(options = {})\n template.render options\n end",
"def render opts = {}\n renderer.render opts\n end",
"def options\n render nothing: true\n end",
"def render_to_body(options); end",
"def rendering_options\n end",
"def render_to_body(options = {})\n\t end",
"def options_for_render(options = {})\n style = options_for_style(options[:style] || DEFAULT_OPTIONS[:style])\n DEFAULT_OPTIONS.merge(style).merge(options)\n end",
"def render(opts={})\n update(opts)\n render_template\n end",
"def render_template(context, options); end",
"def render(options = T.unsafe(nil), locals = T.unsafe(nil), &block); end",
"def render_options(classname, *a)\n\t\taccept = env['rack-accept.request']\n\n\t\tif !classname.is_a?(Class)\n\t\t\tclassname = GreyGoo.collection_to_class(classname)\n\t\tend\n\t\toptions = get_options_for(classname, *a)\n\n\t\t# If in the root, also get options for the resource\n\t\tunless a.empty?\n\t\t\trequest.path.match(%r{^/(\\w+)$}) do |thing|\n\t\t\t\toptions += get_options_for(GreyGoo.collection_to_class(thing[1]))\n\t\t\tend\n\t\tend\n\n\t\toptions_json = JSON.pretty_generate(options)\n\t\tout = \"\"\n\t\tunless options.empty? \n\t\t\tif accept.media_type?('text/html')\n\t\t\t\tform_html = form_from_options(options)\n\t\t\t\tunless form_html.empty?\n\t\t\t\t\tout += \"<br><h1>Forms</h1>#{form_html}\"\n\t\t\t\tend\n\t\t\t\tout += \"<br><h1>Options</h1><pre>#{linkify(options_json)}</pre>\"\n\t\t\telse\n\t\t\t\tcontent_type('application/json')\n\t\t\t\tout = options_json\n\t\t\tend\n\t\tend\n\t\treturn out\n\tend",
"def render(options = {}, &block)\n\t\t\t\t@options[:global] = options\n\n\t\t\t\t# Hash\n\t\t\t\thash = 1\n\n\t\t\t\t# Parse axes\n\t\t\t\t@options[:global][:x_axis] = parse_axis(@options[:global][:x_axis])\n\t\t\t\t@options[:global][:y_axis] = parse_axis(@options[:global][:y_axis])\n\n\t\t\t\t# Call nested block to capture parts and its options\n\t\t\t\tunused = @template.capture(self, &block).to_s\n\n\t\t\t\t# Render parts\n\t\t\t\tresult = \"\"\n\t\t\t\tresult += %{\n\t\t\t\t\t<table id=\"statistics-#{hash}\" class=\"table statistics\">\n\t\t\t\t\t\t#{render_parts}\n\t\t\t\t\t</table>\n\t\t\t\t}\n\t\t\t\treturn result.html_safe\n\t\t\tend",
"def show\n view_options(\n full_width: true,\n small_footer: @game.uses_small_footer? || enable_scrolling?,\n has_i18n: @game.has_i18n?\n )\n end",
"def render(options)\n case\n when options.has_key?(:text)\n response.body = options[:text]\n when options.has_key?(:template)\n template_filename = options[:template]\n template_string = IO.read(template_filename)\n view = View.new(self)\n template_engine = engine_for(template_string, :filename => template_filename)\n view.content = template_engine.render(view)\n if has_layout?\n layout_string = IO.read(layout)\n layout_engine = engine_for(layout_string, :filename => layout)\n response.body = layout_engine.render(view) do |*args|\n view.get_content_for(*args)\n end\n else\n response.body = view.content\n end\n else\n raise 'invalid options passed to render'\n end\n @_rendered = true\n response.body\n end",
"def render_to_string(options)\n \"Rendered #{options[:file] || options[:partial]}.\"\n end",
"def render(options={})\n status = options[:status] || 200\n response = JSON.dump(options[:json])\n\n [status, { 'Content-Type' => 'application/json' }, [response]]\n end",
"def render_Selection x, *args\n render x.to_s, *args\n end",
"def render_help_text(text, options={})\n options.stringify_keys!\n mapping = {:notice => \"helpInfo\", :info => \"helpInfo\", :warning => \"helpWarning\", :error => \"helpError\"}\n\n id = options.delete('id')\n display = options.delete('display') || false\n onclick = options.delete('onclick') || visual_effect(:blind_up, id, :duration => 0.3)\n type = mapping[(options.delete('type') || 'info').to_sym]\n<<-HTML\n<div id=\"#{id}\" class=\"helpInfoBox\" onclick='#{onclick}' style=\"#{display ? '' : 'display:none;'}\">\n <table cellpadding=0 cellspacing=0>\n \t<tr>\n \t\t<td class=\"helpInfoLeft\">\n \t\t\t<div class=\"#{type}\"></div>\n \t\t</td>\n \t\t<td class=\"helpInfoContent\">\n \t\t #{text}\n \t\t</td>\n \t</tr>\n </table>\n</div>\nHTML\n end",
"def render(options = {}) \n return if @view and !options[:force] # Avoid double rendering, if we have already attached a view\n \n if options == {} # default rendering\n render(:file => default_template_name)\n\n elsif action_name = options[:action]\n result = render(:file => default_template_name(action_name.to_s))\n\n elsif options[:file]\n file = options[:file]\n if file =~ /^\\// # Render from view root\n @view = render_for_file(File.join(\"app\", \"views\", \"#{file}.xml.builder\"))\n else\n @view = render_for_file(view_path(file)) \n end\n\n elsif options[:nothing]\n @view = Skates::Base::View.new()\n end\n end",
"def render(*args); end",
"def render(*args); end",
"def render!(options = {})\n render(options.merge(:raise_errors => true))\n end",
"def scaffold_options_to_html(options)\n options.collect{|k,v| \"#{k}=\\\"#{h v.to_s}\\\"\"}.join(' ')\n end",
"def render_to_body(options = {})\n end",
"def render opts={}\n # italic(bold) => italic{ bold{ data }}, then evaled\n expr = self.expr.gsub(\"(\", \"{\").gsub(\")\", \"}\")\n \n if expr.include?('{')\n expr.sub!( \"}\", \"{@data}}\")\n else\n expr << \"{@data}\"\n end\n self.renderer.instance_eval expr\n end",
"def render(_options = {})\n content_tag :div, class: css_name do\n content_text = data['text'] || ''\n CommonMarker::Rouge.render_html(\n content_text,\n %i[UNSAFE FOOTNOTES STRIKETHROUGH_DOUBLE_TILDE],\n %i[UNSAFE GITHUB_PRE_LANG HARDBREAKS TABLE_PREFER_STYLE_ATTRIBUTES FULL_INFO_STRING FOOTNOTES],\n %i[table strikethrough tasklist tagfilter],\n formatter: Rouge::Formatters::HTMLLegacy.new(inline_theme: 'github')\n ).html_safe\n end\n end",
"def render\n # link_text = \"<span class='item-icon'>#{render_icon}</span>\"\n # link_text += \"<span class='descriptor-icon'>#{options[:descriptor_icon]}</span>\" if options[:descriptor_icon]\n # link_text += \"<span class='item-text'>#{h @name}</span>\"\n # link_text += \"<span class='item-count'>#{delimit @count}</span>\" if count\n # item = ''\n # item += \"<li>#{s_link_to link_text, @url, @options.selected_if(selected?)}</li>\" if count.nil? || count.positive?\n #\n # s item\n\n link_text = content_tag(:span, render_icon, class: 'item-icon')\n link_text += content_tag(:span, options[:descriptor_icon], class: 'descriptor-icon') if options[:descriptor_icon]\n link_text += content_tag(:span, @name, class: 'item-text')\n link_text += content_tag(:span, delimit(@count), class: 'item-count') if count\n\n content_tag :li do\n link_to link_text, @url, @options.selected_if(selected?)\n end\n\n end",
"def format_options(options)\n data = []\n options.each do |name, option_spec|\n data << format_option(option_spec)\n end\n \"Options:\\n\" + render_table(data, \": \")\n end",
"def render(options = {})\n options[:theme] ||= theme\n options[:value_formatter] ||= value_formatter\n options[:point_markers] ||= point_markers\n options[:size] ||= (options[:width] ? [options[:width], (options.delete(:width) * 0.6).to_i] : [600, 360])\n options[:title] ||= title\n options[:layers] ||= layers\n options[:min_value] ||= bottom_value(:padded)\n options[:max_value] ||= top_value\n options[:graph] ||= self\n \n\n # Removed for now.\n # Added for making smaller fonts more legible, but may not be needed after all.\n #\n # if options[:as] && (options[:size][0] <= 300 || options[:size][1] <= 200)\n # options[:actual_size] = options[:size]\n # options[:size] = [800, (800.to_f * (options[:actual_size][1].to_f / options[:actual_size][0].to_f))]\n # end\n \n svg = ( options[:renderer].nil? ? self.renderer.render( options ) : options[:renderer].render( options ) )\n \n # SVG to file.\n if options[:to] && options[:as].nil?\n File.open(options[:to], 'w') { |file|\n file.write(svg)\n }\n end\n \n options[:as] ? rasterizer.rasterize(svg, options) : svg\n end",
"def render(options={}, &block)\n if options[:nothing]\n return \"\" \n end\n \n if options[:text]\n options.reverse_merge!(:render_children => false)\n end\n \n options.reverse_merge! :render_children => true,\n :locals => {},\n :invoke => {},\n :suppress_js => false\n \n \n rendered_children = render_children_for(options)\n \n options[:locals].reverse_merge!(:rendered_children => rendered_children)\n \n @suppress_js = options[:suppress_js] ### FIXME: implement with ActiveHelper and :locals.\n \n \n render_view_for(options, action_name) # defined in Cell::Base.\n end",
"def style(options); end",
"def render template, options={}\n put_on_a_hat\n\n if options.has_key? :dir\n template = :\"#{options[:dir]}/#{template}\" if options[:dir]\n\n elsif view_dir\n template = :\"#{view_dir}/#{template}\"\n end\n\n return erubis template, options\n end",
"def render_options\n opts = { :href => subject.href, :class => subject.name.to_s }\n opts.merge(:class => rendering_strategy.item_classname, &merge_proc).merge(subject.options, &merge_proc)\n end",
"def render(options)\n @tex_out = template_instance.render options\n Latex.new(:preprocess => preprocess, :debug => debug).generate_pdf(tex_out)\n end",
"def render_and_evaluate(options = {})\n render(options)\n evaluate\n end",
"def render aOpts = {}\n aOpts[:@target] = self\n aOpts[:@title] = self.name\n aOpts[:@content] = self.to_html(aOpts)\n\n html = HTML_TEMPLATE.render_with(aOpts)\n\n # make implicit relative paths into explicit ones\n pathPrefix = '../' * self.url.scan(%r{/+}).length\n\n html.gsub! %r{((?:href|src|action)\\s*=\\s*(\"|'))(.*?)(\\2)} do\n head, body, tail = $1, $3.strip, $4\n\n if body !~ %r{^\\w+:|^[/#?]}\n body.insert 0, pathPrefix\n end\n\n head << body << tail\n end\n\n html\n end",
"def preview\r\n\t\t\trender(\"option_#{self.id}_preview\")\r\n\t\tend",
"def render view, options\n options.format! view\n path_store.cached options do\n options.file = template_path view, options\n view.render_with options\n end\n end",
"def render(options = {})\n format = options.delete(:format) || :list\n klass = Breadcrumbs::Render.const_get(format.to_s.classify)\n html = klass.new(self, options).render\n\n html.respond_to?(:html_safe) ? html.html_safe : html\n end",
"def display(results, options = T.unsafe(nil)); end",
"def render\n return ro_standard if @readonly\n\n set_initial_value('html','selected')\n # separate options and html part\n options_part = {}\n @yaml['html'].symbolize_keys!\n %i(selected include_blank).each { |sym| options_part[sym] = @yaml['html'].delete(sym) if @yaml['html'][sym] }\n @yaml['html'][:multiple] = true if @yaml['multiple']\n\n record = record_text_for(@yaml['name'])\n if @yaml['html'][:multiple]\n @html << @parent.select(record, @yaml['name'], get_choices, options_part, @yaml['html'])\n @js << \"$('##{record}_#{@yaml['name']}').selectMultiple();\"\n else\n @html << @parent.select(record, @yaml['name'], get_choices, options_part, @yaml['html'])\n # add code for view more data\n @html << add_view_code() if @yaml['view']\n end\n self\nend",
"def render_essence_view(content, options = {}, html_options = {})\n render content, {\n content: content,\n options: options,\n html_options: html_options\n }\n end",
"def render(*args, &block); end",
"def use_rendering_options?\n end",
"def render(options)\n if options[:haml]\n template_content = File.read(options[:haml])\n @page_contents << Haml::Engine.new(template_content).render(self) \n elsif options[:partial]\n template_content = File.read(options[:haml])\n return Haml::Engine.new(template_content).render(self) \n elsif options[:text]\n @page_contents << options[:text]\n else\n raise \"No render type found. Must be haml, partial or text\"\n end\n end",
"def render\n view_context.fa_icon icon, **html_options, text: text, right: right\n end",
"def render(context, options)\n render_to_object(context, options).body\n end",
"def to_html(*args)\n @output_format = :html\n @options += args\n convert\n end",
"def render_option(result, index)\n color = index == selected_row ? 255 : 234\n bg_color = index == selected_row ? 25 : 255\n\n extra_padding = \" \" * (width_of_suggestions - result.length)\n text = \" #{result}#{extra_padding} \"\n target_spacing = spacing + extra_spacing\n\n diff = Hedgehog::Terminal.columns - (target_spacing + text.length)\n\n actual_spacing = target_spacing\n actual_spacing = actual_spacing + diff if diff < 0\n\n print(\"\\n\")\n print \"\\e[0G\"\n print(\" \" * [actual_spacing, 0].max)\n print(str_with_color(text, color: color, bg_color: bg_color))\n end",
"def tag(text, options={})\n puts \"options before processing: #{options.inspect}\"\n tag = options.delete(:tag) || 'div'\n puts \"options after processing: #{options.inspect}\"\n attrs = options.map {|(key, value)| \"#{key}='#{value}'\" }.join(' ')\n \n \"<#{tag} #{attrs}>#{text}</#{tag}>\"\nend",
"def render_to_body(options)\n _render_to_body_with_renderer(options) || super\n end",
"def render_body(context, options); end",
"def render(context)\n @output = \"<section class=\\\"gh-cards\\\">\\n\"\n if @args.length == 0\n show_n_yours(30)\n elsif @args.length == 1\n # User wants to show n of their repos\n if number_or_nil(@args[0])\n show_n_yours(@args[0].to_i)\n else # User wants to show one of their repos\n show_repo_yours(@args[0])\n end\n elsif @args.length == 2\n # User wants to show n of someone else's repos\n if number_or_nil(@args[1])\n show_n_repos(@args[0], @args[1].to_i)\n else # User wants to show one of someone else's repo\n show_repo(@args[0], @args[1])\n end\n end\n @output += \"</section>\"\n end",
"def create_html(options)\n if(options[:html_template] && options[:html_template] == :scientific) then\n\n if(options[:language] && options[:language] == :english) then\n html = '<h2>Academic Interests<\\/h2>\\r\\n' +\n '<p>Add information about academic fields of interest.<\\/p>\\r\\n' +\n '<h2>Teaching<\\/h2>\\r\\n' +\n '<ul>\\r\\n' +\n ' <li><Link to programme of study/course><\\/li>\\r\\n' +\n ' <li><Link to programme of study/course><\\/li>\\r\\n' +\n ' <li>...<\\/li>\\r\\n' +\n '<\\/ul>\\r\\n' +\n '<h2>Higher education and employment history<\\/h2>\\r\\n' +\n '<p>Brief introduction to previous education and employment.<\\/p>\\r\\n' +\n '<h2>Honoraria<\\/h2>\\r\\n' +\n '<ul>\\r\\n' +\n ' <li><Name of prize and (if applicable) link 1><\\/li>\\r\\n' +\n ' <li><Name of prize and (if applicable) link 2><\\/li>\\r\\n' +\n ' <li>...<\\/li>\\r\\n' +\n '<\\/ul>\\r\\n' +\n '<h2>Appointments<\\/h2>\\r\\n' +\n '<ul>\\r\\n' +\n ' <li><Title and (if applicable) link 1><\\/li>\\r\\n' +\n ' <li><Title and (if applicable) link 2><\\/li>\\r\\n' +\n ' <li>...<\\/li>\\r\\n' +\n '<\\/ul>\\r\\n' +\n '<h2>Cooperation<\\/h2>\\r\\n' +\n '<p> <\\/p>'\n else\n html = '<h2>Faglige interesser<\\/h2>\\r\\n' +\n '<p>Her kan du skrive om faglige interesser.<\\/p>\\r\\n' +\n '<h2>Undervisning<\\/h2>\\r\\n<p>' +\n '<Lenke til studieprogram/emne> <br />\\r\\n' +\n '<Lenke til studieprogram/emne> <br />\\r\\n...<\\/p>\\r\\n' +\n '<h2>Bakgrunn<\\/h2>\\r\\n' +\n '<p>Kort om tidligere arbeidserfaring og utdanning<\\/p>\\r\\n' +\n '<h2>Priser<\\/h2>\\r\\n' +\n '<p><Navn og eventuelt lenke til pris 1> <br />\\r\\n' +\n '<Navn og eventuelt lenke til pris 2> <br />\\r\\n' +\n '...<\\/p>\\r\\n' +\n '<h2>Verv<\\/h2>\\r\\n<p>' +\n '<Navn og eventuelt lenke til verv 1> <br />\\r\\n' +\n '<Navn og eventuelt lenke til verv 2> <br />\\r\\n...' +\n '<\\/p>\\r\\n' +\n '<h2>Samarbeid<\\/h2>\\r\\n' +\n '<p> <\\/p>'\n end\n else\n\n if(options[:language] && options[:language] == :english) then\n html = '<h2>Tasks performed<\\/h2>\\r\\n' +\n '<p>Add information about job duties, as a short text or a bulleted list:<\\/p>' +\n '\\r\\n<ul>\\r\\n' +\n ' <li><Task 1><\\/li>\\r\\n' +\n ' <li><Task 1><\\/li>\\r\\n' +\n ' <li>...<\\/li>\\r\\n' +\n '<\\/ul>\\r\\n' +\n '<h2>Background<\\/h2>\\r\\n' +\n '<p>Add information about previous education and employment.<\\/p>'\n else\n html = '<h2>Arbeidsområder<\\/h2>\\r\\n' +\n '<p>Her kan du skrive om arbeidsområder, ' +\n 'enten som kort tekst eller som listepunkter:</p>' +\n '\\r\\n' +\n '<ul>\\r\\n' +\n ' <li><Arbeidsområde 1></li>\\r\\n' +\n ' <li><Arbeidsområde 1></li>\\r\\n' +\n ' <li>...</li>\\r\\n' +\n '</ul>' +\n '\\r\\n' +\n '<h2>Bakgrunn</h2>\\r\\n' +\n '<p>Eventuelt kort om tidligere arbeidserfaring og utdanning.</p>'\n end\n end\n return html\n end",
"def render(options = {}, extra_options = {}, &block)\n if atom = options[:atom]\n response.content_type ||= Mime::ATOM\n render_for_text(atom.respond_to?(:to_atom) ? atom.to_atom.to_xml : atom.to_xml, options[:status])\n else\n super\n end\n end",
"def to_html(options = T.unsafe(nil)); end",
"def to_html(options = T.unsafe(nil)); end",
"def render_to_body(options = T.unsafe(nil)); end",
"def add_html_output_options(opt)\n end",
"def to_html options = {}\n only = options.fetch :only, [:uri, :inline]\n only = [only] unless Array === only\n markup = queue.map do |type, queue|\n next unless type.in? only\n send :\"render_#{type}\", queue.sort_by { |q| q[:weight] }\n end.join \"\\n\"\n clear\n markup\n end",
"def render(options = nil, extra_options = {}, &block)\n if params[:format] == 'xml' # dump the view state as XML\n put_xml @view_state\n else\n super options\n end\n end",
"def render(*args)\n end",
"def to_html aOpts = {}\n aOpts[:@summarize] = true unless aOpts.key? :@summarize\n aOpts[template_ivar] = self\n template.render_with(aOpts)\n end",
"def render!(*args); end",
"def view( options )\n t = Time.new\n log.debug( \"NodeRenderer#view: #{options.inspect}\" ) if log\n\n node = options[:node] || options[\"node\"]\n return \"<div class='warning'>No node to render!</div>\" unless node\n return \"<div class='warning'>Not an RDF node: #{node.inspect}</div>\" unless node.is_a?( Jena::Core::RDFNode )\n\n options[:context] = options[:context] || options[\"context\"] || default_context\n options[:node_renderer] = self\n options[:model] = get_model( options )\n options[:types] = node.types\n\n r = select_renderer( node, options[:context], options )\n result = render( r.render( options ), options )\n\n log.debug( \"NodeRenderer#view time taken = #{t - Time.now}s\" ) if log\n result\n end",
"def render\n end",
"def render\n <<-HTML\n <div class=\"relative\">\n <a href=\"#{url}\"class=\"#{position_classes}f6 link dim br2 ph3 pv2 dib white bg-blue\" data-help-link=\"Y\" target=\"cbf-help\">#{Icon.new(:question).render} #{text}</a>\n </div>\n HTML\n end",
"def to_s(options = {})\n raise \"Erector::Widget#to_s now takes an options hash, not a symbol. Try calling \\\"to_s(:content_method_name=> :#{options})\\\"\" if options.is_a? Symbol\n _render(options).to_s\n end",
"def render(options)\n # Get the renderable (Object that should be rendered) from options hash.\n renderable = options[:json]\n\n # Return if renderable is blank\n return options unless renderable\n\n # Try to fetch the right serializer for given renderable.\n serializer = serializer_for(renderable, options)\n\n # When no serializer is found just pass the original options hash.\n return options unless serializer\n\n # Replace json value with new serializer\n options.merge(json: serializer.new(renderable, options))\n end",
"def render(opts = {}, &block)\n \n opts[:status] = 200 if !opts[:status]\n if opts[:to_yaml] then\n headers[\"Content-Type\"] = \"text/plain;\"\n yaml = Hash.from_xml(render_to_string(:template => opts[:to_yaml], :layout => false)).to_yaml\n render :text => yaml, :layout => false, :status => opts[:status]\n elsif opts[:to_json] then\n hash = Hash.from_xml(render_to_string(:template => opts[:to_json], :layout => false))\n hash = hash[hash.keys.first] if hash.keys.length == 1\n content = hash.to_json\n cbparam = params[:callback] || params[:jsonp]\n content = \"#{cbparam}(#{content})\" unless cbparam.blank?\n render :json => content, :layout => false, :status => opts[:status]\n elsif opts[:to_xml]\n content = render_to_string(:template => opts[:to_xml], :layout => false)\n headers[\"Content-Type\"] = \"application/xml;\"\n render :text => content, :layout => false, :status => opts[:status]\n elsif opts[:response]\n render_rest_response opts[:response]\n else\n super opts, &block\n end\nend",
"def render_with_options(text, options)\n splitter = \"\\n\"\n splitter = '->' if text.include?('->')\n lines = text.split splitter\n\n # Allow first line to be name of test, if desired\n if options[:name] && options[:name] =~ /vignette_(\\w+)/i\n lines.vignette($1)\n\n # Otherwise, try to use filename and line\n elsif options[:filename] && options[:line]\n if options[:filename] == \"(haml)\"\n lines.vignette(\"(haml:#{options[:line]})\", expect_consistent_name: false)\n else\n lines.vignette(\"(#{Vignette::strip_path(options[:filename])}:#{options[:line]})\", expect_consistent_name: false)\n end\n # If not given, raise an error\n else\n Vignette::Errors::TemplateRequiresNameError.new(\"Missing filename or [test_name] in Vignette test\")\n end\n end",
"def render(*args,&block)\n\t\toptions = args.dup.extract_options!\n\t\t@rendered_action = options[:action]\n\t\tsuper\n\tend",
"def to_html(*options)\n view = View.new(self)\n # todo: this is not clean...\n options = (options.shift || {}).merge!(@options || {})\n # todo: if rails is loaded set the default engine: dynamicreports::report.default_engine\n engine = options.delete(:engine) || @@default_engine\n options[:template] = self.class.template\n view.__send__(\"#{engine}\", options)\n end",
"def render(options = nil, scope = Object.new)\n options ||= @act\n format = nil\n template_path = nil\n case options\n when Hash\n format = options[:format].to_s.empty? ? 'html' : options[:format]\n if options[:partial]\n template_path = compute_template_path(\"_#{options[:partial]}\", format)\n template_source = ERB.new(File.read(template_path), nil, '-', '@_out_buf').src\n elsif options[:action]\n template_path = compute_template_path(options[:action], format)\n template_source = ERB.new(File.read(template_path),\n nil, '-', '@_out_buf').src\n elsif options[:file]\n template_path = File.join(config.template_root, options[:file])\n template_source = ERB.new(File.read(options), nil, '-', '@_out_buf').src\n elsif options[:text]\n output = ERB::Util.h(options[:text])\n elsif options[:html]\n output = options[:html]\n elsif options[:inline]\n template_path = \"#{request_method} #{@act}\"\n template_source = ERB.new(options[:inline].to_s, nil, '-', '@_out_buf').src\n end\n when Symbol\n format = 'html'\n template_path = compute_template_path(options, 'html')\n template_source = ERB.new(File.read(template_path), nil, '-', '@_out_buf').src\n when String\n format = 'html'\n template_path = File.join(config.template_root, options)\n template_source = ERB.new(File.read(template_path), nil, '-', '@_out_buf').src\n end\n \n unless output\n # ヘルパの準備\n ([Mizinco::Helper, ERB::Util] | self.class.helpers).each{ |helper| scope.extend helper }\n # インスタンス変数のコピー\n scope.instance_variable_set('@app', self)\n instance_variables.collect do |var|\n scope.instance_variable_set(var, instance_variable_get(var))\n end\n \n # スクリプト実行\n original_out_buf =\n scope.instance_variables.any? { |var| var.to_sym == :@_out_buf } &&\n scope.instance_variable_get(:@_out_buf)\n scope.instance_eval template_source, template_path, 0\n output = scope.instance_variable_get(:@_out_buf)\n scope.instance_variable_set(:@_out_buf, original_out_buf)\n end\n \n res.write output if !options.is_a?(Hash) || options[:partial].to_s.empty?\n\n output\n end",
"def render_with_options_or_default options\n if paginate?\n render(results_to_render: paginated_results(page: options[:page].presence || 1))\n else\n render\n end\n end",
"def render_mktg( options )\n logger.debug( [ 'render_mktg', options ] )\n\n options[:file] = mktg_template_filename( options )\n if options[:check_existance]\n notfound unless File.exists?(Rails.root.join('app','views',options[:file]))\n end\n partial=options.delete(:partial)\n options.delete(:path)\n\n if partial\n render_to_string options.merge(:layout => false)\n else\n render options.reverse_merge(:layout => true)\n end\n end",
"def render(props)\n # HTML.\n end",
"def render options = nil, extra_options = {}, &block\n [:json, :js, :xml, :file].each do |format|\n self.paloma.clear_request if options.has_key?(format)\n end if options.is_a?(Hash)\n\n super\n end",
"def render(options = {})\n r = renderer(options)\n @options.merge(options)[:header_footer] ? r.render('document', self) : content\n end",
"def show_options\n head :ok\n end",
"def render(format, options = {})\n options[:format] = format\n logger.debug \"#{self.class} is being rendered to #{format} with #{options.inspect}\" if respond_to?(:logger)\n renderer_for(format).render(self, options)\n end",
"def to_s(options = {}, &blk)\n \n raise \"Erector::Widget#to_s now takes an options hash, not a symbol. Try calling \\\"to_s(:content_method_name=> :#{options})\\\"\" if options.is_a? Symbol\n \n options = {\n :output => \"\",\n :prettyprint => prettyprint_default,\n :indentation => 0,\n :helpers => nil,\n :content_method_name => :content,\n }.merge(options)\n context(options[:output], options[:prettyprint], options[:indentation], options[:helpers]) do\n send(options[:content_method_name], &blk)\n output.to_s\n end\n end",
"def render_for( short_name, options = {})\n template = template_for(short_name)\n render options.merge(template.to_params)\n end",
"def rendered; end",
"def to_html_options(options)\n return if options.empty?\n options.delete(:callback) if options[:callback].present?\n options.delete(:class) if options[:class].present?\n\n output = \"\"\n options.each do |k, v|\n output += %Q[#{k.to_s}=\"#{v}\" ]\n end\n\n output\n end",
"def to_html(*args); end",
"def to_html(*args); end",
"def to_html(*args); end",
"def to_html(*args); end",
"def render_search_results(options={})\n default_options = {\n :show_result_count => true,\n :show_heading => true\n }\n render 'alchemy/search/results', :options => default_options.merge(options)\n end",
"def rendered=(_arg0); end"
] |
[
"0.7419733",
"0.7415207",
"0.7281017",
"0.71469915",
"0.7122455",
"0.7122455",
"0.7122455",
"0.7008976",
"0.69250953",
"0.69250953",
"0.68507",
"0.66892415",
"0.6665263",
"0.65970784",
"0.65567183",
"0.6540503",
"0.6526751",
"0.6505733",
"0.65030396",
"0.6449255",
"0.63260764",
"0.6317076",
"0.628894",
"0.6269175",
"0.6258552",
"0.62124985",
"0.6211039",
"0.61946845",
"0.6185303",
"0.61640483",
"0.61640483",
"0.6162596",
"0.61595523",
"0.6150269",
"0.6148872",
"0.61378103",
"0.61365867",
"0.61148006",
"0.6097863",
"0.60684884",
"0.60620105",
"0.6048698",
"0.60474646",
"0.6033542",
"0.6029109",
"0.6024674",
"0.60124",
"0.598387",
"0.5966988",
"0.5964022",
"0.5949955",
"0.5930872",
"0.5927205",
"0.5923397",
"0.59160537",
"0.5903846",
"0.59036136",
"0.5903314",
"0.59031117",
"0.5899304",
"0.58961165",
"0.5886843",
"0.5880046",
"0.5869493",
"0.5858657",
"0.5858249",
"0.5858249",
"0.58552355",
"0.5846964",
"0.5844219",
"0.5831351",
"0.5828158",
"0.5825171",
"0.5819017",
"0.58175856",
"0.58170366",
"0.58112144",
"0.5806004",
"0.5799373",
"0.57978696",
"0.5778915",
"0.57749766",
"0.5773417",
"0.57720405",
"0.5770503",
"0.5759733",
"0.5751939",
"0.5749076",
"0.57438046",
"0.5741781",
"0.5738483",
"0.5728514",
"0.5720924",
"0.57157063",
"0.57073975",
"0.569415",
"0.569415",
"0.569415",
"0.569415",
"0.56760544",
"0.5666799"
] |
0.0
|
-1
|
Defini 2 variables de la fonction soustraction
|
def subtract (num1, num2)
num1 - num2
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def suivre; end",
"def probers=(_arg0); end",
"def mi_carrera\n\n\tend",
"def operations; end",
"def operations; end",
"def terpene; end",
"def ext=(_arg0); end",
"def ext=(_arg0); end",
"def ext=(_arg0); end",
"def schubert; end",
"def zuruecksetzen()\n end",
"def SE02=(arg)",
"def probers; end",
"def param; end",
"def param; end",
"def operation; end",
"def functions\n\n end",
"def whiny=(_arg0); end",
"def schumann; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def sea; end",
"def extra=(_arg0); end",
"def two\n end",
"def lsi=(_arg0); end",
"def lsi=(_arg0); end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def parameters; end",
"def bellini; end",
"def formation; end",
"def romeo_and_juliet; end",
"def SE01=(arg)",
"def isolated=(_arg0); end",
"def isolated=(_arg0); end",
"def returns=(_arg0); end",
"def private; end",
"def s1\n end",
"def stderrs; end",
"def who_we_are\r\n end",
"def sub_b\n end",
"def SAC02=(arg)",
"def origin=(_arg0); end",
"def two_method(x,y,z)\n\t\tx + y + z\nend",
"def berlioz; end",
"def sub_c\n end",
"def intensifier; end",
"def y=(_arg0); end",
"def variables; end",
"def variables; end",
"def ismn; end",
"def verdi; end",
"def strain; end",
"def PO114=(arg)",
"def custom; end",
"def custom; end",
"def PRF02=(arg)",
"def z\n end",
"def lsi; end",
"def ITD02=(arg)",
"def guct\n end",
"def parameters=(_arg0); end",
"def op; end",
"def PO113=(arg)",
"def mech=(_arg0); end",
"def mech=(_arg0); end",
"def CTT02=(arg)",
"def SAC05=(arg)",
"def parameters=(_); end",
"def z\n end",
"def sub_d\n end",
"def return_value=(_arg0); end",
"def PO101=(arg)",
"def SAC07=(arg)",
"def standalone=(_arg0); end",
"def funktionsname\n\tanweisung\nend",
"def PO105=(arg)",
"def ITD07=(arg)",
"def PO111=(arg)",
"def SAC06=(arg)",
"def heroine; end",
"def variable; end",
"def variable; end",
"def summe(a,b)\r\n a+b\r\nend",
"def rossini; end",
"def AMT02=(arg)",
"def agi; param(6); end",
"def selntran(*)\n super\n end",
"def stime=(*) end",
"def ITD03=(arg)",
"def get_x; \t\t@x \t\t\tend",
"def calculated; end",
"def main_variable ; end",
"def villian; end"
] |
[
"0.7078675",
"0.65198433",
"0.63651127",
"0.6354521",
"0.6354521",
"0.6345544",
"0.632831",
"0.632831",
"0.632831",
"0.63188225",
"0.62680763",
"0.62598956",
"0.62519693",
"0.62454736",
"0.62454736",
"0.62033784",
"0.61968815",
"0.6189542",
"0.61565644",
"0.61467534",
"0.61467534",
"0.61467534",
"0.61467534",
"0.614389",
"0.6135938",
"0.61338",
"0.6128841",
"0.6128841",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6107401",
"0.6105452",
"0.6094552",
"0.605436",
"0.60527766",
"0.605045",
"0.605045",
"0.6044321",
"0.60403305",
"0.6025291",
"0.60241973",
"0.6009426",
"0.6007685",
"0.60067004",
"0.6002935",
"0.5997508",
"0.59790295",
"0.59777397",
"0.59678453",
"0.59631807",
"0.59601444",
"0.59601444",
"0.5958921",
"0.5951967",
"0.5945747",
"0.59400535",
"0.5935895",
"0.5935895",
"0.5917155",
"0.59130055",
"0.5906905",
"0.58934057",
"0.58921903",
"0.58897686",
"0.5886208",
"0.58813643",
"0.587441",
"0.587441",
"0.5873226",
"0.5868478",
"0.5853746",
"0.584891",
"0.5846679",
"0.5845062",
"0.5834588",
"0.58320665",
"0.5831449",
"0.58294827",
"0.5828057",
"0.5827942",
"0.58278227",
"0.5820634",
"0.58162576",
"0.58153003",
"0.58153003",
"0.58107984",
"0.5809313",
"0.5805864",
"0.58008295",
"0.5800663",
"0.58002204",
"0.579642",
"0.5793312",
"0.579259",
"0.5789299",
"0.5788671"
] |
0.0
|
-1
|
Defini la variable Array(input) pour la fonction Somme
|
def sum (arr)
somme = 0 # initialiser la variable la somme à 0 #
arr.each do |x| # utilisation de l'itérateur each qui va prendre chaque valeur de cette variable #
somme += x # (somme = somme + x )chaque valeur de l'array est ajouter a la variable somme #
end
return somme #
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def array_method(input)\n\treturn \"thanks for the sweet array!\"\nend",
"def Array(p0) end",
"def input\r\n\t\t@input.map{|i| i}\t\r\n\tend",
"def getArray _args\n \"getArray _args;\" \n end",
"def array()\n\t\t@array\n\tend",
"def converted_arrays; end",
"def array\n raise \"Not implemented\"\n end",
"def array\n\t\t#create an array of\n\t\tarray = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n\tend",
"def array\n @array\n end",
"def mutliplied(array)\nend",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each {|ele| add ele}\n\n # Fill in the rest of the initialize method here.\n \n # What should you do with each element of the incoming array?\n end",
"def initialize array\n @array = array\n end",
"def input; end",
"def input; end",
"def input; end",
"def array_converter(*args)\n \nend",
"def double_array(array)\n # your code here\nend",
"def to_a; Array(force) end",
"def initialize(input_arr=[])\n @internal_arr = []\n \n # take the input_arr and pass each value to add \n input_arr.each{|new_ele| add(new_ele)}\n\n end",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each{|new_ele| add new_ele} # PLEASE EXPLAIN IN SECTION\n # Fill in the rest of the initialize method here.\n # What should you do with each element of the incoming array?\n end",
"def lcts(array)\nend",
"def input; @input; end",
"def input; @input; end",
"def number_array\n @input_string.split(' ')\n end",
"def initialize(input_arr=[])\n \n @internal_arr = []\n\n # Pass each element in input_arr to 'add' method (if it isn't empty)\n input_arr.each { | ele | add(ele) } \n\n end",
"def create_an_array\n [\"oranges\",\"apples\",\"kiwis\",\"mangos\"]\nend",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each { |x| add x }\n # Fill in the rest of the initialize method here.\n # What should you do with each element of the incoming array?\n end",
"def doubler(array)\n \nend",
"def doubler(array)\n \nend",
"def print_elements(input_array)\n # TODO\nend",
"def initialize(input_arr=[])\n @internal_arr = []\n # Fill in the rest of the initialize method here.\n # What should you do with each element of the incoming array?\n input_arr.each { |x|\n add(x)\n }\n end",
"def look_and_say(array)\n\nend",
"def array(input_array)\n output = input_array + [100] # Creates a new array by adding '[]' to the string \"100\",\n # then combines \"input_array\" and \"[\"100\"]\" arrays by '+'\n return output\nend",
"def convert_cons_list_into_array(input)\n input == [] ? [] : convert_cons_list_into_array(input[1]) << input.first\n end",
"def array\n @@array\n end",
"def array_method(input)\n\treturn input[input.length/2]\nend",
"def initialize(array)\n @array = array\n end",
"def __array__; self; end",
"def array(arg)\n if arg\n arg = arg.chomp.rstrip.lstrip\n name = arg.scan(/\\s*(\\w*)\\[\\d*\\]?/).first.first\n \n # following 10 lines seem to be unnecessary\n # and are left over from early array work\n # but they are still here for a bit\n # determine if there is an array assignement, and how many\n # then eliminate the assignment and update the array size\n # if /\\w*\\[\\d*\\]\\s*\\=\\s*\\{(.*)\\}/ =~ arg\n # assignment = arg.scan(/\\w*\\[\\d*\\]\\s*\\=\\s*\\{(.*)\\}/).first.first\n # array_size = assignment.split(\",\").length\n # if /\\[(\\s*)\\]/ =~ arg\n # arg.gsub!(/(\\[\\d*\\])/, \"[#{array_size}]\")\n # end\n # end\n # arg = arg.scan(/^((\\s*|\\w*)*\\s*\\w*\\[\\d*\\])?/).first.first\n\n # help rad_processor do a better job with array types\n types = [\"int\", \"long\", \"char*\", \"unsigned int\", \"unsigned long\", \"byte\", \"bool\", \"float\" ]\n types.each_with_index do |type, i|\n @type = types[i] if /#{type}/ =~ arg\n end\n raise ArgumentError, \"type not currently supported.. got: #{arg}. Currently supporting #{types.join(\", \")}\" unless @type\n\n arg = \"#{arg};\" unless arg[-1,1] == \";\"\n $array_types[name] = @type\n @type = nil\n $external_var_identifiers << name unless $external_var_identifiers.include?(name)\n # add array_name declaration\n $external_array_vars << arg unless $external_array_vars.include?(arg)\n end\n end",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each do |x|\n self.add(x)\n end\n end",
"def name_array(name1, name2)\n real_name_array = [name1, name2]\n real_name_array\nend",
"def initialize(input_arr = [])\n @internal_arr = []\n input_arr.each {|new_ele| add(new_ele)}\n\n end",
"def input=(_arg0); end",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each {|elem| self.add(elem)}\n end",
"def array(*args)\n args_ = (args.size == 1) && (args[0].is_a? ::Array) ? args[0] : args\n args_.each_with_object(newObject('Array')) do |val, obj|\n obj.add val\n end\n end",
"def virus(array_input)\n new_array = [ ]\n number_of_loops = array_input.length\n index = array_input.length - 1\n\n number_of_loops.times do \n new_array << array_input[index]\n index = index - 1 \n end \n\n output = new_array\n return output\nend",
"def initialize\n @array = []\n end",
"def studentArray(value)\n @students = Array.new unless defined? @students\n # \n if value.is_a?(Array)\n value.each{|student| @students << student}\n else\n @students << value\n end\nend",
"def array_method(input)\n\treturn input[-1]\nend",
"def array_method(input, value_input)\n\tmiddle_val = input.length/2\n\tinput[middle_val] = value_input\t\n\tputs input\n\treturn input\nend",
"def convert_song_original_array(song)\n song.map! do |lyric|\n word = lyric[0]\n number = lyric[1]\n (word * number).scan(word) # returns an array of instanaces of word\n end\n song.flatten!\n return song\nend",
"def add_input(input_chunk)\n if ! input_chunk.is_a?(Array)\n input_chunk = [input_chunk]\n end\n\n add_input_chunk(input_chunk)\n end",
"def array(before: Pass.instance, each: Pass.instance, after: Pass.instance)\n ArrayV.new before: before, each: each, after: after\n end",
"def array_method(input, value_input, which_index)\n\tinput[which_index] = value_input\t\n\tputs input\n\treturn input\nend",
"def create_an_array\n [\"a\", \"b\", \"c\", \"d\"]\nend",
"def to_a; [Array]; end",
"def return_string_array(array)\n count = 0\n # create new array to store converted elements\n new_array = []\n # iterate over a provided array\n while count < array.length do\n # add each converted element to the end of a new array with Shovel Method\n new_array << array[count].to_s\n count += 1\n end\n # return new array\n new_array\nend",
"def initialize arr = []\n super arr\n end",
"def make_word_array(input)\n input = input.upcase.split(\"\")\n return input\nend",
"def make_array(n)\n if n.class != Array\n x = []\n x << n\n array = x\n return array\n else\n return n\n end\n end",
"def processes_as_array(processes_parameter)\n return [] if processes_parameter.nil?\n\n return [processes_parameter] unless processes_parameter.is_a?(Array)\n\n processes_parameter\n end",
"def initialize(input_arr=[])\n @internal_arr = []\n input_arr.each{|elem| @internal_arr.push(elem)}\n\n unless input_arr.empty? == true\n input_arr.replace(input_arr.sort)\n \n\n end\n \n\n # Fill in the rest of the initialize method here.\n # What should you do with each element of the incoming array?\n end",
"def coin_array; end",
"def initialize(array)\n @array = array\n end",
"def work_input(input_arr)\n yield(input_arr)\nend",
"def k_array!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 60 )\n\n\n\n type = K_ARRAY\n channel = ANTLR3::DEFAULT_CHANNEL\n # - - - - label initialization - - - -\n\n\n # - - - - main rule block - - - -\n # at line 493:3: 'array'\n match( \"array\" )\n\n\n\n @state.type = type\n @state.channel = channel\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 60 )\n\n\n end",
"def paramstype\n \"Array\"\n end",
"def as_array\n @fm.dup\n end",
"def input1\n [\n [1, 0, 0, 0, 1],\n [0, 1, 0, 0, 5],\n [0, 0, 1, 0, 4],\n [0, 0, 0, 1, 3]\n ]\nend",
"def make_array(item1, item2, item3)\n\tarray = [item1, item2, item3]\n\n\tarray\nend",
"def Array(type)\n Strict(::Array).of(type)\n end",
"def create_array(one, two, three)\n\treturn [one, two, three]\nend",
"def added(array)\nend",
"def make_array\n @phrase_string.downcase.split(WORD_SPLIT).reject(&:empty?)\n end",
"def initialize(array:)\n @array = array\n super()\n end",
"def to_flex_array\n self\n end",
"def visit_array(h); end",
"def array(name, options={})\n param(:array, name, options)\n end",
"def array_translate(array)\n # Write your code here\nend",
"def build_array(param1, param2, param3)\n\t[param1, param2, param3]\nend",
"def elements; end",
"def elements; end",
"def elements; end",
"def issn_array\n return nil unless issn.present?\n return issn if issn.is_a?(Array)\n return JSON.parse(issn) if issn.start_with?('[')\n\n [issn]\n end",
"def i\n\t\t\tprogram = pop\n\t\t\traise ArgumentError, \"I: first element is not an Array.\" unless program.is_a? Array\n\t\t\t~program\n\t\tend",
"def request_player_input(message = 'Please enter an array of numbers 1-6 each separated by \" \"')\n puts message.to_s\n temp_input = gets.chomp\n temp_input = temp_input.split\n temp_input = temp_input.map(&:to_i)\n end",
"def split_input(input)\n array = input.split('')\n array << array[0]\nend",
"def isArray _args\n \"isArray _args;\" \n end",
"def param_array(keys)\n puts \"Entering param_array '#{@sy}'\" if DEBUG\n type = nil\n \n if @sy.type == TokenType::ARRAY_TOKEN\n next_token\n if @sy.type == TokenType::OF_TOKEN\n next_token\n type = param_type(keys | Array.follow)\n else\n error(\"Line #{@sy.line_number} expected 'of', but saw '#{@sy.text}'\", keys | Array.follow)\n end\n else\n error(\"Line #{@sy.line_number} expected 'array', but saw '#{@sy.text}'\", keys | Array.follow)\n end\n puts \"Leaving param_array '#{@sy}'\" if DEBUG\n \n TypeNode.new \"array of #{type.type}\"\n end",
"def to_array\n self.word.split(\"\")\n end",
"def virus(input_array)\n i = input_array.length-1 \n new_array = []\n\n input_array.length.times do \n new_array << input_array[i]\n i -= 1\n end \n return new_array\nend",
"def productify(array)\n\nend",
"def make_list (item_list)\n #convert user input to array\n item_list = item_list.split(' ')\n return item_list\nend",
"def _array(obj)\n obj.map { |v| _renc(v) }\n end",
"def params_array_from(raw_params); end",
"def sequence_to_array_objects\n @sequence = Array.new if @sequence.nil?\n\n array = []\n if !@sequence.empty?\n @sequence.each { |element|\n downcaseElement = element.downcase\n if instance_attribute_defined?(downcaseElement)\n object = get(downcaseElement)\n if object.kind_of?(Array)\n array.concat object\n else\n array << object\n end\n end\n }\n else\n if !@objects.nil?\n @objects.each { |o|\n array << o\n }\n end\n end\n return array;\n end",
"def array_word\n p @arrayed_word = @secret_word.split(\"\")\n end",
"def instantiate_new_array\n<<<<<<< HEAD\n Array.new\nend",
"def to_array\n @word.split(\" \") #or @word.chars will work too.\n end",
"def imprimir_nome(*nomes) #splat operator, transforma argumentos em array\n nomes.each{|n| puts n}\nend",
"def initialize(val, nombre)\n @value = Array.new(nombre, val)\nend"
] |
[
"0.7308989",
"0.717847",
"0.6574854",
"0.6253808",
"0.6248152",
"0.62263083",
"0.62097806",
"0.6200058",
"0.61489546",
"0.6116126",
"0.6084882",
"0.60466164",
"0.6031486",
"0.6031486",
"0.6031486",
"0.6011125",
"0.5981597",
"0.59698737",
"0.5938714",
"0.59287256",
"0.5919278",
"0.59113526",
"0.59113526",
"0.5904678",
"0.590195",
"0.5897055",
"0.588182",
"0.5879359",
"0.5879359",
"0.5876567",
"0.5866789",
"0.58418894",
"0.5837433",
"0.58359784",
"0.5817021",
"0.58106947",
"0.58062613",
"0.58027476",
"0.5789913",
"0.5783215",
"0.57776374",
"0.5745945",
"0.57378304",
"0.57180125",
"0.57093453",
"0.5704529",
"0.5702882",
"0.5695745",
"0.5672077",
"0.5671803",
"0.56275845",
"0.5619605",
"0.5615489",
"0.5610105",
"0.5606056",
"0.55982006",
"0.5597192",
"0.55894804",
"0.55889064",
"0.5576095",
"0.55744904",
"0.5572144",
"0.55704516",
"0.5567371",
"0.5562734",
"0.5549007",
"0.55477244",
"0.5547666",
"0.5542734",
"0.55348605",
"0.55283886",
"0.55210805",
"0.551382",
"0.5512964",
"0.5497583",
"0.5495894",
"0.5491729",
"0.54840285",
"0.54762256",
"0.547389",
"0.5470551",
"0.5470551",
"0.5470551",
"0.5464005",
"0.54550153",
"0.5454667",
"0.54514194",
"0.5449998",
"0.544405",
"0.5443402",
"0.5443275",
"0.5440471",
"0.5422723",
"0.5414245",
"0.54066813",
"0.5406468",
"0.54055566",
"0.54017305",
"0.5401315",
"0.53976226",
"0.53859085"
] |
0.0
|
-1
|
s.request(link) do|success,body| body if success end
|
def request(link, &blk)
link = hook(link)
log "request: #{link} -> #{blk.inspect}"
@multi.add( Curl::Easy.new(link) do|c|
c.follow_location = true
c.headers["User-Agent"] = "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_3; en-us) AppleWebKit/525.18 (KHTML, like Gecko) Version/3.1.1 Safari/525.20"
c.on_success{|curl| yield(true, curl.body_str) ; @active_requests -= 1 ; log("request:#{link} success") }
c.on_failure{|curl,code| yield(false, curl.body_str) ; @active_requests -= 1 ; log("request:#{link} failure with curl code: #{code}") }
end )
# returns active request count
@active_requests += 1
@active_requests
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def run_request(method, url, body, headers); end",
"def request(*args, &block); end",
"def get_response(uri, req)\n Net::HTTP.start(uri.hostname, uri.port){|http| http.request(req) }\nend",
"def request(endpoint, request, &block); end",
"def make_get_request(uri)\n response = Net::HTTP.get_response(uri)\n response.is_a?(Net::HTTPSuccess) ? response.body : nil\nend",
"def detect_new_article_link(link)\n response = Net::HTTP.get_response(URI.parse(link))\n puts \"#{link}\"\n puts \"......response.code => #{response.code} \"\n response\nend",
"def do_request url\n Nokogiri::HTML(HTTParty.get(url))\nend",
"def xml_http_request?; end",
"def get_response(url)\n uri = URI(url)\n Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|\n request = Net::HTTP::Get.new uri\n return http.request(request).body\n end\nend",
"def external_request(uri)\n require 'uri'\n require 'net/http'\n\n res = Net::HTTP.get_response(URI(uri))\n res.is_a?(Net::HTTPSuccess) ? (res.body || '{}') : nil\n rescue\n nil\n end",
"def issue_from_link(link)\n uri = URI.parse(link)\n http = Net::HTTP.new(uri.host)\n response = http.get(uri.path)\n if response.code == '200'\n return response.body.dup\n else\n return nil\n end\n end",
"def parse(uri, response, body); end",
"def fetch_url(https,req)\n res = https.request(req)\n case res\n when Net::HTTPSuccess\n answer=JSON.parse(res.body)\n return answer\n else\n puts \"HTTP Error #{res.code} calling #{https}\"\n res.error!\n end\nend",
"def send_request; end",
"def make_request(url,headers,query)\n c = HTTPClient.new\n c.get_content(url,query,headers)\nend",
"def http_get_direct(url)\n log(\"http get : #{url}\") if $opt[\"debug\"]\n begin\n html = Net::HTTP.get_response(URI.parse(url)).body\n # XXX must fix the rescue its not working\n rescue => err\n log(\"Error: #{err}\")\n exit 2\n end\n html\nend",
"def http_call(payload); end",
"def get(url)\n uri = URI.parse(url)\n response = nil\n opt = {:use_ssl => true}\n #start(address, port=nil, p_addr=nil, p_port=nil, p_user=nil, p_pass=nil, opt, &block)\n Net::HTTP.start(uri.host, uri.port, p_addr=nil, p_port=nil, p_user=nil, p_pass=nil, opt) { |http|\n request = Net::HTTP::Get.new uri\n request['Referer'] = REFERER\n response = http.request request # Net::HTTPResponse object\n }\n return response\nend",
"def do_request(request, want_reply, data); end",
"def make_http_request\n Net::HTTP.get_response('localhost', '/ping', 3000).body\nend",
"def net_http_res; end",
"def send_request(method, params, &block); end",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n\n begin\n response = site.get(:accept=>\"application/json\")\n # puts \"URL response: #{response}\"\n return JSON.parse(response)\n rescue => e\n e.response\n return nil\n end\nend",
"def get(url); end",
"def request(method, path, parameters = {}, second_try = false)\n puts convert_body(parameters)\n response = send(method, path, convert_body(parameters), \"Content-Type\" => content_type) \n\n if response.code.to_i / 100 == 2\n result = Hash.from_xml(response.body)\n elsif response.code == \"302\" && !second_try\n connect!(@url, !@use_ssl)\n request(path, parameters, true)\n else\n raise \"#{response.message} (#{response.code})\"\n end\n end",
"def http; end",
"def send_request(req); end",
"def perform(request, response); end",
"def send_url(url)\n # debug - puts \"trying #{url}\"\n result = JSON.parse(URI.parse(url).read)\n puts \"#{result['status']} #{result['message']}\" if result['status'] == 'ERROR'\nend",
"def read_http(url)\n uri = URI(url)\n Net::HTTP.get_response(uri)\nend",
"def read_http(url)\n uri = URI(url)\n Net::HTTP.get_response(uri)\nend",
"def execute_call_plain(url)\n res = Net::HTTP.get_response(URI.parse(url))\n case res\n when Net::HTTPRedirection\n # Return the new URL\n res['location']\n when Net::HTTPSuccess\n res.body\n else\n raise TransportError.new(res)\n end\n end",
"def fetch_link(uri)\n\tr = rand(3)\n\tsleep(0.5)\n\ta = Mechanize.new {\t|agent|\n\t\tagent.user_agent_alias = 'Mac Safari'\n\t}\n\tpage = a.get(uri)\n\t#\tputs page.body\n\treturn page.body\nend",
"def check_response(response)\n case response\n when Net::HTTPSuccess then\n #puts response\n when Net::HTTPRedirection then\n location = response['location']\n warn \"redirected to #{location}\"\n fetch(location, limit - 1)\n else\n puts response.value\n end\nend",
"def request(path, parameters = {}, second_try = false)\n response = post(path, convert_body(parameters), \"Content-Type\" => content_type)\n \n if DEBUG\n puts \"Reponse:\"\n puts response.body\n end\n \n if response.code.to_i / 100 == 2\n result = XmlSimple.xml_in(response.body, 'keeproot' => true,\n 'contentkey' => '__content__', 'forcecontent' => true)\n typecast_value(result)\n elsif response.code == \"302\" && !second_try\n connect!(@url, !@use_ssl)\n request(path, parameters, true)\n else\n raise \"#{response.message} (#{response.code})\"\n end\n end",
"def getResponse url\n code = \"\"\n body = \"\"\n while code != \"200\" or body.include? \"DOCTYPE HTML\" \n begin\n uriList = URI.parse(url)\n http = Net::HTTP.new(uriList.host,uriList.port)\n http.read_timeout = 500\n request = Net::HTTP::Get.new(uriList.request_uri)\n response = http.request(request)\n code = response.code.to_s\n body = response.body.to_s\n rescue\n puts \"Problem with the Connection !\"\n puts \"Will wait 25 before retry .. \"\n sleep 25\n retry\n end\n end\n return body\nend",
"def send_get(url)\r\n result = @client.get(self.target_uri(url))\r\n raise \"Invalid status #{result.http_status} from server #{@host}:#{@port}\" if(result.http_status != '200')\r\n if block_given?\r\n yield(result.http_body)\r\n else\r\n result.http_body\r\n end\r\n end",
"def do_request(request, response)\n body = make_request(request)\n\n # Always 200. A simplification, but fine for user\n # error messages.\n response.status = 200\n response['Content-Type'] = 'text/html' \n response.body = body\n end",
"def consume_url; end",
"def get_link(link,args={})\n link = BASE_URL + link\n get_request(link,args)\n end",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def check_http_status(href)\n url = href.split(\".com/\")\n response = nil\n Net::HTTP.start(url[0].split(\"https://\").last + \".com\", 80) {|http|\n response = http.head(\"/\" + url[1])\n }\n if(response.code != \"200\")\n fail(href + \" returned code: \" + response.code)\n end\nend",
"def should_open?(url, &block)\n resp = Net::HTTP.get_response(URI(url))\n case resp\n when Net::HTTPRedirection\n location = resp['location']\n puts \"Redirecting #{url} to #{location}\"\n should_open?(location) { |resp1| block.call(resp1) }\n when Net::HTTPSuccess\n block.call(resp)\n when Net::HTTPNotFound\n false\n else\n p url\n p resp.code\n false\n end\nend",
"def doPost(url)\n init\n checkHTTP(url)\n display\nend",
"def do_get url\n\t\turi = URI.parse(url)\n\t\tNet::HTTP.get_response(uri)\n\tend",
"def fetchURL(url)\n open(url) {|response| response.read}\nend",
"def check_package (url)\n Net::HTTP.start('dl.iuscommunity.org') do |http|\n http.open_timeout = 2\n http.read_timeout = 2\n http.head(url).code == '200'\n end\nend",
"def request_url url \n response = RestClient::Request.execute(method: :get, url: url, timeout: 500 , user_agent: \"Mozilla/5.0 (Linux; U; Android 6.0.1; zh-CN; HUAWEI RIO-AL00 Build/HuaweiRIO-AL00) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/40.0.2214.89 UCBrowser/11.4.5.937 Mobile Safari/537.36\" )\nend",
"def get_response(url)\n\t\t\t\t\t\tres_flag = false\n\t\t\t\t\t\t\t\tresponse = RestClient.get(url){|response, request, result| response \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tif response.code != 200\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tputs response.code\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tres_flag = true\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tputs \"Skipped due to #{response.code}\"\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tend\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\treturn res_flag\nend",
"def follow_get_redirection(&block); end",
"def make_request(request, error)\n # URI request with timeouts\n uri = URI.parse(\"https://derpiboo.ru/#{request}\")\n http = Net::HTTP.new(uri.host, uri.port)\n http.open_timeout = 10\n http.read_timeout = 20\n http.use_ssl = true\n attempts = 1\n # Limit attempts so we dont annoy Derpibooru too badly\n response = nil\n while (attempts < 4) && response.nil?\n begin\n response = http.request_get(uri.request_uri)\n rescue\n sleep(attempts * 2)\n attempts += 1\n end\n end\n\n if response\n return JSON.parse(response.body)\n else\n error = \"Could not get a response from Derpibooru. Wait a few minutes and try again.\"\n return nil\n end\n end",
"def request_success(packet); end",
"def get_url(url)\n myurl = URI.parse(url)\n req = Net::HTTP::Get.new(url)\n res = Net::HTTP.start(myurl.host, myurl.port) { |http|\n http.request(req)\n }\n \n res.body # return\n end",
"def response\n @response ||= Net::HTTP.new(uri.host).request(request)\n end",
"def request(path, parameters = {}, second_try = false)\n method = parameters.delete(:method) || :put\n @response = make_request(method, path, parameters)\n\n if success?\n return true if response.body.to_s.strip.empty?\n result = XmlSimple.xml_in(response.body, 'keeproot' => true,\n 'contentkey' => '__content__', 'forcecontent' => true)\n typecast_value(result)\n elsif try_again && code == 302 && !second_try\n begin\n connect!(!@connection.use_ssl)\n request(path, parameters, true)\n rescue Errno::ECONNREFUSED\n raise WebServiceRequesterError, \"Error occured (#{code}): #{response.body}\"\n end\n else\n raise WebServiceRequesterError, \"Error occured (#{code}): #{response.body}\"\n end\n end",
"def doc(response)\n Nokogiri::HTML(response.body) #selectionne le tag body de la reponse\nend",
"def on_success(&block); end",
"def request(method, request_uri, long_url)\n Net::HTTP.start(@uri.host, @uri.port) do |http|\n headers = { 'Content-Type' => 'text/plain' }\n response = http.send_request(method, request_uri, long_url, headers)\n process_response(response)\n end\n end",
"def http_request(host)\n begin\n response = Nokogiri::HTML(open(\"http:\\/\\/bleed-1161785939.us-east-1.elb.amazonaws.com\\/bleed\\/#{host}\"))\n display_result(response, host)\n rescue\n puts \"[-] #{host}: Issues connecting to site\"\n end\nend",
"def request(*args); end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request; end",
"def request_successful(response)\n\t\tresponse.code == \"200\"\n\tend",
"def get_content\n send_get_content(url)\n end",
"def makeRequest(url)\n uri = URI.parse(url)\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n request = Net::HTTP::Get.new(uri.request_uri)\n\n r = http.request(request)\n return r\nend",
"def requestHelper(url, method = 'Get', body = nil)\n\n # Set header value\n header = {\n 'Content-Type': 'text/json',\n 'Content-Security-Policy': 'default-src *'\n }\n\n # Set the uri value based on the url sent through.\n uri = URI(url)\n # Format request\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n\n # Create new request based on method\n request = Net::HTTP.const_get(method.capitalize).new(uri.request_uri, header)\n request.body = body\n\n # Send the request\n http.request(request) do |response|\n puts uri\n yield(JSON.parse(response.body))\n end\n end",
"def request(url, options)\n\t\tmy_url = URI.parse(URI.encode(url))\n\n\t\tbegin\n\t\t\tmy_url = URI.parse(url)\n\t\trescue URI::InvalidURIError\n\t\t\tmy_url = URI.parse(URI.encode(url))\n\t\tend\n\nstart_time = Time.now\n\t\tproxy_host = 'ubio.cnio.es'\n\t\tproxy_port = 3128\n\t\treq = Net::HTTP::Get.new(my_url.request_uri)\n#\t\tres = Net::HTTP.start(my_url.host, my_url.port, proxy_host, proxy_port) { |http|\n\t\tres = Net::HTTP.start(my_url.host, my_url.port) { |http|\n\t\t\thttp.request(req)\n\t\t}\n\n\n\n\t\t#http_session = proxy.new(my_url.host, my_url.port)\n\t\t#\n\t\t#res = nil\n\t\t#proxy.new(my_url.host, my_url.port).start { |http|\n\t\t#Net::HTTP::Proxy(proxy_host, proxy_port).start(my_url.host) { |http|\n\t\t#\treq = Net::HTTP::Get.new(my_url.request_uri)\n\t\t#\tres, data = http.request(req)\n\t\t#\n\t\t#\tputs \"shitting data: #{data}\\n\"\n\t\t#\tputs \"res.code: #{res.code}\\n\"\n\t\t#}\n\t\t#\n\t\t#\n\t\t#res = Net::HTTP.start(my_url.host, my_url.port) { |http|\n\t\t#\treq = Net::HTTP::Get.new(my_url.request_uri)\n\t\t#\thttp.request(req)\n\t\t#}\n\n\n#end_time = Time.now\n#elapsed_time = (end_time - start_time) * 1000\n#puts \"***=> Time elapsed for #{url}: #{elapsed_time} ms\\n\"\n#\n#puts \"response code: #{res ? res.code: 'res not available here'}\"\n\n\t\tres\n\tend",
"def respond(link, url)\n case params['format']\n # Handle format = html\n when 'html'\n return haml :main, locals: { link: link }\n # Handle format = image\n when 'image'\n link.sub!('https://', 'http://')\n uri = URI(link)\n\n head = Net::HTTP.start(uri.host, uri.port) do |http|\n http.head(uri.request_uri)\n end\n\n headers 'Content-Type' => 'image/jpeg'\n headers 'Cache-Control' => 'max-age=2592000, no-transform, public'\n headers 'Expires' => 'Thu, 29 Sep 2022 01:22:54 GMT+00:00'\n\n return stream do |out|\n Net::HTTP.get_response(uri) do |f|\n f.read_body { |ch| out << ch }\n end\n end\n # Handle no format or format = json.\n else\n content_type :json\n return JSONP({ link: link, website: url }) # JSONP is an alias for jsonp method\n end\nend",
"def request(type, path)\n response = connection.send(type) do |req|\n req.url path\n req.params[\"maxResult\"] = 1_000\n req.headers.merge! headers\n yield req if block_given?\n end\n\n raise KontaktIo::Error.classify(response.status) unless response.success?\n\n response\n end",
"def requestor(req, json = nil)\n res = Net::HTTP.start(@host, @port, {:use_ssl => true}) { |http|\n create_the_request(req, json, http)\n }\n unless res.kind_of?(Net::HTTPSuccess)\n # let rails and sinatra handle this or print out if using ruby i say if, elsif, else\n handle_error(req, res)\n end\n res\n end",
"def get_response_body\n uri = URI.parse(@url) #parse the url being passed in with 'URI.parse'\n response = Net::HTTP.get_response(uri) # 'GET' the response of the uri with 'Net::HTTP.get_resonse' and pass in the uri variable\n response.body #return the 'body' from the 'response' variable\n end",
"def proxy_google(path)\n res = Net::HTTP.start('www.google.com', 80) do |http|\n http.get path\n end\n res.body\nend",
"def response\n parse_request\n do_something\n put_response\n end",
"def read_https(url)\n response = nil\n uri = URI(url)\n \n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n http.start do |http|\n response = Net::HTTP.get_response(uri)\n end\n response\nend",
"def http_request(url, options = {})\n\t\t\treq = Net::HTTP::Get.new(url)\n\t\t\treq[\"user-agent\"] = \"Mozilla/5.0 Gecko/20070219 Firefox/2.0.0.2\" # ensure returns XML\n\t\t\treq[\"cookie\"] = \"cookieMenu=all; cookieLangId=\" + options[:lang] + \"; cookies=true;\"\n\t\t\t\n\t\t\treq[\"cookie\"] += options[:cookie] if options[:cookie]\n\t\t\t\n\t\t\turi = URI.parse(url)\n\t\t\t\n\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\n\t\t\tif (options[:secure])\n\t\t\t\tputs \"Secure authentication\" if options[:debug]\n\n\t\t\t\thttp.verify_mode = OpenSSL::SSL::VERIFY_NONE\n\t\t\t\thttp.use_ssl = true\n\t\t\tend\n\t\t \n\t\t\t\n\t\t\tbegin\n\t\t\t http.start do\n\t\t\t res = http.request req\n\t\t\t\t\t# response = res.body\n\t\t\t\t\t\n\t\t\t\t\ttries = 0\n\t\t\t\t\tresponse = case res\n\t\t\t\t\t\twhen Net::HTTPSuccess, Net::HTTPRedirection\n\t\t\t\t\t\t\tres.body\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\ttries += 1\n\t\t\t\t\t\t\tif tries > @@max_connection_tries\n\t\t\t\t\t\t\t\traise Wowr::Exceptions::NetworkTimeout.new('Timed out')\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tretry\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t end\n\t\t\trescue \n\t\t\t\traise Wowr::Exceptions::ServerDoesNotExist.new('Specified server at ' + url + ' does not exist.');\n\t\t\tend\n\t\tend",
"def process_request(uri)\n request = Net::HTTP::Get.new(uri)\n connection = Net::HTTP.start(uri.hostname, uri.port, use_ssl: https?(uri))\n\n connection\n .request(request)\n .tap(&method(:validate_response!))\n end",
"def http_request(url, options = {})\n\t\t\treq = Net::HTTP::Get.new(url)\n\t\t\treq[\"user-agent\"] = @@user_agent # ensure returns XML\n\t\t\treq[\"cookie\"] = \"cookieMenu=all; cookieLangId=\" + options[:lang] + \"; cookies=true;\"\n\t\t\t\n\t\t\treq[\"cookie\"] += options[:cookie] if options[:cookie]\n\n\t\t\turi = URI.parse(URI.escape(url))\n\t\t\t\n\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\n\t\t\tif (options[:secure])\n\t\t\t\tputs \"Secure authentication\" if options[:debug]\n\n\t\t\t\thttp.verify_mode = OpenSSL::SSL::VERIFY_NONE\n\t\t\t\thttp.use_ssl = true\n\t\t\tend\n\t\t \n\t\t\t\n\t\t\tbegin\n\t\t\t\ttries = 0\n\t\t\t http.start do\n\t\t\t\t puts \"Get URL \"+ url if options[:debug]\n\t\t\t res = http.request req\n\t\t\t\t\t# response = res.body\n\t\t\t\t\t\n\t\t\t\t\t# FIXME WoW Armory rate limiter. Simple version\n\t\t\t\t\t# Needs to work across instances and not sleep for 1.5 if the\n\t\t\t\t\t# request took more than 1.5\n\t\t\t\t\t# just need a 1.5 second wait until the start of the next request\n \n if options[:rate_limit]\n\t\t\t\t\t puts \"Sleeping for 1.5 seconds\" if options[:debug]\n \t\t\t\t\tsleep 1.5\n\t\t\t\t\tend\n\n\t\t\t\t\tresponse = case res\n\t\t\t\t\t\twhen Net::HTTPSuccess, Net::HTTPRedirection\n\t\t\t\t\t\t\tres.body\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\ttries += 1\n\t\t\t\t\t\t\tif tries > @@max_connection_tries\n\t\t\t\t\t\t\t\traise Wowr::Exceptions::NetworkTimeout.new('Timed out')\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tredo\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t end\n\t\t\trescue Timeout::Error => e\n raise Wowr::Exceptions::NetworkTimeout.new('Timed out - Timeout::Error Exception')\n\t\t\trescue SocketError, Net::HTTPExceptions => e\n\t\t\t\traise Wowr::Exceptions::ServerDoesNotExist.new('Specified server at ' + url + ' does not exist.')\n\t\t\tend\n\t\tend",
"def url_test\n response = HTTParty.get('http://www.baidu.com')\n res = Rack::Response.new\n res.write response.body\n res.finish\n end",
"def request(uri, request = nil)\n # TODO: Possibly use SAX parsing for large request bodies (?)\n\n request ||= Net::HTTP::Get.new(uri.request_uri)\n\n connection.request(uri, sign(uri, request)) do |response|\n case response\n when Net::HTTPNotFound\n return nil\n\n when Net::HTTPSuccess\n if block_given?\n yield(response)\n else\n return response.body\n end\n\n else\n raise Error.from_xml(response.body)\n\n end\n end\n end",
"def perform_awsdirect_request(uri, body)\n res = nil\n req = get_abs_post_request(uri)\n\n if req\n req.body = body\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n http.read_timeout = 120\n\n puts \"sending request body:\"\n puts body\n puts \"to uri: #{uri}\"\n puts\n\n res = http.request(req)\n puts \"response code: #{res.code}\" unless res.nil?\n puts \"response body: #{res.body}\" unless res.nil?\n puts\n else\n puts \"Unable to complete the specified ABS request\"\n end\n\n res\n end",
"def http_peek(url)\n @log.debug \"http_peek... #{url}\"\n uri = Addressable::URI.parse url\n if uri.port\n http = Net::HTTP.new(uri.host, uri.port)\n else\n http = Net::HTTP.new(uri.host,\n Addressable::URI.port_mapping[uri.scheme])\n end\n http.open_timeout = 5\n\n # Unfortunately the net/http(s) API can't seem to do this for us,\n # even if we require net/https from the beginning (ruby 1.8)\n if uri.scheme == \"https\"\n require 'net/https'\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n end\n\n if bot.config[\"log_level\"] == \"debug\"\n http.set_debug_output $stderr\n end\n\n begin\n res = http.start { |http|\n @log.debug \"http.start, http object: \" + \n PP.singleline_pp(http, '')\n req = Net::HTTP::Get.new(uri.request_uri,\n { 'User-Agent' => 'campfire-bot/20110709 ' +\n '(x86_64-unknown-linux-gnu) ruby-stdlib-net/1.8.7' })\n\n if uri.user != nil && uri.user != \"\" &&\n uri.password != nil && uri.password != \"\"\n req.basic_auth uri.user, uri.password\n end\n\n response = http.request req\n @log.debug \"http.start, response: \" + \n PP.singleline_pp(response, '')\n response\n }\n\n rescue Exception => e\n @log.error \"Exception... #{e.class.name}, #{e.message}\"\n end\n\n case res\n when Net::HTTPRedirection\n uri.merge({ :host => res.header['Location'] })\n @log.debug \"following HTTPRedirection... res: #{res}, uri: \" +\n \"#{uri.omit(:user, :password)}, header: #{res.header['Location']}\"\n [res.header['Location'], res]\n\n else # Net::HTTPSuccess or error\n @log.debug \"proper non-redirected location... res: #{res}, uri: #{uri.omit(:user, :password)}\"\n [url, res]\n end\n end",
"def request(url,token = nil)\n url = URI(\"#{url}&api_key=#{token}\") # se quita uri y parentesis\n #puts url_string\n \n \n https = Net::HTTP.new(url.host, url.port)\n https.use_ssl = true\n request = Net::HTTP::Get.new(url)\n response = https.request(request)\n data = JSON.parse(response.read_body)\n #puts data\nend",
"def request (addrs)\n\t\turi = URI.parse(addrs) rescue addrs\n\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\tif addrs.index('https').nil? == false # it is an secure connection\n\t\t\thttp.use_ssl = true\n\t\tend\n#\t\thttp.verify_mode = OpenSSL::SSL::VERIFY_NONE # read into this\n\t\treq = Net::HTTP::Get.new(uri.request_uri)\n\t\tbegin\n\t\t\tresponse = Timeout::timeout(TIMEOUT) {\n\t\t\t\thttp.request(req)\n\t\t\t}\n\t\trescue Timeout::Error => exc\n\t\t\t@requestErrMsg = \"ERROR: #{exc.message}\"\n\t\t\tputs \"#{@requestErrMsg}\"\n\t\t\t-1\n\n\t\trescue Errno::ETIMEDOUT => exc\n\t\t\t@requestErrMsg = \"ERROR: #{exc.message}\"\n\t\t\tputs \"#{@requestErrMsg}\"\n\t\t\t-2\n\n\t\trescue Errno::ECONNREFUSED => exc\n\t\t\t@requestErrMsg = \"ERROR: #{exc.message}\"\n\t\t\tputs \"#{@requestErrMsg}\"\n\t\t\t-3\n\n\t\telse\n\t\t\t# puts \"Response is...\"\n\t\t\t# puts response.code.to_i\n\t\t\tresponse\n\t\tend\n\tend",
"def get_content(mid)\r\n uri = URI.parse(\"https://www.googleapis.com/freebase/v1/rdf/\" << mid)\r\n http = Net::HTTP.new(uri.host, uri.port)\r\n http.use_ssl = true\r\n http.verify_mode = OpenSSL::SSL::VERIFY_PEER\r\n request = Net::HTTP::Get.new(uri.request_uri)\r\n response = http.request(request)\r\n if response.code == \"403\"\r\n response.code \r\n else\r\n response.body\r\n end\r\nend",
"def http_get(request_uri)\n response = http.request(Net::HTTP::Get.new(request_uri))\n yield response.body if response.code == \"200\"\n end",
"def request(url,via = :get, &block)\n req = Request.new(url,via)\n yield req if block_given?\n req\n end",
"def fetch_process(uri)\n case r = fetch(uri)\n when Net::HTTPSuccess\n process_result(r.body)\n else\n r.error!\n end\nend",
"def perform_api_request(query) \n request = Net::HTTP::Post.new( \n $url.path + ($url.query != nil ? (\"?\" + $url.query) : \"\"), \n initheader = {\"Content-Type\" => \"application/json\", \n \"X-Replicon-Security-Context\" => \"User\"}) \n request.basic_auth($companyKey + \"\\\\\" + $loginname, $password) \n request.body = JSON.generate(query) \n \n server = Net::HTTP.new($url.host, $url.port) \n server.use_ssl = $url.scheme == \"https\" \n response = server.start {|http| http.request(request)} \n \n http_code = response.code.to_i \n if http_code != 200 \n puts response.body \n raise \"Expected success code 200, but was #{http_code}\" \n end \n \n return JSON.parse(response.body) \nend",
"def nessus_request(uri, post_data)\n\t\t\tbody=nessus_http_request(uri, post_data)\n\t\t\t# puts response.body\n\t\t\tdocxml = REXML::Document.new(body)\n\t\t\tbegin\n\t\t\t\tstatus = docxml.root.elements['status'].text\n\t\t\trescue\n\t\t\t\tputs(\"Error connecting/logging to the server!\")\n\t\t\t\treturn\n\t\t\tend\n\t\t\tif status == \"OK\"\n\t\t\t\treturn docxml\n\t\t\telse\n\t\t\t\treturn ''\n\t\t\tend\n\t\tend",
"def fetch(url, headers = {accept: \"*/*\"}, user = \"\", pass=\"\") # got from course notes. It consists of a secure form of getting webpage content.\n response = RestClient::Request.execute({\n method: :get,\n url: url.to_s,\n user: user,\n password: pass,\n headers: headers})\n return response\n \n rescue RestClient::ExceptionWithResponse => e\n $stderr.puts e.inspect\n response = false\n return response # now we are returning 'False', and we will check that with an \\\"if\\\" statement in our main code\n rescue RestClient::Exception => e\n $stderr.puts e.inspect\n response = false\n return response # now we are returning 'False', and we will check that with an \\\"if\\\" statement in our main code\n rescue Exception => e\n $stderr.puts e.inspect\n response = false\n return response # now we are returning 'False', and we will check that with an \\\"if\\\" statement in our main code\nend"
] |
[
"0.6746118",
"0.6691358",
"0.65664744",
"0.656512",
"0.6539215",
"0.6491686",
"0.63756734",
"0.63609964",
"0.63474333",
"0.63073367",
"0.6291987",
"0.62752783",
"0.62700534",
"0.62659705",
"0.626111",
"0.62349266",
"0.6214002",
"0.6188199",
"0.61848915",
"0.61757624",
"0.6171481",
"0.61599016",
"0.61320657",
"0.6128603",
"0.6123476",
"0.6118966",
"0.6113175",
"0.60869133",
"0.6083282",
"0.6069883",
"0.6069883",
"0.605846",
"0.60466564",
"0.6037008",
"0.6031433",
"0.59991753",
"0.5977641",
"0.5972358",
"0.5968613",
"0.5959816",
"0.59217584",
"0.59217584",
"0.5920035",
"0.5915393",
"0.59016407",
"0.5900596",
"0.5870755",
"0.58680624",
"0.58677113",
"0.5861849",
"0.5843609",
"0.5839242",
"0.5838266",
"0.583459",
"0.5832439",
"0.58308226",
"0.5829197",
"0.58260036",
"0.58165056",
"0.5795531",
"0.5793241",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57863057",
"0.57847893",
"0.5781954",
"0.5771451",
"0.57679373",
"0.57657486",
"0.5761363",
"0.57556915",
"0.5751998",
"0.57509226",
"0.57367015",
"0.5735463",
"0.57339",
"0.57297087",
"0.5726192",
"0.57136613",
"0.57095313",
"0.5708688",
"0.5703608",
"0.5701491",
"0.569215",
"0.5687836",
"0.56852484",
"0.56779635",
"0.56779426",
"0.5673977",
"0.56658214",
"0.56632",
"0.5662774"
] |
0.7164632
|
0
|
c = Crawl::Extract.new(session, feed_obj, 'url..',Feed::Atom)
|
def initialize(dir_root,session, feed, feed_url, feed_klass)
@dir_root = dir_root
@post_cb = lambda{|p,fo| nil }
@feed_url = feed_url
@session = session
@feed_klass = feed_klass
@feed = feed
@dup_check = lambda{|ptitle,plink| false }
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_feed(url)\n source = URI.open(url, 'User-Agent' => 'Mozilla/5.0')\n feed = RSS::Parser.parse(source)\nend",
"def parse_by_rss_feed(url,rss_link_id)\n feeds = RssFeed::RssFeed.parse_rss_url(url)\n feeds.entries.each do |item|\n params = {\n :title => item.title,\n :description => ActionController::Base.helpers.strip_tags(item.description),\n :link => item.link,\n :author => item.author,\n :publication_date => item.published,\n :media_contents => (item.media_image ? [{:url => item.media_image}] : []),\n :media_description => item.media_description,\n :media_credit => item.media_credit,\n :keywords => (item.categories.present? ? item.categories.join(\",\") : \"\"),\n :rss_link_id => rss_link_id\n }\n f = Feed.new(params)\n if f.save\n activity = Activity.new({:action => \"Create\", :parent_id => rss_link_id, :parent_type => \"RssLink\", :data => params}) \n activity.save\n puts \"*\" * 50\n puts \"Title: \" + f.title + \" parsed and saved\"\n end\n end if feeds && feeds.entries\n end",
"def parse_feed\n feed = self.download_feed\n Nokogiri::XML(feed).xpath(\"//item\").map do |item|\n enclosure = item.xpath(\"enclosure\").first\n\n title = CGI::unescapeHTML(item.xpath(\"title\").text.chomp)\n publish_date = Time.parse(item.xpath(\"pubDate\").inner_html.chomp)\n type = enclosure ? enclosure[:type] : nil\n url = enclosure ? enclosure[:url] : nil\n Podcast.new title, publish_date, type, url, self\n end\n end",
"def fetch!\n parsed_feed = FeedNormalizer::FeedNormalizer.parse open(self.feed_url)\n \n self.update_attributes( :title => parsed_feed.title,\n :url => parsed_feed.url\n #:etag => parsed_feed.etag\n #:last_modified => parsed_feed.last_modified\n )\n \n parsed_feed.entries.each do |entry|\n self.entries.create(:url => entry.url,\n :title => entry.title,\n :author => entry.author,\n #:summary => entry.summary,\n :content => entry.content\n #:published => entry.published\n #:categories => entry.categories\n ) if !Entry.find_by_url(entry.url)\n end\n end",
"def parse_by_feedzirra(feed_text, src)\n if @src.uri =~ /citeulike/\n Feedzirra::Feed.add_common_feed_entry_element('dc:source', :as => :source)\n #Feedzirra::Feed.add_common_feed_entry_element('dc:creator', :as => :authors)\n Feedzirra::Feed.add_common_feed_entry_element('prism:publicationYear', :as => :pub_year)\n end\n feed_data = Feedzirra::Feed.parse feed_text\n #debugger\n feed_data.entries.map do|e|\n metadata = {}\n metadata[:author] = e.author if e.author\n #metadata[:author] = e.authors if e.respond_to?(:authors)\n metadata[:pub_year] = e.pub_year if e.respond_to?(:pub_year)\n metadata[:source] = e.source if e.respond_to?(:source)\n metadata[:tag_list] = e.categories.join(\",\") unless e.categories.blank?\n #debugger\n {:did=>(e.id || e.url), :title=>e.title,:content=>(e.content || e.summary),:basetime=>e.published, \n :metadata=>metadata, :uri=>e.url}\n end \n end",
"def parse_feed url=rss_url, now = Time.now\n\n options = {\n user_agent: 'Geolinguist Test',\n max_redirects: 2,\n compress: true\n }\n\n\n f = Feedjira::Feed.fetch_and_parse url, options\n if f.url != rss_url.sub(RSS_SUFFIX,'')\n self.base_url = f.url.sub(RSS_SUFFIX,'').sub(SUFFIX,'')\n url = rss_url\n save\n f = Feedjira::Feed.fetch_and_parse url, options\n end\n\n\n if f.last_modified.blank?\n save_and_update_last_fetched now if self.last_fetched.blank?\n return\n end\n if last_fetched.blank? || f.last_modified > last_fetched\n puts f.inspect\n f.entries.each do |entry|\n if last_fetched.blank? || last_fetched < entry.published\n self.total_entries += 1\n body = [entry.title,entry.summary].join(\"\\n\")\n matches = LanguageRecognizer.recognize body\n if matches.blank?\n self.no_matches += 1\n else\n matches.each {|match| self[match] += 1}\n end\n end\n end\n save_and_update_last_fetched now\n end\n end",
"def parse_feed_line line\n # Return [url, category, title]\n Feed.new(*line.split(' ', 3).map(&:strip))\nend",
"def initialize(item) \n\t\t\t@url = item.url\n @doc = Nokogiri::HTML(item.html)\n end",
"def initialize(*args)\n @url, @max_age, @feed_class, @entry_class, @title, @rss_feed_entries = args\n check_feed\n end",
"def scrape(url)\n html = ScraperWiki.scrape(url)\n doc = Nokogiri::HTML(html)\n doc.search('object').each do |object|\n obj = object['data']\n if obj\n puts obj\n ScraperWiki.save(['URL', 'SOURCE'], {'URL' => obj, 'SOURCE' => url})\n end\n end\nend",
"def scrape(url)\n html = ScraperWiki.scrape(url)\n doc = Nokogiri::HTML(html)\n doc.search('object').each do |object|\n obj = object['data']\n if obj\n puts obj\n ScraperWiki.save(['URL', 'SOURCE'], {'URL' => obj, 'SOURCE' => url})\n end\n end\nend",
"def crawl\n update_all_feeds\n fetch_and_store_articles\n end",
"def parse\n # fzout = Feedjira::Feed.parse(fetch)\n fzout = Feedjira::Feed.fetch_and_parse(@url)\n case fzout\n when Fixnum\n @success = false\n @code = fzout\n else\n @success = true\n @code = 200\n @fz_feed_parser = fzout\n @feed_type = fzout.class.to_s.demodulize.underscore\n end\n end",
"def initialize(feed, item)\n if (feed.feed_type == \"rss\")\n @feed_title = feed.channel.title\n @title = item.title\n @link = item.link\n @date = parse_time(item.date)\n @content = item.description\n @content = item.content_encoded if item.content_encoded\n @guid = item.guid.content\n @audio = nil\n if item.enclosure\n if item.enclosure.type == \"audio/mpeg\"\n @audio = item.enclosure.url\n elsif item.enclosure.type.start_with? \"image/\" # If there is an image in the enclosure\n unless @content.include? \"<img \" # and no images in the content\n # then include the enclosure image\n @content = \"<img src=\\\"#{item.enclosure.url}\\\" /><br/>\" + @content\n end\n end\n end\n elsif (feed.feed_type == \"atom\")\n @feed_title = feed.title.content\n @title = item.title.content\n @link = item.link.href\n if !item.published.nil?\n @date = parse_time(item.published.content)\n else\n @date = parse_time(item.updated.content)\n end\n if !item.content.nil?\n @content = CGI.unescapeHTML(item.content.to_s)\n else\n @content = CGI.unescapeHTML(item.summary.to_s)\n end\n @guid = item.id.to_s\n @audio = nil # TODO podcast support for Atom feeds?\n end\n end",
"def class_from_xml(xml)\n xml, feed_scheme, entry_scheme, feed_href, entry_href = xml_data(xml)\n if xml\n r = case feed_scheme\n when /#user$/\n case entry_scheme\n when /#album$/\n RubyPicasa::User.new(xml, self)\n when /#photo$/\n RubyPicasa::RecentPhotos.new(xml, self)\n else\n RubyPicasa::Search.new(xml, self)\n end\n when /#album$/\n RubyPicasa::Album.new(xml, self)\n when /#photo$/\n case entry_scheme\n when /#photo$/\n RubyPicasa::Search.new(xml, self)\n else\n if feed_href && (feed_href.starts_with? 'http://picasaweb.google.com/data/feed/api/all')\n RubyPicasa::Search.new(xml, self)\n else\n RubyPicasa::Photo.new(xml, self)\n end\n end\n end\n if r\n r.session = self\n r\n else\n raise RubyPicasa::PicasaError, \"Unknown feed type\\n feed: #{ feed_scheme }\\n entry: #{ entry_scheme }\"\n end\n end\n end",
"def extract_items(content)\n GnewsItemsExtractor.new.get_gnews_items(content)\nend",
"def scrape\n\t\turl = 'http://www.wsj.com/xml/rss/3_7455.xml'\n open(url) do |rss|\n \tfeed = RSS::Parser.parse(rss, false)\n puts \" \"\n puts \"*********************************\"\n \tputs \"Title: #{feed.channel.title}\"\n puts \"--------------------------------\"\n feed.items.each do |item|\n tags = tag_article(item.title.to_s)\n \tarticle = Article.new(title: item.title.to_s, \n summary: item.description.to_s.gsub(/\\\"/,''), \n link: item.link, \n date: item.pubDate.to_s.gsub(/,/,''),\n tag_list: tags, \n source: \"Wall Street Journal\")\n article.save\n end\n end\n end",
"def fetch\n options = {:on_success => method(:success), :on_failure => method(:failure), :timeout => 30}\n feed = Feedzirra::Feed.fetch_and_parse(self.feed_url, options)\n rescue Exception => e\n puts \"Failure fetching feed: #{e.message}\" \n end",
"def fetch(source)\n Feedjira::Feed.fetch_and_parse source\n end",
"def fetch\n feed_data = REXML::Document.new(open(@url, :proxy => true)).root\n parse(feed_data)\n end",
"def scrape\n\t\topen(@url) do |rss|\n\t\t\tfeed = RSS::Parser.parse(rss)\n\t\t\t@source_name = feed.channel.title\n\t\t\tfeed.items.each do |item|\n\t\t\t\tif date_valid?(item.pubDate) and item.title\n\t\t\t\t\tcreate_article(item.dc_creator, item.title, item.description,\\\n\t\t\t\t\t\t\"\", @source_name, item.pubDate.to_date, item.link)\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t@articles\n\tend",
"def scrape\r\n @article_arr = []\r\n\t\turl = 'http://feeds.news.com.au/heraldsun/rss/heraldsun_news_technology_2790.xml'\r\n open(url) do |rss|\r\n \tfeed = RSS::Parser.parse(rss, false)\r\n \tputs \"Title: #{feed.channel.title}\"\r\n puts \"*********************************\"\r\n puts \" \"\r\n feed.items.each do |item|\r\n \t@article_arr << HSArticle.new(author: \"nil\", title: item.title.to_s.gsub(/,/,' ').gsub(/\"/,' ').gsub(/'s/,'s').gsub(/'/, ''), \r\n summary: item.description.to_s.gsub(/,/,' ').gsub(/\\\"/,'\\'').gsub(/'s/,''), images: item.enclosure.url, source: item.link,\r\n date: item.pubDate.to_s.gsub(/,/,'').gsub(/\\\"/,'\\'').gsub(/'s/,''))\r\n end\r\n end\r\n @articles.concat(@article_arr)\r\n end",
"def get_feed(url, opts)\n\n opts.extra = Hash.new\n opts.extra[\"Connection\"] = \"close\"\n # some sites need User-Agent field\n opts.extra[\"User-Agent\"] = \"RSSClient/2.0.9\"\n\n # Ask for changes (get 304 code in response)\n # opts.since is Time::\n if not opts.forceUpdate and opts.since\n time = Time.parse(opts.since.to_s)\n opts.extra[\"If-Modified-Since\"] = time.httpdate() if time\n end\n\n begin\n @rssc_raw = get_url(url, opts)\n return nil unless @rssc_raw\n\n case @rssc_raw.status\n when 200 # good\n when 301, 302 # follow redirect ...\n @rssc_raw = get_url(@rssc_raw.header[\"Location\"], opts)\n return nil unless @rssc_raw\n\n when 304 # Not modified - nothing to do\n return nil\n\n # errors\n when 401\n raise RuntimeError, \"access denied, \" + @rssc_raw.header['WWW-Authenticate'].to_s\n when 404\n raise RuntimeError, \"feed [ #{url} ] not found\"\n else\n raise RuntimeError, \"can't fetch feed (unknown response code: #{@rssc_raw.status})\"\n end\n\n return nil unless @rssc_raw.content\n\n # Parse the raw RSS\n begin\n FeedNormalizer::FeedNormalizer.parse(@rssc_raw.content, :try_others => true)\n rescue NoMethodError\n # undefined method `channel' for #<RSS::Atom::Feed:0x9f03b70>\n # try a simpler parser ...\n FeedNormalizer::FeedNormalizer.parse(@rssc_raw.content,\n :try_others => true, :force_parser => FeedNormalizer::SimpleRssParser\n )\n end\n rescue RuntimeError => error\n @rssc_error = error\n return nil\n end \n end",
"def scrape\n articles = []\n url = 'http://feeds.news.com.au/heraldsun/rss/heraldsun_news_sport_2789.xml'\n\n open(url) do |rss|\n feed = RSS::Parser.parse(rss)\n feed.items.each do |item|\n articles << (interpret item)\n end\n end\n articles\n end",
"def parse_feed_url\n url = sanitize_url(self.url)\n Feedbag.find(url)[0]\n end",
"def scrape\n\t\topen(@url) do |rss|\n\t\t\tfeed = RSS::Parser.parse(rss)\n\t\t\tfeed.items.each do |item|\n\t\t\t\tif date_valid?(item.pubDate) and item.title\n\t\t\t\t\tcreate_article(@default_author, item.title, item.description,\\\n\t\t\t\t\t\t\"\", @source_name, item.pubDate.to_date, item.link)\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t@articles\n\tend",
"def fetch_channel(url)\n FeedTools::Feed.open(url)\n end",
"def run\n super\n\n uri = _get_entity_attribute \"name\"\n\n # Scanner options\n @opt_threads = _get_option(\"threads\").to_i\n @opt_max_pages = _get_option(\"max_pages\").to_i\n #@opt_user_agent = _get_option \"user_agent\"\n @opt_extract_uris = _get_option \"extract_uris\" # create an object for each page\n @opt_extract_dns_records = _get_option \"extract_dns_records\" # create an object for each dns_record\n @opt_extract_file_metadata = _get_option \"extract_file_metadata\" # create a Uri object for each page\n @opt_extract_patterns = _get_option(\"extract_patterns\").split(\",\") # only extract entities withthe following patterns\n\n crawl_and_extract(uri)\n\n end",
"def parse(feed_data)\n @hub_url = REXML::XPath.first(feed_data, 'link[@rel=\"hub\"]').attributes['href']\n @id = feed_data.elements['id'].text\n @title = feed_data.elements['title'].text\n @updated_at = Time.parse(feed_data.elements['updated'].text)\n @url = REXML::XPath.first(feed_data, 'link[@rel=\"self\"]').attributes['href']\n\n feed_data\n end",
"def parse_feed\n remove_previous_entries\n @items = @content[\"rss\"][\"channel\"][\"item\"]\n if !@items.nil?\n for item in @items do\n item[\"pubDate\"] ||= \"\"\n item[\"creator\"] ||= \"\"\n item[\"guid\"] ||= \"\"\n item[\"title\"] ||= \"\"\n item[\"description\"] ||= \"\"\n clean_content(item[\"encoded\"] ||= \"\")\n item[\"link\"] ||= \"\"\n params = { \n :pubdate => item[\"pubDate\"], \n :creator => item[\"creator\"], \n :guid => relative_link(item[\"guid\"]), \n :title => item[\"title\"], \n :description => item[\"description\"], \n :content => @content, \n :link => relative_link(item[\"link\"])\n }\n insert_entry(params)\n end\n end\n end",
"def scrape\n open(@url) do |rss|\n feed = RSS::Parser.parse(rss)\n\n feed.items.each do |item|\n # Remove the p tag and retrieve image url from the description\n # if it exists\n p_tag = item.description[%r{<p>.*</p>}]\n if p_tag\n item.description.slice! p_tag\n img_url = p_tag.match(/src=\"(?<img>[^\"]*)\"/)[:img]\n else\n img_url = nil\n end\n\n # Sanitize HTML\n item.title = CGI.unescapeHTML(item.title)\n item.description = CGI.unescapeHTML(item.description)\n\n @articles.push(\n title: item.title,\n summary: item.description,\n image_url: img_url,\n source: @source,\n url: item.link,\n pub_date: item.pubDate.to_s,\n guid: item.guid.content\n )\n end\n end\n end",
"def feed!\n http_fetch(feed_url)\n end",
"def feed\n @data.feed ||= parsed_document.xpath(\"//link\").select{ |link|\n link.attributes[\"type\"] && link.attributes[\"type\"].value =~ /(atom|rss)/\n }.map { |link|\n absolutify_url(link.attributes[\"href\"].value)\n }.first rescue nil\n end",
"def get_all_infos page, category\n list_items = page.search('.post')\n\n link = page.uri.to_s\n list_items.each_with_index{|item,index|\n # get all items in page -------------------\n content = item.at('.entry-content a').text\n author = item.at('.entry-author a').text\n record = {\n :category => category,\n :author => author,\n :conent => content\n }\n ScraperWiki.save_sqlite([], record)\n }\nend",
"def get_all_infos page, category\n list_items = page.search('.post')\n\n link = page.uri.to_s\n list_items.each_with_index{|item,index|\n # get all items in page -------------------\n content = item.at('.entry-content a').text\n author = item.at('.entry-author a').text\n record = {\n :category => category,\n :author => author,\n :conent => content\n }\n ScraperWiki.save_sqlite([], record)\n }\nend",
"def get_all_infos page, category\n list_items = page.search('.post')\n\n link = page.uri.to_s\n list_items.each_with_index{|item,index|\n # get all items in page -------------------\n content = item.at('.entry-content a').text\n author = item.at('.entry-author a').text\n record = {\n :category => category,\n :author => author,\n :conent => content\n }\n ScraperWiki.save_sqlite([], record)\n }\nend",
"def get_all_infos page, category\n list_items = page.search('.post')\n\n link = page.uri.to_s\n list_items.each_with_index{|item,index|\n # get all items in page -------------------\n content = item.at('.entry-content a').text\n author = item.at('.entry-author a').text\n record = {\n :category => category,\n :author => author,\n :conent => content\n }\n ScraperWiki.save_sqlite([], record)\n }\nend",
"def parse(content,browser=nil)\n\t\t\t@ret=Nokogiri::XML(content)\n\t\t\t@sniffed_type=sniff(@ret)\n\t\t\tcase @sniffed_type\n\t\t\twhen :acquisition then return OPDS::AcquisitionFeed.from_nokogiri(@ret,browser)\n\t\t\twhen :navigation then return OPDS::NavigationFeed.from_nokogiri(@ret,browser)\n\t\t\twhen :entry then return OPDS::Entry.from_nokogiri(@ret,nil,browser)\n\t\t\tend\n\t\tend",
"def scrape\n\t\topen(@url) do |rss|\n\t\t\tfeed = RSS::Parser.parse(rss)\n\t\t\t@source_name = feed.channel.title\n\t\t\tfeed.items.each do |item|\n\t\t\t\tif date_valid?(item.pubDate) and item.title\n\t\t\t\t\tcreate_article(get_author(item), item.title, item.description,\\\n\t\t\t\t\t\tget_images(item), @source_name, item.pubDate.to_date,\\\n\t\t\t\t\t\titem.link, get_image_length(item))\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t@articles\n\tend",
"def scraper\n blog.scraper\n end",
"def feed_item(list, title = @config[:title], identifier = '/feed/')\n Nanoc::Item.new(\n '<%= atom_feed(:articles => @item[:list]) %>',\n {:title => title, :extension => 'atom', :list => list},\n identifier\n )\nend",
"def parse(str)\n # Dirty hack: some feeds contain the & char. It must be changed to &\n str.gsub!(/&(\\s+)/, '&\\1')\n doc = REXML::Document.new(str)\n @xml = doc.root\n # get feed info\n @encoding = doc.encoding\n @title,@link,@description,@creator = nil\n @items = []\n if doc.root.elements['channel'] || doc.root.elements['rss:channel']\n @type = \"rss\"\n # We have a RSS feed!\n # Title\n if (e = doc.root.elements['channel/title'] ||\n doc.root.elements['rss:channel/rss:title']) && e.text\n @title = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!\n end\n # Link\n if (e = doc.root.elements['channel/link'] ||\n doc.root.elements['rss:channel/rss:link']) && e.text\n @link = e.text.rmWhiteSpace!\n end\n # Description\n if (e = doc.root.elements['channel/description'] || \n doc.root.elements['rss:channel/rss:description']) && e.text\n @description = e.text.toUTF8(@encoding).rmWhiteSpace!\n end\n # Creator\n if ((e = doc.root.elements['channel/dc:creator']) && e.text) ||\n ((e = doc.root.elements['channel/author'] ||\n doc.root.elements['rss:channel/rss:author']) && e.text)\n @creator = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!\n end\n # Items\n if doc.root.elements['channel/item']\n query = 'channel/item'\n elsif doc.root.elements['item']\n query = 'item'\n elsif doc.root.elements['rss:channel/rss:item']\n query = 'rss:channel/rss:item'\n else\n query = 'rss:item'\n end\n doc.root.each_element(query) { |e| @items << RSSItem::new(e, self) }\n\n elsif doc.root.elements['/feed']\n # We have an ATOM feed!\n @type = \"atom\"\n # Title\n if (e = doc.root.elements['/feed/title']) && e.text\n @title = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!\n end\n # Link\n doc.root.each_element('/feed/link') do |e|\n if e.attribute('type') and (\n e.attribute('type').value == 'text/html' or\n e.attribute('type').value == 'application/xhtml' or\n e.attribute('type').value == 'application/xhtml+xml')\n if (h = e.attribute('href')) && h\n @link = h.value.rmWhiteSpace!\n end\n end\n end\n # Description\n if e = doc.root.elements['/feed/info']\n e = e.elements['div'] || e\n @description = e.to_s.toUTF8(@encoding).rmWhiteSpace!\n end\n # Items\n doc.root.each_element('/feed/entry') do |e|\n @items << AtomItem::new(e, self)\n end\n else\n raise UnknownFeedTypeException::new\n end\n end",
"def search_and_fetch_jobs\n feed = RSS::Parser.parse(open(target_url_with_query))\n feed.items.take(10)\n end",
"def extract(file,myurl)\n STDERR.puts \"# Scanning: #{myurl} via file:#{file}\"\n doc=\"\"\n dct='http://purl.org/dc/terms/'\n # rdf = \"<dc:Document rdf:about='#{myurl}' xmlns:dc='http://purl.org/dc/terms/' xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\\n\"\n nt = ''\n File.read(file).each do |x| \n doc += x\n end\n doc.gsub!(/\\n/, \"\")\n doc.gsub!(/\\s+/, \" \")\n\n if (doc =~ /<title>\\s*([^<]*)\\s*<\\/title>/) \n # puts \"title: #{$1}\"\n t = $1\n t.gsub!(/\\s*$/,\"\")\n nt += \"<#{myurl}> <#{dct}title> \\\"#{t}\\\" . \\n\"\n end\n doc.scan(/<meta name=\"([^\"]*)\" con∫tent=\"([^\"]*)\"\\s*\\/>/) do\n p=$1\n v=$2\n p.downcase!\n puts \"#{p}: #{v}\" \n end\n doc.scan(/<div\\s+class=\"arr\">\\s*<a\\s+href=\"([^\"]*)\">\\s*([^<]*)\\s*<\\/a>\\s*<\\/div>/) do\n rt = $2\n rl = $1\n n = normal(file,rl)\n # puts \"# Starting dotfix with #{n}\"\n n = dotfix(n)\n n.chomp!\n nt += \"<#{myurl}> <#{dct}relation> <#{n}> .\\n\"\n rt.chomp!\n rt.gsub!(/\\s*$/,\"\")\n nt += \"<#{n}> <#{dct}title> \\\"#{rt}\\\" .\\n\"\n end\n puts \"\\n\"\n puts nt\nend",
"def parse_link; end",
"def fetch\n puts \"Fetching feed: #{self.feed_url}\"\n Feedzirra::Feed.add_common_feed_entry_element('georss:point', :as => :point)\n Feedzirra::Feed.add_common_feed_entry_element('geo:lat', :as => :geo_lat)\n Feedzirra::Feed.add_common_feed_entry_element('geo:long', :as => :geo_long)\n Feedzirra::Feed.add_common_feed_element('generator', :as => :generator)\n\n feed = Feedzirra::Feed.fetch_and_parse(self.feed_url)\n\n self.update_attributes(\n :title => feed.title,\n :url => feed.url,\n :description => feed.description,\n :generator => feed.generator,\n :last_fetched => DateTime.now\n )\n\n feed.entries.each do |e|\n \n if e.geo_lat && e.geo_long\n latlon = [e.geo_lat, e.geo_long]\n elsif e.point\n latlon = e.point.split(' ')\n else\n next\n end\n \n attrs = {\n :title => e.title,\n :url => e.url,\n :author => e.author,\n :summary => e.summary,\n :content => e.content,\n :published => e.published,\n :guid => e.id,\n :lon => latlon[1].to_f,\n :lat => latlon[0].to_f\n }\n \n # Create a new post or update an existing one\n post = Post.find_or_initialize_by_url(e.url)\n post.feed = self\n post.assign_attributes(attrs)\n post.save\n end\n end",
"def parse rss_item, index, proxy = nil, parse_desc = true\n item = FeedItem.new\n item.title = encoding(html_to_txt(rss_item.title), @encode)\n item.link = rss_item.link\n item.date = rss_item.date if rss_item.respond_to?(:date)\n item.date = rss_item.dc_date if rss_item.respond_to?(:dc_date)\n if parse_desc\n plugin = get_content_plugin(item.link)\n begin\n content_and_link = plugin.fetch rss_item, proxy\n rescue Exception => e\n unless plugin.instance_of? Rss::Plugin::DefaultContentPlugin\n log_info \"Can't parse #{item.link}! Reason: #{e.message} Try DefaultContentPlugin.\"\n content_and_link = get_default_plugin().fetch rss_item, proxy\n\t end\n\tend\n content = Nokogiri::HTML(content_and_link[:content])\n parsed = parse_html_and_download_images(content_and_link[:link], content, index, proxy)\n \titem.description = parse_description parsed[:doc], parsed[:images], index\n end\n item\n end",
"def get_new_articles\n # Download the RSS feed and save to self.doc\n get_source\n \n # Keep track of which articles are in the feed \n articles = []\n \n article_links = (self.doc/'li.mjItemMain').collect do |mjItem|\n mjItem.at('a.mjLinkItem')\n end\n \n # For each item in the RSS feed \n article_links.each_with_index do |link, index|\n \n # Create or update the article in the db\n articles << Article.factory(\n :category => self.category,\n :description => '',\n :feed => self,\n :url => \"http://online.wsj.com#{link.attributes['href']}\",\n :priority => index\n )\n end\n \n articles\n end",
"def process_feed(url, limit=200)\n rss = SimpleRSS.parse open(url)\n rss.items.each_with_index do |item, index|\n puts \"Parsing RSS item #{item.title}\"\n screenshoot(item.link, to_filename(item.title, IMG_FILENAME_SIZE))\n puts \"... donez\"\n puts \"\"\n break if index == limit-1\n end \nend",
"def parse(uri); end",
"def extract_video_page_urls(webpage,options)\r\n puts \"Extracting data from html5 data\"\r\n webpage.css('li.regularitem').each do |post|\r\n link = post.css('h4.itemtitle').css('a').first\r\n description = post.css('div.itemcontent').first.text\r\n download_episode(link.child.text,link['href'],description, options)\r\n end\r\nend",
"def index\n #body, ok = SuperfeedrEngine::Engine.retrieve(Feed.first) \n @entries = Entry.all\n end",
"def links_feed\n end",
"def fetch\n curl = build_curl_easy\n curl.perform\n feed = process_curl_response(curl)\n Feedtosis::Result.new(curl, feed)\n end",
"def read_atom_feed_for(avalon_id)\n\n end",
"def initialize(title, url) # from first scrape data initialize == Lifecycle method in Ruby\n @title = title\n @url = url\n @@all << self if @@all.none?(self)\n end",
"def generate_feed(title='Rails 程序测试指南', link='http://guides.ruby-china.org/testing.html',\n source = 'http://guides.ruby-china.org/testing.html', author='MasterQiu')\n feed = Feed.new\n feed.title = title\n feed.link=link\n feed.source = source\n feed.author = author\n return feed\n end",
"def crawl_url stylesheet_path, entity_type, url\n site = Site.new stylesheet_path\n details = site.style[entity_type].attributes\n details.url = url\n job = Job.new(entity_type, details, site.style, site.context) \n job.perform()\nend",
"def scrape\n @articles = []\n url = 'http://feeds.news.com.au/heraldsun/rss/heraldsun_news_technology_2790.xml'\n open(url) do |rss|\n feed = RSS::Parser.parse(rss, false)\n feed.items.each do |item|\n article = Article.create(title: item.title.to_s.tr('\"', '\\''),\n summary: item.description.to_s\n .gsub(/’/, '\\'').gsub(/\\\"/, '\\''),\n imageURL: item.enclosure.url,\n link: item.link,\n pubDate: DateTime.parse(item.pubDate.to_s),\n source: HSImporter.source_name)\n @articles << article\n end\n end\n @articles\n end",
"def initialize(url)\n download = open(url) # goes to the site and grabs stuff to be stored in download\n # Nokogiri is a class, here we're going insite it as if it was a folder # no @ because we're not saving it\n @html = Nokogiri::HTML(download) # translates the html so ruby can understand it, @ beccause we're saving it \n end",
"def init_atom_feed\n @atom_feed = \"#{params[:controller]}/feed\"\n end",
"def url_obj (url)\n url_1 = HTTParty.get(url)\n return Nokogiri::HTML(url_1)\nend",
"def newsfeed_feed_link\n $tracer.trace(__method__)\n return ToolTag.new(div.className(\"/tabs/\").a.at(0).innerText(\"/the feed/\"), __method__)\n end",
"def scrape\r\n @article_arr = []\r\n\t\turl = 'http://www.theage.com.au/rssheadlines/technology-news/article/rss.xml'\r\n open(url) do |rss|\r\n \tfeed = RSS::Parser.parse(rss, false)\r\n puts \" \"\r\n puts \"*********************************\"\r\n \tputs \"Title: #{feed.channel.title}\"\r\n puts \"--------------------------------\"\r\n feed.items.each do |item|\r\n \t@article_arr << AgeArticle.new(author: \"nil\", title: item.title.to_s.gsub(/,/,''), \r\n summary: (item.description).match(/\\<\\/p\\>[\\w ?,''\"\"]+/).to_s.gsub(/\\<\\/p\\>/,'').gsub(/,/,'').gsub(/\\\"/,''), \r\n images: (item.description).match(/http.+\\.(jpg|png)/), source: item.link, date: item.pubDate.to_s.gsub(/,/,''))\r\n end\r\n end\r\n @articles.concat(@article_arr)\r\n end",
"def find_feed\n @feed = @node.content\n end",
"def initialize(url)\n self.url = url\n self\n end",
"def full_parse\n self.href\n\n self.cache_object\n \n self.http_headers\n self.encoding\n self.feed_data_utf_8\n self.xml_document\n self.root_node\n self.channel_node\n \n self.base_uri\n self.feed_type\n self.feed_version\n\n self.entries\n\n self.id\n self.title\n self.subtitle\n self.links\n self.link\n self.icon\n self.favicon\n self.author\n self.publisher\n self.time\n self.updated\n self.published\n self.categories\n self.images\n self.rights\n self.time_to_live\n self.generator\n self.language\n\n self.docs\n self.text_input\n self.cloud\n\n self.itunes_summary\n self.itunes_subtitle\n self.itunes_author\n\n self.media_text\n\n self.explicit?\n \n self.entries.each do |entry|\n entry.full_parse()\n end\n\n nil\n end",
"def initialize feed_uri = nil, http = Atom::HTTP.new\n @entries = []\n @http = http\n\n if feed_uri\n @uri = feed_uri.to_uri\n self.base = feed_uri\n end\n\n super()\n end",
"def feed\n @feed ||= (parsed_feed('rss') || parsed_feed('atom'))\n end",
"def feed\n @feed ||= (parsed_feed('rss') || parsed_feed('atom'))\n end",
"def fetch\n response = get_request\n # Permanent redirects should get pushed up into the feed.\n request.parse_response(response)\n request\n end",
"def initialize(item, stream = nil)\n @stream = stream\n @feed = Greedy::Feed.new(item['origin'])\n \n @author = normalize item['author'] \n @google_item_id = item['id']\n @published = item['published']\n @updated = item['updated']\n \n set_body!(item)\n set_title!(item)\n set_href!(item)\n end",
"def scrape\n end",
"def initialize(html)\n url = html.scan(/http:\\/\\/pastie.org\\/pastes\\/([\\d]{1,})\\/text(\\?key=([A-Za-z\\d]{1,}))?/)\n unless url.nil?\n url.flatten!\n @id = url[0] ; @key = url[2]\n @content = Request.fetch(raw_link)\n else\n raise 'Invalid html!'\n end\n end",
"def rss_entries(url)\n\t\tresponse = fetch(url)\n\t\tresponse[\"feed\"][\"entry\"]\n\tend",
"def scrape_page\n self.url = page.url # gives a resolved url\n self.title = page.title\n self.description = page.description\n end",
"def fetch(url)\n options = {\n :timeout => 10\n }\n begin\n $logger.info(\"Fetching Feed #{url}\")\n feed = Feedjira::Feed.fetch_and_parse(url, options)\n rescue\n # error with Feedjira Feed\n $logger.error \"Fetch failure\"\n return nil\n end\n\n begin\n $logger.info \"Sanitizing\"\n feed.sanitize_entries!\n rescue\n $logger.error \"Problem sanitizing feed from #{url}. proceeding with nil.\" \n return nil\n end\n\n feed\n end",
"def fetch_feed\n endpoint = @current_feed.values.first\n\n begin\n document = SimpleRSS.parse(URI.open(endpoint, 'User-Agent' => 'Ruby-wget'))\n rescue StandardError => e\n puts \"Error: <#{e}> while trying to call <#{@current_feed_link}>\"\n # effectively skip document\n document = { title: Rss::NO_VALUE, items: {} }\n end\n\n # Ensuring string access instead of symbol access.\n # I know there's probably a better way to do this...\n # but I can't remember if with_indifferent_access is\n # a rails thing...\n @cache[@current_feed.keys.first] = JSON.parse(document.items.to_json)\n end",
"def get_rss_feed( rss_url )\n\t\tfeed = false\n\t\tuntil feed.class == Feedzirra::Parser::RSS\n\t\t\tfeed = Feedzirra::Feed.fetch_and_parse( rss_url )\n\t\tend\n\t\tfeed\n\tend",
"def scrap_data_from_page link\n p link\n page = @agent.get(link)\n\n # get all categories\n get_items_with_all_category(page)\nend",
"def scrap_data_from_page link\n p link\n page = @agent.get(link)\n\n # get all categories\n get_items_with_all_category(page)\nend",
"def scrap_data_from_page link\n p link\n page = @agent.get(link)\n\n # get all categories\n get_items_with_all_category(page)\nend",
"def scrap_data_from_page link\n p link\n page = @agent.get(link)\n\n # get all categories\n get_items_with_all_category(page)\nend",
"def update_from_feed(feed_url)\n\t\tputs \"pulling feeds\"\n\t\tfeed = Feedzirra::Feed.fetch_and_parse(feed_url)\n\t\t# feed.last_modified - if it's been modified since last time\n\t\tfeed.entries.each do |entry|\n\t\t\t# if the post occured after it was last checked\n\t\t\tfind_keywords(entry.url)\n\t\t\tputs entry.url\n\t\t\t# call the keyword check and save on the actual post url\t\n\t\tend\nend",
"def get_feed(feed_url = nil)\n unless feed_url.blank?\n # trim the url element\n feed_url.strip!\n begin\n feed = Atom::Feed.load_feed(URI.parse(feed_url))\n rescue\n feed = nil\n end\n feed\n end\n end",
"def update_from_feed()\n\t\t\n\t@links = Link.all \n\n\t@links.each do |link| \n\n\t\tfeed = Feedzirra::Feed.fetch_and_parse(link.url)\n\n\t\tputs \"pulling feeds\"\n\t\tfeed.entries.each do |entry|\n\n\t\t\tif entry.published > link.updated_at\n\n\t\t\t\tif entry.url =~ /^#{URI::regexp}$/\n\t\t\t\t\tfind_keywords(entry.url, link.tags)\n\t\t\t\t\tputs entry.url\t\n\t\t\t\telse\n\t\t\t\t\tputs \"bad url\"\n\t\t\t\t\tputs entry.url\t\n\t\t\t\tend\n\t\t\t\t\t\n\t\t\tend\n\t\tend\n\n\tend\n\nend",
"def fetch_articles\n current_feed = get_rss_feed( self.url )\n current_feed.entries.each do |article|\n unless self.array_of_article_urls.include?(article.url)\n a = Article.new(title: article.title, url: article.url, clicks: 0)\n a.title ||= article.summary\n self.articles.push a \n end\n end\n\tend",
"def run\n scraper = ThreatDetector::Scraper.new options\n\n fetch_feeds.map do |item|\n next unless valid_feed?(item)\n\n scraper.for(item['name'], item['url'])\n scraper.parse_and_save_entries\n\n yield(item, scraper) if block_given?\n item.slice('name', 'url', 'source')\n end.compact\n end",
"def initialize(url)\n @picuki_page = Nokogiri::XML(URI.open(url))\n end",
"def initialize(url)\n @url = url\n end",
"def fetch_url(body)\n aux = body.split('<link>').last\n aux = aux.split('<pubdate>').first\n aux\n end",
"def parse_by_feednormalizer(feed_text)\n feed_data = FeedNormalizer::FeedNormalizer.parse feed_text\n feed_data.entries.map do|e|\n metadata = {:author => e.author} if e.author\n {:did=>(e.id || e.urls.join(\" \")), :title=>e.title,:content=>e.content,:basetime=>e.date_published, \n :metadata=>metadata, :uri=>e.urls.join(\" \"), :tag_list=>e.categories.join(\",\")}\n end\n end",
"def read\n begin\n Feedjira::Feed.fetch_and_parse(@url)\n rescue\n false\n end\n end",
"def fetch_by_issn(issn)\r\n xml = fetch_xml(issn)\r\n\r\n\r\n results = BentoSearch::Results.new.concat(\r\n xml.xpath(\"./rdf:RDF/rss:item\", xml_ns).collect do |node|\r\n item = BentoSearch::ResultItem.new\r\n\r\n item.format = \"Article\"\r\n\r\n item.issn = issn # one we searched with, we know that!\r\n\r\n item.title = xml_text(node, \"rss:title\")\r\n item.link = xml_text(node, \"rss:link\")\r\n\r\n item.publisher = xml_text(node, \"prism:publisher\") || xml_text(node, \"dc:publisher\")\r\n item.source_title = xml_text(node, \"prism:PublicationName\")\r\n item.volume = xml_text(node, \"prism:volume\")\r\n item.issue = xml_text(node, \"prism:number\")\r\n item.start_page = xml_text(node, \"prism:startingPage\")\r\n item.end_page = xml_text(node, \"prism:endingPage\")\r\n\r\n # Look for something that looks like a DOI in dc:identifier\r\n node.xpath(\"dc:identifier\").each do |id_node|\r\n if id_node.text =~ /\\ADOI (.*)\\Z/\r\n item.doi = $1\r\n # doi's seem to often have garbage after a \"; \", especially\r\n # from highwire. heuristically fix, sorry, a real DOI with \"; \"\r\n # will get corrupted.\r\n if (parts = item.doi.split(\"; \")).length > 1\r\n item.doi = parts.first\r\n end\r\n\r\n break\r\n end\r\n end\r\n\r\n # authors?\r\n node.xpath(\"dc:creator\", xml_ns).each do |creator_node|\r\n name = creator_node.text\r\n name.strip!\r\n\r\n # author names in RSS seem to often have HTML entities,\r\n # un-encode them to literals.\r\n name = HTMLEntities.new.decode(name)\r\n\r\n\r\n item.authors << BentoSearch::Author.new(:display => name)\r\n end\r\n\r\n # Date is weird and various formatted, we do our best to\r\n # look for yyyy-mm-dd at the beginning of either prism:coverDate or\r\n # dc:date or prism:publicationDate\r\n date_node = xml_text(node, \"prism:coverDate\") || xml_text(node, \"dc:date\") || xml_text(node, \"prism:publicationDate\")\r\n if date_node && date_node =~ /\\A(\\d\\d\\d\\d-\\d\\d-\\d\\d)/\r\n item.publication_date = Date.strptime( $1, \"%Y-%m-%d\")\r\n elsif date_node\r\n # Let's try a random parse, they give us all kinds of things I'm afraid\r\n item.publication_date = Date.parse(date_node) rescue ArgumentError\r\n end\r\n\r\n # abstract, we need to strip possible HTML tags (sometimes they're\r\n # there, sometimes not), and also decode HTML entities. \r\n item.abstract = xml_text(node, \"rss:description\").try do |text| \r\n HTMLEntities.new.decode(strip_tags(text))\r\n end\r\n\r\n item\r\n end\r\n )\r\n\r\n # Items seem to come back in arbitrary order, we want to sort\r\n # by date reverse if we can\r\n if results.all? {|i| i.publication_date.present? }\r\n results.sort_by! {|i| i.publication_date}.reverse!\r\n end\r\n\r\n fill_in_search_metadata_for(results)\r\n\r\n return results\r\n end",
"def parse!\n init_url\n response = HTTParty.get(@url)\n pattern = /<a (href\\s*=\\s*(?:\"([^\"]*)\"|'([^']*)'|([^'\">\\s]+)))*>(.*?)<\\/a>/i\n body = response.body\n while pattern =~ body\n @uri=$1\n @obj=$+\n clean!\n @items[\"#{@uri}\"] = @obj\n body = $~.post_match\n end\n end",
"def feed_url(url=self.blog_url)\n blog = Nokogiri::HTML(open(url))\n \n # select \n if (feed = blog.xpath(\"html/head/link[@rel='alternate']\")).present?\n feed.attribute(\"href\").text\n else\n nil\n end\n end",
"def title() @feed.read_attribute( :title ); end",
"def parse(xml)\n @id = xml.xpath('//xmlns:feed/xmlns:id').first.text\n @title = xml.xpath('//xmlns:feed/xmlns:title').first.text\n\n @author_email =\n xml.xpath('//xmlns:feed/xmlns:author/xmlns:email').first.text\n @author_name = xml.xpath('//xmlns:feed/xmlns:author/xmlns:name').first.text\n\n xml.xpath('//xmlns:feed/xmlns:entry').each do |entry|\n title = entry.xpath('.//xmlns:title').first.text\n emails = []\n primary = entry.xpath('.//gd:email[@primary]')\n next unless primary.first\n emails << primary.first['address']\n alternates = entry.xpath('.//gd:email[not(@primary)]')\n\n emails.push(*alternates.map { |e| e['address'] })\n\n ims = []\n entry.xpath('.//gd:im').each do |im|\n ims << [im['address'], im['protocol']]\n end\n\n phones = []\n entry.xpath('.//gd:phoneNumber').each do |phone|\n phones << [phone.text, phone['rel']]\n end\n\n addresses = []\n entry.xpath('.//gd:postalAddress').each do |address|\n addresses << [address.text, address['rel']]\n end\n\n photo_link = entry.xpath('.//xmlns:link[@rel=\"http://schemas.google.com/contacts/2008/rel#photo\"]').first\n photo_url = photo_link['href'] if photo_link\n\n contact = Contact.new title, emails, ims, phones, addresses, photo_url\n\n @contacts << contact\n end\n\n self\n end",
"def read_rss\n query = \"http://news.google.ru/news?hl=ru&topic=#{@topic}&output=rss&ned=ru_ru&num=30&&scoring=n\"\n feed = Feedjira::Feed.fetch_and_parse(query)\n feed.entries.map do |entry|\n {\n uuid: SecureRandom.uuid,\n title: entry.title,\n url: entry.url.match(GOOGLE_URI_REGEX)[0],\n published_datetime: entry.published,\n published_unixtime: entry.published.to_i\n }\n end\n end",
"def fetch_urls_from_feedly\n yaml = YAML.load_file('env.yaml')\n client = Feedlr::Client.new(oauth_access_token: yaml['account']['feedly']['access_token'])\n client.user_subscriptions.map{|m|\n # puts m.id\n hotentries = client.stream_entries_contents(m.id, :count => 5 ).items\n return hotentries\n };\nend",
"def parse(url)\n instance = self.new\n instance.url = url\n instance.body = open(url).read\n if instance.body.match(%r{<title>(.*?)</title>}m)\n instance.title = $1.to_s.strip.gsub(%r{[\\n\\r\\t]}m, '')\n end\n instance\n end"
] |
[
"0.64352965",
"0.6323135",
"0.62857777",
"0.6271508",
"0.62419844",
"0.61828256",
"0.6113405",
"0.6035113",
"0.60275364",
"0.6024494",
"0.6024494",
"0.6014455",
"0.59951246",
"0.59930396",
"0.5975961",
"0.5970141",
"0.5934416",
"0.59123224",
"0.5911166",
"0.58972096",
"0.5888513",
"0.5885932",
"0.5881197",
"0.5864591",
"0.58357483",
"0.58190143",
"0.58115005",
"0.5810696",
"0.5804429",
"0.58027446",
"0.5781272",
"0.5776191",
"0.5775129",
"0.57723165",
"0.57723165",
"0.57723165",
"0.57723165",
"0.5771446",
"0.5768149",
"0.57615006",
"0.57461673",
"0.57399094",
"0.56989926",
"0.5682674",
"0.56730556",
"0.56650054",
"0.565107",
"0.56432164",
"0.5642622",
"0.56390923",
"0.5633648",
"0.5630285",
"0.5627216",
"0.5620751",
"0.5603517",
"0.5600061",
"0.5582938",
"0.5579061",
"0.5574881",
"0.5572861",
"0.55712956",
"0.5569415",
"0.5562456",
"0.55589",
"0.5555385",
"0.5550004",
"0.5539923",
"0.55297005",
"0.5522454",
"0.5522454",
"0.5519187",
"0.5515253",
"0.5506945",
"0.54981375",
"0.5496659",
"0.5488957",
"0.54798377",
"0.5473833",
"0.54703975",
"0.54692954",
"0.54692954",
"0.54692954",
"0.54692954",
"0.5464283",
"0.5459096",
"0.54582894",
"0.5457327",
"0.54499114",
"0.5443782",
"0.54358065",
"0.54263186",
"0.54113424",
"0.541074",
"0.54077536",
"0.5401015",
"0.5399176",
"0.5398292",
"0.53970206",
"0.5393047",
"0.53910625",
"0.53830993"
] |
0.0
|
-1
|
override this to extract specific elements, e.g. a post image
|
def extract(body,uri,item_content={})
{:body => normalize((Hpricot(body)/'body').inner_html), :thumb_path=>nil, :has_video=>false }
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def extract_body(article)\n out_html = \"\"\n elem = article.at('.news-image').next_element\n\n while true do\n break if elem.attribute(\"class\") && elem.attribute(\"class\").text == \"news-single-rightbox\"\n out_html << elem.to_html\n elem = elem.next_element\n # Let it crash if there is no news-single-rightbox\n end\n\n out_html.strip\nend",
"def extract_badgeimages()\n@badgeimages_array = []\n file = File.open('app/assets/post.html')\n doc = Nokogiri::HTML(file)\n doc.search('.mb_div a img').map do |element|\n image_url = 'http://www.boyscouttrail.com' + element['src']\n @badgeimages_array << image_url\n end\n return @badgeimages_array\nend",
"def parse_post(post)\n if (!post.nil?)\n img_re = /\\[img ([0-9]+)( (small|medium))?( (left|right))?\\]/\n link_re = /\\[link (\\S+)\\]/\n\n parsed = post\n img_matches = post.scan(img_re)\n\n # Outer array is number of times regex matched\n # Inner array is each group of a given match\n img_matches.each do |match|\n # Substitute one-by-one (not globally)\n img_id = match[0].to_i\n float = match[4] ? match[4] : \"left\"\n size = match[2] ? match[2] : \"medium\"\n\n if (Image.find_by(id: img_id) && Image.find_by(id: img_id).file && Image.find_by(id: img_id).file.url(:medium))\n parsed.sub!(img_re, link_to(image_tag(Image.find_by(id: img_id).file.url(size), style: \"float: #{float}\"), Image.find_by(id: img_id).file.url, target: \"_new\") )\n end\n end\n\n return parsed\n end\n end",
"def parse_image(elem)\n anchor = elem.at(\"a\")\n #TODO\n if anchor == nil\n return\n end\n link = anchor[\"href\"]\n image = anchor.at(\"img\")\n thumbnail = image[\"src\"]\n caption = clean_ws( elem.at(\"p\").to_plain_text )\n @image = Image.new(link, thumbnail, caption, @id)\n \n end",
"def extract_posts(doc, t)\n doc.search('post').each do |post|\n post_url = post['url']\n small_image_url = post.search('photo-url[@max-width=\"400\"]').first\n if small_image_url\n small_image_url = small_image_url.content\n max_image_url = post.search('photo-url[@max-width=\"1280\"]').first\n if max_image_url\n max_image_url = max_image_url.content\n end\n\n # try to locate a possible original blog\n via = nil\n link = post.search('photo-link-url').first\n if link\n link = validate_url(link.content)\n if link =~ TEST_TUMBLR_REGEX\n via = root_url(link)\n end\n end\n if via\n caption = post.search('photo-caption').first\n if caption\n Nokogiri::HTML.fragment(caption.content).search('a').each do |a|\n unless via\n href = a['href']\n if href && (href =~ TEST_TUMBLR_REGEX)\n via = root_url(href)\n end\n end\n end\n end\n end\n t_via =via ? (Tumblr.filter(:url => via).first || Tumblr.create(:url => via)) : nil\n unless Post.filter(:url => post_url).first\n Post.create(:url => post_url,\n :small_image_url => small_image_url,\n :max_image_url => max_image_url,\n :tumblr => t,\n :timestamp => Time.at(post['unix-timestamp'].to_i).send(:to_datetime),\n :via => t_via)\n end\n else\n p post\n end\n end\n end",
"def extract_image(page)\n imgs = page.css('.thumbimage')\n return unless imgs\n img = imgs.reject { |img| img[:src].starts_with? 'data:' }.first\n img[:src]\n end",
"def post_info(url)\n doc = Nokogiri::HTML(open(url))\n content = doc.css('div.entry-content')\n fix_img_url(content)\n title = doc.css('header h1.entry-title').inner_html\n categories = doc.css('a.category').collect do |link| link.content end\n return title, content.to_s, categories\nend",
"def extract(rec)\n super(rec)\n @abstracts = rec.doc.xpath(path).map(&:text)\n end",
"def scrape_images(doc)\n images = []\n i = 0\n doc.css(\".imageSeriesImage\").each do |item|\n url = item.attr(\"src\")\n caption = doc.css(\".imageText\")[i].text\n images << { :url => url, :caption => caption }\n i = i + 1\n end\n return images\nend",
"def image_elements #:nodoc:\n @image_elements[0...number_elements]\n end",
"def description_image\n parsed_description.css('img').first # there's only one\n end",
"def get_image_data(file, f)\n images = f.xpath('//div[@id=\"articletext\"]/div[@id=\"ImageRotator\"]')\n images = images.empty? ? f.xpath('//div[@class=\"article\"]/div[@id=\"ImageRotator\"]') : images\n images = images.empty? ? f.xpath('//div[@id=\"column_info\"]/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"logo\"]/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"article_head\"]/h2/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"articletext\"]/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"ibox\"]/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"newsstorytext\"]/div[@id=\"ImageRotator\"]') : images\n images = images.empty? ? f.xpath('//div[@id=\"articletext\"]/div[@class=\"jubilarian\"]/p/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"articletext\"]/div[@class=\"rotator_image\"]') : images\n images = images.empty? ? f.xpath('//div[@id=\"articletext\"]/p/img') : images\n images = images.empty? ? f.xpath('//div[@id=\"articletext\"]/div[@class=\"item\"]') : images\n images = images.empty? ? f.xpath('//div[@id=\"ImageRotator\"]') : images\n images = images.empty? ? f.xpath('//div[@style=\"width:438px; color:#888; font-size:85%;\"]') : images\n images = images.empty? ? f.xpath('//p[@class=\"no_indent\"]/img') : images\n images = images.empty? ? f.xpath('//ul[@id=\"deacon_list\"]/li/img') : images\n images = images.empty? ? f.xpath('//ul[@id=\"deaconlist\"]/li/img') : images\n images = images.empty? ? f.xpath('//div[@style=\"margin:8px auto; width:400px;\"]/img') : images\n images = images.empty? ? f.xpath('//div[@class=\"imgdiv\"]') : images\n\n if images.empty?\n images = f.xpath('//img')\n if images.size == 20\n images = \"/images/FindingGraceDeadlySins.png\"\n else\n images = ''\n end\n end\n images\nend",
"def extract_meta\n end",
"def get_extras(hash, node, data)\n hash[\"body\"] = get_body(hash[\"url\"], data[\"body\"])\n hash[\"body\"] = hash[\"body\"].gsub(/[^a-zA-Z0-9\\- ]/,\"\") if (hash[\"body\"] != nil)\n hash[\"tags\"] = Array.new\n hash[\"tags\"] = fetch_tags(hash[\"url\"], data[\"tags\"]) if data[\"tags\"].last\n hash[\"url\"] = fetch_url(node.to_s) if data[\"special\"]\n aux = data[\"image\"]\n if aux != nil\n hash[\"image\"] = get_image(hash[\"url\"], aux) unless aux[0] == 0\n else\n hash[\"image\"] = \"\"\n end\n hash[\"image\"] = get_any_image(hash[\"url\"]) if hash[\"image\"] == \"\"\n hash\n end",
"def element\n image_name_list = get_image_name_list ORIGINALS_PATH\n image_name_list.each { |image_name| post(image_name) }\n end",
"def extract\n nil\n end",
"def extract_images article\n\n # Extract all image urls in the article and put them into a single array.\n if(article['images'] == nil)\n article['images'] = []\n end\n \n if(article['image_urls'] == nil)\n article['image_urls'] = []\n end\n\n #Yes, i'm aware this is repetitive code.\n article['images'].each do |image|\n image_address = image['url']\n\n byebug\n if !image_address.starts_with?(\"http\")\n # build up missing parts\n prefix = \"\"\n if(image_address.starts_with?(\":\"))\n prefix = 'https'\n elsif(image_address.starts_with?(\"//\"))\n prefix = 'https:'\n elsif(image_address.starts_with?(\"/\"))\n prefix = base_url\n else\n prefix = base_url + \"/\"\n end \n # Obviously needs to be fixed\n full_url = prefix + image_address\n\n image['url'] = full_url\n image['start'] = 0\n image['length'] = 0\n\n article['image_urls'] << full_url\n else\n if(@force_https)\n uri = Addressable::URI.parse(image_address)\n uri.scheme = 'https'\n image_address = uri.to_s\n end\n\n image['url'] = full_url\n image['start'] = 0\n image['length'] = 0\n end\n end\n\n elements = Nokogiri::HTML article['body']\n images_array = elements.css('img')\n images_array.each do |image|\n image_address = image.attributes['src'].value\n\n if !image_address.starts_with?(\"http\")\n # build up missing parts\n prefix = \"\"\n if(image.attributes['src'].value.starts_with?(\":\"))\n prefix = 'https'\n elsif(image.attributes['src'].value.starts_with?(\"//\"))\n prefix = 'https:'\n elsif(image.attributes['src'].value.starts_with?(\"/\"))\n prefix = base_url\n else\n prefix = base_url + \"/\"\n end \n # Obviously needs to be fixed\n full_url = prefix + image.attributes['src'].value\n\n image_object = {url: full_url, start: image.line, length: image.to_s.length, caption: \"\", width: \"\", height: \"\", byline: \"\"}\n article['images'] << image_object\n\n article['image_urls'] << full_url\n \n if(image == images_array.first)\n image.remove\n end\n\n image['href'] = full_url\n else\n if(@force_https)\n uri = Addressable::URI.parse(image_address)\n uri.scheme = 'https'\n image_address = uri.to_s\n image['href'] = image_address\n end\n\n image_object = {url: image_address, start: image.line, length: image.to_s.length, caption: \"\", width: \"\", height: \"\", byline: \"\"}\n article['images'] << image_object\n end\n\n\n # This is a filler for the app itself. Which will replace the text with the images \n # (order being the same as in the array)\n # for versioning we put this in\n multiple_image_version_required = 1.1\n\n # Add gravestone\n image['push'] = \":::\"\n end\n\n article['body'] = elements.to_html\n\n end",
"def extract_related_content\n end",
"def find_images_and_attachments\n @image_content_nodes = []\n @attachment_nodes = []\n\n @node.children.accessible.with_content_type(%w(Image Attachment ContentCopy)).include_content.all.each do |node|\n node = node.content.copied_node if node.content_type == 'ContentCopy'\n if node.content_type == 'Image' && !node.content.is_for_header? && node.content.show_in_listing\n @image_content_nodes << node.content\n elsif node.content_type == 'Attachment'\n @attachment_nodes << node\n end\n end\n end",
"def get_image1(doc, image)\n x = doc.xpath(image).to_s\n end",
"def get_info_from_products(bodypart)\n\tallproducts = page.css('.panelnav_detail_hd')\n\tallproducts.each do |p|\n\t\tproductObj = {\n\t\t\t\"class\" => p.xpath(\"../../../../../../../img\").attribute(\"alt\").value,\n\t\t\t\"name\" => p.attribute(\"alt\").value,\n\t\t\t\"URL\" => p.xpath(\"../../../..\").attribute('href').value\n\t\t}\n\tend\nend",
"def get_image\n blog_contents = Nokogiri::HTML(self.content)\n\n if blog_contents.xpath(\"//img\").blank?\n self.post_image = nil\n else\n image_link = blog_contents.xpath(\"//img\")[0]['src']\n\n if image_link.include?(\"http://\")\n self.post_image = File.open(image_link)\n else\n image_link = Dir.pwd.concat(\"/public\" + image_link)\n self.post_image = File.open(image_link)\n end\n end\n\nend",
"def scrape_basic_content(t)\n\t\t\tbegin\n\t\t\t\ttweet_id = t.xpath(\"@data-item-id\").text().to_s.strip\n\t\t\t\tposter_name = t.xpath(\"//strong/text()\").to_s.strip\n\t\t\t\t#check if the poster is the current user!!\n\t\t\t\tputs \"NAME#{@name}\"\n\t\t\t\t@max_tweet_id = tweet_id\n\t\t\t\tset_id(tweet_id)\n\t\t\t\t#puts tweet_id\n\t\t\t\ttweet_content = t.xpath(\"./div/div/p/text()\").to_s.strip\n\t\t\t\t#puts tweet_content\n\t\t\t\tset_content(tweet_content)\n\n\n\t\t\trescue Exception => e\n\t\t\t\tLogWriter.error(e)\n\t\t\t\treturn self\t\n\t\t\tend\n\tend",
"def load_notetags\n init_custom_fields\n self.note.split(/[\\r\\n]+/).each { |line|\n case line\n when /<image:\\s*\"(.*)\"\\s*>/i\n @image = $1\n when /<subtype_id:\\s*(\\d*)\\s*>/i\n @subtype_id = $1.to_i\n end\n }\n end",
"def posts\n @browser.divs(:class, 'post').map { |div| PostSummary.new(div) }\n end",
"def posts\n @browser.divs(:class, 'post').map { |div| PostSummary.new(div) }\n end",
"def parse_body\n return if @doc\n\n @doc = Nokogiri.XML(self.body)\n values = {}\n values[:title] = @doc.attributes['title'].text rescue nil\n @doc.search('background').each do |bkelt|\n if bkelt.attributes['image']\n @background_image = bkelt.attributes['image']\n end\n end\n values[:pages] = @doc.search(\"page\").collect {|xml| Page.new(xml)}\n\n @title = values[:title]\n @pages = values[:pages]\n @pages.each_with_index {|page,idx| page.number = idx}\n end",
"def extract\n @browser.visit @url\n Nokogiri::HTML(@browser.html)\n end",
"def extract_metadata; end",
"def getImageUrlAndDetails(story_url, provider_id, category_id, b_related)\n\tstory_content_html = Nokogiri::HTML(open(story_url))\n\t\n\t## El Masry El Youm\n\tif provider_id == 1\n\t\n\t\t## Image Parsing\n\t\tbegin\n\t\t\timage_div_id = \"articleimg\"\n\t\t\timage_url = story_content_html.css('div.'+ image_div_id).css('img').attribute('src').to_s\n\t\trescue \n \t\t\timage_url = \"\" \n\t\tend\n\t\n\t\t## Details Parsing\n\t\t# get div with id 'arabic-news'\n\t\t# from it get div class 'pane-content'\n\t\tdetails_div_id = \"NewsStory\"\n\t\tdetails = story_content_html.css('div#'+ details_div_id).text.strip\n\t#\tputs details\n\t\n\t\t## Related Parse\n\t\tif !b_related\n\t\t\tbegin\n\t\t\t\trelated_div_class = \"ret_post\"\n\t\t\t\trelated = story_content_html.css('div.'+ related_div_class).css('ul.side-nav a')\n\t\t\t\trelated1_id = related[0]['href'].split(pattern=\"/\")[-1]\n\t\t\t\trelated2_id = related[1]['href'].split(pattern=\"/\")[-1]\n\t\t\t\t# get info or related news\n\t\t\t\tgetStory(\"http://www.almasryalyoum.com/news/details/\"+related1_id,1, category_id, b_related)\n\t\t\t\tgetStory(\"http://www.almasryalyoum.com/news/details/\"+related2_id,1, category_id, b_related)\n\t\t\trescue \n\t\t\t\t# no related news found\n\t\t\t\trelated1_id = 0\n\t\t\t\trelated2_id = 0\n\t\t\tend\n\t\t# not getting related stories of a related one as it loop to almost infinity\n\t\telse\n\t\t\trelated1_id = 0\n\t\t\trelated2_id = 0\n\t\tend\n\t\t## Title Parse\n\t\ttitle = story_content_html.css('title').text.to_s.split(' | ')[0]\n\t\t\n\t\treturn [image_url, details, related1_id, related2_id, title]\n\t\n\t## Youm7\n\telsif provider_id == 2\n\t\t# Image Parsing\n\t\tbegin\n\t\t\timage_div_id = \"newsStoryImg\"\t\t\n\t\t\timage_url = story_content_html.css('div#'+image_div_id).css('img').attribute('src').to_s\n\t\trescue \n \t\t\timage_url = \"\" \n\t\tend\n\t\t# Details Parsing\n\t\tdetails_div_id = \"newsStoryTxt\"\n\t\tdetails = story_content_html.css('div#'+details_div_id).css('p').text.strip\n\t\t\n\t\t# Related Parsing\n\t\t## TODO\n\t\t# no related news found\n\t\trelated1_id = 0\n\t\trelated2_id = 0\n\t\t\n\t\treturn [image_url, details, related1_id, related2_id]\n\t\t\n\t\n\t## El Watan\n\telsif provider_id == 3\n\t\t# Image Parsing\n\t\tbegin \n\t\t\timage_div_class = \"main_focus\"\t\t\n\t\t\timage_url = story_content_html.css('div.'+image_div_class).css('img').attribute('src').to_s\n\t\trescue \n \t\t\timage_url = \"\"\n\t\tend \n\t\t\n\t\t# Details Parsing\n\t\tdetails_div_class = \"main_content_ip\"\n\t\tdetails = story_content_html.css('div.'+details_div_class).css('p').text.strip\n\n\t\t# Related Parsing\n\t\t## TODO\n\t\t# no related news found\n\t\trelated1_id = 0\n\t\trelated2_id = 0\n\t\t\n\t\treturn [image_url, details, related1_id, related2_id]\n\tend\nend",
"def images; (page.images rescue []); end",
"def images; (page.images rescue []); end",
"def extract_data( page )\n strip_tags page[:content]\n\n #extract_concepts( page[:title] , page , LOC_TITLE ) if page[:title] && page[:title] !=~ PTN_EMPTY\n if page[:tag] && page[:tag] !=~ PTN_EMPTY\n page[:tag] = page[:tag].split(SEP_TAG).map{|e|\"[[\"+e+\"]]\"}.join(\";\")\n extract_concepts( page[:tag] , page , LOC_TAG )\n end\n\n extract_concepts( page[:title] , page , LOC_TITLE)\n extract_concepts( page[:content] , page )\n extract_resources( page[:content] , page )\n end",
"def parse(data)\r\n super(data)\r\n \r\n case doc\r\n when Nokogiri::HTML::Document\r\n # Get Name\r\n self.name = doc.css(\"h1.parseasinTitle\").first_string\r\n if self.name.nil?\r\n self.name = doc.css(\"h1#title\").first_string\r\n end\r\n \r\n # Get Description\r\n self.description = doc.css(\"div#productDescriptionWrapper\").first_string \r\n \r\n # Get description from meta title if not found\r\n self.description = doc.xpath(\"//meta[@name='description']/@content\").first_string if description.nil?\r\n \r\n # Get Price\r\n price_check = doc.css(\"b.priceLarge\").first_string\r\n unless price_check.nil?\r\n parse_price(doc.css(\"b.priceLarge\").first_string)\r\n else\r\n parse_price(doc.css(\"span.a-color-price\").first_string)\r\n end \r\n \r\n # Get Images\r\n self.images = doc.xpath(\"//table[@class='productImageGrid']//img\").attribute_array\r\n self.image = images.first\r\n if self.image.nil?\r\n self.images = doc.at_css(\"img#main-image\")\r\n self.image = self.images['src']\r\n end\r\n\r\n self.brand = doc.css(\"a#brand\").first_string\r\n\r\n end \r\n end",
"def poster\n doc.search(\".film-img-box img\").first.attr 'src'\n end",
"def extract_thumbnails\n\t\t\t@small = @preview[\"small\"]\n\t\t\t@medium = @preview[\"medium\"]\n\t\t\t@large = @preview[\"large\"]\n\t\t\t@template = @preview[\"template\"]\n\t\tend",
"def get_image_desc(page_doc)\n\treturn page_doc.css('//body/p')[-2].inner_html\nend",
"def collect_elements element\n # capture first element name\n elements = []\n # iterate text until next headline\n while true do\n elements << element\n element = element.next\n break if element.nil? || element.to_html.include?(\"class=\\\"mw-headline\\\"\")\n end\n elements\n end",
"def process_contents\n @img_tags = @contents.xpath( '//img[@src]' )\n @img_tags.each do |tag|\n download_resource(File.join('http://wiki.dublincore.org', tag[:src]), File.join(@image_dir, File.basename(tag[:src])))\n end\n find_links\n end",
"def scrap_the_images\n url = RestClient.get(@url)\n parsed_result = Nokogiri::HTML(url)\n images = parsed_result.search('img').map { |img| img['src'] }\n images\n end",
"def images\n img = nokogiri_obj.css('img')\n img.attribute('data-src')&.text || img.attribute('data-key')&.text\n end",
"def media_elements_at\n case self.kind\n when AUDIO, VIDEO1, VIDEO2\n resp = self.media_elements_slides.first\n resp.nil? ? nil : resp.media_element\n when COVER, IMAGE1, IMAGE3\n self.media_elements_slides.first\n when IMAGE2\n resp = [nil, nil]\n mes = self.media_elements_slides\n resp[mes[0].position - 1] = mes[0] if !mes[0].nil?\n resp[mes[1].position - 1] = mes[1] if !mes[1].nil?\n resp\n when IMAGE4\n resp = [nil, nil, nil, nil]\n mes = self.media_elements_slides\n resp[mes[0].position - 1] = mes[0] if !mes[0].nil?\n resp[mes[1].position - 1] = mes[1] if !mes[1].nil?\n resp[mes[2].position - 1] = mes[2] if !mes[2].nil?\n resp[mes[3].position - 1] = mes[3] if !mes[3].nil?\n resp\n else\n nil\n end\n end",
"def original_poster(doc)\n doc.search('.subtext > a:nth-child(2)').map { |link| link.inner_text }[0]\n end",
"def list_posts(api_object)\r\n puts \"Current Post:\"\r\n doc = Nokogiri::XML.parse api_object.read\r\n contents= doc.xpath('posts/post/content').collect {|e| e.text }\r\n puts contents.join(\", \")\r\n puts \"\"\r\nend",
"def poster\n doc.search(\".film-img-box img[itemprop='image']\").first.attr 'src'\n end",
"def determine_post_element_xpath\n els = detect_post_element_xpaths\n els.first.andand[0]\n end",
"def get_image2(doc, image)\n x = doc.xpath(image).first.to_s\n end",
"def get_elements(source)\n @elements = Array.new\n if @source_type == \"url\"\n reader = Nokogiri::HTML(open(source).read)\n else\n reader = Nokogiri::HTML(File.open(source))\n end\n reader = remove_empty_text(reader)\n reader.at('body').attribute_nodes.each do |element_attribute|\n node[:parent] = \"html\"\n node[:tag] = \"body\"\n node[:attribute] = element_attribute.name if !element_attribute.name.nil?\n node[:value] = element_attribute.value if !element_attribute.value.nil?\n @elements << node\n end\n reader.at('body').children.each do |child|\n if child.attribute_nodes.empty?\n node = Hash.new\n node[:parent] = \"body\"\n node[:tag] = child.name\n node[:content] = child.text if child.text?\n @elements << node\n else\n child.attribute_nodes.each do |element_attribute|\n node = Hash.new\n node[:parent] = \"body\"\n node[:tag] = child.name\n node[:attribute] = element_attribute.name if !element_attribute.name.nil?\n node[:value] = element_attribute.value if !element_attribute.value.nil?\n @elements << node\n end\n end\n\n add_children(child) if child.children.any?\n end\n @elements\n end",
"def load_posts(id)\n url = DOMAIN + \"/#{id}\"\n #if File.exist?(\"./out/#{id}.xml\")\n # p \"skip id(file exists):#{id}\"\n # return\n #end\n p \"loading #{url}\"\n agent = Mechanize.new\n images = []\n begin\n page = agent.get(url)\n title = page.at(\"title\").text\n date = page.at(\"article\").get_attribute('date')\n if (page.at(\"article div.text\"))\n # text post\n text = page.at(\"article div.text\").inner_html\n elsif (page.at(\"article div.photo\"))\n # photo post\n text = page.at(\"article div.photo\").to_html + page.at(\"article div.captions\").to_html\n puts 'photo'\n images = page.images_with(:src => /.*media.tumblr.com\\/.*\\/tumblr_.*/).each do |img|\n img.fetch.save(\"./out/\" + img.to_s.gsub(\"/\",\"_\").gsub(\":\",\"\"))\n end\n else\n # video post\n text = page.at(\"body\").inner_html\n end\n buffer = <<-EOT\n <item>\n <title><![CDATA[#{title}]]></title>\n <link>#{url}</link>\n <guid isPermaLink=\"true\">#{url}</guid>\n <pubDate>#{date}</pubDate>\n <description><![CDATA[#{text}]]></description>\n </item>\n EOT\n File.open(\"./out/#{id}.xml\", \"w:UTF-8\") do |file|\n file.print buffer\n end\n rescue => e\n p e.message\n p \"Error: we coudn't parse content from this url:#{url}\"\n end\nend",
"def post_process\n @result = @result[:content].first\n raise ::Grafana::ImageCouldNotBeRenderedError, @panel if @result.include?('<html')\n end",
"def extract\n case type\n when /jpe?g/i\n extract_jpg\n when /png/i\n extract_png\n end\n metadata.except( *REJECTED_TAGS )\n rescue Errno::ENOENT, Exiftool::ExiftoolNotInstalled, Exiftool::NoSuchFile, Exiftool::NotAFile => e\n raise ExtractionError, \"#{e.class.name}: #{e.message}\"\n end",
"def image_node\n return @image_node if defined? @image_node\n\n @image_node = @node.xpath('.//img').first\n end",
"def image_elements(identifier)\n platform.images_for(identifier.clone)\n end",
"def grab_the_images\n get_the_url = RestClient.get(@url)\n doc = Nokogiri::HTML(get_the_url)\n images = doc.search('img').map{ |img| img['src'] }\n images\n end",
"def find_images el, images = Set.new\n el.children.each {|elem| find_images elem, images}\n if el.type == :img\n images << el.attr['src']\n end\n images\n end",
"def process_nodes(html_nodes, properties); end",
"def fetch\n feed = Feedzirra::Feed.fetch_and_parse(FEED_URL)\n\n # Loop counters\n product_image_counter = 0\n photo_counter = 0\n\n # Loop over the feed entries creating a new photo object for each..\n feed.entries.each do |entry|\n photo = Photo.new\n photo.title = entry.title\n photo.published_at = entry.published\n photo.categories = entry.categories\n\n download_image(entry.links[1].gsub(DEFAULT_IMAGE_SIZE, PREFERED_IMAGE_SIZE), \"photos\", photo_counter, true)\n\n photo.products = []\n\n # Run a regex match loop getting all of the products embedded in the entriy's content\n while product_tag = PRODUCT_EXP.match(entry.content)\n product_tag = product_tag.to_s\n\n product = Product.new\n\n # Grab the product URL\n product.url = PRODUCT_URL_EXP.match(product_tag).to_s \n\n # Grab the product's image url \n product.image_url = PRODUCT_IMAGE_URL_EXP.match(product_tag).to_s \n\n download_image(product.image_url, \"products\", product_image_counter)\n\n product_image_counter += 1\n\n photo.products << product\n\n # Delete this tag so we dont trip over it again\n entry.content.gsub!(product_tag, '') \n end\n photo_counter += 1\n end\nend",
"def get_images(tag)\n\tpageThumb = get_page(\"#{URL_MOTARU}/categories/view/name/#{tag}\")\n\treturn pageThumb.search(\"//div[@id='categoryWallpapersList']//img[@class='wallpaperThumb']\")\nend",
"def inline_image(element)\n invalid = [\"span\",{\"class\"=>\"red\"},\"invalid image\"]\n return invalid unless element.attr.has_key? 'src'\n return invalid unless element.attr['src'].start_with? \"data:image/png;base64,\"\n return [\"img\",{\"src\"=>element.attr['src']}]\nend",
"def disunity_extract(src: nil)\n end",
"def parse_with_instructions(browser, site_instruction, website)\n good = create_good_essential(browser, site_instruction, website)\n\n # If other images are accessable without any actions\n if site_instruction.images_selector.present?\n parse_other_images(browser, site_instruction, good)\n\n # If thumbnails must be clicked to get other images\n elsif site_instruction.button_selector.present?\n parse_thumbnail_images(browser, site_instruction, good)\n end\n good\n end",
"def preview() @page.find(input_elements[:preview]) end",
"def extract_attributes(file_name)\n extract_publish_date(file_name)\n extract_tags(file_name)\n extract_filter(file_name)\n extract_title_and_content(file_name)\n @path = Pathname.new(file_name)\n @file = @path.to_s\n @title = @file.gsub('_', ' ').capitalize if @title.to_s.empty?\n @summary = @content.match(%r{<p>.*</p>}).to_s\n self\n end",
"def art_image(art)\n art.poster\n end",
"def images\n if @images.nil?\n @images = []\n image_nodes = FeedTools::XmlHelper.combine_xpaths_all(\n self.channel_node, [\n \"image\",\n \"logo\",\n \"apple-wallpapers:image\",\n \"imageUrl\"\n ]\n )\n unless image_nodes.blank?\n for image_node in image_nodes\n image = FeedTools::Image.new\n image.href = FeedTools::XmlHelper.try_xpaths(image_node, [\n \"url/text()\",\n \"@rdf:resource\",\n \"@href\",\n \"text()\"\n ], :select_result_value => true)\n if image.href.nil? && image_node.base_uri != nil\n image.href = \"\"\n end\n begin\n if !(image.href =~ /^file:/) &&\n !FeedTools::UriHelper.is_uri?(image.href)\n image.href = FeedTools::UriHelper.resolve_relative_uri(\n image.href, [image_node.base_uri, self.base_uri])\n end\n rescue\n end\n if self.configurations[:url_normalization_enabled]\n image.href = FeedTools::UriHelper.normalize_url(image.href)\n end \n image.href.strip! unless image.href.nil?\n next if image.href.blank?\n image.title = FeedTools::XmlHelper.try_xpaths(image_node,\n [\"title/text()\"], :select_result_value => true)\n image.title.strip! unless image.title.nil?\n image.description = FeedTools::XmlHelper.try_xpaths(image_node,\n [\"description/text()\"], :select_result_value => true)\n image.description.strip! unless image.description.nil?\n image.link = FeedTools::XmlHelper.try_xpaths(image_node,\n [\"link/text()\"], :select_result_value => true)\n image.link.strip! unless image.link.nil?\n image.height = FeedTools::XmlHelper.try_xpaths(image_node,\n [\"height/text()\"], :select_result_value => true).to_i\n image.height = nil if image.height <= 0\n image.width = FeedTools::XmlHelper.try_xpaths(image_node,\n [\"width/text()\"], :select_result_value => true).to_i\n image.width = nil if image.width <= 0\n image.style = FeedTools::XmlHelper.try_xpaths(image_node, [\n \"style/text()\",\n \"@style\"\n ], :select_result_value => true)\n image.style.strip! unless image.style.nil?\n image.style.downcase! unless image.style.nil?\n @images << image unless image.href.nil?\n end\n end\n for link_object in self.links\n if link_object.type != nil && link_object.type =~ /^image/\n image = FeedTools::Image.new\n image.href = link_object.href\n image.title = link_object.title\n @images << image unless image.href.nil?\n end\n end\n end\n return @images\n end",
"def scrape_img( page, title )\n\t\t@desired_node=@img_url=nil\n\t\t@desired_nodes=[]\n\n\t\ttitle = scrape_title( page )\n\t\ttitle.slice!(title.rindex(\"|\")..title.length) unless title.rindex(\"|\").nil?\n\t\ttitle_words = title.downcase.strip.split(/ |-/).reject{|s| s=~/(\\|)|(with)|(recipe)|( [a-z]{1,3} )|\\d/}\n\n\t\t# for all 'img' tags, determine if it's title tag is \n\t\t# similar to the recipe title, or determine if the image filename\n\t\t# itself is similar to the title of the recipe. If so, hold on to the node\n\t\tpage.search(\"img\").each do |node|\n\t\t\tunless node.nil?\n\t\t\t\tunless node.attr(\"title\").nil?\n\t\t\t\t\ttitle_words.each do |word|\n\t\t\t\t\t\tif node.attr(\"title\").downcase =~ /(#{word})/\n\t\t\t\t\t\t\t@desired_nodes.push(node)\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\tend\n\n\t\t\t\tunless node.attr(\"src\").nil?\n\t\t\t\t\ttitle_words.each do |word|\n\t\t\t\t\t\tif node.attr(\"src\").split(/\\//).last.downcase =~ /(#{word})/\n\t\t\t\t\t\t\t@desired_nodes.push(node)\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t\t\n\t\t# Some sites strip out the host; add it, if necessary\n\t\t# Use default image if the algorithm couldn't find anything\n\t\t@img_url = @desired_nodes.first.attr(\"src\")\n\n\t\tif @img_url.nil?\n\t\t\treturn \"/assets/img_404.png\"\n\t\telse\n\t\t\t@img_url = ( \"http://\" << page.canonical_uri.host << @img_url ) unless uri?( @img_url )\n\t\t\treturn @img_url\n\t\tend\n\tend",
"def article_components_for(article)\n article.pictures[1..-1] || []\n end",
"def get_elements(xpath); end",
"def get_img(coords, mid)\n url = URI(URI.encode(\"http://google.com/movies?near=#{coords[0]}, #{coords[1]}&mid=#{mid}\"))\n\n\n doc_str = Net::HTTP.get(url)\n doc = Nokogiri::HTML(doc_str)\n\n#working here\n str = nil\n if doc.css('.img img').empty?\n return nil\n else\n str = doc.css('.img img').attr('src').to_s\n if str.include?('tbn')\n return str\n end\n end\n return nil\n end",
"def process_gml\n Rails.logger.debug \"Tag #{id}: process_gml\"\n doc = gml_document\n return if doc.nil?\n\n header = (doc/'header')\n if header.blank?\n Rails.logger.error \"Tag.process_gml: no header found in GML\"\n # TODO raise exception\n return nil\n end\n\n attrs = {}\n attrs[:filename] = (header/'filename')[0].inner_html rescue nil\n\n obj = (header/'client')[0] rescue nil\n attrs[:client] = (obj/'name').inner_html rescue nil\n\n # STDERR.puts \"Tag.process_gml: #{attrs.inspect}\"\n # self.application = attrs[:client] unless attrs[:client].blank?\n self.remote_image = attrs[:filename] unless attrs[:filename].blank?\n\n return attrs\n rescue\n Rails.logger.error \"Tag.process_gml error: #{$!}\"\n return nil\n end",
"def elements\n find_by_tag('*')\n end",
"def harvest(pattern, html, arr)\n file = File.open(html)\n doc = Nokogiri::HTML(file)\n doc.xpath(pattern).each do |node|\n if pattern == '//a'\n arr << node.text\n elsif pattern == '//img' && arr.include?(node.to_s)\n elsif pattern == '//img'\n arr << node.to_s\n elsif pattern == '//html'\n arr << node\n end\n end\n arr\n end",
"def extract\n case type\n when /jpe?g/i\n extract_jpg\n when /png/i\n extract_png\n end \n metadata\n rescue Errno::ENOENT, Exiftool::ExiftoolNotInstalled, Exiftool::NoSuchFile, Exiftool::NotAFile => e\n raise ExtractionError, \"#{e.class.name}: #{e.message}\"\n end",
"def extract_badgenames()\n@badgenames_array = []\n file = File.open('app/assets/post.html')\n doc = Nokogiri::HTML(file)\n doc.search('.mb_div > a').map do |element|\n @badgenames_array << element.inner_text\n end\n return @badgenames_array\nend",
"def process_pxe_image_type(pxes, task)\n process_elements(pxes, PxeImageType, task)\n end",
"def process_pxe_image_type(pxes, task)\n process_elements(pxes, PxeImageType, task)\n end",
"def element?; end",
"def element?; end",
"def observation_image_xpath\n \"//div[@id='content']/descendant::div[contains(@class, 'show_images')]/\n descendant::a[child::img]\"\n end",
"def get_portraits_and_icons(hash, element)\n # Iterate through each character and obtain portrait and icon\n element.css(\"li.gallerybox\").each do |cell|\n\n # Retreive name in li for hash comparision\n name = cell.text.split(\"(\")[0].strip() # Remove (notes)\n name = name.split(\" \")[1..-1].join(\" \") # Remove order number\n\n if !!hash[name] # If the character exsists in the hash\n # Find portrait link in HTML and add to hash\n portrait_url = cell.css('div.thumb img').attr('src').value\n hash[name][:portrait] = \"https://www.mariowiki.com\" + portrait_url\n\n # Find image link in HTML and add to hash\n image_url = cell.css('a').attr('href').value\n hash[name][:image] = get_image(image_url)\n\n # Find icon link in HTML and add to hash\n icon_url = cell.css(\"div.gallerytext img\").attr('src').value\n hash[name][:icon] = \"https://www.mariowiki.com\" + icon_url\n end\n end\nend",
"def handle_element(cs, element, new_model)\n case cs.content_type\n when 'content'\n handle_content_element(cs, element, new_model)\n when 'foreign_key'\n handle_foreign_key_element(cs, element, new_model)\n when 'link'\n # handles parsing issues with malformed HTML where content isn't captured by the selector (williams rss links)\n url = element.text.blank? ? next_non_blank(element).text.squish : element.text.squish\n # needs to save the url in the model in order to display the detail page rather than the index\n new_model.assign_attributes(cs.column_name => url)\n detail_page_scrape(cs, url, new_model)\n else\n logger.error \"UNKNOWN CONTENT TYPE for child selector #{cs.id}: #{cs.selector}\"\n end # end content_type case statement\n end",
"def extract_interviewee(detail_page)\n interviewee_selector = '.episode_sub_title span'\n detail_page.search(interviewee_selector).text.strip\nend",
"def parse_thumb\n return if public_xml_doc.nil?\n\n thumb = public_xml_doc.xpath('//thumb')\n # first try and parse what is in the thumb node of publicXML, but fallback to the first image if needed\n if thumb.size == 1\n thumb.first.content\n elsif thumb.size == 0 && parse_sw_image_ids.size > 0\n parse_sw_image_ids.first\n end\n end",
"def extract(media_element_id, an_user_id, my_sti_type)\n media_element = find_by_id media_element_id\n return nil if media_element.nil? || media_element.sti_type != my_sti_type\n media_element.set_status(an_user_id)\n return nil if media_element.status.nil?\n media_element\n end",
"def parsePhotoRequestReponseXMl\n Dir.glob(File.join(LOCAL_DIR, FILE_EXTN)).each do |file|\n doc = Nokogiri::XML.parse(File.open(file)) { |xml| xml.noblanks }\n project = doc.root.child\n project.children.each { |shotGrp|\n if shotGrp.name == 'ShotGroup'\n puts shotGrp.name #puts node.children.first.name\n puts 'SalsifyID: ' + shotGrp['SalsifyID']\n puts 'ShotGroupStatus: ' + shotGrp['ShotGroupStatus']\n puts '------------'\n shotGrp.children.each { |image|\n puts image.name\n puts image.values\n puts '-----------'\n image.children.each { |sample|\n puts sample.name\n puts sample.values\n puts '##########'\n }\n }\n end\n }\n end\n end",
"def parseBlogAndPrint()\n self.getHTML()\n self.parsePosts()\n self.printPosts()\n end",
"def images_from_img_tag\n img_array = []\n # пробегаю по тегам img (meta og:images...), хватаю урл и закидываю в img_array\n @doc.xpath('//img').each do |img|\n if img['src'] != nil\n array = [img['src'].to_s]\n src = @handler_link.remove_unless_symbols(array)\n got_link = @handler_link.handler_prefix_link(@link_host_name, src.to_s.delete!(\"[\\\"]\"))\n\n img_array << got_link\n end\n end\n\n img_array.uniq!\n @handler_link.remove_unless_link(img_array)\n img_array\n end",
"def body\n if extractable?\n return {\n ingredients: @recipe.extract_ingredients,\n directions: @recipe.extract_directions,\n images: @images\n }\n end\n return nil\n end",
"def extract_args *args, &block\n [extract_id(*args), extract_selector(*args), extract_markup(*args, &block), extract_action(*args, &block)]\n end",
"def content_from(html, url)\n \n def extract_pre_from(html)\n regex = /<pre.*?>.*?<\\/pre>/m\n pre_list = html.scan regex\n html.gsub! regex, 'DUMMY-STRING'\n [pre_list, html]\n end\n\n def add_domain(html, domain)\n html.gsub! /a href=\\\"(\\/.*?\\\")/, \"a href=\\\"#{domain}\\\\1\"\n html.gsub! /img src=\\\"(\\/.*?\\\")/, \"img src=\\\"#{domain}\\\\1\"\n html\n end\n\n def add_pre(html, pre_list)\n pre_list.each do |p|\n html.sub!('DUMMY-STRING', p)\n end\n html\n end\n \n pre_list, replaced = extract_pre_from html\n params = { :tags => %w[div span p a b i pre h1 h2 h3 h4 h5 h6 strong small em\n blockquote ul ol li img],\n :attributes => %w[href src] }\n html = HtmlPress.press Readability::Document.new(replaced, params).content\n domain = domain_of url\n output = add_pre(add_domain(html, domain), pre_list)\n output = sanitize_with_img output\n output.gsub /<img /, \"<img onError=\\\"this.style.display='none';\\\" \"\n \n end",
"def get_art_for_page( rb, tagged, page )\n\n # Get the body of the page of art.\n if tagged then\n verbose( \"Getting page #{page} of your #{$params[ :product ]} tagged with \\\"#{tagged}\\\"\" )\n else\n verbose( \"Getting page #{page} of your #{$params[ :product ]}\" )\n end\n art = grab_art_page( rb, tagged, page )\n\n # Get the works from the body.\n works = art.elements.to_a( \"//span[@class='work-info']\" )\n\n # For each work found...\n works.each do |work|\n # ...emit the basic details for it.\n puts extract_work_id( work.elements.to_a( \"span[@class='title']/a\" ).first.attributes[ \"href\" ] ) +\n \"\\t\" +\n work.elements.to_a( \"span[@class='title']/a\" ).first.attributes[ \"title\" ] +\n \"\\t\" +\n work.elements.to_a( \"a/img\" ).first.attributes[ \"src\" ]\n end\n\n verbose( \"Done.\" )\n \nend",
"def image\n return @children['image'][:value]\n end",
"def create_post\n post_title = parse_html.css('title')[0].text\n post_url = @url\n points = parse_html.search('.subtext > span:first-child').map { |span| span.inner_text}\n post_points = points[0]\n all_ids = parse_html.search('tr.athing td center a').map { |link| link['id']}\n post_id = all_ids[0].gsub(/[[a-z]_\" \"\"]/,\"\") # taken from the first upvote button\n @post = Post.new(post_title, post_url, post_points, post_id, parse_comments)\n end",
"def element; end",
"def element; end",
"def element; end",
"def element; end",
"def extract_text(elements)\n elements.map { |text| base_class.new(text).export }.join\n end",
"def read_post(post_list, id)\n post = post_list['data']['children'][id]['data']\nend",
"def readPage \n @doc = Nokogiri::HTML.parse(@@BROWSER.html)\n\n # related TAGS\n @tags = []\n @doc.css('.tags.tags--postTags li a').each do |related_tag|\n @tags.push({\n :tag_name => related_tag.children.text,\n :tag_link => related_tag.attribute('href').value\n })\n end\n\n # BLOGS\n @blogs = []\n @doc.css('.streamItem').each do |blog|\n # author details: name, link to medium\n author_details = blog.css('.postMetaInline-authorLockup a').css('[data-action=\"show-user-card\"]')\n author_name = author_details.text.strip\n author_link = author_details.map { |link| link['href'] }\n\n # blog_archieve details\n blog_archieve_details = blog.css('.postMetaInline-authorLockup a').css('[data-action=\"show-collection-card\"]')\n blog_archieve_name = blog_archieve_details.text\n blog_archieve_link = blog_archieve_details.map { |link| link['href'] }\n\n # blog title image\n img_link = \"\"\n if blog.css('.progressiveMedia-image.js-progressiveMedia-image').empty?\n else\n img_link = blog.css('.progressiveMedia-image.js-progressiveMedia-image').attribute('data-src').value\n end\n\n # blog_link\n blog_link = blog.css('.postArticle-readMore .button--smaller').attribute('href').value\n\n @blogs.push({\n :title => blog.css('.graf--title').text, \n :sub_title => blog.css('.graf--subtitle').text,\n :trailing => blog.css('.graf--trailing').text,\n :author_name => author_name,\n :author_link => author_link[0],\n :blog_archieve_name => blog_archieve_name,\n :blog_archieve_link => blog_archieve_link[0],\n :blog_link => blog_link,\n :reading_time => blog.css('.readingTime').attr('title').value,\n :upvotes => blog.css('.js-actionMultirecommendCount').text,\n :img_link => img_link\n })\n end\n \n respond_to do |format|\n format.json{\n render json: {\n \"tags\": @tags,\n \"blogs\": @blogs\n }.to_json\n }\n end\n end"
] |
[
"0.62659484",
"0.6106848",
"0.6067401",
"0.60529053",
"0.5922791",
"0.5860852",
"0.5851947",
"0.5839287",
"0.58313787",
"0.5827338",
"0.5778406",
"0.57426995",
"0.57204425",
"0.57093227",
"0.56891894",
"0.56310445",
"0.55962515",
"0.55898577",
"0.5572398",
"0.55665094",
"0.5520173",
"0.5512701",
"0.550411",
"0.5486612",
"0.54737014",
"0.54737014",
"0.5472497",
"0.5447922",
"0.54457873",
"0.54377705",
"0.5434685",
"0.5434685",
"0.5418393",
"0.54133946",
"0.54062915",
"0.5398201",
"0.5395574",
"0.5391457",
"0.5375515",
"0.53730446",
"0.5353941",
"0.534421",
"0.53386813",
"0.5330399",
"0.5326381",
"0.53253746",
"0.531608",
"0.53145415",
"0.5312915",
"0.52893627",
"0.528919",
"0.5281285",
"0.52684087",
"0.52634704",
"0.5252145",
"0.5202201",
"0.51984036",
"0.5195891",
"0.51864976",
"0.51847136",
"0.5172189",
"0.5164108",
"0.5161967",
"0.51473486",
"0.5144105",
"0.51424396",
"0.51401037",
"0.5117709",
"0.5110245",
"0.51060545",
"0.510581",
"0.5102302",
"0.51001716",
"0.50935555",
"0.509224",
"0.509224",
"0.5091762",
"0.5091762",
"0.5089494",
"0.5072666",
"0.50573266",
"0.5053373",
"0.5051749",
"0.5049017",
"0.50405633",
"0.5040459",
"0.503792",
"0.50236374",
"0.5019237",
"0.5017369",
"0.50119656",
"0.50054455",
"0.5003208",
"0.50016016",
"0.50016016",
"0.50016016",
"0.50016016",
"0.49949965",
"0.4987714",
"0.4987173"
] |
0.60957813
|
2
|
c.posts do|post| post.source_url post.title post.link post.thumb post.summary post.body post.tags post.author end
|
def posts # proxy the posts struct
@post_cb = lambda{|post,fobj| yield post,fobj }
self
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def posts; end",
"def getPosts()\n\t\tself.post\n\tend",
"def view_posts()\n posts = @db.execute(\"SELECT * FROM posts\")\n @categories = @db.execute(\"SELECT * FROM categories\")\n\n comments = @db.execute(\"SELECT * FROM comments\").each do |comment|\n comment = comment[\"username\"] = @db.execute(\"SELECT username FROM users WHERE id=?\", [comment[\"user_id\"]]).first[\"username\"] \n end\n\n @posts = posts.each do |post|\n post[\"username\"] = @db.execute(\"SELECT username FROM users WHERE id=?\", [post[\"user_id\"]]).first[\"username\"]\n post[\"comments\"] = comments.select { |comment| comment[\"post_id\"] == post[\"id\"] }\n \n post[\"categories\"] = @db.execute(\"SELECT categorie_id FROM posts_categories WHERE post_id=?\",[post[\"id\"]]).map { |cat| p @db.execute(\"SELECT name FROM categories WHERE id=?\",[cat[\"categorie_id\"]]).first[\"name\"] }\n end\n\n @posts.first\n end",
"def posts\n Post.filter(:tag_id => self.tag_id)\n end",
"def posts\n @posts ||= retrieve_posts\n end",
"def posts\n Posts.new(self)\n end",
"def all_post\n end",
"def explore\n @posts = Post.all\n end",
"def posts\n waterfall(@site.posts.docs,\n true\n )\n end",
"def posts\n @browser.divs(:class, 'post').map { |div| PostSummary.new(div) }\n end",
"def posts\n @browser.divs(:class, 'post').map { |div| PostSummary.new(div) }\n end",
"def related_posts; end",
"def show\n @sci = Post.limit(4).order('created_at ASC')\n @latest = Post.limit(6).order('created_at DESC')\n @popular2 = Post.limit(6).order(\"RANDOM()\")\n @footer = Post.limit(3).order('created_at DESC')\n @footer2 = Post.limit(3).order(\"RANDOM()\")\n @also = Post.limit(4).order(\"RANDOM()\")\n\n prepare_meta_tags(site: 'The Shedonist',\n title: @post.title,\n description: @post.body,\n image: @post.image,\n twitter: {card: \"summary_large_image\"})\n\n end",
"def show\n\t @tags = @posts.tags\n end",
"def posts\n return @posts\n end",
"def posts\n return @posts\n end",
"def get_blog_posts\n\t\treturn @blog_posts\n\tend",
"def index\n\t\t@post = Post.all\n\t\t# stream\n\tend",
"def posts\n posts = @client.entries(content_type: 'post').items\n posts || []\n end",
"def explore\n #all posts are collected from the database\n @posts = Post.all\n @newPost = Post.new\n end",
"def newsfeed\n Post.newsfeed_for(self)\n end",
"def posts_feed\n\n init_posts_feed\n\n end",
"def user_posts\n posts = []\n self.posts.order(\"id desc\").each do |post|\n post = post.attributes.merge(image: post.image.url)\n posts << post\n end\n posts\n end",
"def retrieve_posts\n # Get posts\n rss = RSS::Parser.parse(AWL_RSS_URL)\n\n # Grab shortened URLs\n links = rss.items.map(&:guid).map(&:content)\n\n @articles = []\n\n links.each do |link|\n @articles << Article.new(link)\n end\n\n # TODO: Only grab the tags for articles that haven't already be tweeted\n @articles.map(&:retrieve_tags)\n end",
"def publish(all_blog_posts) #something wrong with publish\n all_blog_posts.each do |blog_post| #something wrong with each here\n puts blog_post.title\n puts blog_post.created_at\n puts blog_post.content\n end\n end",
"def extract_posts(doc, t)\n doc.search('post').each do |post|\n post_url = post['url']\n small_image_url = post.search('photo-url[@max-width=\"400\"]').first\n if small_image_url\n small_image_url = small_image_url.content\n max_image_url = post.search('photo-url[@max-width=\"1280\"]').first\n if max_image_url\n max_image_url = max_image_url.content\n end\n\n # try to locate a possible original blog\n via = nil\n link = post.search('photo-link-url').first\n if link\n link = validate_url(link.content)\n if link =~ TEST_TUMBLR_REGEX\n via = root_url(link)\n end\n end\n if via\n caption = post.search('photo-caption').first\n if caption\n Nokogiri::HTML.fragment(caption.content).search('a').each do |a|\n unless via\n href = a['href']\n if href && (href =~ TEST_TUMBLR_REGEX)\n via = root_url(href)\n end\n end\n end\n end\n end\n t_via =via ? (Tumblr.filter(:url => via).first || Tumblr.create(:url => via)) : nil\n unless Post.filter(:url => post_url).first\n Post.create(:url => post_url,\n :small_image_url => small_image_url,\n :max_image_url => max_image_url,\n :tumblr => t,\n :timestamp => Time.at(post['unix-timestamp'].to_i).send(:to_datetime),\n :via => t_via)\n end\n else\n p post\n end\n end\n end",
"def show\n @post = @post_block.post\n end",
"def posts\n Event.source(self).posts.order(created_at: :desc)\n end",
"def post_titles\n self.posts.collect{|post| post.title}\n end",
"def index\n if params[:category_slug].present?\n @category = PostCategory.friendly.find(params[:category_slug])\n @posts = Post.where(category: @category).latest.limit(5)\n else\n @posts = Post.latest.limit(5)\n end\n\n @featured = Post.order('RANDOM()').limit(4)\n @result = Front::RelatedItemsBuilder.new(@posts).build\n end",
"def view_post\n content \n end",
"def index\n @tags_posts = TagsPost.all\n end",
"def retrieve_posts(dir); end",
"def index\n\t@posts = list_posts\n end",
"def blog\n @posts = Post.page(params[:page]).order('created_at DESC').where(:industry_category_id => nil)\n end",
"def index\n\t@posts = Post.order(sort_column_votes + \" \" + sort_direction)\n\n\t@posts = @posts.tipo(\"url\")\n\t@contador = 0\n\n end",
"def initialize\r\n @posts = []\r\nend",
"def explorer\n @posts =Post.all\n end",
"def posts \n Post.all.select {|post| post.author == self}\n end",
"def show\n @comments = @posting.forest\n end",
"def post\n array = []\n Post.post.each do |element|\n if element.user_id == self.user_id\n array << element\n end\n end\n array.each do |post|\n puts post.title\n end\n end",
"def index\n @post_tags = PostTag.all\n end",
"def view_posts\n self.user.posts.map do |post|\n post.reload.content\n end\n end",
"def index\n\n res_posts = Post.select(\"id, title, author_id, left(content,#{MAX_CONTENT_LENGTH}) as content, created_at, published\").order( created_at: :desc )\n\n a_parms = get_params()\n\n @author_id = nil\n\n if( a_parms[:author_id] ) #filter posts by author\n parm_author_id = a_parms[:author_id].to_i\n\n raise ApplicationController::NotAuthorized, 'Access denied' if !user_signed_in?\n raise ApplicationController::NotAuthorized, \"Access denied to resources from another author\" if( current_author_id != parm_author_id )\n @author_id = parm_author_id \n res_posts = res_posts.where(author_id: @author_id)\n else\n res_posts = res_posts.published\n end\n\n\n @posts = res_posts.paginate(page: params[:page], per_page: POSTS_PER_PAGE)\n end",
"def index\n @posts = Post.all\n \n end",
"def index\n @posts = Post.all \n #appel le modèle Post pour retrourner tous les posts dans la table\n #le résultat de cet appel est un tableau de posts stocké dans la variable d'instance @posts\n end",
"def index\n # @post = Post.find(params[:post_id])\n @comments = @post.comments\n end",
"def index\n @collection_posts = CollectionPost.all\n end",
"def index\n #@posts = Post.all\n @posts = Post.all\n end",
"def index\n \t# @posts = Post.all.limit(10).includes(:photos, :user, :likes).order('created_at desc')\n\n @posts = Post.paginate(:page => params[:page], :per_page => 5).includes(:photos, :user, :likes).order('created_at desc')\n \t@post = Post.new\n end",
"def blog\n object._blog\n end",
"def posts\n return [] unless valid?\n\n @posts ||=\n Course::Discussion::Post.forum_posts.from_course(@course).\n includes(topic: { actable: :forum }).\n calculated(:upvotes, :downvotes).\n where(created_at: start_time..end_time).\n where(creator_id: @user)\n end",
"def index\n @posts = Post.includes(:tags).all.page(params[:page]).per(PER).order(id:\"DESC\")\n end",
"def index\n @posts = Post.find(:all)\n end",
"def posts( params={} )\n posts = get_connections(\"posts\", params)\n return map_connections posts, :to => Facebook::Graph::Post\n end",
"def posts( params={} )\n posts = get_connections(\"posts\", params)\n return map_connections posts, :to => Facebook::Graph::Post\n end",
"def index\n @posts = Post.eager_loading.last_published\n end",
"def all\n@posts = Post.all\nend",
"def index\n @posts = BlogPost.all\n end",
"def show\n @categories = Category.all\n @post_sections = @post.post_sections\n @comments = @post.comments.limit(5).order(created_at: :desc)\n @posts = Post.published.where(category: @post.category.id)\n end",
"def collect_blog_posts\n\t\treturn @all_blog_posts\n\tend",
"def posts limit = 50\n query = {\n posts: \"SELECT post_id, actor_id, message, description, attachment.name, attachment.href, attachment.caption, attachment.description, type,\n attachment.icon, attachment.media, created_time, updated_time FROM stream WHERE source_id = #{@id} ORDER BY created_time DESC LIMIT #{limit}\",\n comments: \"SELECT id, fromid, time, text, object_id, parent_id FROM comment WHERE post_id IN(SELECT post_id FROM #posts) ORDER BY time DESC LIMIT 10\",\n users: \"SELECT uid, name FROM user WHERE uid IN(SELECT actor_id FROM #posts) OR uid IN(SELECT fromid FROM #comments)\",\n pages: \"SELECT page_id, name FROM page WHERE page_id IN(SELECT actor_id FROM #posts) OR page_id IN(SELECT fromid FROM #comments)\"\n }\n\n proxy_exceptions do\n query = FbGraph::Query.new(query).fetch(access_token: @access_token)\n\n # Ignore posts that are created automatically following a video or photo, as we already alert about it anyway.\n query[:posts].delete_if do |post|\n post[:type].in? [POST_TYPE_VIDEO_POSTED, POST_TYPE_PHOTOS_POSTED]\n end\n\n query[:posts].map do |post_data|\n Services::Facebook::Post.new do |post|\n post.id = post_data[:post_id]\n post.message = post_data[:message]\n\n if post_attachment_data = post_data[:attachment]\n post.name = post_attachment_data[:name]\n post.caption = post_attachment_data[:caption]\n post.description = post_attachment_data[:description]\n post.icon = post_attachment_data[:icon]\n\n if post_attachment_data[:media] && post_attachment_data[:media].any?\n post.picture = post_attachment_data[:media][0][:src]\n end\n end\n\n post.created_at = Time.at post_data[:created_time]\n post.updated_at = Time.at post_data[:updated_time]\n\n # The author of a post can be either a User or a Page.\n user_or_page_data = query[:users].find { |user_data| user_data[:uid] == post_data[:actor_id] } ||\n query[:pages].find { |page_data| page_data[:page_id] == post_data[:actor_id] }\n\n # There may occasionally be no data for the author of a comment, despite the 'fromid' of the comment being\n # set to a valid Facebook ID. There's no documentation as to the circumstances under which this occurs, but it\n # is generally assumed that it is because the user that queries it doesn't have access to view it (for example,\n # the user could fall outside of geographical limitations set by the page that authored the comment).\n if user_or_page_data\n post.author = new_user user_or_page_data\n end\n\n # To find the post a comment belongs to, we must compare its 'object_id' attribute and to part of the post's id.\n comments_data = query[:comments].select { |comment_data| comment_data[:object_id] == post_data[:post_id].split(\"_\").last }\n\n post.comments = new_comments comments_data, users: query[:users], pages: query[:pages]\n end\n end.compact\n end\n end",
"def index\n @linkposts = Linkpost.all\n end",
"def posts\n Post.all_for_event(self.id)\n end",
"def show\n @last_posts = Post.order('created_at DESC').limit(10) #se recogen los 10 posts mas recientes.\n @comment = Comment.new() # Se crea un comentario vacio que será el que se salve si el usuario escribe un comentario en alguno de los posts.\n @post = Post.find(params[:id])\n @title = \"The unfolding blue box: \" + @post.title\n @tags = Tag.all\n @meta_tags = @post.tags.all\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @post }\n end\n end",
"def portfolio\n\t\t@products = Post.where(\"category_id = 4\")\n\tend",
"def index\n @post = Post.all.order(\"created_at DESC\")\n @category = Category.all.order(\"id ASC\").limit(13)\n @category = Post.where(category: true)\n end",
"def index\n @comments = @post.comments.all\n \n end",
"def get_wp_posts(category = 'the-policy')\n # wp_sfposts\n wp.query(<<-QUERY).to_a\n SELECT f.forum_id, t.topic_id, topic_slug, topic_name, topic_date, t.user_id topic_user_id, \n tu.display_name topic_user_name, tu.user_login topic_user, u.user_login post_user, \n u.display_name post_user_name, p.post_id, post_content, post_date post_date, p.user_id \n FROM wp_sfposts p \n JOIN wp_sftopics t ON p.topic_id = t.topic_id\n JOIN wp_sfforums f ON f.forum_id = t.forum_id \n JOIN wp_users u ON u.id = p.user_id\n JOIN wp_users tu ON tu.id = t.user_id\n WHERE f.forum_slug = '#{category}' AND topic_date >= DATE_SUB(NOW(),INTERVAL 1 YEAR)\n ORDER BY t.topic_date DESC, p.post_date ASC\n QUERY\n end",
"def posts\n backend.wall_page(self).posts\n end",
"def index\n @posts = Post.all\n\n liquid_markup = '\n <div id=\"posts\">\n {% for post in posts %}\n <div class=\"panel\">\n <div class=\"panel-heading\">\n <h3 class=\"panel-title\">{{ post.title }}\n <ul class=\"list-unstyled list-inline pull-right\">\n <li><a href=\"{{ post.url }}\"><i class=\"icon-eye-open\"></i> Show</a></li>\n <li><a href=\"{{ post.edit_url }}\"><i class=\"icon-pencil\"></i> Edit</a></li>\n <li><a href=\"{{ post.url }}\" data-method=\"delete\" data-confirm=\"Are you sure?\"><i class=\"icon-trash\"></i> Destroy</a></li>\n </ul></h3>\n </div>\n {{ post.body }}\n </div>\n {% endfor %}\n </div>'\n @template = Liquid::Template.parse(liquid_markup)\n end",
"def index\n @posts = paginate(Post.eager(:comments, :user))\n @title = 'Posts'\n end",
"def related_posts\n @related_posts ||= Jekyll::RelatedPosts.new(self).build\n end",
"def feed\n @posts = Post.feed_of(params[:id])\n end",
"def get_posts posts\n # Get the 6 latest -- TODO this should be configurable\n limit = 6\n # Our page number\n page = (params[:page].to_i - 1) || 1\n # Our query if there is one set\n @query = params[:query] || ''\n # Get the latest posts by go_live\n posts = posts.order('go_live DESC')\n # Make sure we are only getting those that are published\n posts = posts.where( :state => :published )\n # Make sure we are talking about posts or messages\n t = Post.arel_table\n posts = posts.where( t[:object_type].matches(:post).or(t[:object_type].matches(:message)))\n # Make sure they don't have a password.. those are \"private\"\n posts = posts.where( :password => nil )\n # If a query is set, use it\n posts = posts.where([\"content like ?\", '%'+@query+'%'] ) if @query.present?\n # Get our filtered post count for pagination\n filtered_post_count = posts.count\n # Limit the number of posts to show\n posts = posts.limit(limit)\n # Set the offset if we aren't on the first page.\n posts = posts.offset(limit.to_i * page.to_i) if page > 0\n # Need this to show a previous/next button\n @pagination_number_of_pages = (filtered_post_count / limit) +1\n @pagination_current_page = (page.to_i + 1) > 0 ? (page.to_i + 1) : 1\n\n posts\n end",
"def index\n @posts = Post.includes(:author)\n .order(created_at: :desc)\n .paginate(page: params[:page], per_page: 4)\n end",
"def get_posts_for_year_and_tags\n posts = get_posts_for_year\n posts = get_posts_for_tags posts\n posts\n end",
"def index\n @posts = Post.global.main.sorted\n end",
"def index\n #how do i get data here\n @posts = Post.all\n end",
"def index\n super\n @posts = Post.all\n end",
"def index\n \t@posts = Post.all\n end",
"def index\n @posts = Post.order(\"published_at DESC\").all\n end",
"def get_blog_posts\n return @items.select { |item| item.identifier.index('/blog/') == 0 && item[:published] }.reverse\nend",
"def index\n @events = Event.order('created_at DESC')\n @instagram = Instagram.user_recent_media(\"28199981\", {:count => 9})\n @posts = Post.order('created_at DESC').limit(6)\n end",
"def index\n @posts = Post.paginate(:all, :page => params[:page], :per_page => 20, :order => \"posts.created_on desc, comments.created_on\", :include => [ :comments, :user ])\n @title = \"rawdod\"\n# @hotness = Post.find(:all, :order => \"commented_on desc\", :limit => 8, :conditions => [\"commented_on is NOT NULL\"])\n respond_to do |format|\n format.html # index.rhtml\n format.xml { render :xml => @posts.to_xml }\n end\n end",
"def get_posts\n db = SQLite3::Database.new(\"db/database.db\")\n db.results_as_hash = true\n\n posts = db.execute(\"SELECT posts.Text, posts.PostId, posts.Upvotes, users.Username FROM posts INNER JOIN users ON users.UserId = posts.UserIdP\")\n\n return posts\n end",
"def index\n\t #this accesses all the posts from the model 'Post' and stores them in @post\n\t #the includes method ensures that comments will be loaded simultaneously with Posts\n\t if params[:tag]\n @posts = Post.includes(:comments).order(\"created_at DESC\").tagged_with(params[:tag]).page(params[:page]).per(21)\n\t else\t\n\t @posts = Post.includes(:comments).order(\"created_at DESC\")\n\t end\n\t \n\n\n\t\t@q = @posts.search(params[:q])\n\t\t@posts = @q.result(:distinct => true).page(params[:page]).per(21)\n\t #This enables atom feeds\n\t # respond_to do |format|\n # format.html\n # format.atom\n # format.rss { render :layout => false } #index.rss.builder\n # end\n\tend",
"def next_posts\n Post.\n eager(:tumblr).\n eager(:tags).\n where('skip is not ?', true).\n where(:posted => false).\n where('tumblr_id not in (?)', skippable_tumblr_ids).\n order(:score.desc, :fetched.desc)\n end",
"def index\n @posts = Post.all\n\n\n\n end",
"def index\n @posts = Post.front_page_posts\n end",
"def index\n @posts = Post.top.includes(user: :avatar_attachment).paginate(page: params[:page], per_page: 5)\n @posts = @posts.includes(:comments, :likes)\n @posts = @posts.includes(image_attachment: :blob)\n\n\n end",
"def index\n @post = find_post\n @post_sections = @post.sections\n end",
"def list_post\n \t@post = Post.find(params[:id])\n end",
"def index\n @posts = posts_index(Post.all)\n end",
"def links_feed\n end",
"def index\n @posts = Post.all\n\tend",
"def index\n \t# instance variable is available in other files - i.e the view\n \t# without the @ it will be a local variable only available within this method\n \t@posts = Post.all\n end",
"def scraper\n blog.scraper\n end",
"def index\n @posts = Post.all\n\n end",
"def index\n @posts = Post.all\n\n end"
] |
[
"0.7035623",
"0.6527618",
"0.64957213",
"0.645495",
"0.6439085",
"0.63842607",
"0.6325334",
"0.6231727",
"0.6226449",
"0.6223985",
"0.6223985",
"0.6198908",
"0.6194824",
"0.617871",
"0.6150881",
"0.6150881",
"0.61096644",
"0.6045314",
"0.6037336",
"0.6037199",
"0.60022485",
"0.59972703",
"0.59926",
"0.599019",
"0.5988741",
"0.59844005",
"0.5973435",
"0.5965282",
"0.59603727",
"0.5953647",
"0.59509057",
"0.59448713",
"0.59385395",
"0.5932052",
"0.5927092",
"0.5923857",
"0.59191006",
"0.5918803",
"0.591876",
"0.5896902",
"0.58954424",
"0.5872013",
"0.5860797",
"0.5856709",
"0.58507377",
"0.584321",
"0.5842684",
"0.5835012",
"0.58323294",
"0.5827726",
"0.58209336",
"0.58184594",
"0.5813425",
"0.5797028",
"0.57931465",
"0.57931465",
"0.5785605",
"0.57817626",
"0.5769361",
"0.5763905",
"0.57611",
"0.57543445",
"0.57474345",
"0.57463133",
"0.5743426",
"0.5738359",
"0.57339454",
"0.5724071",
"0.57231873",
"0.5720055",
"0.5715837",
"0.57121706",
"0.5708182",
"0.57061243",
"0.57007855",
"0.5697908",
"0.5697841",
"0.5696078",
"0.5692716",
"0.56859165",
"0.568303",
"0.5681711",
"0.56769747",
"0.5675748",
"0.56719446",
"0.56635684",
"0.5658376",
"0.56553465",
"0.56536067",
"0.56471914",
"0.5643485",
"0.5638372",
"0.563805",
"0.5630555",
"0.5630046",
"0.56239665",
"0.5621457",
"0.56212944",
"0.5617597",
"0.5617597"
] |
0.5796785
|
54
|
The tree name is the same for any genealogy tree, so it doesn't make sense to load the selected node from the session.
|
def active_node_set(tree_nodes)
# Find the right node to be selected based on the @root.id
selected = tree_nodes.first[:nodes].find do |node|
self.class.extract_node_model_and_id(node[:key])[1] == @root.id.to_s
end
# If no node has been found, just select the root node
selected ||= tree_nodes.first
# Set it as the active node in the tree state
@tree_state.x_node_set(selected[:key], @name)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def name\n\n tree[0]\n end",
"def default_tree_name\n ''\n end",
"def set_tree\n\t\t@tree = Tree.find(params[:id])\n\tend",
"def set_tree\n @tree = Tree.find(params[:id])\n end",
"def set_tree\n @tree = Tree.find(params[:id])\n end",
"def set_tree\n @tree = Tree.find(params[:id])\n end",
"def set_tree\n @tree = Tree.find(params[:id])\n end",
"def set_tree\n @tree = Tree.find(params[:id])\n end",
"def name\n @name ||= @node['name']\n end",
"def name\n node.name\n end",
"def name\n node.name\n end",
"def name\n @name ||= @node['name']\n end",
"def tree_select\n @explorer = true\n\n @lastaction = \"explorer\"\n self.x_node = params[:id]\n @nodetype, id = parse_nodetype_and_id(params[:id])\n\n if x_tree[:type] == :containers_filter && TreeBuilder.get_model_for_prefix(@nodetype) != \"Container\"\n search_id = @nodetype == \"root\" ? 0 : from_cid(id)\n adv_search_build(vm_model_from_active_tree(x_active_tree))\n session[:edit] = @edit # Set because next method will restore @edit from session\n listnav_search_selected(search_id) unless params.key?(:search_text) # Clear or set the adv search filter\n if @edit[:adv_search_applied] &&\n MiqExpression.quick_search?(@edit[:adv_search_applied][:exp]) &&\n %w(reload tree_select).include?(params[:action])\n self.x_node = params[:id]\n quick_search_show\n return\n end\n end\n\n replace_right_cell\n end",
"def show_tree\n\t\t@root_node.show\n\tend",
"def node_name(name)\n self.__add_string('node_name', name)\n end",
"def node_name(custom_node_name = \"\")\n self._node_name = custom_node_name\n end",
"def node(name)\n nodes[name]\n end",
"def shure_select_node(_node)\n return if @selecting_node\n #return if @tree_exp.exist?(_node.rif)\n @selecting_node = true\n _proc = @tree_exp.selectcommand\n @tree_exp.selectcommand(nil)\n begin\n @tree_exp.selection_clear\n @tree_exp.selection_add(_node.rif)\n @opened = false\n to_open = @last_open_node\n parent = _node.parent\n while !parent.nil? && parent.rif != 'root'\n @tree_exp.open_tree(parent.rif, false)\n @opened = to_open==parent.rif || @opened\n @last_open_node=parent.rif\n parent = parent.parent\n end\n\n @tree_exp.close_tree(to_open) if to_open && !@opened\n\n @tree_exp.see(_node.rif)\n ensure\n @tree_exp.selectcommand(_proc)\n @selecting_node = false\n end\n end",
"def show_tree\n\tend",
"def goto_controller(name_parameter)\n node_object = TreeFolder.find_by(name: name_parameter)\n session[:root] = FolderNode.find_by(node_object_id: node_object.id).id\n redirect_to controller: 'tree_display', action: 'list'\n end",
"def on_node_name_set( node, name )\n\t\t\tself.log.debug \"unhandled on_node_name_set: %p is now named %p\" % [ node, name ]\n\t\tend",
"def tree_params\n params.require(:tree).permit(:common_name, :scientific_name, :forest_id)\n end",
"def tree\r\n @rootNode\r\n end",
"def get_tree_item(tree, path)\n if path.nil? || path == ''\n tree\n else\n m = /^([^ ]*) ([^ ]*) ([^\\t]*)\\t.*$/.match(invoke(:ls_tree, tree, path))\n mode = m[1]\n type = m[2]\n hash = m[3]\n if type == 'tree'\n hash\n elsif type == 'blob'\n return BlobWithMode.new(hash, mode)\n else\n raise ShellExecutionError, 'Tree item is not a tree or a blob'\n end\n end\n end",
"def node(name)\n return node_manager.find(name)\n end",
"def get_node(node)\n\t\t\t@nodes[node]\n\t\tend",
"def tree\n @stack = @rpn.clone\n get_tree\n end",
"def reload\n @_params[:id] = x_node\n @report_deleted = true if params[:deleted].present?\n tree_select\n end",
"def tree\n @tree ||= build_tree\n end",
"def target_name\n target_node.name\n end",
"def tree_lookup(name)\n @pairs[name]\n end",
"def load_tree\n\t\t\twtree = Tree.new(\"ROOT_TREE\")\n\n\t\t\tif selected_host == nil\n\t\t\t\tprint_error(\"Target not selected\")\n\t\t\telse\n\t\t\t\tframework.db.each_request_target do |req|\n\t\t\t\t\ttarray = req.path.to_s.split(WMAP_PATH)\n\t\t\t\t\ttarray.delete(\"\")\n\t\t\t\t\ttpath = Pathname.new(WMAP_PATH)\n\n\t\t\t\t\ttarray.each do |df|\n\t\t\t\t\t\twtree.add_at_path(tpath.to_s,df)\n\t\t\t\t\t\ttpath = tpath + Pathname.new(df.to_s)\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\t\treturn wtree\n\t\tend",
"def eval_tree(tree)\n geoname_ids = tree.split('.')\n geonames = geoname_ids.map { |id| Geoname.find(id).name }\n geonames.join(';')\n end",
"def node\n retract[:node]\n end",
"def get_node_name(node)\n begin\n node.name\n rescue NoMethodError\n node.to_s\n end\n end",
"def node(name)\n name = name.to_sym\n @nodes.detect{|node|\n node.name == name\n }\n end",
"def find_node_by_name(name)\n @nodes[name]\n end",
"def node(node_name)\n nodes(node_name).first\nend",
"def name\n @root\n end",
"def set_treeing\n @treeing = Treeing.find(params[:id])\n end",
"def fetch_tree(klass, name, node_id = nil)\n tree = klass.new(name, {}, false)\n\n # FIXME: maybe here we would need instance_exec/eval instead\n yield(tree) if block_given?\n\n tree.reload!\n\n if node_id\n tree.x_get_child_nodes(node_id).to_json\n else\n tree.instance_variable_get(:@bs_tree)\n end\n end",
"def node(name)\n if name =~ /\\./\n # probably got a fqdn, since periods are not allowed in node names.\n # so, take the part before the first period as the node name\n name = name.split('.').first\n end\n @nodes[name]\n end",
"def set_tree_plot\n @tree_plot = TreePlot.find(params[:id])\n end",
"def moved_node\n current_tree.find(node_2.id)\n end",
"def cmd_tree\n print_tree(Editor, 0)\n end",
"def tree_parent_node\n tree_parent + \".adoc\"\n end",
"def tree\n @treetop = @proj.default_ontology_class\n @proj.ontology_classes.first if !@treetop\n redirect_to :action => :new, :controller => :ontology_classes and return if !@treetop\n @colored_object_relationships = @proj.object_relationships.with_color_set\n @all_object_relationships = @proj.object_relationships \n render :action => 'ontology/tree/index'\n end",
"def node\n @node\n end",
"def node\n @node\n end",
"def tree\n\n h.updated_tree || h.original_tree\n end",
"def show_node(tree, node)\n print \"ID:#{node.id} Parent:#{node.parent} Keys:\"\n node.keys.each { |key| print \"[#{key}]\"}\n print \" Sub trees:\"\n node.sub_trees.each { |sub_tree| print \"-#{sub_tree}-\"}\n print \"\\n\"\n node.sub_trees.compact.each { |sub_tree| show_node(tree, tree.nodes[sub_tree])}\nend",
"def set_tree\n @tree = Tree\n .where(:root_uri => params[:root_uri])\n .first_or_create(:root_uri => params[:root_uri])\n end",
"def nodeName\n @name\n end",
"def nodeName\n @name\n end",
"def nodeName\n @name\n end",
"def node; changeset.node; end",
"def set_branch_tree\n @branch_tree = BranchTree.find(params[:id])\n end",
"def node\n @context.node\n end",
"def tree_select_box(nodes, selected= nil, hide= nil, label=\"Parent\", add_initial=false)\n level = 0\n select_box = add_initial ? \"<option value=0>No #{label}</option>\\n\" : \"\"\n selected = nodes[0].id if selected.nil? and not add_initial\n nodes.each {|node| select_box += add_select_tree_node(node, selected, level, hide) }\n select_box += ''\n end",
"def show_tree\n htmltree = \"\"\n self.each { |node| \n htmltree += \"<li><a href='#{normalize(node.name)}'>\"\n htmltree += ' ' * node.node_depth * 3\n htmltree += \"#{node.name}</a></li>\\n\"\n }\n htmltree\n end",
"def tree(name = nil)\n if name.present?\n joins(:curriculum).where('curriculums.name = ? OR curriculums.slug = ?', name, name)\n elsif (default = Curriculum.default)\n where(curriculum_id: default.id)\n else\n where(nil)\n end\n end",
"def tree(data_path, options = {})\n\t\t\t\tresult = \"\"\n\n\t\t\t\t# Unique hash\n\t\t\t\t@hash = Digest::SHA1.hexdigest(data_path.to_s)\n\n\t\t\t\t# Options\n\t\t\t\t@options = options.nil? ? {} : options\n\n\t\t\t\t# Clipboard\n\t\t\t\tif @options[:clipboard_attrs]\n\t\t\t\t\tclipboard = true\n\t\t\t\t\t@options[:clipboard_attrs] = [@options[:clipboard_attrs]] if !@options[:clipboard_attrs].is_a?(Array)\n\t\t\t\t\tclipboard_attrs_js = \"[\" + @options[:clipboard_attrs].map { |item| \"'#{item}'\" }.join(\",\") + \"]\"\n\t\t\t\telse\n\t\t\t\t\tclipboard = false\n\t\t\t\t\tclipboard_attrs_js = \"[]\"\n\t\t\t\tend\n\n\t\t\t\t# Actions\n\t\t\t\tif @options[:actions]\n\t\t\t\t\tactions_js = \"[\"\n\t\t\t\t\toptions[:actions].each do |key, action|\n\t\t\t\t\t\tactions_js += %{\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\turl: '#{action[:path] ? @path_resolver.resolve(action[:path], \":id\") : \"\"}',\n\t\t\t\t\t\t\t\ticon: '#{action[:icon]}',\n\t\t\t\t\t\t\t\tlabel: '#{action[:label]}',\n\t\t\t\t\t\t\t\tcollapsed: #{action[:collapsed] == true ? \"true\" : \"false\"},\n\t\t\t\t\t\t\t\tstyle: '#{action[:style] ? action[:style] : \"default\"}',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t}\n\t\t\t\t\tend\n\t\t\t\t\tactions_js += \"]\"\n\t\t\t\telse\n\t\t\t\t\tactions_js = \"[]\"\n\t\t\t\tend\n\n\t\t\t\t# Parent\n\t\t\t\tparent = (options[:parent] ? options[:parent] : nil)\n\n\t\t\t\t# Save state\n\t\t\t\tsave_state = (options[:save_state] ? options[:save_state] : :simple)\n\n\t\t\t\t# Application JS\n\t\t\t\tresult += @template.javascript_tag(%{\n\t\t\t\t\tvar rug_tree_#{@hash} = null;\n\t\t\t\t\t$(document).ready(function() {\n\t\t\t\t\t\trug_tree_#{@hash} = new RugTree('#{@hash}', {\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t// Model\n\t\t\t\t\t\t\tmodel: 'node',\n\n\t\t\t\t\t\t\t// State\n\t\t\t\t\t\t\tsaveState: '#{save_state.to_s}',\n\n\t\t\t\t\t\t\t// Parent element\n\t\t\t\t\t\t\tparent: '#{parent.to_s}',\n\n\t\t\t\t\t\t\t// Icons\n\t\t\t\t\t\t\tclosedIcon: '#{@icon_builder.render(@options[:closed_icon] ? @options[:closed_icon] : \"chevron-right\")}',\n\t\t\t\t\t\t\topenedIcon: '#{@icon_builder.render(@options[:opened_icon] ? @options[:opened_icon] : \"chevron-down\")}',\n\n\t\t\t\t\t\t\t// Show\n\t\t\t\t\t\t\tshow: #{check_show(@options) ? 'true' : 'false'},\n\t\t\t\t\t\t\tshowEvent: '#{@options[:show_event] && @options[:show_event].to_sym == :double_click ? \"dblclick\" : \"click\"}',\n\t\t\t\t\t\t\tshowUrl: '#{@path_resolver.resolve(@options[:paths][:show], \":id\")}',\n\n\t\t\t\t\t\t\t// Create\n\t\t\t\t\t\t\tcreate: #{check_create(@options) ? 'true' : 'false'}, \n\t\t\t\t\t\t\tcreateUrl: '#{@path_resolver.resolve(@options[:paths][:create])}',\n\t\t\t\t\t\t\tcreateIcon: '#{@icon_builder.render(@options[:update_icon] ? @options[:update_icon] : \"plus\")}',\n\t\t\t\t\t\t\tcreateLabel: '#{I18n.t(\"general.action.create_child\").upcase_first}',\n\t\t\t\t\t\t\tcreateActionCollapsed: #{@options[:create_action_collapsed] == true ? 'true' : 'false'}, \n\t\t\t\t\t\t\tcreateSuccessMessage: '#{I18n.t(\"general.messages.create.success\")}',\n\n\t\t\t\t\t\t\t// Update\n\t\t\t\t\t\t\tupdate: #{check_update(@options) ? 'true' : 'false'}, \n\t\t\t\t\t\t\tupdateUrl: '#{@path_resolver.resolve(@options[:paths][:update], \":id\")}', \n\t\t\t\t\t\t\tupdateIcon: '#{@icon_builder.render(@options[:update_icon] ? @options[:update_icon] : \"pencil\")}',\n\t\t\t\t\t\t\tupdateLabel: '#{I18n.t(\"general.action.update\").upcase_first}',\n\t\t\t\t\t\t\tupdateActionCollapsed: #{@options[:update_action_collapsed] == true ? 'true' : 'false'}, \n\t\t\t\t\t\t\tupdateSuccessMessage: '#{I18n.t(\"general.messages.create.success\")}',\n\n\t\t\t\t\t\t\t// Destroy\n\t\t\t\t\t\t\tdestroy: #{check_destroy(@options) ? 'true' : 'false'}, \n\t\t\t\t\t\t\tdestroyUrl: '#{@path_resolver.resolve(@options[:paths][:destroy], \":id\")}', \n\t\t\t\t\t\t\tdestroyIcon: '#{@icon_builder.render(@options[:update_icon] ? @options[:update_icon] : \"trash\")}',\n\t\t\t\t\t\t\tdestroyLabel: '#{I18n.t(\"general.action.destroy\").upcase_first}',\n\t\t\t\t\t\t\tdestroyActionCollapsed: #{@options[:destroy_action_collapsed] == true ? 'true' : 'false'}, \n\t\t\t\t\t\t\tdestroyConfirmMessage: '#{I18n.t(\"general.are_you_sure\")}',\n\t\t\t\t\t\t\tdestroySuccessMessage: '#{I18n.t(\"general.messages.destroy.success\")}',\n\n\t\t\t\t\t\t\t// Moving\n\t\t\t\t\t\t\tmoving: #{check_moving(@options) ? 'true' : 'false'},\n\t\t\t\t\t\t\tmovingUrl: '#{@path_resolver.resolve(@options[:paths][:move], \":id\", \":relation\", \":destination_id\")}',\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t// Type\n\t\t\t\t\t\t\ttypeIconTemplate: '#{@icon_builder.render(\":icon\", class: \"jqtree-icon\")}',\n\t\t\t\t\t\t\ttypeIconAttr: '#{@options[:type_icon_attr]}',\n\n\t\t\t\t\t\t\t// Actions\n\t\t\t\t\t\t\tactions: #{actions_js},\n\t\t\t\t\t\t\tactionsIconTemplate: '#{@icon_builder.render(\":icon\")}',\n\n\t\t\t\t\t\t\t// Clipboard\n\t\t\t\t\t\t\tclipboard: #{clipboard ? 'true' : 'false'},\n\t\t\t\t\t\t\tclipboardIcon: '#{@icon_builder.render(@options[:clipboard_icon] ? @options[:clipboard_icon] : \"clipboard\")}',\n\t\t\t\t\t\t\tclipboardTemplate: \"#{clipboard ? (@options[:clipboard_template] ? @options[:clipboard_template].gsub('\"', \"'\") : \":\" + @options[:clipboard_attrs].first) : \"\"}\",\n\t\t\t\t\t\t\tclipboardAttrs: #{clipboard_attrs_js},\n\t\t\t\t\t\t\tclipboardActionCollapsed: #{@options[:clipboard_action_collapsed] == true ? 'true' : 'false'}, \n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t// Select\n\t\t\t\t\t\t\tselectByDefault: #{@options[:select_by_default] ? @options[:select_by_default].to_i : \"null\"},\n\n\t\t\t\t\t\t\t// Reload\n\t\t\t\t\t\t\treloadIcon: '#{@icon_builder.render(@options[:update_icon] ? @options[:update_icon] : \"refresh\")}',\n\t\t\t\t\t\t\treloadLabel: '#{I18n.t(\"general.action.reload\").upcase_first}',\n\t\t\t\t\t\t});\n\t\t\t\t\t\trug_tree_#{@hash}.ready();\n\t\t\t\t\t});\n\t\t\t\t\t$(document).on('turbolinks:load', function() {\n\t\t\t\t\t\trug_tree_#{@hash}.repair();\n\t\t\t\t\t});\n\t\t\t\t})\n\n\t\t\t\tresult += %{\n\t\t\t\t\t<div id=\"tree-#{@hash}\" data-url=\"#{data_path.to_s}\"></div>\n\t\t\t\t}\n\n\t\t\t\treturn result.html_safe\n\t\t\tend",
"def tree\n @vision = Vision.first\n end",
"def x_show\n @explorer = true\n tree_select\n end",
"def master_node\n {:nodename => @master_nodename}\n end",
"def set_tree\n @tree = Tree.with_attached_images.find(params[:id])\n end",
"def jstree\n show\n end",
"def TreeView_Select(hwnd, hitem, code) send_treeview_message(hwnd, :SELECTITEM, wparam: code, lparam: hitem) end",
"def tree_params\n params.require(:tree).permit(:name, :data, :root_uri)\n end",
"def tree\n h.updated_tree || h.original_tree\n end",
"def set_tree\n @organism = Tree.with_all.find(params[:id])\n end",
"def tree\n Content::ContentTree.key\n end",
"def default_tree_mode=(mode)\n @default_tree_mode = mode.to_sym\n end",
"def tree\n\n @definition = Definition.find(params[:id])\n\n uri = @definition.local_uri\n\n # TODO : reject outside definitions ?\n\n pdef = open(uri).read\n\n var = params[:var] || 'proc_tree'\n\n # TODO : use Rails callback thing (:callback)\n\n tree = RuotePlugin.ruote_engine.get_def_parser.parse(pdef)\n\n render(\n :text => \"var #{var} = #{tree.to_json};\",\n :content_type => 'text/javascript')\n end",
"def tree_params\n params.require(:tree).permit(:tree, :row, :planting_date, :pullout_date, :rootstock, :oldcode, :oldaccessioncode, :oldcollectioncode, :block_id)\n end",
"def reload_server_tree\n assert_privileges(\"reload_server_tree\")\n parent = x_node == \"root\" ? MiqRegion.my_region : Zone.find(x_node.split('-').last)\n build_server_tree(parent)\n render :update do |page|\n page << javascript_prologue\n # Replace tree\n page.replace(\"selected_#{@sb[:active_tab].split('_').last}_div\", :partial => \"selected\")\n end\n end",
"def node_entry\n \"node #{name}\"\n end",
"def get_tree_source\n raise NotImplementedError\n end",
"def node\n scope.node\n end",
"def fetchNode(name)\n n = @node_def_list[name.to_sym]\n n ? n : raise(TypeCheckError, BAD_NODE_NAME + name.to_s)\n end",
"def fetchNode(name)\n n = @node_def_list[name.to_sym]\n n ? n : raise(TypeCheckError, BAD_NODE_NAME + name.to_s)\n end",
"def walk(oidorname)\n\t\tprint_status(\"Trying to Walk the '#{oidorname}' tree......\")\n\t\t@manager.walk(\"#{oidorname}\") { |x| print_good(\"#{x}\") }\n\tend",
"def node\r\n\t\t\tparent\r\n\t\tend",
"def x_show\n # @explorer = true\n @record = VmdbIndex.find(params[:id])\n params[:id] = x_build_node_id(@record) # Get the tree node id\n tree_select\n end",
"def load_node(name)\n Chef::Log.debug(\"Loading Chef Node #{name} from CouchDB\")\n @node = Chef::Node.load(name)\n Chef::Log.debug(\"Loading Recipe for Chef Node #{name}\")\n @node.find_file(name)\n @node\n end",
"def extract_node_name(ast)\n case ast.type\n when :symbol_literal\n ast.jump(:ident).source.to_sym\n when :string_literal\n ast.jump(:tstring_content).source\n else\n nil\n end\n end",
"def tree(path)\n root.tree(path)\n end",
"def current_node\n Neo4j.load(@traversal_position.currentNode.getId)\n end",
"def lstree(treeish = 'master', options = {})\n tree = self.tree(treeish)\n Tree.tree_contents(self, tree.id)\n end",
"def get_node(node)\n return nil unless node[:name]\n\n #Convert the node into a Key string and fetch the corresponding data\n key = Keyify.node(node)\n value = @db.n_get(key)\n\n if value\n new_node = Marshal.load(value)\n new_node[:name] = node[:name]\n new_node[:type] = node[:type] || Config::DEFAULT_TYPE\n new_node\n end\n end",
"def selected_trees\n Rails.logger.info(\">>>Selected Tree #{params.inspect}\")\n if Pictureandmeta.add_assigned_pics(params['selected_tree'], params['add_to'])\n flash[:notice] = \"Successfully added sslected pictures.\"\n else\n flash[:notice] = \"Pictures not added due to error.\"\n end\n redirect_to :controller => 'trees', :action => 'show', :id => params['selected_tree']\n end",
"def name\n @root_name\n end",
"def select_tree(tree, *path_elements)\n path = tree_path(path_elements)\n append_to_script \"select_tree \\\"#{tree}\\\",#{path}\"\n end",
"def ajax_get_tree\n Log.add_info(request, params.inspect)\n\n show_tree\n\n render(:partial => 'ajax_get_tree', :layout => false)\n end",
"def goto_questionnaires\n node_object = TreeFolder.find_by_name('Questionnaires')\n session[:root] = FolderNode.find_by_node_object_id(node_object.id).id\n redirect_to controller: 'tree_display', action: 'list'\n end",
"def site_tree_select\n pages.order(:names_depth_cache).map { |c| [\"--\" * c.depth + c.menu_name, c.id] }\n end",
"def test_accessing_node_name\n\t\tassert_equal \"Hillman\", @location2.nodes[0].name\n\tend",
"def print_tree(id)\n puts \"--------------------- Tree Record: #{NewYorkTrees::Tree.all[id].name} ---------------------\"\n puts \"\"\n puts \"Common Name:\"\n puts \"#{NewYorkTrees::Tree.all[id].name.ljust(25)}\"\n puts \"\"\n puts \"Scientific Name:\"\n puts \"#{NewYorkTrees::Tree.all[id].scientific_name.ljust(25)}\"\n puts \"\"\n puts \"Bark:\"\n puts \"#{NewYorkTrees::Tree.all[id].bark.ljust(25)}\"\n puts \"\"\n puts \"Twigs:\"\n puts \"#{NewYorkTrees::Tree.all[id].twigs.ljust(25)}\"\n puts \"\"\n puts \"Winter Buds:\"\n puts \"#{NewYorkTrees::Tree.all[id].winter_buds.ljust(25)}\"\n puts \"\"\n puts \"Leaves:\"\n puts \"#{NewYorkTrees::Tree.all[id].leaves.ljust(25)}\"\n puts \"\"\n puts \"Fruit:\"\n puts \"#{NewYorkTrees::Tree.all[id].fruit.ljust(25)}\"\n puts \"\"\n puts \"Distinguishing Features:\"\n puts \"#{NewYorkTrees::Tree.all[id].distinguishing_features.ljust(25)}\"\n puts \"\"\n puts \"---------------------Description---------------------\"\n\n puts \"#{NewYorkTrees::Tree.all[id].description}\"\n puts \"\"\n end",
"def tree\n Tree.new(self)\n end",
"def goto_assignments\n node_object = TreeFolder.find_by_name('Assignments')\n session[:root] = FolderNode.find_by_node_object_id(node_object.id).id\n redirect_to controller: 'tree_display', action: 'list'\n end"
] |
[
"0.64836603",
"0.6103375",
"0.60930496",
"0.60095096",
"0.6008018",
"0.6008018",
"0.6008018",
"0.6008018",
"0.59673995",
"0.59000236",
"0.59000236",
"0.58977807",
"0.5787297",
"0.5723056",
"0.57167554",
"0.5714791",
"0.5699579",
"0.5693705",
"0.5688577",
"0.56785065",
"0.5655258",
"0.56219804",
"0.5579823",
"0.55529433",
"0.55510503",
"0.5546816",
"0.5508257",
"0.5499142",
"0.5485488",
"0.5438056",
"0.5436918",
"0.54359525",
"0.5431565",
"0.5427659",
"0.5416097",
"0.54111004",
"0.5399334",
"0.53973866",
"0.5375787",
"0.53753453",
"0.5370677",
"0.5356391",
"0.53218335",
"0.5316066",
"0.5296226",
"0.5286638",
"0.5277736",
"0.52753145",
"0.52753145",
"0.52616954",
"0.52463126",
"0.5244441",
"0.5241327",
"0.5241327",
"0.5241327",
"0.523522",
"0.52261996",
"0.5220453",
"0.5217551",
"0.52172965",
"0.5208621",
"0.52084917",
"0.52064383",
"0.5202347",
"0.520183",
"0.5196147",
"0.51922375",
"0.5180949",
"0.5180234",
"0.5179136",
"0.5168694",
"0.5168189",
"0.51666",
"0.5149719",
"0.51494414",
"0.5146183",
"0.51319873",
"0.51257384",
"0.5121722",
"0.5121006",
"0.5121006",
"0.51190734",
"0.51013744",
"0.50966907",
"0.5087745",
"0.50806636",
"0.50803715",
"0.50803",
"0.5078651",
"0.5074263",
"0.5070581",
"0.5058107",
"0.50506103",
"0.50483674",
"0.50477844",
"0.5041947",
"0.5037153",
"0.50357777",
"0.5034183",
"0.5019231"
] |
0.53079295
|
44
|
End point: (POST) Usage: FundAmerica::Entity.create(options) Output: Creates a new entity person or company
|
def create(options)
API::request(:post, 'entities', options)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create\n entity_data = entity_params\n entity_data[:uid] = Services::UniqueIdGenerator.new.call\n cmd = Commands::Entities::CreateEntity.new(entity_data)\n execute(cmd)\n redirect_to entities_url, success: 'Entity was successfully created.'\n rescue => error\n redirect_to new_entity_url, warning: error_messages(error)\n end",
"def create(entity)\n post(resource_path_for_entity(entity), entity.to_json)\n end",
"def create_entity(_options = {})\n # TODO: Handle exceptions\n entity = self.class.client.post(to_entity)[\"entity\"][self.class.entity_type].with_indifferent_access\n self.gr_id = entity[:id]\n end",
"def create\n @entity = Entity.new(params[:entity])\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity, notice: 'Entity was successfully created.' }\n format.json { render json: @entity, status: :created, location: @entity }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entity = Entity::Repo.new(entity_params)\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to entity_url(@entity), notice: 'Entity was successfully created.' }\n format.json { render :show, status: :created, location: @entity }\n else\n format.html { render :new }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @breadcrumb = 'create'\n @entity = Entity.new(params[:entity])\n @entity.created_by = current_user.id if !current_user.nil?\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity, notice: crud_notice('created', @entity) }\n format.json { render json: @entity, status: :created, location: @entity }\n else\n @towns = towns_dropdown\n @provinces = provinces_dropdown\n @zipcodes = zipcodes_dropdown\n format.html { render action: \"new\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n begin\n @resource = Entity.new(params[:entity])\n @resource.save!\n render :response => :POST\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def create\n entity = _get_class.new(_entity_params)\n\n # do any object-specific processing, if any\n _process_on_create entity\n\n # Rails does not understand your route namespaces when inferring the route,\n # so it attempts <MODEL NAME>_url - a route which does not exist!\n # Adding symbols in front of the resource will allow Rails to infer the route correctly,\n # in the Company case, api_v1_company_url\n\n # When using `respond_with`, you don't need to use `if record.save` before a `respond_with` call.\n # Rails will check if the record saved successfully for you and render a 422 with errors if it failed to save.\n # Cannot use save! here since save! does not suppress the exceptions\n status = entity.save\n _maybe_log_errors 'create', entity\n respond_with :v2, entity, entity: _get_class\n end",
"def create(entity)\n\n # check some basic pre-conditions\n raise \"Endpoint is not connected!\" unless @connected\n raise \"#{entity} not an entity\" unless entity.kind_of? Occi::Core::Entity\n\n # is this entity valid?\n entity.model = @model\n entity.check\n\n Occi::Log.debug \"Entity kind: #{entity.kind}\"\n kind = entity.kind\n raise \"No kind found for #{entity}\" unless kind\n\n # get location for this kind of entity\n Occi::Log.debug \"Kind location: #{entity.kind.location}\"\n location = kind.location\n collection = Occi::Collection.new\n\n # is this entity a Resource or a Link?\n Occi::Log.debug \"Entity class: #{entity.class.name}\"\n collection.resources << entity if entity.kind_of? Occi::Core::Resource\n collection.links << entity if entity.kind_of? Occi::Core::Link\n\n # make the request\n post location, collection\n end",
"def create_entity(entity, aliases)\n store_entity(entity, aliases)\n end",
"def create\n @breadcrumb = 'create'\n @entity_type = EntityType.new(params[:entity_type])\n @entity_type.created_by = current_user.id if !current_user.nil?\n \n respond_to do |format|\n if @entity_type.save\n format.html { redirect_to @entity_type, notice: crud_notice('created', @entity_type) }\n format.json { render json: @entity_type, status: :created, location: @entity_type }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entity = Entity.new(params[:entity])\n @entity.company_id = session[:company_id]\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to(session[:company_id].c, :notice => 'Entity was successfully created.') }\n format.xml { render :xml => @entity, :status => :created, :location => @entity }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @entity.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @entity = Entity.new(params[:databaseformalizer_entity])\n @entity.attr_vals.clear\n EntitiesHelper.setAttrVals(params[:attr_vals], @entity)\n \n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity, notice: 'Entity was successfully created.' }\n format.json { render json: @entity, status: :created, location: @entity }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(entity_name, attributes)\n\n entity = XML::Entity.new(entity_name)\n entity.attributes = XML::Attributes.new(attributes)\n\n xml_response = post(organization_endpoint, create_request(entity))\n return Response::CreateResult.new(xml_response)\n end",
"def create(options = nil)\n valid_param?(:options, options, Hash, true)\n if not options[:profile_alias]\n raise_invalid_request(\"profile_alias must be provided\")\n end\n if not options[:customer_type]\n raise_invalid_request(\"customer_type must be provided\")\n end\n if not options[:entity_type]\n raise_invalid_request(\"entity_type must be provided\")\n end\n if not options[:company_name]\n raise_invalid_request(\"company_name must be provided\")\n end\n if not options[:vertical]\n raise_invalid_request(\"vertical must be provided\")\n end\n perform_create(options)\n end",
"def create\n if params[:person][:company_name]\n params[:person][:company] = Company.find_or_create_by_name(params[:person][:company_name])\n params[:person].delete(:company_name)\n end\n @person = Person.new(params[:person])\n\n authorize! :create, @person\n \n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n the_param = entity_params\n to = the_param.delete(:to)\n\n research_methods = the_param.delete(:research_methods)\n research_participants = the_param.delete(:research_participants)\n evidence_methods = the_param.delete(:evidence_methods)\n methodologies = the_param.delete(:methodologies)\n\n @entity = Entity.new(the_param)\n @entity.bibliographic = @bibliographic\n @entity.research_methods = ResearchMethod.where(id: research_methods).all\n @entity.research_participants = ResearchParticipant.where(id: research_participants).all\n @entity.evidence_methods = EvidenceMethod.where(id: evidence_methods).all\n @entity.methodologies = Methodology.where(id: methodologies).all\n # byebug\n\n respond_to do |format|\n if @entity.save\n\n # format.html { redirect_to [@bibliographic, @entity], notice: 'Entity was successfully created.' }\n format.html { redirect_to confirmed_list_bibliographics_path, notice: 'Entity was successfully created.' }\n\n #format.html { redirect_to send(to.to_s.concat('_path')), notice: 'Bibliographic was successfully created.' }\n\n format.html { redirect_to [@bibliographic, @entity], notice: 'Entity was successfully created.' }\n format.json { render :show, status: :created, location: @entity }\n else\n format.html { render :new }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(entity)\n raise Occi::Api::Client::Errors::NotImplementedError, \"#{__method__} is just a stub!\"\n end",
"def create\n if @company = Company.find(entity_id_from_params(:company))\n respond_to do |format|\n current_user.account.companies << @company\n format.html { redirect_to root_path, notice: 'Company was successfully created.' }\n format.json\n end\n end\n end",
"def create\n @entity_type = EntityType.new(entity_type_params)\n\n respond_to do |format|\n if @entity_type.save\n format.html { redirect_to @entity_type, notice: 'Entity type was successfully created.' }\n format.json { render :show, status: :created, location: @entity_type }\n else\n format.html { render :new }\n format.json { render json: @entity_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(entity)\n @dataset.create(\n _serialize(entity)\n )\n end",
"def create(entity)\n @dataset.create(\n _serialize(entity)\n )\n end",
"def create\n @entity = Entity.new(entity_params)\n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity.entity ? @entity.entity : entities_path, notice: 'Entity was successfully created.' }\n format.json { render :show, status: :created, location: @entity }\n else\n\t @entities = @entity.entity ? @entity.entity.sub_entities : Entity.where(entity_id: nil)\n format.html { render :index }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @conceptual_entity = ConceptualEntity.new(params[:conceptual_entity])\n\n respond_to do |format|\n if @conceptual_entity.save\n format.html { redirect_to @conceptual_entity, notice: 'Conceptual entity was successfully created.' }\n format.json { render json: @conceptual_entity, status: :created, location: @conceptual_entity }\n else\n format.html { render action: \"new\" }\n format.json { render json: @conceptual_entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_entity\n return TaskRecord.new(:company => current_user.company)\n end",
"def create\n # Consider request as illegal if performing POST on identifiable resource\n if params[entities_key] && params[entities_key][:id]\n render json: { errors: process_errors([\"Creation of resource with id\"], 404) }, status: :conflict\n return\n end\n \n # Upsert the entity\n entity = ConnecEntity.new(group_id: @group_id, entity_name: entities_key)\n entity.document = (entity.document || {}).merge(params[entities_key])\n entity.save\n \n if entity && entity.errors.empty?\n logger.info(\"INSPECT: #{entities_key} => #{process_entity(entity).to_json}\")\n render json: { entities_key => process_entity(entity.reload) }, status: :created, location: resource_url(entity)\n else\n render json: { errors: process_errors(entity.errors.full_messages, 400, entity) }, status: :bad_request\n end\n \n end",
"def new_entity(options, &b)\n @entity_class.new(self, options, &b)\n end",
"def create\n @legal_entity = LegalEntity.new(legal_entity_params)\n\n respond_to do |format|\n if @legal_entity.save\n format.html { redirect_to @legal_entity, notice: 'Legal entity was successfully created.' }\n format.json { render :show, status: :created, location: @legal_entity }\n else\n format.html { render :new }\n format.json { render json: @legal_entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entity = Entity.find_my_title( entity_params[:title] )\n\n if @entity.nil?\n @entity = Entity.new(entity_params)\n else\n @entity.update(entity_params)\n end\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to '/', notice: 'Entidad creada.' }\n format.json { render action: 'show', status: :created, location: @entity }\n else\n format.html { render action: 'new' }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_company\n company = Company.create!()\n company\n end",
"def create_person_field(**args)\n params = parameters(args) do\n required_params :name, :field_type\n optional_params :name, :field_type, :options\n end\n request(:post, 'personFields', params)\n end",
"def create\n @entity_contact = EntityContact.new(params[:entity_contact])\n\n respond_to do |format|\n if @entity_contact.save\n format.html { redirect_to @entity_contact, notice: 'Entity contact was successfully created.' }\n format.json { render json: @entity_contact, status: :created, location: @entity_contact }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity_contact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(data)\n data.each do |response|\n puts person = @person_repository.create_or_find(response)\n homeworld_response = StarwarsService.get_response(response[\"homeworld\"])\n planet = @planet_repository.find(homeworld_response[\"name\"]).first\n person.planet_id = planet.id\n\n if response[\"species\"].empty? == false\n species_response = StarwarsService.get_response(response[\"species\"].first)\n specie = @specie_repository.find(species_response[\"name\"]).first\n person.specie_id = specie.id\n end\n person.save\n end\n end",
"def create\n @company = Company.create!(company_params)\n end",
"def _create_entity(type, hash, primary_entity=nil)\n # No need for a name in the hash now, remove it & pull out the name from the hash\n name = hash.delete(\"name\")\n\n # Create or merge the entity\n EntityManager.create_or_merge_entity(@task_result, type, name, hash, primary_entity)\n end",
"def postEntityEmployee( entity_id, title, forename, surname, job_title, description, email, phone_number)\n params = Hash.new\n params['entity_id'] = entity_id\n params['title'] = title\n params['forename'] = forename\n params['surname'] = surname\n params['job_title'] = job_title\n params['description'] = description\n params['email'] = email\n params['phone_number'] = phone_number\n return doCurl(\"post\",\"/entity/employee\",params)\n end",
"def create\n @company = Company.new(company_params)\n\n render status: \\\n current_user.save_company(@company) ? :created : :unprocessable_entity\n end",
"def create\n Rails.logger.info(params)\n # check if all the criterias are filled\n # first I just continue to create iff name, positionl, institution exists\n if params.has_key?(:name) && params.has_key?(:position) && params.has_key?(:institution)\n # check if the person already exists? The person might exists as a mentor of other maybe\n unless Person.exists?(name: params[:name])\n @person = Person.new_person(params[:name], params[:position], params[:institution])\n if @person != nil && @person.save\n render json: @person.as_json, status: :created\n return\n end\n else\n render json: {error: 'person exists'}, status: :bad_request\n end\n end\n #render json: {warning: 'not implemented'}, status: 200\n end",
"def create(entity)\n unless entity.id\n @adapter.create(collection, entity)\n end\n\n entity\n end",
"def create\n @person = @account.people.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(permit_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to(@person, :notice => 'Person was successfully created.') }\n format.xml { render :xml => @person, :status => :created, :location => @person }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @person.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def postEntityName( entity_id, name, formal_name, branch_name)\n params = Hash.new\n params['entity_id'] = entity_id\n params['name'] = name\n params['formal_name'] = formal_name\n params['branch_name'] = branch_name\n return doCurl(\"post\",\"/entity/name\",params)\n end",
"def create\n @person = Person.new(person_params)\n # @person.addresses.build()\n respond_to do |format|\n if @person.save\n # @person.addresses.create\n # @person.companies.create\n\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n @addresses = @person.addresses\n @page_title = 'Add a new person'\n addresses = @person.addresses.build\n companies = @person.companies.build\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n begin\n \n detail = @@data_util.hash_data_to_upper_case( params[:company], ['description'])\n\n detail[:mypclient_id] = session[:client_id]\n detail[:createdby] = session[:username]\n detail[:isactive] = 1\n\n @company = Company.new(detail)\n if @company.save\n @@request_result[:success] = true\n @@request_result[:notice] = 'New company successfully created.'\n else\n @@request_result[:errormsg] = @company.errors.full_messages[0]\n end\n rescue Exception => e\n @@request_result[:errormsg] = e.message\n end\n render json: @@request_result\n end",
"def create\n @tipo_entidade = TipoEntidade.new(tipo_entidade_params)\n\n respond_to do |format|\n if @tipo_entidade.save\n format.html { redirect_to @tipo_entidade, notice: 'Tipo entidade was successfully created.' }\n format.json { render :show, status: :created, location: @tipo_entidade }\n else\n format.html { render :new }\n format.json { render json: @tipo_entidade.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n \t#@person = Person.new(params[:person]) #create a new person\n \t@person = Person.new(post_params) #create a new person using security post\n \tif @person.save #save the person in database, but the rails' feature strong_parameteres doesn't allow to save without specify the fields those are accepted\n \t\tredirect_to @person\n\telse\n\t\tflash[:type] = \"warning\"\n \t\tflash[:message] = \"Please, complete the required fields\"\n\t\trender \"new\"\n\tend\n end",
"def create(*args)\n post(*args)\n end",
"def create(*args)\n post(*args)\n end",
"def _process_on_create(entity)\n end",
"def create\n \n end",
"def create\n @entity = @klass.new(params[@klass.table_name.singularize])\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to admin_entity_url(entity: @klass_path, id: @entity.id), notice: \"#{@klass.model_name.capitalize} was successfully created.\" }\n format.json { render json: @entity, status: :created }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new\n \tpopulate_attributes(@person, params[:person])\n \n respond_to do |format|\n if @person.save\n @person = Person.find(@person.id)\n populate_attributes(@person, params[:person])\n @person.save\n\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @client = Client.find(params[:client_id])\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to(client_entities_url(@client), :notice => \"Entity was successfully created. #{undo_link}\") }\n else\n # load in the form config so we can re-construct the form\n load_form_config\n\n format.html { render :action => \"new\" }\n end\n end\n end",
"def create\n @entity = get_new(params)\n @entity.type = get_type\n @entity.verbindung_id = current_user.verbindung_id\n @entity.creator = current_user.id\n @entity.last_edited_by = current_user.id\n @verbindung = Verbindung.find(current_user.verbindung_id)\n if !has_access_to_verbindung(@verbindung) then return end\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to :action => 'index', notice: 'Event was successfully created.' }\n format.json { render json: @entity, status: :created }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n if @person.save\n render :show, status: :created, location: api_v2_person_url(@person)\n else\n render json: @person.errors, status: :unprocessable_entity\n end\n end",
"def create\n @entity_end_point_rel = EntityEndPointRel.new(params[:entity_end_point_rel])\n\n respond_to do |format|\n if @entity_end_point_rel.save\n format.html { redirect_to(@entity_end_point_rel, :notice => 'Entity end point rel was successfully created.') }\n format.xml { render :xml => @entity_end_point_rel, :status => :created, :location => @entity_end_point_rel }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @entity_end_point_rel.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\r\n\r\n\r\n end",
"def create\n @person = Person.new(params[:person].merge :creator_site_id => Site.current_id)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to(@person, :notice => 'Person was successfully created.') }\n format.xml { render :xml => @person, :status => :created, :location => @person }\n format.json { render :json => @person, :status => :created, :location => @person }\n else\n status = @person.errors.delete(:status) || :unprocessable_entity\n\n format.html { render :action => 'new' }\n format.xml { render :xml => @person.errors, :status => status }\n format.json { render :json => @person.errors, :status => status }\n end\n end\n end",
"def create\n \n @company = Company.new(params[:company])\n \n respond_to do |format|\n if @company.save\n format.html { redirect_to @company, notice: 'Empresa foi criada com sucesso.' }\n format.json { render json: @company, status: :created, location: @company }\n else\n format.html { render action: \"new\" }\n format.json { render json: @company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = current_user.created_people.new(person_params_with_school)\n if @person.save\n render :show, status: :created, location: api_v1_person_url(@person)\n else\n render json: @person.errors, status: :unprocessable_entity\n end\n end",
"def create\n \n end",
"def create\n @person = Person.new(person_params)\n\n if @person.save\n render json: { status: 'POST Success', id: @person.id }, status: :ok\n else\n render json: { status: 'Error', message:'Error registering a new person', person: @person.errors }, status: :unprocessable_entity\n end\n end",
"def create\n\t\t@person = Person.create(person_params)\n\t\tredirect_to person_url(@person)\n\tend",
"def create\n authorize!(:create,@user) unless @user.has_access?('People & Legal Team')\n data = params\n matter_ppl_data = data[:matter_people]\n matter_ppl_data.merge!({\n :created_by_user_id => current_user.id,\n :company_id => get_company_id\n })\n @matter_people = @matter.matter_peoples.new(matter_ppl_data)\n @matter_people_client = @matter_people\n filter_employees\n @matter_people.is_active = true\n @matter_people_other = @matter_people\n @matter_people_opposite = @matter_people\n @matter_people_client_representative = @matter_people\n respond_to do |format|\n if @matter_people.save(matter_ppl_data)\n flash[:notice] = \"#{t(:text_matter_people)} \" \"#{t(:flash_was_successful)} \" \"#{t(:text_created)}\"\n format.html { redirect_to matter_matter_peoples_path(@matter) }\n format.xml { head :ok }\n else\n format.html { redirect_to matter_matter_peoples_path(@matter) }\n end\n end\n end",
"def add_create_action(options = {})\n post '/' do\n item = model.new permitted_params\n authorize item, :create? if options[:authorize]\n if item.save\n present item, with: entity_class\n else\n error!({ errors: item.errors.messages }, 422)\n end\n end\n end",
"def create\n @person = current_user.created_people.new(person_params_with_school)\n if @person.save\n render :show, status: :created, location: api_v2_person_url(@person)\n else\n render json: @person.errors, status: :unprocessable_entity\n end\n end",
"def create\n make_create_request\n end",
"def create_team(opts)\n HelloSign::Resource::Team.new post('/team/create', :body => opts)\n end",
"def create(options)\n new(options).create\n end",
"def create; end",
"def create; end",
"def create; end",
"def create; end",
"def createWithStaff\n created_location = Company.create(params[\"company\"])\n if params[\"id\"]\n updated_person = Person.setCompany(params[\"id\"], created_location)\n end\n render json: created_location\n end",
"def create\n @person = Person.new(params[:person])\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(params[:person])\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(params[:person])\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(params[:person])\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render json: @person, status: :created, location: @person }\n else\n format.html { render action: \"new\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entity = Entity.new(entity_params) \n @branch = Branch.new \n respond_to do |format|\n if @entity.save\n\n @branch.entity = @entity\n @branch.name = @entity.name\n @branch.initials = @entity.initials\n @branch.code = @entity.code\n @branch.mgr_name = @entity.mgr_name\n @branch.mgr_email = @entity.mgr_email\n @branch.mgr_tel = @entity.mgr_tel\n @branch.mgr_cel = @entity.mgr_cel\n @branch.municipality = @entity.municipality\n @branch.department = @entity.department\n @branch.address = @entity.address\n @branch.entype = @entity.entype\n \n @branch.save\n\n format.html { redirect_to @entity, notice: 'IPS creada exitosamente. Hicimos por ti una sede principal con los mismos datos, revísala!' }\n format.json { render :show, status: :created, location: @entity }\n else\n format.html { render :new }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\r\n @person = Person.new(person_params)\r\n set_field\r\n\r\n respond_to do |format|\r\n if @person.save\r\n format.json { render :show, status: :created, location: @person }\r\n else\r\n format.html { render :new }\r\n format.json { render json: @person.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create\n @person = Person.new(params[:person])\n @person.organization = @organization\n\n respond_to do |format|\n if @person.save\n @person.services << Service.new(:service_type_id => 'MEMBERSHIP', :paid => true) if params[:membership]\n @person.services << Service.new(:service_type_id => 'EAB', :paid => true) if params[:eab]\n @person.visits << Visit.new if params[:visiting]\n \n flash[:notice] = 'Person was successfully created.'\n format.html do\n if params[:visiting]\n redirect_to today_visits_path\n else\n redirect_to(person_path(:id => @person))\n end\n end\n format.xml { render :xml => @person, :status => :created, :location => @person }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @person.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def add_entity\n res = {\n :success => false,\n :msg => '',\n :data => {}\n }\n if (params[:id].nil?)\n res[:msg] = 'order/update_entity was called without an :id'\n return render(:json => res.to_json, :layout => false)\n end\n \n order = Order.find_by_id(params[:id])\n entities = order.type.entities\n entities.each do |e|\n if (e.name == params[\"entity\"])\n data = params[e.name]\n data[:order_id] = params[:id]\n data[:order_type_entity_id] = e.id\n oe = OrderEntity.create(data)\n \n res[:success] = true\n res[:data][:entity] = oe.to_h\n res[:msg] = \"Added #{oe.type.name.capitalize}\" \n end\n end \n render :json => res.to_json, :layout => false \n end",
"def create\n _create_or_update(@person)\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n company = Company.create(company_params)\n if company\n render json:{\n status: :created,\n company: company\n }\n else\n render json: { status: 500 }\n end\n\n \n \n end",
"def create\n HTTParty.post(create_url, :options => { :headers => HEADERS })\n end",
"def create\n end",
"def create\n standard_create(OrganizationType, organization_type_params)\n end",
"def create\n @emu_person = EmuPerson.new(emu_person_params)\n\n respond_to do |format|\n if @emu_person.save\n format.html { redirect_to @emu_person, notice: 'Emu person was successfully created.' }\n format.json { render action: 'show', status: :created, location: @emu_person }\n else\n format.html { render action: 'new' }\n format.json { render json: @emu_person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_team(opts)\n HelloSign::Resource::Team.new post('/team/create', body: opts)\n end",
"def create\n\n @entity = Entity.new()\n\n if params[:entity][:image]\n @entity.image = params[:entity][:image].read\n @entity.filename = params[:entity][:image].original_filename\n @entity.mine_type = params[:entity][:image].content_type\n end\n\n @entity.latitude = params[:entity][:latitude]\n @entity.longitude = params[:entity][:longitude]\n\n if @entity.save\n redirect_to(@entity, :notice => 'Photo was successfully created.')\n else\n render :action => \"new\"\n end\n\n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity, notice: 'Entity was successfully created.' }\n format.json { render action: 'show', status: :created, location: @entity }\n else\n format.html { render action: 'new' }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create \n @person = Person.new(person_params)\n respond_to do |format|\n if @person.save!\n format.html { redirect_to @person, notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n render json: Company.create(params[\"company\"])\n end"
] |
[
"0.80050886",
"0.75879395",
"0.7370819",
"0.734434",
"0.7215701",
"0.72090715",
"0.7173726",
"0.69844687",
"0.6907714",
"0.68506914",
"0.68433094",
"0.68350613",
"0.6777085",
"0.67148036",
"0.6704023",
"0.6653209",
"0.66500217",
"0.66299933",
"0.65896857",
"0.6578828",
"0.6568684",
"0.6568684",
"0.65621597",
"0.65590364",
"0.6530111",
"0.64245284",
"0.6409821",
"0.6402153",
"0.6385076",
"0.6383908",
"0.63760084",
"0.6355872",
"0.6348637",
"0.6315563",
"0.6308303",
"0.6306835",
"0.627248",
"0.62596536",
"0.62162244",
"0.61804885",
"0.6178015",
"0.6175946",
"0.6168983",
"0.6168101",
"0.6165174",
"0.61434305",
"0.6140109",
"0.6140109",
"0.6135056",
"0.61328554",
"0.61320555",
"0.61151737",
"0.6112852",
"0.61074984",
"0.6088214",
"0.6086612",
"0.6083835",
"0.60821867",
"0.6079925",
"0.6065136",
"0.60556906",
"0.6051765",
"0.6048672",
"0.60384375",
"0.60349977",
"0.60319275",
"0.6030669",
"0.6022863",
"0.60106987",
"0.59995407",
"0.59995407",
"0.59995407",
"0.59995407",
"0.5995179",
"0.5987782",
"0.5987782",
"0.5987782",
"0.5987782",
"0.5987144",
"0.59810424",
"0.59701884",
"0.59690803",
"0.5967773",
"0.5960159",
"0.5960159",
"0.5960159",
"0.5960159",
"0.5960159",
"0.5960159",
"0.5960159",
"0.5960159",
"0.59541917",
"0.5952065",
"0.59440535",
"0.5940583",
"0.5939082",
"0.5939066",
"0.5937298",
"0.5933612",
"0.5928412"
] |
0.7351618
|
3
|
End point: (PATCH) Usage: FundAmerica::Entity.update(entity_id, options) Output: Updates an entity person or company Uses test_mode update when used in sandbox mode
|
def update(entity_id, options)
API::request(:patch, "entities/#{entity_id}", options)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n entity_data = entity_params\n entity_data[:uid] = @entity.uid\n cmd = Commands::Entities::EditEntity.new(entity_data)\n execute(cmd)\n redirect_to entities_url, success: 'Entity was successfully updated.'\n rescue => error\n redirect_to edit_entity_url, warning: error_messages(error)\n end",
"def update\n @entity = Entity.find(params[:id])\n\n respond_to do |format|\n if @entity.update_attributes(params[:entity])\n format.html { redirect_to(session[:company_id].c, :notice => 'Entity was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entity.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update(entity, conditions, id)\n endpoint = \"/manage/#{entity}/#{id}\"\n api_post(endpoint, conditions)\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @entity_override_mode = args[:entity_override_mode] if args.key?(:entity_override_mode)\n @name = args[:name] if args.key?(:name)\n end",
"def update(entity)\n return unless entity\n return unless entity.id\n\n address = Core::Dal::Address.find(entity.id)\n return unless address\n\n address.update(entity.to_json)\n address.save!\n entity.id\n end",
"def update\n @entity = Entity.find(params[:id])\n @entity.attr_vals.clear\n EntitiesHelper.setAttrVals(params[:attr_vals], @entity)\n @entity.attributes = params[:databaseformalizer_entity]\n \n respond_to do |format|\n if @entity.save\n format.html { redirect_to @entity, notice: 'Entity was successfully updated.'}\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(entity)\n entity_id = get_id(entity);\n if entity_id.nil?\n create(entity)\n else\n put(resource_path_for_entity(entity) + \"/#{entity_id}\", entity.to_json)\n end\n end",
"def investor_suitability_update(entity_id, options)\n API::request(:patch, \"entities/#{entity_id}/investor_suitability\", options)\n end",
"def update\n if @entity.update(_entity_params)\n #respond_with @entity, entity: _get_class\n render :json => @entity\n else\n # TODO: no code coverage in tests - figure out a way to get this to execute\n _maybe_log_errors 'update', @entity\n respond_with(@entity, status: :unprocessable_entity, json: @entity.errors, entity: _get_class)\n end\n end",
"def update\n @entity = Entity.find(params[:id])\n\n respond_to do |format|\n if @entity.update_attributes(params[:entity])\n format.html { redirect_to @entity, notice: 'Entity was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n format.html { redirect_to @entity, notice: 'Entity was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n format.html { redirect_to @entity.entity ? @entity.entity : entities_path, notice: 'Entity was successfully updated.' }\n format.json { render :show, status: :ok, location: @entity }\n else\n format.html { render :edit }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(escrow_service_application_id, options)\n API::request(:patch, \"https://sandbox.fundamerica.com/api/test_mode/escrow_service_applications/#{escrow_service_application_id}\", options)\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n format.html { redirect_to entity_url(@entity), notice: 'Entity was successfully updated.' }\n format.json { render :show, status: :ok, location: @entity }\n else\n format.html { render :edit }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @country_code = args[:country_code] if args.key?(:country_code)\n @entity = args[:entity] if args.key?(:entity)\n @name = args[:name] if args.key?(:name)\n end",
"def update\n @person = current_company.person\n\n respond_to do |format|\n if @person.update_attributes(params[:person])\n flash[:notice] = 'Dados atualizados com sucesso!'\n format.html { render :action => \"edit\" }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @person.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n begin\n @resource = Entity.find params[:id]\n @resource.update_attributes! params[:entity]\n render :response => :PUT\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def update!(**args)\n @entity_group_type = args[:entity_group_type] if args.key?(:entity_group_type)\n @from_answer = args[:from_answer] if args.key?(:from_answer)\n @name = args[:name] if args.key?(:name)\n end",
"def update!(**args)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @feature_descriptors = args[:feature_descriptors] if args.key?(:feature_descriptors)\n end",
"def update\n @project = Project.find(params[:entity][:project_id])\n @client = @project.client\n\n respond_to do |format|\n if @entity.update_attributes(params[:entity])\n format.html { redirect_to(client_entities_url(@client), :notice => \"Entity was successfully updated. #{undo_link}\") }\n else\n # load in the form config so we can re-construct the form\n load_form_config\n\n format.html { render :action => \"edit\" }\n end\n end\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @format = args[:format] if args.key?(:format)\n @present = args[:present] if args.key?(:present)\n @semantic = args[:semantic] if args.key?(:semantic)\n @taxonomic = args[:taxonomic] if args.key?(:taxonomic)\n end",
"def update!(**args)\n @company = args[:company] if args.key?(:company)\n @response_metadata = args[:response_metadata] if args.key?(:response_metadata)\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @resource = args[:resource] if args.key?(:resource)\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n format.html { redirect_to @entity, notice: 'Entidad actualizada.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n format.html { redirect_to entities_path, notice: 'IPS editada exitosamente.' }\n format.json { render :show, status: :ok, location: @entity }\n else\n format.html { render :edit }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @language_code = args[:language_code] if args.key?(:language_code)\n @update_mask = args[:update_mask] if args.key?(:update_mask)\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @type = args[:type] if args.key?(:type)\n end",
"def update!(**args)\n @entity_data = args[:entity_data] if args.key?(:entity_data)\n end",
"def update\n @end_point = EndPoint.find(params[:id])\n\n respond_to do |format|\n if @end_point.update_attributes(params[:end_point])\n format.html { redirect_to @end_point, notice: 'End point was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @end_point.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity_id = args[:entity_id] if args.key?(:entity_id)\n @feature_values = args[:feature_values] if args.key?(:feature_values)\n end",
"def test_update_company()\n # Parameters for the API call\n\n campaign_model = CampaignModel.new()\n campaign_model.utm_source = \"Adwords\"\n campaign_model.utm_medium = \"Twitter\"\n\n company_model = CompanyModel.new()\n company_model.modified_time = Time.now.utc.iso8601\n company_model.company_id = \"12345\"\n company_model.campaign = campaign_model\n\n # Perform the API call through the SDK function\n self.class.controller.update_company(company_model)\n\n # Test response code\n assert_equal(@response_catcher.response.status_code, 201)\n end",
"def update\n @breadcrumb = 'update'\n @entity = Entity.find(params[:id])\n @entity.updated_by = current_user.id if !current_user.nil?\n\n respond_to do |format|\n if @entity.update_attributes(params[:entity])\n format.html { redirect_to @entity,\n notice: (crud_notice('updated', @entity) + \"#{undo_link(@entity)}\").html_safe }\n format.json { head :no_content }\n else\n @towns = towns_dropdown\n @provinces = provinces_dropdown\n @zipcodes = zipcodes_dropdown\n format.html { render action: \"edit\" }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(*options)\n update(*options)\n save\n end",
"def update\n respond_to do |format|\n if @entity.update(entity_params)\n # cookies['update_entity_flag'] = { value: true, expires: 1.hour.from_now }\n format.html { redirect_to entities_corporates_stockholder_path( @entity.key ), notice: 'Entity was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity_id = args[:entity_id] if args.key?(:entity_id)\n @feature_selector = args[:feature_selector] if args.key?(:feature_selector)\n end",
"def update\n @entity_end_point_rel = EntityEndPointRel.find(params[:id])\n\n respond_to do |format|\n if @entity_end_point_rel.update_attributes(params[:entity_end_point_rel])\n format.html { redirect_to(@entity_end_point_rel, :notice => 'Entity end point rel was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entity_end_point_rel.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @enforcement_mode = args[:enforcement_mode] if args.key?(:enforcement_mode)\n @evaluation_mode = args[:evaluation_mode] if args.key?(:evaluation_mode)\n @require_attestations_by = args[:require_attestations_by] if args.key?(:require_attestations_by)\n end",
"def update!(**args)\n @entity_type_id = args[:entity_type_id] if args.key?(:entity_type_id)\n @feature_selector = args[:feature_selector] if args.key?(:feature_selector)\n @settings = args[:settings] if args.key?(:settings)\n end",
"def update!(**args)\n @account_provenance = args[:account_provenance] if args.key?(:account_provenance)\n @attentional_entity = args[:attentional_entity] if args.key?(:attentional_entity)\n @dasher_user = args[:dasher_user] if args.key?(:dasher_user)\n @followon = args[:followon] if args.key?(:followon)\n @grounding_provider = args[:grounding_provider] if args.key?(:grounding_provider)\n @prefilter = args[:prefilter] if args.key?(:prefilter)\n @qu = args[:qu] if args.key?(:qu)\n @sensitivity_mode = args[:sensitivity_mode] if args.key?(:sensitivity_mode)\n @synthetic_intent = args[:synthetic_intent] if args.key?(:synthetic_intent)\n @winning_fulfillment = args[:winning_fulfillment] if args.key?(:winning_fulfillment)\n end",
"def update_by_body\n @person = Person.find(person_update_params[:id])\n\n if @person.update_attributes(person_update_params)\n render json: { status: 'PUT Success' }, status: :ok\n else\n render json: { status: 'Error', message:'Error updating person', person: @person.errors }, status: :unprocessable_entity\n end\n end",
"def update\n authorize! :manage, Employee\n if responsibility_changes?\n new_employee = Employee.new_from_old(employee_params['responsibility'], @employee)\n @employee.destroy\n new_employee.save\n @employee = new_employee\n end\n\n respond_to do |format|\n if @employee.update(employee_attrs)\n format.html { redirect_to (@employee.try(:employee) || @employee), notice: t('action.update.succeed', entity: Employee.model_name.human) }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @employee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @is_head_of_intent = args[:is_head_of_intent] if args.key?(:is_head_of_intent)\n @is_verb = args[:is_verb] if args.key?(:is_verb)\n @number = args[:number] if args.key?(:number)\n end",
"def update!(**args)\n @data = args[:data] if args.key?(:data)\n @entity_id = args[:entity_id] if args.key?(:entity_id)\n end",
"def update!(**args)\n @application_id = args[:application_id] if args.key?(:application_id)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @metadata = args[:metadata] if args.key?(:metadata)\n end",
"def update!(**args)\n @customer_id = args[:customer_id] if args.key?(:customer_id)\n @entity_id = args[:entity_id] if args.key?(:entity_id)\n @profile_id = args[:profile_id] if args.key?(:profile_id)\n @type = args[:type] if args.key?(:type)\n @user_email = args[:user_email] if args.key?(:user_email)\n end",
"def update!(options = {}, &block)\n update(options.merge(save_response: true), &block)\n end",
"def update_account(client, options)\n accounts = get_accounts(client, options)\n if accounts.nil?\n return\n end\n\n account = find_account(accounts, options[:email])\n if !account.nil?\n if !options[:firstname].nil?\n account.given_name = options[:firstname]\n end\n if !options[:surname].nil?\n account.surname = options[:surname]\n end\n if !options[:username].nil?\n account.username = options[:username]\n end \n if !options[:password].nil?\n account.password = options[:password]\n end\n if !options[:status].nil?\n account.status = (options[:status] == \"disabled\" ? Stormpath::Resource::Status::DISABLED : Stormpath::Resource::Status::ENABLED)\n end\n\n begin\n account.save\n puts \"Account updated.\"\n rescue Stormpath::Error => e\n print_error(e)\n end\n else\n puts \"Account not found\"\n return\n end\nend",
"def update(options = {})\n @client.put(self.link(:edit), self.to_json, options)\n end",
"def put_update(options = {})\n options[:id] ||= @website.id\n options[:website] ||= @attributes\n\n put :update,options\n end",
"def update\n @conceptual_entity = ConceptualEntity.find(params[:id])\n\n respond_to do |format|\n if @conceptual_entity.update_attributes(params[:conceptual_entity])\n format.html { redirect_to @conceptual_entity, notice: 'Conceptual entity was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @conceptual_entity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n set_action(:update)\n set_account_type\n validate_account_type!\n assign_params\n set_affiliate\n set_updated_by\n\n after_update\n account\n end",
"def fire_patch(url_or_path, entity, options = {}, &block)\n url = absolute_url(url_or_path)\n headers = {:Accept => MEDIA_TYPE_JSON, :'Content-type' => ENCODED_MEDIA_TYPE_JSON_PATCH}.\n merge(options.fetch(:headers, {}))\n headers = merge_log_weasel_header(headers)\n timeout = options.fetch(:timeout, Ladon.default_request_timeout)\n body = encode_entity(entity)\n response = Typhoeus::Request.run(url, headers: headers, timeout: timeout, body: body, method: :patch)\n handle_response(response, method: :patch, url: url, default_data: options[:default_data],\n raise_on_error: options[:raise_on_error], &block)\n end",
"def update\n @test_post = TestPost.find(params[:id])\n\n respond_to do |format|\n if @test_post.update_attributes(params[:test_post])\n format.html { redirect_to @test_post, notice: 'Test post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @test_post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @annotations = args[:annotations] if args.key?(:annotations)\n @entities = args[:entities] if args.key?(:entities)\n @intents = args[:intents] if args.key?(:intents)\n @issue_model_result = args[:issue_model_result] if args.key?(:issue_model_result)\n @phrase_matchers = args[:phrase_matchers] if args.key?(:phrase_matchers)\n @sentiments = args[:sentiments] if args.key?(:sentiments)\n end",
"def update!(**args)\n @annotations = args[:annotations] if args.key?(:annotations)\n @entities = args[:entities] if args.key?(:entities)\n @intents = args[:intents] if args.key?(:intents)\n @issue_model_result = args[:issue_model_result] if args.key?(:issue_model_result)\n @phrase_matchers = args[:phrase_matchers] if args.key?(:phrase_matchers)\n @sentiments = args[:sentiments] if args.key?(:sentiments)\n end",
"def update\n @breadcrumb = 'update'\n @entity_type = EntityType.find(params[:id])\n @entity_type.updated_by = current_user.id if !current_user.nil?\n \n respond_to do |format|\n if @entity_type.update_attributes(params[:entity_type])\n format.html { redirect_to @entity_type,\n notice: (crud_notice('updated', @entity_type) + \"#{undo_link(@entity_type)}\").html_safe }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entity_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @allow_tenants = args[:allow_tenants] if args.key?(:allow_tenants)\n @default_tenant_location = args[:default_tenant_location] if args.key?(:default_tenant_location)\n end",
"def update!(**args)\n @contact_edit_context = args[:contact_edit_context] if args.key?(:contact_edit_context)\n @metadata = args[:metadata] if args.key?(:metadata)\n end",
"def update\n respond_to do |format|\n if @guarantee_company.update(guarantee_company_params)\n format.html { redirect_to @guarantee_company, notice: 'Guarantee company was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @guarantee_company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @alias = args[:alias] if args.key?(:alias)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @text = args[:text] if args.key?(:text)\n @user_defined = args[:user_defined] if args.key?(:user_defined)\n end",
"def update!(**args)\n @alias = args[:alias] if args.key?(:alias)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @text = args[:text] if args.key?(:text)\n @user_defined = args[:user_defined] if args.key?(:user_defined)\n end",
"def update!(**args)\n @etag = args[:etag] if args.key?(:etag)\n @partner_permissions = args[:partner_permissions] if args.key?(:partner_permissions)\n @update_mask = args[:update_mask] if args.key?(:update_mask)\n end",
"def update\n @opportunity = Opportunity.find(params[:id])\n\n if @opportunity.update(opportunity_params)\n head :no_content\n else\n render json: @opportunity.errors, status: :unprocessable_entity\n end\n end",
"def updateProductAndOpp(oppid, quantityToUpdate, accId, recordTppeToUpdate)\n #puts \"in updateProductAndOpp\"\n product = fetchProductDetails(oppid)\n #puts product[0].fetch('Id')\n updated_product = {Id: \"#{product[0].fetch('Id')}\", Quantity: \"#{quantityToUpdate}\"}\n #updated_product = Hash[\"Quantity\" => \"#{quantityToUpdate}\", \"id\" => \"#{product[0].fetch('Id')}\"]\n #puts updated_product\n #puts @restforce.updateRecord('OpportunityLineItem', updated_product)\n #update('OpportunityLineItem', updated_product)\n mapRecordType = fetchRecordTypeId('Account')\n #puts mapRecordType['Mid Market']\n updated_Acc = {Id: accId, RecordTypeId: mapRecordType[\"#{recordTppeToUpdate}\"]}\n #puts updated_Acc\n #updated_Acc = Hash[\"RecordTypeId\" => mapRecordType[\"#{recordTppeToUpdate}\"], \"id\" => accId]\n @restforce.updateRecord('Account', updated_Acc)\n #update('Account', updated_Acc)\n #puts \"account recordTypeupdated\"\n return true\n end",
"def update!(**args)\n @behavioral_trust_verdict = args[:behavioral_trust_verdict] if args.key?(:behavioral_trust_verdict)\n @card_testing_verdict = args[:card_testing_verdict] if args.key?(:card_testing_verdict)\n @stolen_instrument_verdict = args[:stolen_instrument_verdict] if args.key?(:stolen_instrument_verdict)\n @transaction_risk = args[:transaction_risk] if args.key?(:transaction_risk)\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @language_code = args[:language_code] if args.key?(:language_code)\n end",
"def update\n @company = Company.find(params[:id])\n Rails.logger.info \"******\\n\\n\\nCompany: #{params[:company]}***********\\n\\n\\n\"\n respond_to do |format|\n if @company.update_attributes(params[:company])\n format.html { redirect_to @company, notice: 'Company was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @date = args[:date] if args.key?(:date)\n @entity = args[:entity] if args.key?(:entity)\n @etag = args[:etag] if args.key?(:etag)\n @kind = args[:kind] if args.key?(:kind)\n @parameters = args[:parameters] if args.key?(:parameters)\n end",
"def test_edited\n user = User.find(980190962);\n user.update({\"user_name\" => 'abasd',\"user_password\" => '456789', \"user_email\"=>'abc@yahoo.com'})\n if assert_not_nil('user_name', nil)\n arrert false\n elsif assert_not_nil('user_password', nil)\n assert false\n elsif assert_not_nil('user_email', nil)\n arrert false\n else\n assert true\n end\n end",
"def update\n @person = Person.find(params[:id])\n\n populate_attributes(@person, params[:person])\n respond_to do |format|\n \n if @person.save && @person.identifiable_entries.each(&:save!)\n format.html { redirect_to @person, notice: 'Person was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @supports_partial_fulfillment = args[:supports_partial_fulfillment] if args.key?(:supports_partial_fulfillment)\n @supports_synchronous_execution = args[:supports_synchronous_execution] if args.key?(:supports_synchronous_execution)\n end",
"def update\n @testbed_owner = TestbedOwner.find(params[:id])\n\n respond_to do |format|\n if @testbed_owner.update_attributes(params[:testbed_owner])\n format.html { redirect_to @testbed_owner, notice: 'Testbed owner was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @testbed_owner.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @hierarchy_type = args[:hierarchy_type] if args.key?(:hierarchy_type)\n @source = args[:source] if args.key?(:source)\n @trusted_genome_type = args[:trusted_genome_type] if args.key?(:trusted_genome_type)\n end",
"def update\n @company = Company.find(params[:id])\n respond_to do |format|\n if @company.update(company_params)\n @company.email_format = nil if @company.allow_email_regex == false\n @company.save\n @company.track_company_activity(\" updated the company \")\n format.html { redirect_to @company, notice: 'Company was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @antecedent = args[:antecedent] if args.key?(:antecedent)\n @entity_type = args[:entity_type] if args.key?(:entity_type)\n @entity_type_probability = args[:entity_type_probability] if args.key?(:entity_type_probability)\n @gender = args[:gender] if args.key?(:gender)\n @info = args[:info] if args.key?(:info)\n @mention = args[:mention] if args.key?(:mention)\n @name = args[:name] if args.key?(:name)\n @profile = args[:profile] if args.key?(:profile)\n @referent = args[:referent] if args.key?(:referent)\n @representative_mention = args[:representative_mention] if args.key?(:representative_mention)\n @salience = args[:salience] if args.key?(:salience)\n @type = args[:type] if args.key?(:type)\n end",
"def update\n @company = Company.find(COMPANY_ID)\n\n respond_to do |format|\n if @company.update_attributes(params[:company])\n format.html { redirect_to administration_company_path(@company), notice: 'Company was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @confidence = args[:confidence] if args.key?(:confidence)\n @logical_entity = args[:logical_entity] if args.key?(:logical_entity)\n end",
"def update\n if params[:person][:company_name]\n params[:person][:company] = Company.find_or_create_by_name(params[:person][:company_name])\n params[:person].delete(:company_name)\n end\n @person = Person.find(params[:id])\n\n authorize! :edit, @person\n \n respond_to do |format|\n if @person.update_attributes(params[:person])\n format.html { redirect_to @person, notice: 'Person was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @emu_person.update(emu_person_params)\n format.html { redirect_to @emu_person, notice: 'Emu person was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @emu_person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n begin\n @company = Company.find(params[:id])\n detail = @@data_util.hash_data_to_upper_case(params[:company], ['description'])\n detail[:lastupdateby] = session[:username]\n\n @@request_result[:data] = detail \n @@request_result[:type] = params[:company].class \n if @company.update_attributes(detail)\n @@request_result[:success] = true\n @@request_result[:notice] = 'Company successfully updated.'\n else\n @@request_result[:errormsg] = @company.errors.full_messages[0]\n end\n rescue Exception => e\n @@request_result[:errormsg] = e.message\n end\n render json: @@request_result\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @id = args[:id] if args.key?(:id)\n @kind = args[:kind] if args.key?(:kind)\n @permissions = args[:permissions] if args.key?(:permissions)\n @self_link = args[:self_link] if args.key?(:self_link)\n @user_ref = args[:user_ref] if args.key?(:user_ref)\n end",
"def update\n @prd_etc = PrdEtc.find(params[:id])\n\n respond_to do |format|\n if @prd_etc.update_attributes(params[:prd_etc])\n format.html { redirect_to(@prd_etc, :notice => 'PrdEtc was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @prd_etc.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @person.update_attributes(permit_params)\n format.html { redirect_to(@person, :notice => 'Person was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @person.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entity = args[:entity] if args.key?(:entity)\n @partition = args[:partition] if args.key?(:partition)\n @sampled_data_locations = args[:sampled_data_locations] if args.key?(:sampled_data_locations)\n @type = args[:type] if args.key?(:type)\n end",
"def update\n @company = Company.find(params[:id])\n\n respond_to do |format|\n if @company.update_attributes(params[:company])\n format.html { redirect_to @company, notice: 'Empresa foi atualizada com sucesso.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @company.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(entity)\n @dataset.update(\n _serialize(entity)\n )\n end",
"def update(entity)\n @dataset.update(\n _serialize(entity)\n )\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @language = args[:language] if args.key?(:language)\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @language = args[:language] if args.key?(:language)\n end",
"def update!(**args)\n @ad_words_accounts = args[:ad_words_accounts] if args.key?(:ad_words_accounts)\n @entity = args[:entity] if args.key?(:entity)\n @id = args[:id] if args.key?(:id)\n @kind = args[:kind] if args.key?(:kind)\n @name = args[:name] if args.key?(:name)\n @profile_ids = args[:profile_ids] if args.key?(:profile_ids)\n @self_link = args[:self_link] if args.key?(:self_link)\n end",
"def update!\n entity_json = [{ name: @source_file.entity_name, entries: expanded_entries }]\n\n response = @api_client.update_entities_request(entity_json)\n\n handle_response(response, :entity)\n end",
"def update!(**args)\n @company = args[:company] if args.key?(:company)\n @end_time = args[:end_time] if args.key?(:end_time)\n @start_time = args[:start_time] if args.key?(:start_time)\n end",
"def update options={}\n client.put(\"/#{id}\", options)\n end",
"def update!(**args)\n @entities = args[:entities] if args.key?(:entities)\n @rewrite_type = args[:rewrite_type] if args.key?(:rewrite_type)\n @textual_rewrite = args[:textual_rewrite] if args.key?(:textual_rewrite)\n end",
"def update\n @effort = Effort.find(params[:id])\n\n respond_to do |format|\n if @effort.update_attributes(params[:effort])\n format.html { redirect_to @effort, notice: 'Effort was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @effort.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @docid = args[:docid] if args.key?(:docid)\n @entity = args[:entity] if args.key?(:entity)\n end",
"def update\n @test_set = TestSet.find(params[:id])\n permitted_to! :update, @test_set.problem\n respond_to do |format|\n if @test_set.update_attributes(permitted_params)\n format.html { redirect_to @test_set, :notice => 'Test set was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @test_set.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update(options = {})\n run_hooks(:before, :update)\n options.each do |key, value|\n send(\"#{key}=\", value)\n end\n run_hooks(:after, :update)\n @persisted = false\n save\n end",
"def update\n @allow_test = AllowTest.find(params[:id])\n\n respond_to do |format|\n if @allow_test.update_attributes(params[:allow_test])\n format.html { redirect_to(@allow_test) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @allow_test.errors, :status => :unprocessable_entity }\n end\n end\n end"
] |
[
"0.6717854",
"0.66933495",
"0.6560759",
"0.6522267",
"0.6510602",
"0.6475136",
"0.6429616",
"0.64248943",
"0.6417863",
"0.63421935",
"0.62995476",
"0.62362045",
"0.620672",
"0.6189223",
"0.6152925",
"0.6125904",
"0.61234576",
"0.6115374",
"0.6100337",
"0.60869914",
"0.6070025",
"0.6036141",
"0.60358757",
"0.60308075",
"0.60240424",
"0.6018142",
"0.601545",
"0.60152304",
"0.6004972",
"0.59494483",
"0.594427",
"0.5928551",
"0.59283864",
"0.5926018",
"0.5903049",
"0.5891719",
"0.5889318",
"0.58720315",
"0.5861341",
"0.5838895",
"0.5831665",
"0.58311695",
"0.58240247",
"0.5823912",
"0.5818285",
"0.58135664",
"0.58020985",
"0.5790606",
"0.57774657",
"0.57673126",
"0.57667726",
"0.5760819",
"0.5758889",
"0.57576394",
"0.575479",
"0.575479",
"0.5746824",
"0.574264",
"0.57406807",
"0.5736629",
"0.573299",
"0.5731725",
"0.57110184",
"0.5709353",
"0.5705753",
"0.5702306",
"0.5699622",
"0.5698097",
"0.56978774",
"0.5697876",
"0.56913763",
"0.56895524",
"0.56883615",
"0.56882167",
"0.56796515",
"0.56782126",
"0.5677922",
"0.5674331",
"0.5673469",
"0.5670845",
"0.56647927",
"0.56566143",
"0.5653919",
"0.56487936",
"0.56366557",
"0.5636023",
"0.56353694",
"0.56353694",
"0.56324035",
"0.56324035",
"0.56302875",
"0.5622139",
"0.5622049",
"0.5616292",
"0.5612958",
"0.5612813",
"0.5608635",
"0.5606313",
"0.56050324",
"0.5600538"
] |
0.69770414
|
0
|
End point: (GET) Usage: FundAmerica::Entity.details(entity_id), request options &_expand[]=1 Output: Returns the details of an entity with matching id
|
def details(entity_id, request_options = "")
API::request(:get, "entities/#{entity_id}" + request_options)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def details(entity)\n details_by_type_and_name(entity.properties[:type], entity.properties[:name])\n end",
"def _get_entity_detail(detail_name)\n @entity.get_detail(detail_name)\n end",
"def show\n @entity = Entity.find(params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def details_by_type_and_id(type, id)\n get(resource_path_for_entity_type(type) + \"/#{id}\")\n end",
"def get_details(resource, id, **params)\n ops_hash = {\n id: id\n }\n ops_hash.merge! params\n resp = _make_request(resource, ops_hash)\n ComicVine::Resource.create_resource(resp['results'])\n end",
"def show\n @entity = Entity.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def find(id)\n describe(entity(id))\n end",
"def article_details(article_id, opts = {})\n data, _status_code, _headers = article_details_with_http_info(article_id, opts)\n return data\n end",
"def show\n @breadcrumb = 'read'\n @entity = Entity.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def show\n @entity = Entity.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entity }\n end\n end",
"def show\n @edetail = Edetail.find_by(id: params[:id])\n end",
"def show\n @entity_end_point_rel = EntityEndPointRel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entity_end_point_rel }\n end\n end",
"def article_details_with_http_info(article_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: ArticlesApi.article_details ...\"\n end\n # verify the required parameter 'article_id' is set\n if @api_client.config.client_side_validation && article_id.nil?\n fail ArgumentError, \"Missing the required parameter 'article_id' when calling ArticlesApi.article_details\"\n end\n if @api_client.config.client_side_validation && article_id < 1\n fail ArgumentError, 'invalid value for \"article_id\" when calling ArticlesApi.article_details, must be greater than or equal to 1.'\n end\n\n # resource path\n local_var_path = \"/articles/{article_id}\".sub('{' + 'article_id' + '}', article_id.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n auth_names = []\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'ArticleComplete')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: ArticlesApi#article_details\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def details\n get(\"v1/event/#{@id}\")\n end",
"def details\n data.details\n end",
"def info(id)\n http.get(\"/nfse/#{id}\") do |response|\n respond_with_entity(response)\n end\n end",
"def details\n\n end",
"def show\n @entity = @klass.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def show\n @entity = PruegelEntity.find(params[:id])\n @verbindung = Verbindung.find(params[:verbindung_id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def show\n @breadcrumb = 'read'\n @entity_type = EntityType.find(params[:id])\n @entities = @entity_type.entities.paginate(:page => params[:page], :per_page => per_page).order('fiscal_id')\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity_type }\n end\n end",
"def show\n token_ok, token_error = helpers.API_validate_token(request)\n if not token_ok\n render json: {message: token_error }, status: 401\n else\n rec_id = params[:id].to_i\n begin\n o = Entity.find(rec_id)\n @rec = { \n id: o.id,\n name: o.name,\n address1: o.address1,\n address2: o.address2,\n city: o.city,\n zipcode: o.zipcode,\n state: o.state,\n alias: o.alias,\n entityType: o.entity_type,\n countryId: o.country_id,\n companyId: o.company_id\n }\n rescue ActiveRecord::RecordNotFound\n @rec = {}\n end\n\n respond_to do |format|\n format.json { render json: @rec }\n end\n end\n end",
"def show\n @exp_detail = ExpDetail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @exp_detail }\n end\n end",
"def getEntity( entity_id, domain, path, data_filter)\n params = Hash.new\n params['entity_id'] = entity_id\n params['domain'] = domain\n params['path'] = path\n params['data_filter'] = data_filter\n return doCurl(\"get\",\"/entity\",params)\n end",
"def show\n respond_with @entity, entity: _get_class\n end",
"def deal_detail(id:, **args)\n params = parameters(args) do\n optional_params\n end\n request(:get, \"deals/#{id}\", params)\n end",
"def show_info_by_id(target_id, opts = {})\n show_info_by_id_with_http_info(target_id, opts)\n return nil\n end",
"def detail(resource_id)\n @do_resource_mixin.detail(resource_id)\n end",
"def show\n @entity_mapping = EntityMapping.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity_mapping }\n end\n end",
"def get_dispute_details_with_http_info(dispute_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: DisputesApi.get_dispute_details ...'\n end\n # verify the required parameter 'dispute_id' is set\n if @api_client.config.client_side_validation && dispute_id.nil?\n fail ArgumentError, \"Missing the required parameter 'dispute_id' when calling DisputesApi.get_dispute_details\"\n end\n pattern = Regexp.new(/^(dsp)_(\\w{26})$/)\n if @api_client.config.client_side_validation && dispute_id !~ pattern\n fail ArgumentError, \"invalid value for 'dispute_id' when calling DisputesApi.get_dispute_details, must conform to the pattern #{pattern}.\"\n end\n\n # resource path\n local_var_path = '/disputes/{dispute_id}'.sub('{' + 'dispute_id' + '}', CGI.escape(dispute_id.to_s))\n\n # query parameters\n query_params = opts[:query_params] || {}\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body]\n\n # return_type\n return_type = opts[:debug_return_type] || 'Dispute'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || ['ApiSecretKey']\n\n new_options = opts.merge(\n :operation => :\"DisputesApi.get_dispute_details\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: DisputesApi#get_dispute_details\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def get_dispute_details(dispute_id, opts = {})\n data, _status_code, _headers = get_dispute_details_with_http_info(dispute_id, opts)\n data\n end",
"def show\n @conceptual_entity = ConceptualEntity.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @conceptual_entity }\n end\n end",
"def get_card_details(handle, id, opts = {})\n data, _status_code, _headers = get_card_details_with_http_info(handle, id, opts)\n return data\n end",
"def investor_suitability_details(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_suitability\")\n end",
"def details\n @estate_agent = EstateAgent.find(params[:id])\n @property = Property.where(\"estate_agent_id = ? and id = ?\", @estate_agent.id, params[:id2])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @property }\n end\n end",
"def show\n @entity = Entity.find(params[:id])\n session[:entity_id] = @entity.id\n session[:company_id] = @entity.company.id.to_i\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entity }\n end\n end",
"def details\n end",
"def details\n data = Storm::Base::SODServer.remote_call '/Product/details',\n :code => @code\n self.from_hash data\n end",
"def details\n @details ||= fetch_details\n end",
"def entity(dbname, id, params = {})\n version = params.fetch(:t, '-')\n get db_url(dbname, version, 'entity'), params.merge(:e => id)\n end",
"def show_details(id_to_show_details_from_db)\n @db.query(\"SELECT * FROM products WHERE id = '#{id_to_show_details_from_db}'\", :symbolize_keys => true).first\n end",
"def get_details\n return self if detailed?\n res = client.get(path_base).to_h\n update(res)\n res\n end",
"def details\n @attributes[:details]\n end",
"def details\n @details ||= Tmdb::Collection.detail(@id)\n return @details\n end",
"def show_detail(n)\n puts \"Here's the detail for contact ID #{n}\"\n puts \"================================\"\n puts \"Name: #{Contact.find(n).name}\"\n puts \"Email: #{Contact.find(n).email}\"\n puts Contact.find(n).phone_hash.to_yaml\n puts \"================================\"\n end",
"def event_detail(id, options = {})\n get \"event_details/#{id}\", options\n end",
"def show\n begin\n @resource = Entity.find params[:id]\n render :response => :GET\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def get_details\n location = MapTopic::Location.find(params[:id])\n return render_json_dump serialize_data(location, MapTopic::LocationDetailedSerializer, root: false)\n end",
"def checkin_details(id)\n options = { :id => id }\n get('/details', options)\n end",
"def get_details\n theSelection = \"sel=Number\" \n @MAP.each do |k, v|\n theSelection << \",\" << v\n end \n \n uri=\"#{$V1HOST['base_uri']}/rest-1.v1/Data/Defect?#{theSelection}&where=Number\"\n details = self.class.get(\"#{uri}=\\'#{@story}\\'\", :verify => false)\n return details\n end",
"def show\n #@detail = Detail.find(params[:id])\n @plan = Plan.find(params[:plan_id])\n @detail = @plan.details.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @detail }\n end\n end",
"def action_details_with_http_info(action_definition_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: ActionsApi.action_details ...\"\n end\n # verify the required parameter 'action_definition_id' is set\n fail ArgumentError, \"Missing the required parameter 'action_definition_id' when calling ActionsApi.action_details\" if action_definition_id.nil?\n # resource path\n local_var_path = \"/action-definitions/{actionDefinitionId}\".sub('{format}','json').sub('{' + 'actionDefinitionId' + '}', action_definition_id.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n local_header_accept = ['application/json']\n local_header_accept_result = @api_client.select_header_accept(local_header_accept) and header_params['Accept'] = local_header_accept_result\n\n # HTTP header 'Content-Type'\n local_header_content_type = ['application/json']\n header_params['Content-Type'] = @api_client.select_header_content_type(local_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n auth_names = ['basicAuth']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'ActionDefinitionEntry')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: ActionsApi#action_details\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def show\n @entity_tag = EntityTag.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity_tag }\n end\n end",
"def show\n if singular_resource?\n entity = ConnecEntity.where(group_id: @group_id, entity_name: entities_key).first\n entity ||= ConnecEntity.create(group_id: @group_id, entity_name: entities_key)\n else\n entity = ConnecEntity.where(group_id: @group_id, entity_name: entities_key, uid: params[:id]).first\n end\n \n if entity\n logger.info(\"INSPECT: #{entities_key} => #{process_entity(entity).to_json}\")\n render json: { entities_key => process_entity(entity) }\n else\n render json: { errors: process_errors([\"Resource not found\"], 404) }, status: :not_found\n end\n end",
"def details_by_type_and_name(type, name)\n entity_id = get_id_by_type_and_name(type, name)\n if entity_id.nil?\n raise \"Id for entity with type '#{type}' and name '#{name}' can't be found\"\n else\n details_by_type_and_id(type, entity_id)\n end\n end",
"def extract_entity_details entity = nil, entity_type = nil\n if entity\n validate_author(entity)\n return [entity.type, entity.id]\n else\n unless entity_type\n raise ArgumentError.new(\"Must include an author/recipient as an Unloq::Entity instance or include an author_type or recipient_type\")\n end\n return [entity_type, nil]\n end\n end",
"def detail\n attributes.fetch(:detail)\n end",
"def detail\n attributes.fetch(:detail)\n end",
"def details\n @details ||= Tmdb::TV.detail(@id)\n return @details\n end",
"def details\n data = Storm::Base::SODServer.remote_call '/Server/details',\n :uniq_id => @uniq_id\n self.from_hash data\n end",
"def show\n @actuality = Actuality.find(params[:id])\n end",
"def private_article_embargo_details_with_http_info(article_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: ArticlesApi.private_article_embargo_details ...\"\n end\n # verify the required parameter 'article_id' is set\n if @api_client.config.client_side_validation && article_id.nil?\n fail ArgumentError, \"Missing the required parameter 'article_id' when calling ArticlesApi.private_article_embargo_details\"\n end\n if @api_client.config.client_side_validation && article_id < 1\n fail ArgumentError, 'invalid value for \"article_id\" when calling ArticlesApi.private_article_embargo_details, must be greater than or equal to 1.'\n end\n\n # resource path\n local_var_path = \"/account/articles/{article_id}/embargo\".sub('{' + 'article_id' + '}', article_id.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n auth_names = ['OAuth2']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'ArticleEmbargo')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: ArticlesApi#private_article_embargo_details\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def show\n\t\t\tputs params.to_s\n\t\t\n\t\t\tset_individual_action_meta_information({\n\t\t\t\t:title => @entity.page_title,\n\t\t\t\t:description => @entity.page_description\n\t\t\t})\n\n\t\t\trespond_to do |format|\n\t\t\t\tformat.html do \n\t\t\t\t\trender \"/entities/show\"\n\t\t\t\tend\n\t\t\t\tformat.js do \n\t\t\t\t\trender \"/entities/show\"\n\t\t\t\tend\n\t\t\t\tformat.json do \n\t\t\t\t\trender :json => @entity.as_json\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def show\n if admin?\n @entity_datum = EntityDatum.find(params[:id])\n else\n @entity_datum = EntityDatum.find current_entity.property_document_id\n end # end if admin?\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entity_datum }\n end\n end",
"def retrieve_with_details(repo_id)\n retrieve(repo_id, :details => true)\n end",
"def details_for(**options)\n\t\t\t\t\toptions[:details]\n\t\t\t\tend",
"def show\n @detail = @listing.details.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @detail }\n end\n end",
"def show\n @details = current_custom.details\n end",
"def event_details(reference, event_id, options={})\n options.merge!(reference: reference, event_id: event_id)\n\n get('event/details', options).result\n end",
"def show\n @parent = @entity.entity\n @entities = @entity.sub_entities\n\t@entity = Entity.new(entity_id: @entity.id)\n render :index\n end",
"def show\n @product_detail_entry = ProductDetailEntry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @product_detail_entry }\n end\n end",
"def show\n @emedidor = Emedidor.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @emedidor }\n end\n end",
"def details\n @details ||= Tmdb::Movie.detail(@id)\n return @details\n end",
"def body_entity(entity_id)\n {\n :entity_id => entity_id,\n :options => {\"pretty\"=>\"true\"}\n }\n end",
"def show\n begin\n @resource = get_relation(params[:id], params[:entity_id])\n render :response => :GET\n rescue Exception => e\n @error = process_exception(e)\n render :response => @error\n end\n \n \n\n end",
"def private_article_embargo_details(article_id, opts = {})\n data, _status_code, _headers = private_article_embargo_details_with_http_info(article_id, opts)\n return data\n end",
"def GetArticle id\n\n APICall(path: \"help_center/articles/#{id}.json\")\n\n end",
"def show\n @detail = Detail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @detail }\n end\n end",
"def show\n @ef_instruction = EfInstruction.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @ef_instruction }\n end\n end",
"def time_accruals_id_details_detail_id_get(id, detail_id, opts = {})\n data, _status_code, _headers = time_accruals_id_details_detail_id_get_with_http_info(id, detail_id, opts)\n return data\n end",
"def show\n @emprendedor = Emprendedor.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @emprendedor }\n end\n end",
"def show\n @detail = Detail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @detail }\n end\n end",
"def show\n @detail = Detail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @detail }\n end\n end",
"def details\n data()\n end",
"def show_details\n @selected.details\n end",
"def get_info(id)\n url = \"http://www.omdbapi.com/?i=#{id}&y=&plot=short&r=json\"\n return_result(url)\n end",
"def show_deal(id)\n get(\"deals/#{id}\")\n end",
"def show\n @tc_detail_step = TcDetailStep.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @tc_detail_step }\n end\n end",
"def getDetails id\n\t\tticket = @tickets.read ['id', 'pid', 'title', 'description', 'tracker', 'creator', 'created', 'status'], ['id', id]\n\t\tticket = ticket[0]\n\tend",
"def private_article_details(article_id, opts = {})\n data, _status_code, _headers = private_article_details_with_http_info(article_id, opts)\n return data\n end",
"def show\n @mostsmalltrapinfo = Mostsmalltrapinfo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @mostsmalltrapinfo }\n end\n end",
"def full_details\n @account = Account.find(params[:account_id])\n @subscription = @account.subscriptions.find(params[:id])\n @order = Order.find(@subscription.order_id)\n\n if @order.user_id\n @user = User.find(@order.user_id)\n end\n\n if @order.by_agent\n @agent = User.find(@order.by_agent)\n end\n\n if @order.price_plan_id\n @price_plan = Country.where(:\"price_plans._id\" => @order.price_plan_id).first.price_plans.find(@order.price_plan_id)\n end\n\n respond_to do |format|\n format.html {render(layout: 'management')}\n end\n end",
"def details\n data = Storm::Base::SODServer.remote_call '/Storm/Template/details',\n :id => @id\n self.from_hash data\n end",
"def show\n @resource = Resource.find(params[:resource_id])\n @incident = Incident.find(@resource.incident_id)\n @demob = Demob.find(params[:id])\n @logistics_units = @demob.units[0..5]\n @finance_units = @demob.units[6..8]\n @other_units = @demob.units[9..10]\n @plans_units = @demob.units[11..13]\n end",
"def getdetails\n trek = Trek.find_by_id(params[:id])\n if trek.nil?\n redirect_to treks_path, :alert => \"Trek not found.\"\n end\n ele_json = trek.get_processed_path + \"/ele.json\"\n if File.exists? ele_json\n send_file(ele_json,\n {:type => \"application/json\", :disposition => \"inline\"})\n else\n ele_details = trek.get_elevation_details.to_json\n processed_ele = File.new(ele_json, \"w\")\n processed_ele.write ele_details\n processed_ele.close\n send_data(ele_details,\n {:type => \"application/json\", :disposition => \"inline\"})\n end\n end",
"def show\n @emm_details = Emm.get_emm_details(@emm.id, get_user_id)\n end",
"def show\n @person = Person.find(params[:id])\n @address = @person.addresses.take\n @identifiers = @person.identifiers\n @parent = @person.company\n end",
"def details\n return @details\n end",
"def details\n return @details\n end",
"def details\n return @details\n end",
"def show \n coach = Coach.find_by(id: params[:id])\n @details = coach.details\n render :show\n end"
] |
[
"0.72119665",
"0.6698045",
"0.66664255",
"0.6545143",
"0.63418263",
"0.6329604",
"0.63291484",
"0.6324539",
"0.623237",
"0.6170544",
"0.6044367",
"0.6018698",
"0.6010537",
"0.5982401",
"0.5978084",
"0.5972607",
"0.5950019",
"0.59452444",
"0.59263295",
"0.58793914",
"0.58724123",
"0.5869659",
"0.5847014",
"0.5843786",
"0.5825712",
"0.5818864",
"0.58163774",
"0.58047587",
"0.5785718",
"0.57749104",
"0.5773305",
"0.57725143",
"0.5771529",
"0.5761855",
"0.5757055",
"0.5748676",
"0.5735887",
"0.5734767",
"0.57290137",
"0.5716466",
"0.5706188",
"0.56935257",
"0.5670504",
"0.5660703",
"0.56526864",
"0.5648072",
"0.56270176",
"0.56251997",
"0.561878",
"0.5617678",
"0.5611408",
"0.5609461",
"0.5609134",
"0.56034356",
"0.5596168",
"0.5575002",
"0.5575002",
"0.5573045",
"0.5570407",
"0.55669725",
"0.556416",
"0.55639225",
"0.5556509",
"0.5554206",
"0.555401",
"0.5553348",
"0.55447066",
"0.5536928",
"0.5534344",
"0.5517217",
"0.55077213",
"0.5477443",
"0.5463968",
"0.54589534",
"0.54445755",
"0.54303503",
"0.5426938",
"0.54251856",
"0.54215866",
"0.54178965",
"0.5415303",
"0.5415303",
"0.5409978",
"0.5409479",
"0.5406631",
"0.54003066",
"0.5392812",
"0.5389453",
"0.5385038",
"0.5382095",
"0.5377168",
"0.5375349",
"0.5364779",
"0.5360476",
"0.53490716",
"0.53409606",
"0.5338239",
"0.5338239",
"0.5338239",
"0.533163"
] |
0.8206718
|
0
|
End point: (GET) Usage: FundAmerica::Entity.ach_authorizations(entity_id) Output: Returns ACH authorizations of an entity
|
def ach_authorizations(entity_id)
API::request(:get, "entities/#{entity_id}/ach_authorizations")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get(*args)\n require_authentication\n arguments(args, required: [:authorization_id])\n\n get_request(\"/authorizations/#{authorization_id}\", arguments.params)\n end",
"def get(*args)\n raise_authentication_error unless authenticated?\n arguments(args, required: [:id])\n\n get_request(\"/authorizations/#{arguments.id}\", arguments.params)\n end",
"def authorizations_list(opts = {})\n data, _status_code, _headers = authorizations_list_with_http_info(opts)\n data\n end",
"def list\n response = Tiptaplab.api.make_call(\"users/authorizations\")\n response.keys\n end",
"def authorizations(params = {})\n scope 'default'\n post('authorizations/', params)\n end",
"def index\n @authorizations = Authorization.all\n end",
"def index\n @authorizations = Authorization.all\n end",
"def authorizations\n @@authorized_actions ||= {}\n @@authorized_actions\n end",
"def enter_pahma_authorizations(test_data)\n authorizations = test_data[UseOfCollections::AUTHORIZATION_GRP.name] || [UseOfCollections.empty_authorization]\n prep_fieldsets_for_test_data([fieldset(UseOfCollections::AUTHORIZATION_GRP.name)], authorizations)\n authorizations.each_with_index do |auth, index|\n enter_auto_complete(authorized_by_input(index), authorized_by_options(index), auth[UseOfCollections::AUTHORIZED_BY.name], 'PAHMA Persons')\n wait_for_element_and_type(authorization_date_input(index), auth[UseOfCollections::AUTHORIZATION_DATE.name])\n hit_enter\n wait_for_element_and_type(authorization_note_input(index), auth[UseOfCollections::AUTHORIZATION_NOTE.name])\n wait_for_options_and_select(authorization_status_input(index), authorization_status_options(index), auth[UseOfCollections::AUTHORIZATION_STATUS.name])\n end\n end",
"def authorization(id)\n get \"/authorizations/#{id}\"\n end",
"def authorizes(*authorizees)\n TransitiveAuthorization::AuthorizedUser.transitive_authorized_user.class_eval do\n alias_method :old_authorizables_for, :authorizables_for\n alias_method :old_has_role?, :has_role?\n alias_method :old_roles_for, :roles_for\n alias_method :old_method_missing, :method_missing\n include TransitiveAuthorization::Authorizer::InstanceMethods\n self.cattr_accessor :transitive_authorizees\n self.transitive_authorizees ||= Array.new\n self.transitive_authorizees << authorizees\n end\n end",
"def index\n @claimauthorizations = Claimauthorization.all\n end",
"def enter_authorizations(test_data)\n authorizations = test_data[UseOfCollections::AUTHORIZATION_GRP.name] || [UseOfCollections.empty_authorization]\n prep_fieldsets_for_test_data([fieldset(UseOfCollections::AUTHORIZATION_GRP.name)], authorizations)\n authorizations.each_with_index do |auth, index|\n enter_auto_complete(authorized_by_input(index), authorized_by_options(index), auth[UseOfCollections::AUTHORIZED_BY.name], 'Local Persons')\n wait_for_element_and_type(authorization_date_input(index), auth[UseOfCollections::AUTHORIZATION_DATE.name])\n hit_enter\n wait_for_element_and_type(authorization_note_input(index), auth[UseOfCollections::AUTHORIZATION_NOTE.name])\n wait_for_options_and_select(authorization_status_input(index), authorization_status_options(index), auth[UseOfCollections::AUTHORIZATION_STATUS.name])\n end\n end",
"def verify_authorizations(test_data)\n authorizations = test_data[CoreUseOfCollectionsData::AUTHORIZATION_GRP.name] || [CoreUseOfCollectionsData.empty_authorization]\n authorizations.each_with_index do |auth, index|\n verify_values_match(auth[CoreUseOfCollectionsData::AUTHORIZED_BY.name], element_value(authorized_by_input index))\n verify_values_match(auth[CoreUseOfCollectionsData::AUTHORIZATION_DATE.name], element_value(authorization_date_input index))\n verify_values_match(auth[CoreUseOfCollectionsData::AUTHORIZATION_NOTE.name], element_value(authorization_note_input index))\n verify_values_match(auth[CoreUseOfCollectionsData::AUTHORIZATION_STATUS.name], element_value(authorization_status_input index))\n end\n end",
"def index\n @authorities = Authority.all\n end",
"def index\n @authorities = Authority.all\n end",
"def get_all_authors\n count = params[:count] # Optional - and must be an integer. Cuts the amount of authors return down to the number specified.\n timeline = params[:timeline] # Optional - and must be boolean. Determines whether to return personality predictions by day, month, and year.\n traits = params[:traits] # Optional - value must be a substring of \"ESACO\". Determines which traits to return.\n puts \"count:#{count}\"\n puts \"timeline:#{timeline}\"\n puts \"traits:#{traits}\"\n\n request = Net::HTTP::Get.new(\"/personality-api/1/all_authors.json?count=#{count}&timeline=#{timeline}&traits=#{traits}\")\n request.basic_auth BmnPersonalityApiSkeletonRor::Application.config.user_name, BmnPersonalityApiSkeletonRor::Application.config.password\n response = @http.request(request)\n render :text => response.body\n\n end",
"def verify_authorizations(test_data)\n authorizations = test_data[UseOfCollections::AUTHORIZATION_GRP.name] || [UseOfCollections.empty_authorization]\n authorizations.each_with_index do |auth, index|\n verify_values_match(auth[UseOfCollections::AUTHORIZED_BY.name], element_value(authorized_by_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_DATE.name], element_value(authorization_date_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_NOTE.name], element_value(authorization_note_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_STATUS.name], element_value(authorization_status_input index))\n end\n end",
"def enter_authorizations(test_data)\n authorizations = test_data[CoreUseOfCollectionsData::AUTHORIZATION_GRP.name] || [CoreUseOfCollectionsData.empty_authorization]\n hide_notifications_bar\n prep_fieldsets_for_test_data([fieldset(CoreUseOfCollectionsData::AUTHORIZATION_GRP.name)], authorizations)\n authorizations.each_with_index do |auth, index|\n logger.info \"Entering authorization data set at index #{index}: #{auth}\"\n enter_auto_complete(authorized_by_input(index), authorized_by_options(index), auth[CoreUseOfCollectionsData::AUTHORIZED_BY.name], 'Local Persons')\n wait_for_element_and_type(authorization_date_input(index), auth[CoreUseOfCollectionsData::AUTHORIZATION_DATE.name])\n hit_enter\n wait_for_element_and_type(authorization_note_input(index), auth[CoreUseOfCollectionsData::AUTHORIZATION_NOTE.name])\n wait_for_options_and_select(authorization_status_input(index), authorization_status_options(index), auth[CoreUseOfCollectionsData::AUTHORIZATION_STATUS.name])\n end\n end",
"def authorizations_for(role)\n auth_roles = roles.find(:all, :joins => :role, :include => :authorizations, :conditions => { \"roles.name\" => role.to_s })\n return nil if auth_roles.empty?\n auth_roles.collect(&:authorizations).flatten.compact\n end",
"def index\n @claimppriorauthorizations = Claimppriorauthorization.all\n end",
"def authorizations_list_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: AuthorizationsApi.authorizations_list ...'\n end\n # resource path\n local_var_path = '/authorizations'\n\n # query parameters\n query_params = opts[:query_params] || {}\n query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?\n query_params[:'per_page'] = opts[:'per_page'] if !opts[:'per_page'].nil?\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n header_params[:'X-PhraseApp-OTP'] = opts[:'x_phrase_app_otp'] if !opts[:'x_phrase_app_otp'].nil?\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:body] \n\n # return_type\n return_type = opts[:return_type] || 'Array<Authorization>' \n\n # auth_names\n auth_names = opts[:auth_names] || ['Basic', 'Token']\n\n new_options = opts.merge(\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: AuthorizationsApi#authorizations_list\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n response = ::Phrase::Response.new(data, headers)\n return response, status_code, headers\n end",
"def investor_accreditation(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_accreditation\")\n end",
"def index\n @authorized_clients = AuthorizedClient.all\n end",
"def authorized_by(authorizer)\n authorizer.to_s.camelize.constantize # get authorizer loaded\n alias_method :old_users, :users\n alias_method :old_method_missing, :method_missing\n include TransitiveAuthorization::Authorizee::InstanceMethods\n self.cattr_accessor :transitive_authorizer\n self.transitive_authorizer = authorizer\n end",
"def apply_authorities(env)\n DogBiscuits.config.authorities_add_new.each do |authority_name|\n term = authority_name.to_s.singularize.to_sym\n next unless env.attributes.key? term\n env.attributes[term].each do |attr|\n add_new(authority_name.to_s, attr)\n end\n end\n end",
"def author_count\n revisions = Marginalia.revisions(params[:id])\n authors = []\n revisions.collect {|rev| authors << rev['user']}\n authors.uniq!\n render :text => authors.length\n end",
"def subauthorities\n SUBAUTHORITIES.keys\n end",
"def find_all_accounts(authorizer)\n debug \"central find_all_accounts\"\n raise 'Method not implemented because the Central Manager just need to pass the same requisition to the other' \\\n ' brokers and create the concatenated results'\n end",
"def index\n @company_authorities = CompanyAuthority.all\n\n render json: @company_authorities\n end",
"def get_author_cr_affiliations(auth_id)\n sql_statement = \\\n \"SELECT id, name FROM cr_affiliations WHERE article_author_id = \" + auth_id.to_s + \";\"\n db = get_db()\n stm = db.prepare sql_statement\n rs = stm.execute\n values_hash = {}\n rs.each do |row|\n values_hash[row[\"id\"]] = row[\"name\"]\n end\n return values_hash\nend",
"def update(*args)\n raise_authentication_error unless authenticated?\n arguments(args, required: [:id])\n\n patch_request(\"/authorizations/#{arguments.id}\", arguments.params)\n end",
"def get_related_authors\n tag = params['query']\n\n @articles = get_articles(tag) # gets all articles of this author\n # puts 'ARTICLES'\n # ap @articles\n\n @related_articles = []\n @authors = []\n\n # for each of the author's articles, get 1st degree articles and their respective authors\n @articles.each do |article|\n puts \"ARTIClE ID \"\n puts article.arxiv_id\n getRelatedPapers(article.arxiv_id, -1).each do |related|\n\n authors = related.authors\n authors.each do |author|\n\n if !@authors.include?(author)\n @authors << author\n end\n\n end\n end\n end\n \n\n @found = 1\n if @authors == []\n @msg = \"None found, try again...\"\n @found = 0\n end\n\n render \"authors\"\n end",
"def index\n @authorized_people = AuthorizedPerson.all\n end",
"def get_authors\n @branches.collect(&:author_names).flatten.uniq.sort_by { |k| k.downcase }\n end",
"def admin_for_companies\n get(\"/organizationalEntityAcls?q=roleAssignee&role=ADMINISTRATOR&state=APPROVED&count=100\")\n end",
"def authored_articles\n Article.where(author: self)\n end",
"def authorities\n Authority.where { |a| a.id.in( requestable_positions.scope.\n select { authority_id } ) }\n end",
"def load_authorities(options)\n return unless options[:authorities]\n\n redis = options.fetch(:redis, redis_connect(options))\n Argot::AuthorityEnricher.new(redis: redis).as_block\n end",
"def authorities\r\n ptr = Api.proj_get_authorities_from_database(self.context)\r\n Strings.new(ptr)\r\n end",
"def index\n @authorize_codes = AuthorizeCode.all\n end",
"def authorized_homerooms\n if EnvironmentVariable.is_true('ENABLE_HOMEROOM_AUTHORIZATION_V2')\n authorizer.homerooms\n else\n authorizer.allowed_homerooms_DEPRECATED(acknowledge_deprecation: true)\n end\n end",
"def orgs\n client.organizations\n end",
"def atom_entry_author(atom_entry, content)\n atom_entry.author do |author|\n entry_author = content.author_for(current_agent)\n\n author.name(sanitize(entry_author.name))\n if entry_author.respond_to?(:openid_uris) && entry_author.openid_uris.any?\n author.uri(entry_author.openid_uris.first)\n end\n end\n\n end",
"def authorize\n if params[:response_type].nil?\n params[:response_type] = \"code\"\n end\n @authorizer = OAuth::Provider::Authorizer.new current_user, true, params\n client_application = ClientApplication.find_by_key(params[:client_id])\n statsd = StatsManager.new\n statsd.feedAuthorizeMetric(current_user, client_application)\n #If this is an auto authentication transparent for end user\n redirect_to @authorizer.redirect_uri\n end",
"def index\n @condition = {}\n @condition[:orgnization] = current_user.orginization unless current_user.orgnization == User::ORGS[0]\n @condition[:status] = params[:status] if params[:status] and AuthorityChangeRequest::STATUS.include? params[:status]\n @acrs = AuthorityChangeRequest.where @condition\n end",
"def authors\n @authors ||= begin\n auths = entries.map {|e| e[:author]}.uniq\n auths.inject({}) {|acc, a| acc[a] = SvnLog::COLORS.next; acc}\n end\n end",
"def author_identities_set\n author_identities.map do |ident|\n normalize_author_identity(ident.first_name, ident.middle_name || 'None',\n ident.last_name, ident.institution || 'None')\n end.to_s\n end",
"def get_authors_by_personality\n count = params[:count] # Optional - and must be an integer. Cuts the amount of authors return down to the number specified.\n timeline = params[:timeline] # Optional - and must be boolean. Determines whether to return personality predictions by day, month, and year.\n traits = params[:traits]\n e = params[:E] # Optional - and must be y, n or o. Extraversion personality trait. \n s = params[:S] # Optional - and must be y, n or o. Emotional Stability personality trait. \n a = params[:A] # Optional - and must be y, n or o. Agreeableness personality trait. \n c = params[:C] # Optional - and must be y, n or o. Conscientiousness personality trait. \n o = params[:O] # Optional - and must be y, n or o. Openness personality trait. \n puts \"count:#{count}\"\n puts \"timeline:#{timeline}\"\n puts \"e:#{e}\"\n puts \"s:#{s}\"\n puts \"a:#{a}\"\n puts \"c:#{c}\"\n puts \"o:#{o}\"\n\n request = Net::HTTP::Get.new(\"/personality-api/1/authors_by_personality.json?count=#{count}&timeline=#{timeline}&Extraversion=#{e}&EmotionalStability=#{s}&Agreeableness=#{a}&Conscientiousness=#{c}&Openness=#{o}\")\n request.basic_auth BmnPersonalityApiSkeletonRor::Application.config.user_name, BmnPersonalityApiSkeletonRor::Application.config.password\n response = @http.request(request)\n render :text => response.body\n\n end",
"def index\n @clients_organizations = ClientsOrganization.all\n end",
"def index\n @representante_athletes = current_user.organization.athletes\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @representante_athletes }\n end\n end",
"def authors\n\t#params[:diff] = params[:diff].eql?\"true\"\n \trespond_in_format Marginalia.authors(params[:id],params[:diff])\n end",
"def update_authorizations(role_ids)\n role_ids = role_ids.map {|i| i.to_i }\n roles = self.roles.collect(&:id) # get current role ids\n roles_to_remove = roles - role_ids\n roles_to_add = role_ids - roles\n\n unless roles_to_remove.blank?\n self.authorizations.where(role_id: roles_to_remove).destroy_all\n end\n\n unless roles_to_add.blank?\n roles_to_add.each do |r|\n self.authorizations.create({:role_id => r})\n end\n email_roles_granted(roles_to_add)\n end\n return {:roles_added => roles_to_add, :roles_removed => roles_to_remove}\n end",
"def create_authorizations_api\n InfluxDB2::API::AuthorizationsApi.new(@api_client)\n end",
"def update(*args)\n require_authentication\n arguments(args, required: [:authorization_id]) do\n sift(VALID_AUTH_PARAM_NAMES)\n end\n\n patch_request(\"/authorizations/#{authorization_id}\", arguments.params)\n end",
"def index\n @authorizedusers = Authorizeduser.all\n end",
"def admin_organizations_with_protocols\n Organization.authorized_for_identity(@id).joins(:sub_service_requests)\n end",
"def show_all_authors\n @all = []\n search_techcrunch[\"articles\"].each do |article|\n @all << article[\"author\"]\n end\n unique_array = @all.uniq!.sort\n puts \"#{dashes}\\n\"\n unique_array.each_with_index do |author, index| puts \"#{index+1}. #{author}\"\n end\n return nil\n end",
"def get_acls(rsrc_hash)\n rule_str = Array.new\n\n # Grant permissions to the group\n rule_str << \"@#{@vdc.GROUP_ID} VM+IMAGE+TEMPLATE/* CREATE\"\n\n # Grant permissions to the vdc admin\n rule_str << \"##{@vdc.VDCADMIN_ID} USER/* CREATE\"\n rule_str << \"##{@vdc.VDCADMIN_ID} USER/@#{@vdc.GROUP_ID} \" \\\n \"USE+MANAGE+ADMIN\"\n rule_str << \"##{@vdc.VDCADMIN_ID} VM+IMAGE+TEMPLATE/@#{@vdc.GROUP_ID} \" \\\n \"USE+MANAGE\"\n\n ####################################################################\n #When more rules are added the class constant RESOURCE_ACL_FIRST_ID\n #must be modified\n ####################################################################\n\n rule_str.concat(get_resource_acls(rsrc_hash))\n end",
"def index\n @aramis_entities = AramisEntity.all\n end",
"def author_ids\n diff[:authors]\n end",
"def authorized(&block)\n authorizer.authorized(&block)\n end",
"def authorized(&block)\n authorizer.authorized(&block)\n end",
"def index\n if params[:terms]\n # Search mode\n @organizations = []\n JSON.parse(params[:terms]).map { |t| @organizations = @organizations | MnoEnterprise::Organization.where(Hash[*t]).fetch }\n response.headers['X-Total-Count'] = @organizations.count\n else\n # Index mode\n query = MnoEnterprise::Organization\n query = query.limit(params[:limit]) if params[:limit]\n query = query.skip(params[:offset]) if params[:offset]\n query = query.order_by(params[:order_by]) if params[:order_by]\n query = query.where(params[:where]) if params[:where]\n all = query.all\n\n all.params[:sub_tenant_id] = params[:sub_tenant_id]\n all.params[:account_manager_id] = params[:account_manager_id]\n\n @organizations = all.fetch\n\n response.headers['X-Total-Count'] = @organizations.metadata[:pagination][:count]\n end\n end",
"def achievements\n @achievements ||= Achievement.where(subject_id: primary_key_value)\n end",
"def index\n @collaborators = Collaborator.accessible_by(current_ability)\n @entities = Entity.accessible_by(current_ability)\n end",
"def assignment_to(assignment_to, authorizes:, via:)\n @authorizations ||= []\n @authorizations << Authorizations::Authorization.new(\n assignment_to: assignment_to,\n authorizes: authorizes,\n via: via\n )\n end",
"def achievements( params={} )\n achievements = get_connections(\"achievements\", params)\n return map_connections achievements, :to => Facebook::Graph::Generic\n end",
"def normalize_author(hsh)\n str = hsh['author']\n tokens = repair_and_tokenize_author_text(str)\n authors = []\n current_auth = []\n begin_auth = 1\n tokens.each {|tok|\n if tok =~ /^(&|and)$/i\n if !current_auth.empty?\n auth = normalize_author_name(current_auth)\n authors << auth\n end\n current_auth = []\n begin_auth = 1\n next\n end\n if begin_auth > 0\n current_auth << tok\n begin_auth = 0\n next\n end\n if tok =~ /,$/\n current_auth << tok\n if !current_auth.empty?\n auth = normalize_author_name(current_auth)\n authors << auth\n current_auth = []\n begin_auth = 1\n end\n else\n current_auth << tok\n end\n }\n if !current_auth.empty?\n auth = normalize_author_name(current_auth)\n authors << auth unless auth.strip == \"-\"\n end\n hsh['authors'] = authors\n hsh\n end",
"def get_list_acc\n JSON.parse(curl_get(\"accounts\").body_str)\n end",
"def current_user_oganizations\n endpoint = '/api/user/orgs'\n @logger.debug(\"Getting current user organizations (GET #{endpoint})\") if @debug\n get(endpoint)\n end",
"def get_articles(author_id)\n\n @author = Author.find(author_id)\n\n @articles = []\n @author.creations.each do |creation|\n temp = Article.find(creation.article_id)\n\n if !@articles.include? temp\n @articles << Article.find(creation.article_id)\n end\n\n end\n # puts \"ARTICLES\"\n\n # ap @articles\n\n return @articles\n end",
"def set_ach_information(params = {})\r\n @PARAM_HASH['PAYMENT_TYPE'] = 'ACH'\r\n @PARAM_HASH['ACH_ROUTING'] = params[:ach_routing]\r\n @PARAM_HASH['ACH_ACCOUNT'] = params[:ach_account]\r\n @PARAM_HASH['ACH_ACCOUNT_TYPE'] = params[:ach_account_type]\r\n @PARAM_HASH['DOC_TYPE'] = params[:doc_type] || ''\r\n end",
"def set_ach_information(params = {})\r\n @PARAM_HASH['PAYMENT_TYPE'] = 'ACH'\r\n @PARAM_HASH['ACH_ROUTING'] = params[:ach_routing]\r\n @PARAM_HASH['ACH_ACCOUNT'] = params[:ach_account]\r\n @PARAM_HASH['ACH_ACCOUNT_TYPE'] = params[:ach_account_type]\r\n @PARAM_HASH['DOC_TYPE'] = params[:doc_type] || ''\r\n end",
"def get_telephony_providers_edges_certificateauthorities_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: TelephonyProvidersEdgeApi.get_telephony_providers_edges_certificateauthorities ...\"\n end\n \n # resource path\n local_var_path = \"/api/v2/telephony/providers/edges/certificateauthorities\".sub('{format}','json')\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n local_header_accept = ['application/json']\n local_header_accept_result = @api_client.select_header_accept(local_header_accept) and header_params['Accept'] = local_header_accept_result\n\n # HTTP header 'Content-Type'\n local_header_content_type = ['application/json']\n header_params['Content-Type'] = @api_client.select_header_content_type(local_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n \n auth_names = ['PureCloud OAuth']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'CertificateAuthorityEntityListing')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: TelephonyProvidersEdgeApi#get_telephony_providers_edges_certificateauthorities\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def authorised_actions\n if auth_notification\n auth_notification.\n actions.map(&method(:transform_action))\n\n else\n []\n\n end\n end",
"def delete(*args)\n require_authentication\n arguments(args, required: [:authorization_id])\n\n delete_request(\"/authorizations/#{authorization_id}\", arguments.params)\n end",
"def authors\n @authors\n end",
"def to_authoring_hash\n hash = to_hash\n hash[:id] = id\n hash[:linked_interactive_id] = linked_interactive_id\n hash[:linked_interactive_type] = linked_interactive_type\n hash[:aspect_ratio] = aspect_ratio\n hash[:interactive_item_id] = interactive_item_id\n hash[:linked_interactive_item_id] = linked_interactive_item_id\n # Note that linked_interactives is independent from linked_interactive_id and linked_interactive_type fields\n hash[:linked_interactives] = linked_interactives_list\n hash\n end",
"def orgs\n @orgs ||= begin\n client.organizations.map(&:login)\n rescue Octokit::Unauthorized, Faraday::ConnectionFailed\n []\n end\n end",
"def save\n response = if @id.nil?\n Cloud.instance.post ['cloud-service-auth', 'accounts', @account.id, 'authorities'], self\n else\n raise 'editing authorities not supported'\n # @cloud.put [\"cloud-service-auth\", \"principals\", @id], self\n end\n apply_data(response.body)\n self\n end",
"def get_agreements\n get_agreements_response = Echochamber::Request.get_agreements(token)\n get_agreements_response.fetch(\"userAgreementList\")\n end",
"def authorizable_ransackable_associations\n reflect_on_all_associations.map { |a| a.name.to_s }\n end",
"def index\n @organizations = Organization.order(:activated)\n end",
"def index\n\t @authentications = current_user.authentications.order('provider asc')\n\t end",
"def index\n @agencies = current_user.agencies.all\n end",
"def find_all_accounts(authorizer)\n accounts = OMF::SFA::Model::Account.exclude(:name => '__default__')\n accounts.map do |a|\n begin\n raise InsufficientPrivilegesException unless authorizer.can_view_account?(a)\n a\n rescue InsufficientPrivilegesException\n nil\n end\n end.compact\n end",
"def patch_authorizations_id(auth_id, authorization_update_request, opts = {})\n data, _status_code, _headers = patch_authorizations_id_with_http_info(auth_id, authorization_update_request, opts)\n data\n end",
"def index\n @organization_accounts = OrganizationAccount.all.sort_by(&:organization_name).reverse\n \n if user_signed_in? && current_user.admin?\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @organization_accounts }\n end\n else\n redirect_to root_path\n end\n end",
"def authors\n return [] if @feed.channel.managingEditor.nil? && @feed.channel.dc_publishers.empty?\n [@feed.channel.managingEditor, ((@feed.channel.dc_publishers.empty?) ? nil : @feed.channel.dc_publishers.collect{|dcp| dcp.content})].flatten.uniq.compact.reject{|au| au == '' || au.match(/^\\s+$/)}\n end",
"def get_organizations\n org_references =\n locations.each_with_object({}) do |loc, acc|\n reference = loc.resource.managingOrganization.reference\n org_id = reference.match(ID_MATCHER)[1]\n\n acc[org_id] ||= []\n acc[org_id] << loc\n end\n\n facility_identifiers = org_references&.keys&.join(',')\n org_response = organization_service.search(_id: facility_identifiers, _count: '100')\n\n org_response&.resource&.entry\n end",
"def create(*args)\n require_authentication\n arguments(args) do\n sift(VALID_AUTH_PARAM_NAMES)\n end\n\n post_request(\"/authorizations\", arguments.params)\n end",
"def index\n @chapter_authors = ChapterAuthor.all\n end",
"def update_authorization(id, options={})\n patch \"/authorizations/#{id}\", :body => options\n end",
"def exchAccounts\n @exch_accounts = @entourage.ExchangeAccounts\n puts @exch_accounts\n end",
"def show_authors(result)\n author_array = []\n if result['Items'].present?\n flag = 0\n authorString = []\n result['Items'].each do |item|\n if item['Group'].present?\n if item['Group'] == \"Au\"\n # let Don and Michelle know what this cleaner function does\n newAuthor = processAPItags(item['Data'].to_s)\n # i'm duplicating the semicolor - fix\n newAuthor.gsub!(\"<br />\", \"; \")\n authorString.push(newAuthor)\n flag = 1\n end\n end\n end\n if flag == 1\n return truncate_article authorString.join(\"; \").html_safe\n end\n end\n contributors = result.fetch('RecordInfo', {}).fetch('BibRecord', {}).fetch('BibRelationships', {}).fetch('HasContributorRelationships', [])\n if not contributors.empty?\n contributors.each do |contributor|\n namefull = contributor.fetch('PersonEntity', {}).fetch('Name', {}).fetch('NameFull', nil)\n if namefull\n url_vars = {\"q\" => '\"' + namefull.gsub(\",\", \"\").gsub(\"%2C\", \"\").to_s + '\"', \"search_field\" => \"author\"}\n link2 = generate_next_url_newvar_from_hash(url_vars)\n author_link = '<a href=\"' + request.fullpath.split(\"?\")[0] + \"?\" + link2 + '\">' + namefull.to_s + '</a>'\n author_array.push(author_link)\n end\n\n end\n return author_array.join(\"; \").html_safe\n end\n return ''\n end",
"def index\n @oauth_accounts = OauthAccount.all\n end",
"def authors\n @authors ||= author_ids.map { |id| Author.new(instance, id) }\n end",
"def index\n @akces = Akce.all\n end",
"def index\n conditions = { :block => false }\n conditions.merge!( :is_opinion => true ) if params[:opinion] == '1'\n conditions.merge!( :is_agency => true ) if params[:agency] == '1'\n unless params[:author_id].blank? && params[:author_ids].blank?\n author_ids = scan_multiple_value_param( :author_id, :first ) || scan_multiple_value_param( :author_ids )\n conditions.merge!( :id => author_ids )\n end\n params[:top] == '1' ? top() : ( !params[:q].blank? ? search( conditions ) : list( conditions ) )\n @authors.delete_if{ |a| a.story_authors.count < 2 } if params[:cf] == '1'\n rxml_data( @authors, :root => 'authors', :with_pagination => true )\n end"
] |
[
"0.62420696",
"0.61521333",
"0.6116939",
"0.60832816",
"0.6021224",
"0.58773667",
"0.58773667",
"0.58372104",
"0.58047384",
"0.5767842",
"0.5491542",
"0.5472516",
"0.54503995",
"0.5433435",
"0.54077476",
"0.54077476",
"0.5384407",
"0.5365944",
"0.5354341",
"0.53037167",
"0.5303101",
"0.5232709",
"0.5135067",
"0.5120039",
"0.5094387",
"0.49685133",
"0.49149916",
"0.48832098",
"0.48778284",
"0.48607093",
"0.4854441",
"0.48459122",
"0.48459014",
"0.48428753",
"0.48352107",
"0.48173448",
"0.48163107",
"0.4804159",
"0.47833967",
"0.47746694",
"0.4762816",
"0.47247934",
"0.47125828",
"0.46817282",
"0.4661779",
"0.46525437",
"0.46522227",
"0.46448067",
"0.462332",
"0.46181422",
"0.46057406",
"0.45861676",
"0.45842502",
"0.4563503",
"0.45569876",
"0.45556644",
"0.45527697",
"0.45398277",
"0.45363185",
"0.45316127",
"0.45278838",
"0.45189202",
"0.45189202",
"0.45055613",
"0.44952938",
"0.44927362",
"0.44916055",
"0.4480239",
"0.445883",
"0.44563037",
"0.44555104",
"0.4452703",
"0.44519776",
"0.44519776",
"0.44448557",
"0.4432311",
"0.44315597",
"0.44298336",
"0.44291064",
"0.4423856",
"0.44207153",
"0.44171658",
"0.4415087",
"0.4399698",
"0.43982154",
"0.43971977",
"0.4395515",
"0.4388734",
"0.43830094",
"0.438096",
"0.43745974",
"0.43716455",
"0.4368901",
"0.4365516",
"0.43633723",
"0.43581766",
"0.43533525",
"0.43471846",
"0.43452623",
"0.43439633"
] |
0.8727051
|
0
|
End point: (GET) Usage: FundAmerica::Entity.cash_blotter(entity_id)
|
def cash_blotter(entity_id)
API::request(:get, "entities/#{entity_id}/cash_blotter")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def bank_transfer_method(entity_id)\n API::request(:get, \"entities/#{entity_id}/bank_transfer_methods\")\n end",
"def get_marketplace_bank_account\n Balanced::BankAccount.find(\"/v1/bank_accounts/BAj6sNNBdMp5WmY6PJ7sAu3\")\n end",
"def balance\n rest.get(:getbalance)['data']\n end",
"def get_account_balance\n submit GetAccountBalance.new\n end",
"def balances(id)\n get(\"/accounts/#{id}/balances\")\n end",
"def getbalance(args={})\n {\n :method=> \"GetBalances\"\n }.to_json\n end",
"def balance\n request_params = params.permit(:account_id)\n\n balance ||= Actions.new.balance(request_params['account_id'])\n\n return render status: balance[0], json: balance[1]\n end",
"def balance\n parse_balance(post('/api/1/generic/info'))\n end",
"def scotch_blended\n puts \"Let's explore blended Scotch whiskies\"\n #call method to list whiskies for this particular type\n list_whiskies('c/304/blended-scotch-whisky?filter=true&rfdata=~size.76#productlist-filter')\n end",
"def balance\n @client.balance(name)\n end",
"def index\n @bills = current_company.bills\n end",
"def fetch_balances\n\n SaasApi::OnBoarding::FetchBalances.new.perform(client_id: @client_id, balances_to_fetch: @balances_to_fetch)\n\n end",
"def index\n @billings = current_account.billings\n end",
"def index\n @debts = Debt.all\n end",
"def index\n @debts = Debt.all\n end",
"def getPtbAll( entity_id, destructive)\n params = Hash.new\n params['entity_id'] = entity_id\n params['destructive'] = destructive\n return doCurl(\"get\",\"/ptb/all\",params)\n end",
"def add_bank_account\n\n get_balanced_key\n\n account_uri = params[:account_uri]\n company_name = \"Mindfire Solutions\"\n\n ##You can set your customer business / company name here \n customer = Balanced::Customer.new({name: company_name}).save\n customer_uri = customer.href\n get_customer = Balanced::Customer.fetch(customer_uri)\n \n bank_account = Balanced::BankAccount.fetch(account_uri)\n bank_account.associate_to_customer(customer_uri)\n \n ##befor debiting your customer you need to verify their bank account as per balanced payment\n bank_account = Balanced::BankAccount.fetch(account_uri)\n verify_bank_account = bank_account.verify\n verification = Balanced::BankAccountVerification.fetch(verify_bank_account.href)\n verification.confirm(\n amount_1 = 1,\n amount_2 = 1\n )\n \n amount_in_dollars = params[:amount].to_i\n #amount_in_dollars * 100 convert into cents\n debit = bank_account.debit(:amount => amount_in_dollars * 100, appears_on_statement_as: \"Debit Amount\")\n \n ##You can save the response in your db for future use\n #debit.transaction_number\n #debit.amount\n #debit.statusdebit.created_at\n \n #get your balanced marketplace\n marketplace = Balanced::Marketplace.my_marketplace\n \n credit = get_marketplace_bank_account.credit(:amount => debit.amount, appears_on_statement_as: \"Credit Amount\")\n\n \n return render json: {success: [\"Debit Transaction:: #{debit.attributes}\", \"Credit Transaction:: #{credit.attributes}\"] }\n\n end",
"def bet(amount, enemy_id)\n begin\n transaction do\n new_bet = Bet.new(:amount => amount, :enemy_id => enemy_id, :channel_account_id => id)\n self.bets << new_bet\n self.balance -= amount\n self.status = STATUS_BETTING \n \n new_bet.save!\n self.save!\n end\n rescue ActiveRecord::RecordInvalid\n false\n end\n end",
"def index\n @cash_balances = CashBalance.all\n end",
"def set_cash_balance\n @cash_balance = CashBalance.find(params[:id])\n end",
"def index\n get_budgets\n end",
"def balance_hash\n @money\n end",
"def index\n @bankets = Banket.all\n end",
"def add_credit_card\n\n get_balanced_key\n card_uri = params[:card_uri]\n\n company_name = \"Mindfire Solutions\"\n customer = Balanced::Customer.new({name: company_name}).save\n customer_uri = customer.href\n get_customer = Balanced::Customer.fetch(customer_uri)\n card = Balanced::Card.fetch(card_uri)\n card.associate_to_customer(customer_uri)\n \n\n amount_in_dollars = params[:amount].to_i\n #amount_in_dollars * 100 convert into cents\n\n debit = card.debit(:amount => amount_in_dollars * 100, appears_on_statement_as: \"Debit Amount\")\n \n ##You can save the response in your db for future use\n #debit.transaction_number\n #debit.amount\n #debit.statusdebit.created_at\n \n #get the balanced market place\n marketplace = Balanced::Marketplace.my_marketplace\n \n credit = get_marketplace_bank_account.credit(:amount => debit.amount, appears_on_statement_as: \"Credit Amount\")\n\n\n return render json: {success: [\"Debit Transaction:: #{debit.attributes}\", \"Credit Transaction:: #{credit.attributes}\"] }\n\n end",
"def index\n @bets = Bet.all\n end",
"def balances()\n request(\"#{@base_url}/account/getbalances\")\n end",
"def get_coins\n get(\"/getcoins\")\n end",
"def budgets\n # https://developer.xero.com/documentation/api/budgets\n # if you are having issues in adding the accounting.budgets.read scope, get in touch => api@xero.com\n @budgets = xero_client.accounting_api.get_budgets(current_user.active_tenant_id).budgets\n @budget = xero_client.accounting_api.get_budget(current_user.active_tenant_id, @budgets.sample.budget_id).budgets\n end",
"def index\n @budgets = Budget.all\n end",
"def index\n @bills = Bill.by_company(current_user.company_id).active.latest\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @bills }\n end\n end",
"def get_banks\n HTTParty.get(BASE_URI + 'bank?country=ghana',\n headers: HEADERS).parsed_response\n end",
"def budget_cash_back(card)\n card_benefits_categories = []\n card.benefits.each {|b| card_benefits_categories << b.category}\n other_purchases = []\n budget_earnings = {}\n card_budgets(card).each do |b|\n if card_benefits_categories.include?(b.name)\n benefit = card.benefits.find_by(category: (b.name))\n cash_back_earned = (((benefit.cash_back)/100)*((sort_purchases_by_card(b, card)).sum)).round(2)\n budget_earnings[benefit.category] = cash_back_earned\n elsif card_benefits_categories.include?('All other purchases')\n benefit = card.benefits.find_by(category: 'All other purchases')\n other_purchases << (((benefit.cash_back)/100)*((sort_purchases_by_card(b, card)).sum)).round(2)\n end\n end\n if card_benefits_categories.include?('All other purchases')\n cash_back_earned = other_purchases.sum.round(2)\n budget_earnings['All other purchases'] = cash_back_earned\n end\n budget_earnings\n end",
"def bet(amount)\n [:bet, amount]\n end",
"def getaccount(bitcoinaddress)\n @api.request 'getaccount', bitcoinaddress\n end",
"def balance\r\n BalanceController.instance\r\n end",
"def getaccount(coinaddress)\n coind.getaccount coinaddress\n end",
"def create\n redirect_to new_bet_path and return if params[:bet][:amount].blank? #if nothing is entered, try again\n\n @line = Line.find(session[:line_id])\n redirect_to lines_path and return if @line.event.started?\n\n @bet = Bet.new(:line_id => session[:line_id], :portfolio_id => session[:portfolio_id], :amount => params[:bet][:amount])\n\n respond_to do |format|\n if @bet.save\n #deduct -> working here\n @portfolio = Portfolio.find(session[:portfolio_id])\n @current_balance = @portfolio.cash\n @portfolio.update_attributes(:cash => @current_balance - params[:bet][:amount].to_i)\n \n format.html { redirect_to @bet, notice: 'Bet was successfully created.' }\n format.json { render json: @bet, status: :created, location: @bet }\n else\n# format.html { render action: \"new\" } #my deletion\n format.html { render \"new\" }\n format.json { render json: @bet.errors, status: :unprocessable_entity }\n end\n end\n end",
"def credit\n handle_response(get(\"/credit.json\"))\n end",
"def get_coin\n @coin = Coin.find(params[:coin_id])\n end",
"def get_coin\n @coin = Coin.find(params[:coin_id])\n end",
"def show\n @bet = Bet.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bet }\n end\n end",
"def index\n @account_ticket_balance_details = AccountTicketBalanceDetail.all\n end",
"def eth_portfolio\n return @@client.accounts[1].balance.amount.to_f\n end",
"def index\n @ballots = Ballot.all\n end",
"def index\n @ballots = Ballot.all\n end",
"def get_standing_orders(account_id = nil, cents = false, accounts = nil)\n if account_id.nil?\n options = { cents: cents, accounts: accounts }.delete_if { |_k, v| v.nil? }.to_query\n path = \"/rest/standing_orders?#{options}\"\n else\n path = \"/rest/accounts/#{account_id}/standing_orders?cents=#{cents}\"\n end\n query_api_object Model::StandingOrder, path, nil, 'GET', 'standing_orders'\n end",
"def index\n @bettings = Betting.all\n end",
"def index\n @money = Money.all\n require 'net/http'\n require 'json'\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n @lookup_money = JSON.parse(@response)\n end",
"def index\n\n @debtors = Debtor.all\n\n render json: @debtors\n end",
"def customer_cash(customers_hash)\n return customers_hash[:cash]\nend",
"def balance_for(account)\n @accounts[account]\n end",
"def cash\n # Set active_tab to use in view filters\n session[:active_tab] = \"pendings-tab\"\n\n invoice_ids = params[:client_payment][:invoices_ids].split(\",\")\n instalment_ids = params[:client_payment][:ids].split(\",\")\n amount = BigDecimal.new(params[:client_payment][:amount]) rescue 0 # 0 if error beause :amount is null and debt negative\n payment_method = params[:client_payment][:payment_method_id]\n redirect_to client_payments_path + \"#tab_pendings\", alert: I18n.t(\"ag2_gest.client_payments.generate_error_payment\") and return if payment_method.blank?\n # If these are instalments, call cash_instalments & exit\n if !instalment_ids.blank?\n cash_instalments(instalment_ids, amount, payment_method)\n return\n end\n # If these are invoices, go on from here\n client_payment = nil\n invoices = Invoice.find_all_by_id(invoice_ids).sort_by {|a| a[:created_at]}\n created_by = current_user.id if !current_user.nil?\n acu = amount\n # Receipt No.\n receipt_no = receipt_next_no(invoices.first.invoice_no[3..4]) || '0000000000'\n invoices.each do |i|\n if amount > 0\n if acu > 0\n if acu >= i.debt\n amount_paid = i.debt\n acu -= i.debt\n invoice_status = InvoiceStatus::CASH\n else\n amount_paid = acu\n acu = 0\n invoice_status = InvoiceStatus::PENDING\n end\n else\n break\n end # acu > 0\n else\n amount_paid = i.debt\n invoice_status = InvoiceStatus::CASH\n end # amount > 0\n client_payment = ClientPayment.new(receipt_no: receipt_no, payment_type: ClientPayment::CASH, bill_id: i.bill_id, invoice_id: i.id,\n payment_method_id: payment_method, client_id: i.bill.client_id, subscriber_id: i.bill.subscriber_id,\n payment_date: Time.now, confirmation_date: nil, amount: amount_paid, instalment_id: nil,\n client_bank_account_id: nil, charge_account_id: i.charge_account_id, created_by: created_by)\n if client_payment.save\n i.invoice_status_id = invoice_status\n i.save\n end\n end # invoices.each do\n redirect_to client_payments_path + \"#tab_pendings\", notice: (I18n.t('ag2_gest.client_payments.index.cash_ok') + \" #{view_context.link_to I18n.t('ag2_gest.client_payments.index.click_to_print_receipt'), payment_receipt_client_payment_path(client_payment, :format => :pdf), target: '_blank'}\").html_safe\n # redirect_to client_payments_path, notice: \"Recibo/Factura/s traspasados/as a Caja.\"\n rescue\n redirect_to client_payments_path + \"#tab_pendings\", alert: I18n.t('ag2_gest.client_payments.index.cash_error')\n end",
"def set_bet\n @bet = Bet.find(params[:id])\n end",
"def set_bet\n @bet = Bet.find(params[:id])\n end",
"def set_bet\n @bet = Bet.find(params[:id])\n end",
"def set_bet\n @bet = Bet.find(params[:id])\n end",
"def set_bet\n @bet = Bet.find(params[:id])\n end",
"def set_bet\n @bet = Bet.find(params[:id]) \n end",
"def test_get_cash\n assert_equal(50, @bakery.get_cash)\n end",
"def service_contract_of(buyer)\n service_contracts.find_by(user_account_id: buyer.id)\n end",
"def index\n @contracts = Contrato.all\n\n # geth attach ipc:\\\\.\\pipe\\geth.ipc\n client = Ethereum::IpcClient.new(\"\\\\\\\\.\\\\pipe\\\\geth.ipc\", false)\n client2 = Ethereum::HttpClient.new('http://localhost:8545')\n @balance = client2.eth_get_balance \"0xCf3cC4A1211920fff9716b0343bFe978DbbAb8B1\"\n @gas_price = client2.eth_gas_price\n puts @gas_price\n\n end",
"def set_bet\n @bet = Bet.find_by_id(params[:id])\n end",
"def set_betting\n @betting = Betting.find(params[:id])\n end",
"def show\n @company = Company.find(params[:id])\n @company_boats = @company.boats\n end",
"def credit\n handle_response(self.class.get(\"/credit.json\"))\n end",
"def balance\n params = {'username' => ENV['ROCK_USERNAME'],\n\t\t 'password' => ENV['ROCK_PASSWORD'],\n 'api_key' => ENV['ROCK_KEY']}\n\n btc_balance = 0.0\n\tusd_balance = 0.0\n\n\tresponse = RestClient.post(\"https://www.therocktrading.com/api/get_balance\", params, {})\n\tr_json = JSON.parse(response)\n\tif (r_json.keys.include?(\"result\"))\n\t r_json[\"result\"].each do |currency|\n if currency[\"currency\"]==\"BTC\"\n \t btc_balance = currency[\"balance\"].to_f\n\t elsif currency[\"currency\"]==\"USD\"\n\t usd_balance = currency[\"balance\"].to_f\n end\n\t end\n \telse\n\t btc_balance = 0.0\n\t usd_balance = 0.0\n\tend\n return [btc_balance, usd_balance]\n end",
"def index\n response = RestClient.get 'http://api.bitvalor.com/v1/order_book.json'\n data = JSON.parse(response.body)[\"bids\"]\n @fox = data.select {|element| element[0] == \"FOX\"}\n @b2u = data.select {|element| element[0] == \"B2U\"}\n @mbt = data.select {|element| element[0] == \"MBT\"}\n end",
"def balance(account_name=nil)\n request('getbalance', account_name)\n end",
"def show\n @b_accounts = BAccount.where(id: params[:id])\n end",
"def balance client\n puts \"Estimado Sr./Sra #{client.name} #{client.last_name}\"\n puts \"Su saldo es:\"\n puts \"Cuentas de ahorros: Bs. #{client.saving_amount}\".colorize(:blue)\n puts \"Cuentas de corriente: Bs. #{client.check_amount}\".colorize(:blue)\n end",
"def balance\n JSON.parse(response.body).fetch('balance')\n end",
"def bills(options = {})\n get('/bills', options)\n end",
"def after_bet_cashout(bet, cashout_amount)\n Ledgers::GenerateBetLedgers.new(ledger_params(bet, cashout_amount)).call\n # BetsNotifyMailer.with(bet_id: bet.id).cashed_out.deliver_later\n end",
"def branche\n Rails.cache.fetch(\"commits/#{branche_id}-#{commit_hash}/branche\", expires_in: 240.hours) do\n Branche.find(@branche_id)\n end\n end",
"def index\n if current_user\n @bids = current_user.bids\n elsif current_contractor\n @bids = current_contractor.bids\n end\n end",
"def index\n @tranhead = Tranheads::Bankclient.all\n end",
"def show\n coin = Coin.find(params[:id]) \n require 'net/http'\n url = url = \"https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=#{coin.coin_api_id}&order=market_cap_desc&per_page=100&page=1&sparkline=false&price_change_percentage=1h\"\n request = URI.parse(url)\n response = Net::HTTP.get_response(request)\n crypto_hash = JSON.parse(response.body)\n coin.image = crypto_hash[0]['image']\n coin.current_price = crypto_hash[0]['current_price']\n coin.price_change_percentage_1h_in_currency = crypto_hash[0]['price_change_percentage_1h_in_currency']\n coin.high_24h = crypto_hash[0]['high_24h']\n coin.low_24h = crypto_hash[0]['low_24h']\n coin.total_volume = crypto_hash[0]['total_volume']\n coin.market_cap = crypto_hash[0]['market_cap']\n coin.market_cap_rank = crypto_hash[0]['market_cap_rank']\n coin.circulating_supply = crypto_hash[0]['circulating_supply']\n\n # Serializer\n # render json: CoinSerializer.new(coin)\n render json: coin\n end",
"def retrieve(id)\n @client.make_request(:get, \"carrier_accounts/#{id}\", MODEL_CLASS)\n end",
"def index\n @accounting = Accounting.find(params[:accounting_id])\n @shares = @accounting.shares\n end",
"def update\n @bet = Bet.find(params[:id])\n @line = @bet.line\n redirect_to lines_path and return if @line.event.started?\n current_bet_size = @bet.amount\n @portfolio = @bet.portfolio\n current_balance = @portfolio.cash\n\n respond_to do |format|\n if @bet.update_attributes(params[:bet])\n @portfolio.update_attributes(:cash => current_balance + current_bet_size - params[:bet][:amount].to_i)\n\n format.html { redirect_to @bet, notice: 'Bet was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bet.errors, status: :unprocessable_entity }\n end\n end\n end",
"def find_with_balance(account_id)\n @request = setup_request \"#{@@resource_url}/getAccount\"\n @request.query = { accountId: account_id }\n @request\n end",
"def getbalance(account = nil, minconf = 1)\n request :getbalance, account, minconf\n end",
"def set_cash\n @cash = Cash.find(params[:id])\n end",
"def show\n render \"api/v1/bounties/show\"\n end",
"def rob(cash)\n\nend",
"def index\n @bets = Bet.where(user_id: current_user.id)\n\n end",
"def index\n @bitcoins = Bitcoin.all\n end",
"def customer_cash(customer_hash)\n return customer_hash[:cash]\nend",
"def despositing_adds_transaction_to_bank_statement\n account = BankAccount.new\n account.deposit('10-01-2012', 1000)\n p account\n p account.bank_statement\nend",
"def my_bets\n @bets = Bet.where('owner = ? AND status != ? AND status != ?', params[:id], \"won\", \"lost\").to_a\n @bets.sort! {|x,y| x.id <=> y.id }\n render 'my-bets.json.jbuilder'\n end",
"def get_account_balance(account_id)\n query_api_object AccountBalance, \"/rest/accounts/#{account_id}/balance\"\n end",
"def index\n @cashbox = Cashbox.all\n end",
"def fetch\n FetchClientBalances.new(\n client_id: @client_id,\n balances_to_fetch: {\n GlobalConstant::CriticalChainInteractions.value_chain_type => {\n address: @address,\n balance_types: [\n GlobalConstant::BalanceTypes.ost_balance_type,\n GlobalConstant::BalanceTypes.eth_balance_type\n ]\n }\n }\n ).perform\n end",
"def cashbox\n return @cashbox if @cashbox.present?\n return nil unless has_money_program?\n @cashbox = self.accounts.where(:program_id => money_program.id, :is_money => true).first\n end",
"def getbatteries\n puts params\n buildid = params[\"buildingid\"]\n\n batteries = Battery.where(:building_id => buildid)\n\n puts batteries.inspect\n puts \"#################################################\"\n \n respond_to do |format|\n format.json { render json: batteries }\n end\n end",
"def index\n @account_balances = AccountBalance.all\n end",
"def bank\n @session.get_bank @bank_id\n end",
"def index\n @bills = @dwelling.bills\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bills }\n end\n end",
"def create\n @bond = Bond.new(bond_params)\n @bond.citizen = current_citizen\n\n respond_to do |format|\n if @bond.save\n format.html { redirect_to \"/citizens/#{@bond.citizen.id}?tab=finances\", notice: 'Bond bought.' }\n format.json { render :show, status: :created, location: @bond }\n else\n format.html { render :new }\n format.json { render json: @bond.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @bentos = Bento.all\n end"
] |
[
"0.59842044",
"0.5824421",
"0.5668388",
"0.56333244",
"0.55924106",
"0.5484383",
"0.5412799",
"0.54103756",
"0.53989995",
"0.53522265",
"0.53488004",
"0.5310438",
"0.52722174",
"0.5244552",
"0.5244552",
"0.5240701",
"0.5240025",
"0.52253515",
"0.5205345",
"0.5200413",
"0.51946443",
"0.5172339",
"0.51637334",
"0.51607054",
"0.5160273",
"0.51581246",
"0.51579",
"0.51523024",
"0.51498824",
"0.51498413",
"0.51450074",
"0.5141274",
"0.51305413",
"0.51227695",
"0.51215833",
"0.51162565",
"0.51158255",
"0.5114866",
"0.5113453",
"0.5113453",
"0.5096154",
"0.5092419",
"0.5089845",
"0.5082437",
"0.5082437",
"0.50763327",
"0.5070405",
"0.5069286",
"0.5062672",
"0.50612277",
"0.5054688",
"0.50534916",
"0.5050609",
"0.5050609",
"0.5050609",
"0.5050609",
"0.5050609",
"0.5050034",
"0.5049574",
"0.5048265",
"0.50475216",
"0.5047282",
"0.50425243",
"0.5039318",
"0.50367826",
"0.50346",
"0.50306004",
"0.5028438",
"0.5021622",
"0.50213176",
"0.5021126",
"0.5016477",
"0.5015902",
"0.50149584",
"0.5013931",
"0.5007531",
"0.5006009",
"0.500419",
"0.4999961",
"0.49989024",
"0.49890247",
"0.49887148",
"0.49873477",
"0.49831682",
"0.49826568",
"0.49815693",
"0.4980955",
"0.49789724",
"0.49745783",
"0.49729696",
"0.49695027",
"0.49694294",
"0.49545097",
"0.49535453",
"0.4944427",
"0.49438283",
"0.49429414",
"0.49317348",
"0.49289858",
"0.4924939"
] |
0.8980167
|
0
|
End point: (GET) Usage: FundAmerica::Entity.investor_suitability_details(entity_id)
|
def investor_suitability_details(entity_id)
API::request(:get, "entities/#{entity_id}/investor_suitability")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def investor_suitability_update(entity_id, options)\n API::request(:patch, \"entities/#{entity_id}/investor_suitability\", options)\n end",
"def platform_investor(entity_id )\n API::request(:get, \"entities/#{entity_id}/platform_investor\")\n end",
"def investor_accreditation(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_accreditation\")\n end",
"def details(investor_payment_id)\n API::request(:get, \"investor_payments/#{investor_payment_id}\")\n end",
"def show\n @investment = Investment.find(params[:id])\n end",
"def show\n @escenario_ideal = EscenarioIdeal.find(params[:id])\n\n end",
"def details(entity_id, request_options = \"\")\n API::request(:get, \"entities/#{entity_id}\" + request_options)\n end",
"def show\n @expense = current_user.organization.expenses.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def investor_sector\n @investor = Investor.find(params[:id])\n end",
"def show\n @tab_idx = params[:tab_idx] || 0\n @fdn_organization = Fdn::Organization.find(params[:id])\n #@pprs = Prs::PropertyRight.by_ent_id(@fdn_organization.resource_id)\n #if @fdn_organization.org_type_code == 'ENT'\n # @investors = Fdn::EntInvestor.where('org_id = ?', @fdn_organization.id).order(\"percentage DESC\")\n #end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @fdn_organization }\n end\n end",
"def show\n @player_investment = PlayerInvestment.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_investment }\n end\n end",
"def show\n @actuality = Actuality.find(params[:id])\n end",
"def show\n @fundamentals_history = @company.fundamentals_histories.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @fundamentals_history }\n end\n end",
"def view\n\t\t\t@investor = Investor.find params[:id]\n\t\tend",
"def show\n respond_with @expense\n end",
"def show\n @investment_type = InvestmentType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @investment_type }\n end\n end",
"def investor(id:)\n Investor.find(id)\n end",
"def actual_attestation_detail\n AttestationDetail.find_by_study_plan_id_and_attestation_term(id,\n Attestation.actual_for_faculty(index.student.faculty))\n end",
"def index\n @wallet_id = params[:wallet_id]\n @investment_funds = InvestmentFund.where(\"wallet_id = ?\", @wallet_id)\n end",
"def show\n @educational_level = EducationalLevel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @educational_level }\n end\n end",
"def show\n @client = Client.find(params[:id])\n @profitability = Client.client_profitability_actual(@client)\n all_client_profitability = Client.all_client_profitability(current_user)\n @avg_profitability = Client.avg_client_profitability(all_client_profitability)\n end",
"def show\n @expense = Expense.find(params[:id])\n index\n end",
"def show\n @benefit = Benefit.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @benefit }\n end\n end",
"def show\n @competences = Competence.all - @demand.competences\n @criterions = Criterion.all - @demand.criterions\n @explanations_props = { explanations: Explanation.to_react(@demand),\n demand: @demand.as_json(only: [ :id,\n :description,\n :name,\n :organization_profile_id ]),\n current_user: current_user.as_json(only: [ :id,\n :active_profile_id,\n :organization_account_id ]).merge({\"supplier\" => current_user.supplier?,\"customer\" => current_user.customer?}),\n # createExplanationPath: demand_explanations_path(@demand)\n }\n authorize @demand\n end",
"def expense_details\n if date_format_check\n filter_by_account, account_id = account_filter false\n\n if filter_by_account\n ft_joins = \"\" #[:finance_transaction_receipt_record]\n filter_conditions = \"AND finance_transaction_receipt_records.fee_account_id #{account_id == nil ? 'IS' : '='} ?\"\n filter_values = [account_id]\n else\n ft_joins = filter_values = []\n filter_conditions = \"\"\n end\n\n @expense_category = FinanceTransactionCategory.find(params[:id])\n\n if @expense_category.name == 'Refund'\n ft_joins = \"INNER JOIN fee_refunds fr ON fr.finance_transaction_id = finance_transactions.id\n INNER JOIN finance_fees ff ON ff.id = fr.finance_fee_id\n INNER JOIN finance_fee_collections ffc ON ffc.id = ff.fee_collection_id\n LEFT JOIN fee_accounts fa On fa.id = ffc.fee_account_id\"\n cond = \"(fa.id IS NULL OR fa.is_deleted = false) AND \"\n else\n cond = \"\"\n end\n\n @grand_total = @expense_category.finance_transactions.all(:select => \"finance_transactions.amount\",\n :joins => ft_joins, :conditions => [\"#{cond} transaction_date BETWEEN ? AND ? #{filter_conditions}\",\n @start_date, @end_date] + filter_values).map { |x| x.amount.to_f }.sum\n\n @expense = @expense_category.finance_transactions.all(:joins => ft_joins, :conditions =>\n [\"#{cond} transaction_date BETWEEN ? AND ? #{filter_conditions}\", @start_date, @end_date] + filter_values)\n end\n end",
"def set_investor\n @investor = ::Cap::Table::Investor.find(params[:id])\n end",
"def investor_payments(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_payments\")\n end",
"def index\n @investment_declaration = InvestmentDeclaration.new\n @investment_declarations = InvestmentDeclaration.all\n @policy_details = PolicyDetail.all\n @investment_declaration = InvestmentDeclaration.find(params[:investment_declaration_id])\n end",
"def show\n @benefits = ProductsPurposesRelation.where(product_id: @product.id)\n end",
"def show\n authorize @expense_report\n end",
"def show\n @accident_assignee_expense = AccidentAssigneeExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @accident_assignee_expense }\n end\n end",
"def index\n @fund_company_investments = FundCompanyInvestment.all\n end",
"def overview\n case id\n when \"CDN-REALESTATE\"\n \"ETFs that provide exposure to the Canadian Real Estate market - broadly distributed across the country.\"\n when \"COMMODITIES\"\n \"ETFs that provide exposure to various commodities - generally considered as input to a growing economy.\"\n when \"US-LGCAP-STOCK\"\n \"ETFs that provide exposure to the equity of large, U.S. based companies.\"\n when \"US-LONG-GOV-BOND\"\n \"ETFs that provide exposure to U.S. Government debt, with long maturities.\"\n when \"INTL-REALESTATE\"\n \"ETFs that provide exposure to the International Real Estate market - broadly distributed across the globe.\"\n when \"US-REALESTATE\"\n \"ETFs that provide exposure to the U.S. Real Estate market - broadly distributed across the country.\"\n when \"US-SHORT-CORP-BOND\"\n \"ETFs that provide exposure to U.S. Corporate debt, with short maturities.\"\n when \"CDN-LONG-BOND\"\n \"ETFs that provide exposure to Canadian Corporate debt, with long maturities.\"\n when \"CDN-SHORT-BOND\"\n \"ETFs that provide exposure to Canadian Corporate debt, with short maturities.\"\n when \"US-SMCAP-STOCK\"\n \"ETFs that provide exposure to the equity of smaller U.S. based companies.\"\n when \"INTL-BOND\"\n \"ETFs that provide exposure to International Government & Corporate debt, with varying maturities.\"\n when \"US-SHORT-GOVT-BOND\"\n \"ETFs that provide exposure to U.S. Government debt, with shorter maturities.\"\n when \"US-MED-CORP-BOND\"\n \"ETFs that provide exposure to U.S. Corporate debt, with medium maturities.\"\n when \"CDN-STOCK\"\n \"ETFs that provide exposure to the equity of Canadian companies.\"\n when \"US-MED-GOV-BOND\"\n \"ETFs that provide exposure to U.S. Government debt, with medium maturities.\"\n when \"EMERG-STOCK\"\n \"ETFs that provide exposure to the equity of companies based in countries classified as Emerging Markets.\"\n when \"US-LONG-CORP-BOND\"\n \"ETFs that provide exposure to U.S. Corporate debt, with longer maturities.\"\n when \"INTL-STOCK\"\n \"ETFs that provide exposure to the equity of companies based in Europe, Asia and the Far East (EAFE).\"\n else\n raise \"Asset class overview not prepared.\"\n end\n end",
"def expense_list\n\n end",
"def index\n @investables = Investable.all\n end",
"def index\n @individual_company_investments = IndividualCompanyInvestment.all\n end",
"def show\n @expense = Expense.for_user(current_user).find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def show\n @account_movement = @investor.account_movements.find(params[:id])\n authorize @account_movement\n end",
"def show\n @redeem = Redeem.find(params[:id])\n p @redeem.deal_id\n @deal = Deal.find(@redeem.deal_id)\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @redeem }\n end\n end",
"def show\n @entitlement = Entitlement.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entitlement }\n end\n end",
"def show\n @housing_expense = HousingExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.rhtml\n format.xml { render :xml => @housing_expense.to_xml }\n end\n end",
"def show\n @endorsement = Endorsement.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @endorsement }\n end\n end",
"def show\n @estimate = Estimate.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @estimate }\n end\n end",
"def show\n if current_user.is_not_member?\n flash[:error] = \"You do not have permissions to access that feature.\"\n redirect_to root_path and return\n end\n \n @safety_inspection = SafetyInspection.find(params[:id])\n @safety_item_responses = @safety_inspection.safety_item_responses\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @safety_inspection }\n end\n end",
"def index\n @educational_details = EducationalDetail.all\n end",
"def show\n @invest = Invest.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @invest }\n end\n end",
"def show\n render json: @investment, root: false\n end",
"def show\n @expense = current_user.expenses.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @expense }\n end\n end",
"def show\n @extended_warranty = ExtendedWarranty.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @extended_warranty }\n end\n end",
"def show\n @fixed_expense = FixedExpense.for_user(current_user).find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @fixed_expense }\n end\n end",
"def index\n @investment_funds = InvestmentFund.all\n end",
"def show\n @endurance = Endurance.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @endurance }\n end\n end",
"def show\n # @asserted_distribution = AssertedDistribution.find(params[:id])\n end",
"def investor\n end",
"def show\n @operating_expense = OperatingExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @operating_expense }\n end\n end",
"def show\n @cases = @admin_user.cases.page(params[:page]).per(7)\n @cases_for_profit = @admin_user.cases\n end",
"def show\n @strategy_guide = StrategyGuide.find(params[:id])\n @hero = @strategy_guide.hero\n @hero_pros = @strategy_guide.hero_pros\n @hero_cons = @strategy_guide.hero_cons\n @skill_build = @strategy_guide.skill_build\n @strategy_items = @strategy_guide.strategy_items\n end",
"def show\n @merchant ||= Merchant.find(params[:merchant_id])\n @loyalty_benefit = @merchant.loyalty_benefits.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @loyalty_benefit }\n end\n end",
"def show\n @effort = Effort.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @effort }\n end\n end",
"def show\n @expense_claim.expense_entries.new if @expense_claim.expense_entries.count.zero?\n end",
"def show\n @performance_benefit_std = PerformanceBenefitStd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @performance_benefit_std }\n end\n end",
"def show\n @expense_state = ExpenseState.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense_state }\n end\n end",
"def details(entity)\n details_by_type_and_name(entity.properties[:type], entity.properties[:name])\n end",
"def show\n @accident_vehicle_expense = AccidentVehicleExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @accident_vehicle_expense }\n end\n end",
"def edit\n @deal = @cost_calculation.deal\n if @cost_calculation.has_tender?\n @tender = @cost_calculation.tender\n @tender_response = @tender.tender_responses.where(contractor_id: @deal.supplier_id).first\n end\n end",
"def show\n @achievment = Achievment.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @achievment }\n end\n end",
"def show\n @warranty = Warranty.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @warranty }\n end\n end",
"def index\n @educ_infos = EducInfo.all\n end",
"def show\n @resource = Resource.find(params[:resource_id])\n @incident = Incident.find(@resource.incident_id)\n @demob = Demob.find(params[:id])\n @logistics_units = @demob.units[0..5]\n @finance_units = @demob.units[6..8]\n @other_units = @demob.units[9..10]\n @plans_units = @demob.units[11..13]\n end",
"def show\n @ledger_entry = @organization.ledger_entries.find(params[:id])\n respond_with @organization, @ledger_entry\n end",
"def index\n @company_investors = CompanyInvestor.all\n end",
"def show\n @entity = Entity.find(params[:id])\n session[:entity_id] = @entity.id\n session[:company_id] = @entity.company.id.to_i\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @entity }\n end\n end",
"def index\n @benefits = Benefit.all\n end",
"def show\n @industry = Industry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @industry }\n end\n end",
"def show\n @userin = UserInvestor.find(params[:id])\n if @userin.present?\n data = @userin.as_json(include: %i[product_invest])\n render json: { status: 'OK', results: data, errors: nil }, status: :ok\n else\n render json: { status: 'FAIL', results: nil,\n errors: 'user does not exist' },\n status: :not_found\n end\n end",
"def show\n gr = Rent.find(params[:id]).grossrent\n mi = Rent.find(params[:id]).mortage_interest\n reoair = Rent.find(params[:id]).repairs\n ins = Rent.find(params[:id]).insurance\n manacharge = Rent.find(params[:id]).management_charges\n agefee = Rent.find(params[:id]).agent_fee\n o = Rent.find(params[:id]).other\n wr = Rent.find(params[:id]).wear_and_tear\n good = Rentalprofitorloss::Rentalmaster.expense(gr,mi,reoair,ins,manacharge,agefee,o,wr)\n @duck = good\n \n end",
"def index\n @habilities = Hability.all\n end",
"def show\n @effort = Effort.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @effort }\n end\n end",
"def show\n @spend = Spend.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @spend }\n end\n end",
"def show\n @exp_detail = ExpDetail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @exp_detail }\n end\n end",
"def show\n @breadcrumb = 'read'\n @entity_type = EntityType.find(params[:id])\n @entities = @entity_type.entities.paginate(:page => params[:page], :per_page => per_page).order('fiscal_id')\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity_type }\n end\n end",
"def show\n authorize @life_and_disability\n\n @insurance_card = @life_and_disability\n @group_label = \"Life & Disability\"\n @group_documents = DocumentService.new(:category => @insurance_card.category).get_insurance_documents(resource_owner, @group_label, params[:id])\n session[:ret_url] = general_view? ? life_path(@life_and_disability) : life_and_disability_shared_view_path(@shared_user, @life_and_disability)\n end",
"def show\n @entity = Entity.find(params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entity }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @expense }\n end\n end",
"def show\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @expense }\n end\n end",
"def show\n\n @boss = Boss.find(params[:id])\n @equips = Equip.where(boss_id: @boss.id)\n end",
"def show\n @principal_establec = PrincipalEstablec.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @principal_establec }\n end\n end",
"def entertainment(level)\n data = @data['families'].find { |type| type['name'] == 'Entertainment' }\n badge = data['earnedAchievements'].find { |le| le['familyOrder'] == (level - 1) }\n HQTrivia::Badge.new(badge)\n end",
"def show\n @stock_market_invest_log = StockMarketInvestLog.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @stock_market_invest_log }\n end\n end",
"def index\r\n @fixed_deposit_investments = FixedDepositInvestment.all\r\n end",
"def display_resource(deal)\n \"Deal ##{deal.id} #{deal.item.name}/#{deal.profile.name} #{deal.profile.phone}\"\n end",
"def show\n @purpose_def = PurposeDef.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @purpose_def }\n end\n end",
"def show\n if singular_resource?\n entity = ConnecEntity.where(group_id: @group_id, entity_name: entities_key).first\n entity ||= ConnecEntity.create(group_id: @group_id, entity_name: entities_key)\n else\n entity = ConnecEntity.where(group_id: @group_id, entity_name: entities_key, uid: params[:id]).first\n end\n \n if entity\n logger.info(\"INSPECT: #{entities_key} => #{process_entity(entity).to_json}\")\n render json: { entities_key => process_entity(entity) }\n else\n render json: { errors: process_errors([\"Resource not found\"], 404) }, status: :not_found\n end\n end",
"def show\n @admin_expense_type = Admin::ExpenseType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @admin_expense_type }\n end\n end"
] |
[
"0.6998489",
"0.6399165",
"0.6215873",
"0.6044461",
"0.585896",
"0.5697527",
"0.5684516",
"0.56791675",
"0.5670156",
"0.5600503",
"0.5551321",
"0.5544604",
"0.54723734",
"0.5462545",
"0.5383733",
"0.5380635",
"0.5367114",
"0.5365481",
"0.53644514",
"0.5361769",
"0.53519493",
"0.53403574",
"0.53389984",
"0.5320582",
"0.5314857",
"0.5304234",
"0.5303797",
"0.5303041",
"0.5294014",
"0.5275699",
"0.5261767",
"0.52609235",
"0.5251933",
"0.5244648",
"0.5230813",
"0.5228387",
"0.5219789",
"0.5213827",
"0.5213827",
"0.5213827",
"0.5213827",
"0.5213827",
"0.52053916",
"0.5193364",
"0.5189747",
"0.5175883",
"0.5159184",
"0.5159144",
"0.51584363",
"0.51560414",
"0.51550287",
"0.51544076",
"0.515188",
"0.5149766",
"0.5141292",
"0.5138052",
"0.51365864",
"0.5136583",
"0.51360464",
"0.5122289",
"0.5111245",
"0.5107963",
"0.51078564",
"0.5101112",
"0.5099859",
"0.5099091",
"0.509716",
"0.50924885",
"0.5084861",
"0.5082362",
"0.50799984",
"0.50749904",
"0.5060881",
"0.5060512",
"0.50535816",
"0.50532234",
"0.50500274",
"0.5046397",
"0.50447476",
"0.5043484",
"0.50424564",
"0.50375843",
"0.50186193",
"0.5004053",
"0.5001906",
"0.49987516",
"0.4998229",
"0.49973825",
"0.49922663",
"0.49922663",
"0.49922663",
"0.49896243",
"0.4985818",
"0.49847123",
"0.49843785",
"0.497394",
"0.49705458",
"0.49656624",
"0.4961356",
"0.49604148"
] |
0.91116935
|
0
|
End point: (PATCH) Usage: FundAmerica::Entity.investor_suitability_update(entity_id, options)
|
def investor_suitability_update(entity_id, options)
API::request(:patch, "entities/#{entity_id}/investor_suitability", options)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n respond_to do |format|\n if @investable.update(investable_params)\n format.html { redirect_to @investable, notice: 'Investable was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @investable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @eligible = args[:eligible] if args.key?(:eligible)\n @reason = args[:reason] if args.key?(:reason)\n end",
"def update!(**args)\n @eligible = args[:eligible] if args.key?(:eligible)\n @reason = args[:reason] if args.key?(:reason)\n end",
"def update\n respond_to do |format|\n if @wetsuit.update(wetsuit_params)\n format.html { redirect_to @wetsuit, notice: 'Wetsuit was successfully updated.' }\n format.json { render :show, status: :ok, location: @wetsuit }\n else\n format.html { render :edit }\n format.json { render json: @wetsuit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player_investment = PlayerInvestment.find(params[:id])\n\n respond_to do |format|\n if @player_investment.update_attributes(params[:player_investment])\n format.html { redirect_to @player_investment, notice: 'Player investment was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n @endorsement = Endorsement.find(params[:id])\n @tempEndorsementHash = params[:endorsement]\n @tempPlayer = Player.find(@endorsement.player_id)\n @tempBeverage = @endorsement.endorseable \n \n respond_to do |format|\n #if @endorsement.update_attributes(params[:endorsement])\n if @endorsement.update_attributes(:name => @tempEndorsementHash['name'],\n :cancellation_year => @tempEndorsementHash['cancellation_year'],\n :endorsement_type => @tempEndorsementHash['endorsement_type'],\n :player => @tempPlayer,\n :endorseable => @tempBeverage)\n \n flash[:notice] = 'Endorsement was successfully updated.'\n format.html { redirect_to(@endorsement) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @endorsement.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n effort = Effort.find_by(\"id\" => params[\"id\"])\n effort.update(\"value\" => params[\"value\"],\n \"date\" => params[\"date\"],\n \"goal_id\" => params[\"goal_id\"],\n \"strategy_id\" => params[\"strategy_id\"])\n redirect_to \"/efforts\"\n end",
"def investor_suitability_details(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_suitability\")\n end",
"def update\n respond_to do |format|\n if @company_investor.update(company_investor_params)\n format.html { redirect_to @company_investor, notice: 'Company investor was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @company_investor.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fund_company_investment.update(fund_company_investment_params)\n format.html { redirect_to @fund_company_investment, notice: 'Fund company investment was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fund_company_investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investment.update(investment_params)\n format.html { redirect_to @investment, notice: 'Investment was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @spend_entry.update(spend_entry_params)\n format.html { redirect_to @spend_entry, notice: 'Spend entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @spend_entry }\n else\n format.html { render :edit }\n format.json { render json: @spend_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investigated.update(investigated_params)\n format.html { redirect_to @investigated, notice: 'Investigated was successfully updated.' }\n format.json { render :show, status: :ok, location: @investigated }\n else\n format.html { render :edit }\n format.json { render json: @investigated.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @decline_reason = args[:decline_reason] if args.key?(:decline_reason)\n end",
"def update\n respond_to do |format|\n if @ico_etz_investment.update(ico_etz_investment_params)\n format.html { redirect_to ico_etz_investment_path(@ico_etz_investment), notice: 'Etz investment was successfully updated.' }\n format.json { render :show, status: :ok, location: @ico_etz_investment }\n else\n format.html { render :edit }\n format.json { render json: @ico_etz_investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_investments investment_type\n if self.investment_type.nil?\n self.create_investments investment_type\n else\n self.investment_type.update!(:fix_income => investment_type[:fix_income], :equity=> investment_type[:equity], :gold=> investment_type[:gold], :land_and_estate=> investment_type[:land_and_estate])\n end\n end",
"def update!(**args)\n @disruption_budget = args[:disruption_budget] if args.key?(:disruption_budget)\n @mode = args[:mode] if args.key?(:mode)\n end",
"def update!(**args)\n @risk = args[:risk] if args.key?(:risk)\n end",
"def update!(**args)\n @risk = args[:risk] if args.key?(:risk)\n end",
"def update\n if @investment.update(investment_params)\n render json: @investment, status: :ok\n else\n render json: @investment.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_with Expense.update(params[:id], expense_params), status: 204\n end",
"def update\n respond_to do |format|\n if @individual_company_investment.update(individual_company_investment_params)\n format.html { redirect_to @individual_company_investment, notice: 'Individual company investment was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @individual_company_investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @investor.update investor_params\n redirect_to @investor\n else\n render 'edit'\n end\n end",
"def update!(**args)\n @behavioral_trust_verdict = args[:behavioral_trust_verdict] if args.key?(:behavioral_trust_verdict)\n @card_testing_verdict = args[:card_testing_verdict] if args.key?(:card_testing_verdict)\n @stolen_instrument_verdict = args[:stolen_instrument_verdict] if args.key?(:stolen_instrument_verdict)\n @transaction_risk = args[:transaction_risk] if args.key?(:transaction_risk)\n end",
"def update\n respond_to do |format|\n if @investment.update(investment_params)\n format.html { redirect_to @investment, notice: 'Investment was successfully updated.' }\n format.json { render :show, status: :ok, location: @investment }\n else\n format.html { render :edit }\n format.json { render json: @investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investment.update(investment_params)\n format.html { redirect_to @investment, notice: 'Investment was successfully updated.' }\n format.json { render :show, status: :ok, location: @investment }\n else\n format.html { render :edit }\n format.json { render json: @investment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n respond_to do |format|\r\n if @fixed_deposit_investment.update(fixed_deposit_investment_params)\r\n format.html { redirect_to @fixed_deposit_investment, notice: 'Fixed deposit investment was successfully updated.' }\r\n format.json { render :show, status: :ok, location: @fixed_deposit_investment }\r\n else\r\n format.html { render :edit }\r\n format.json { render json: @fixed_deposit_investment.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n authorize! :manage, Employee\n if responsibility_changes?\n new_employee = Employee.new_from_old(employee_params['responsibility'], @employee)\n @employee.destroy\n new_employee.save\n @employee = new_employee\n end\n\n respond_to do |format|\n if @employee.update(employee_attrs)\n format.html { redirect_to (@employee.try(:employee) || @employee), notice: t('action.update.succeed', entity: Employee.model_name.human) }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @employee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, CompetenceTierGroup\n \n @competence_tier_group.update!(competence_tier_group_params)\n render json: {status: :ok}\n end",
"def update\n @editability = Editability.find(params[:id])\n\n respond_to do |format|\n if @editability.update_attributes(params[:editability])\n format.html { redirect_to @editability, notice: 'Test was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @editability.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(close_offering_request_id, options)\n end_point_url = 'https://sandbox.fundamerica.com/api/test_mode/close_offering_requests/' + close_offering_request_id\n API::request(:patch, end_point_url, options)\n end",
"def update\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n if @expense.update_attributes(params[:expense])\n format.html { redirect_to [@expense.statement.account, @expense.statement], notice: 'Statement expense was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @account_provenance = args[:account_provenance] if args.key?(:account_provenance)\n @attentional_entity = args[:attentional_entity] if args.key?(:attentional_entity)\n @dasher_user = args[:dasher_user] if args.key?(:dasher_user)\n @followon = args[:followon] if args.key?(:followon)\n @grounding_provider = args[:grounding_provider] if args.key?(:grounding_provider)\n @prefilter = args[:prefilter] if args.key?(:prefilter)\n @qu = args[:qu] if args.key?(:qu)\n @sensitivity_mode = args[:sensitivity_mode] if args.key?(:sensitivity_mode)\n @synthetic_intent = args[:synthetic_intent] if args.key?(:synthetic_intent)\n @winning_fulfillment = args[:winning_fulfillment] if args.key?(:winning_fulfillment)\n end",
"def update\n @effort = Effort.find(params[:id])\n\n respond_to do |format|\n if @effort.update_attributes(params[:effort])\n format.html { redirect_to @effort, notice: 'Effort was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @effort.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @expense\n @expense.updated_by = current_user\n respond_to do |format|\n if @expense.update(expense_params)\n format.html { redirect_back_or_default expenses_url, t('Record has been saved') }\n format.json { render :show, status: :ok, location: @expense }\n else\n format.html { render :edit }\n format.json { render json: @expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @assigned_seats = args[:assigned_seats] if args.key?(:assigned_seats)\n @edition_id = args[:edition_id] if args.key?(:edition_id)\n @seat_count = args[:seat_count] if args.key?(:seat_count)\n end",
"def update\n @investment_type = InvestmentType.find(params[:id])\n\n respond_to do |format|\n if @investment_type.update_attributes(params[:investment_type])\n format.html { redirect_to investment_types_path, notice: 'Investment type was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @investment_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @effort = Effort.find(params[:id])\n @effort.completed_at = Time.now if params[:commit] == \"Concluir atividade\"\n\n respond_to do |format|\n if @effort.update_attributes(params[:effort])\n format.html { redirect_to admin_efforts_path, notice: 'Alocação atualizada com sucesso.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @effort.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @benefits = args[:benefits] if args.key?(:benefits)\n @effective_dates = args[:effective_dates] if args.key?(:effective_dates)\n @generic_redemption_code = args[:generic_redemption_code] if args.key?(:generic_redemption_code)\n @id = args[:id] if args.key?(:id)\n @long_title = args[:long_title] if args.key?(:long_title)\n @product_applicability = args[:product_applicability] if args.key?(:product_applicability)\n @redemption_channel = args[:redemption_channel] if args.key?(:redemption_channel)\n end",
"def update\n respond_to do |format|\n if @market_offering.update(market_offering_params)\n format.html { redirect_to @market_offering, notice: 'Market offering was successfully updated.' }\n format.json { render :show, status: :ok, location: @market_offering }\n else\n format.html { render :edit }\n format.json { render json: @market_offering.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_deal(id:, **args)\n params = parameters(args) do\n optional_params :title, :value, :currency, :user_id, :person_id, :org_id, :stage_id, :status, :probability, :lost_reason, :visible_to\n end\n request(:put, \"deals/#{id}\", params)\n end",
"def update!(**args)\n @effective = args[:effective] if args.key?(:effective)\n end",
"def update!(**args)\n @effective = args[:effective] if args.key?(:effective)\n end",
"def update!(**args)\n @effective = args[:effective] if args.key?(:effective)\n end",
"def update\n respond_to do |format|\n if @employer_liability_item.update(employer_liability_item_params)\n format.html { redirect_to @employer_liability_item, notice: 'Employer liability item was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @employer_liability_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @attack_complexity = args[:attack_complexity] if args.key?(:attack_complexity)\n @attack_vector = args[:attack_vector] if args.key?(:attack_vector)\n @availability_impact = args[:availability_impact] if args.key?(:availability_impact)\n @base_score = args[:base_score] if args.key?(:base_score)\n @confidentiality_impact = args[:confidentiality_impact] if args.key?(:confidentiality_impact)\n @exploitability_score = args[:exploitability_score] if args.key?(:exploitability_score)\n @impact_score = args[:impact_score] if args.key?(:impact_score)\n @integrity_impact = args[:integrity_impact] if args.key?(:integrity_impact)\n @privileges_required = args[:privileges_required] if args.key?(:privileges_required)\n @scope = args[:scope] if args.key?(:scope)\n @user_interaction = args[:user_interaction] if args.key?(:user_interaction)\n end",
"def update\n \n @permit.category_id = params[:category_id]\n @permit.employee_id = params[:employee_id]\n @permit.site_id = params[:site_id]\n\n respond_to do |format|\n if @permit.update(permit_params)\n format.html { redirect_to @permit, notice: 'Permit was successfully updated.' }\n format.json { render :show, status: :ok, location: @permit }\n else\n format.html { render :edit }\n format.json { render json: @permit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @warranty.update(warranty_params)\n format.html { redirect_to @warranty, notice: 'Warranty was successfully updated.' }\n format.json { render :show, status: :ok, location: @warranty }\n else\n format.html { render :edit }\n format.json { render json: @warranty.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @effleurage_option.update(effleurage_option_params)\n format.html { redirect_to @effleurage_option, notice: 'Effleurage option was successfully updated.' }\n format.json { render :show, status: :ok, location: @effleurage_option }\n else\n format.html { render :edit }\n format.json { render json: @effleurage_option.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @allowance_type = args[:allowance_type] if args.key?(:allowance_type)\n @is_discount = args[:is_discount] if args.key?(:is_discount)\n @min_purchase_for_validation = args[:min_purchase_for_validation] if args.key?(:min_purchase_for_validation)\n @permit_type = args[:permit_type] if args.key?(:permit_type)\n @service_type = args[:service_type] if args.key?(:service_type)\n @time_based_rate = args[:time_based_rate] if args.key?(:time_based_rate)\n @vehicle_type = args[:vehicle_type] if args.key?(:vehicle_type)\n end",
"def update\n if @escenario_ideal.update_attributes(escenario_ideal_params)\n flash[:success] = \"Escenario actualizado con éxito\"\n redirect_to @escenario_ideal\n else\n render 'edit'\n end\n end",
"def update!(**args)\n @audience = args[:audience] if args.key?(:audience)\n @cost = args[:cost] if args.key?(:cost)\n @customer_data = args[:customer_data] if args.key?(:customer_data)\n @description = args[:description] if args.key?(:description)\n @owners = args[:owners] if args.key?(:owners)\n @questions = args[:questions] if args.key?(:questions)\n @rejection_reason = args[:rejection_reason] if args.key?(:rejection_reason)\n @state = args[:state] if args.key?(:state)\n @survey_url_id = args[:survey_url_id] if args.key?(:survey_url_id)\n @title = args[:title] if args.key?(:title)\n @wanted_response_count = args[:wanted_response_count] if args.key?(:wanted_response_count)\n end",
"def update\n respond_to do |format|\n if @spend.update(spend_params)\n format.html { redirect_to @spend, notice: 'Spend was successfully updated.' }\n format.json { render :show, status: :ok, location: @spend }\n else\n format.html { render :edit }\n format.json { render json: @spend.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @inc_stable_account.update(inc_stable_account_params)\n format.html { redirect_to @inc_stable_account, notice: 'Inc stable account was successfully updated.' }\n format.json { render :show, status: :ok, location: @inc_stable_account }\n else\n format.html { render :edit }\n format.json { render json: @inc_stable_account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @liability.update(liability_params)\n redirect_to liabilities_url, notice: 'Liability was successfully updated!'\n else\n render action: 'edit'\n end\n end",
"def update\n authorize @expense_report\n\n\n @expense_report.actual_expenses.each do |exp|\n exp.requests.each do |req|\n req.amount_from_total = req.percentrequested * exp.total\n req.destination = @expense_report.trip.destination\n req.expense_type = 'actual'\n end\n end\n\n\n respond_to do |format|\n if @expense_report.update(expense_report_params)\n format.html { redirect_to @expense_report, notice: 'Expense report was successfully updated.' }\n format.json { render :show, status: :ok, location: @expense_report }\n else\n format.html { render :edit }\n format.json { render json: @expense_report.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @enforcement_mode = args[:enforcement_mode] if args.key?(:enforcement_mode)\n @evaluation_mode = args[:evaluation_mode] if args.key?(:evaluation_mode)\n @require_attestations_by = args[:require_attestations_by] if args.key?(:require_attestations_by)\n end",
"def update\n respond_to do |format|\n if @benefit.update(benefit_params)\n format.html { redirect_to admin_benefit_path(@benefit), notice: 'Benefit was successfully updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lawsuit.update(lawsuit_params)\n format.html { redirect_to @lawsuit, notice: \"Lawsuit was successfully updated.\" }\n format.json { render :show, status: :ok, location: @lawsuit }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @lawsuit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @utility_expense.update(utility_expense_params)\n format.html { redirect_to @utility_expense, notice: 'Utility expense was successfully updated.' }\n format.json { render :show, status: :ok, location: @utility_expense }\n else\n format.html { render :edit }\n format.json { render json: @utility_expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @offering = Portal::Offering.find(params[:id])\n authorize @offering\n update_successful = @offering.update(portal_offering_strong_params(params[:offering]))\n if request.xhr?\n status = update_successful ? 200 : 500\n head status\n return\n end\n respond_to do |format|\n if update_successful\n flash['notice'] = 'Portal::Offering was successfully updated.'\n format.html { redirect_to(@offering) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @offering.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @accident_assignee_expense = AccidentAssigneeExpense.find(params[:id])\n\n respond_to do |format|\n if @accident_assignee_expense.update_attributes(params[:accident_assignee_expense])\n format.html { redirect_to(@accident_assignee_expense, :notice => 'Accident assignee expense was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @accident_assignee_expense.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @endorsement = Endorsement.find(params[:id])\n\n if @endorsement.update(endorsement_params)\n head :no_content\n else\n render json: @endorsement.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @achievment.update(achievment_params)\n format.html { redirect_to @achievment, notice: 'Achievment was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @achievment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investment_fund.update(investment_fund_params)\n format.html { redirect_to @investment_fund, notice: 'Investment fund was successfully updated.' }\n format.json { render :show, status: :ok, location: @investment_fund }\n else\n format.html { render :edit }\n format.json { render json: @investment_fund.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investment_fund.update(investment_fund_params)\n format.html { redirect_to @investment_fund, notice: 'Investment fund was successfully updated.' }\n format.json { render :show, status: :ok, location: @investment_fund }\n else\n format.html { render :edit }\n format.json { render json: @investment_fund.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ped_strategy = PedStrategy.find(params[:id])\n\n respond_to do |format|\n if @ped_strategy.update_attributes(params[:ped_strategy])\n format.html { redirect_to @ped_strategy, notice: 'Ped strategy was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ped_strategy.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @investigador.update(investigador_params)\n format.html { redirect_to investigadore_path(@investigador), notice: \"Investigador was successfully updated.\" }\n format.json { render :show, status: :ok, location: @investigador }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @investigador.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @assignee_mode = args[:assignee_mode] if args.key?(:assignee_mode)\n @modify_individual_students_options = args[:modify_individual_students_options] if args.key?(:modify_individual_students_options)\n end",
"def update!(**args)\n @assignee_mode = args[:assignee_mode] if args.key?(:assignee_mode)\n @modify_individual_students_options = args[:modify_individual_students_options] if args.key?(:modify_individual_students_options)\n end",
"def update!(**args)\n @availabilities = args[:availabilities] if args.key?(:availabilities)\n end",
"def update!(**args)\n @enforcement_state = args[:enforcement_state] if args.key?(:enforcement_state)\n @provider = args[:provider] if args.key?(:provider)\n end",
"def update\n authorize! :create, @deal\n \n respond_to do |format|\n if @deal.update(deal_params)\n @deal.update_top_industry\n format.html { redirect_to deals_path, notice: 'DEAL đã được sửa thành công!' }\n format.json { render :show, status: :ok, location: @deal }\n else\n format.html { render :edit }\n format.json { render json: @deal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @invest = Invest.find(params[:id])\n\n respond_to do |format|\n if @invest.update_attributes(params[:invest])\n format.html { redirect_to(@invest, :notice => 'Invest was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @invest.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @final_decision.update(final_decision_params)\n format.html { redirect_to @final_decision, notice: 'Final decision was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @final_decision.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @assignbenefit.update(assignbenefit_params)\n format.html { redirect_to assignbenefits_path, notice: 'Asignación de beneficio actualizada satisfactoriamente.' }\n format.json { render :show, status: :ok, location: @assignbenefit }\n else\n format.html { render :edit }\n format.json { render json: @assignbenefit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @funding_status_option = FundingStatusOption.find(params[:id])\n\n respond_to do |format|\n if @funding_status_option.update_attributes(params[:funding_status_option])\n format.html { redirect_to snippets_path, notice: 'Funding status option was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @funding_status_option.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entitlement = Entitlement.find(params[:id])\n\n respond_to do |format|\n if @entitlement.update_attributes(params[:entitlement])\n format.html { redirect_to(@entitlement, :notice => 'Entitlement was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entitlement.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, @impact_level\n respond_to do |format|\n if @impact_level.update(impact_level_params)\n format.html { redirect_to @impact_level, notice: 'Impact level was successfully updated.' }\n format.json { render :show, status: :ok, location: @impact_level }\n else\n format.html { render :edit }\n format.json { render json: @impact_level.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n #SET_CHEF method will be called form BEFORE_ACTION\n #In update we must use the method of whitelisted parameters\n if @chef.update(chef_params)\n flash[:success] = \"You profile is updated successfully\"\n redirect_to chef_path(@chef)\n else\n render 'edit'\n end\n end",
"def update\n respond_to do |format|\n if @expense_tracker.update(expense_tracker_params)\n format.html { redirect_to @expense_tracker, notice: 'Expense tracker was successfully updated.' }\n format.json { render :show, status: :ok, location: @expense_tracker }\n else\n format.html { render :edit }\n format.json { render json: @expense_tracker.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @edition_id = args[:edition_id] if args.key?(:edition_id)\n @kind = args[:kind] if args.key?(:kind)\n @seat_count = args[:seat_count] if args.key?(:seat_count)\n end",
"def update\n\n if @enemy.update(enemy_params)\n render plain: \"successful\"\n else\n render plain: \"unsuccessful\"\n end\n end",
"def update\n @achievment = Achievment.find(params[:id])\n\n respond_to do |format|\n if @achievment.update_attributes(params[:achievment])\n format.html { redirect_to @achievment, notice: 'Achievment was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @achievment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @available = args[:available] if args.key?(:available)\n @country_offer_infos = args[:country_offer_infos] if args.key?(:country_offer_infos)\n @description = args[:description] if args.key?(:description)\n @id = args[:id] if args.key?(:id)\n @max_account_age = args[:max_account_age] if args.key?(:max_account_age)\n @name = args[:name] if args.key?(:name)\n @offer_level = args[:offer_level] if args.key?(:offer_level)\n @offer_type = args[:offer_type] if args.key?(:offer_type)\n @qualified_customer = args[:qualified_customer] if args.key?(:qualified_customer)\n @qualified_customers_complete = args[:qualified_customers_complete] if args.key?(:qualified_customers_complete)\n @show_special_offer_copy = args[:show_special_offer_copy] if args.key?(:show_special_offer_copy)\n @terms = args[:terms] if args.key?(:terms)\n end",
"def update\n if @sesh.update(editable_sesh_params)\n render status: :accepted\n else\n render status: :invalid_resource\n end\n end",
"def update\n respond_to do |format|\n if fund_tier_assignment.update_attributes(params[:fund_tier_assignment])\n format.html { redirect_to fund_source_fund_tier_assignments_url( fund_tier_assignment.fund_source ),\n notice: 'Fund tier assignment was successfully updated.' }\n format.json { respond_with_bip(fund_tier_assignment) }\n else\n format.html { render action: \"edit\" }\n format.json { respond_with_bip(fund_tier_assignment) }\n end\n end\n end",
"def update\n @income_entry = IncomeEntry.find(params[:id])\n\n respond_to do |format|\n if @income_entry.update_attributes(params[:income_entry])\n format.html { redirect_to @income_entry, notice: 'Income entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @income_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n if @expense.update_attributes(params[:expense])\n format.html { redirect_to expenses_url, notice: 'Expense was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n \n respond_to do |format|\n if @deal.update(deal_params)\n if @deal.stylist_agree == true && @deal.scrub_agree != true\n @buyer = @deal.user\n # Sends email to buyer\n AcceptedNotifierMailer.send_accepted_email(@deal, @buyer).deliver\n end\n format.html { redirect_to @deal, notice: 'Deal was successfully updated.' }\n format.json { render :show, status: :ok, location: @deal }\n else\n format.html { render :edit }\n format.json { render json: @deal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @extended_verdict_reasons = args[:extended_verdict_reasons] if args.key?(:extended_verdict_reasons)\n @reasons = args[:reasons] if args.key?(:reasons)\n @score = args[:score] if args.key?(:score)\n end",
"def update\n respond_to do |format|\n if @etat_depense.update(etat_depense_params)\n format.html { redirect_to etat_depenses_path, notice: 'Etat depense was successfully updated.' }\n format.json { render :show, status: :ok, location: @etat_depense }\n else\n format.html { render :edit }\n format.json { render json: @etat_depense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @applied_labels = args[:applied_labels] if args.key?(:applied_labels)\n @client_customer = args[:client_customer] if args.key?(:client_customer)\n @currency_code = args[:currency_code] if args.key?(:currency_code)\n @descriptive_name = args[:descriptive_name] if args.key?(:descriptive_name)\n @hidden = args[:hidden] if args.key?(:hidden)\n @id = args[:id] if args.key?(:id)\n @level = args[:level] if args.key?(:level)\n @manager = args[:manager] if args.key?(:manager)\n @resource_name = args[:resource_name] if args.key?(:resource_name)\n @status = args[:status] if args.key?(:status)\n @test_account = args[:test_account] if args.key?(:test_account)\n @time_zone = args[:time_zone] if args.key?(:time_zone)\n end",
"def update!(**args)\n @client = args[:client] if args.key?(:client)\n @comment = args[:comment] if args.key?(:comment)\n @decision = args[:decision] if args.key?(:decision)\n @duration_mins = args[:duration_mins] if args.key?(:duration_mins)\n @evaluation = args[:evaluation] if args.key?(:evaluation)\n @hashes = args[:hashes] if args.key?(:hashes)\n @is_legal_issued = args[:is_legal_issued] if args.key?(:is_legal_issued)\n @misc_scores = args[:misc_scores] if args.key?(:misc_scores)\n @reason_code = args[:reason_code] if args.key?(:reason_code)\n @region = args[:region] if args.key?(:region)\n @restriction = args[:restriction] if args.key?(:restriction)\n @strike_category = args[:strike_category] if args.key?(:strike_category)\n @target = args[:target] if args.key?(:target)\n @target_timestamp_micros = args[:target_timestamp_micros] if args.key?(:target_timestamp_micros)\n @timestamp_micros = args[:timestamp_micros] if args.key?(:timestamp_micros)\n @user_notification = args[:user_notification] if args.key?(:user_notification)\n @version = args[:version] if args.key?(:version)\n end",
"def update_harman_employee_pricing\n authorize! :update, :harman_employee_pricing\n Array(params[:product_attr].to_unsafe_h).each do |key, attr|\n product = Product.find(key)\n product.update(attr)\n end\n redirect_to(harman_employee_pricing_admin_products_path, notice: \"Pricing updated successfully.\")\n end",
"def update!(**args)\n @entity_score = args[:entity_score] if args.key?(:entity_score)\n end",
"def update(entity_id, options)\n API::request(:patch, \"entities/#{entity_id}\", options)\n end",
"def update\n @fixed_expense = FixedExpense.for_user(current_user).find(params[:id])\n\n respond_to do |format|\n if @fixed_expense.update_attributes(params[:fixed_expense])\n flash[:notice] = 'FixedExpense was successfully updated.'\n format.html { redirect_to(fixed_expenses_path) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @fixed_expense.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @expense = Expense.find(params[:id])\n\n respond_to do |format|\n if @expense.update_attributes(params[:expense])\n format.html { redirect_to @expense, notice: 'Expense was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @actor = args[:actor] if args.key?(:actor)\n @amount = args[:amount] if args.key?(:amount)\n @creation_date = args[:creation_date] if args.key?(:creation_date)\n @reason = args[:reason] if args.key?(:reason)\n @reason_text = args[:reason_text] if args.key?(:reason_text)\n end"
] |
[
"0.61958325",
"0.6139761",
"0.6139761",
"0.61195874",
"0.6080244",
"0.6074975",
"0.60582757",
"0.6056857",
"0.60435456",
"0.6018325",
"0.5944545",
"0.5940642",
"0.59330267",
"0.5920518",
"0.5919287",
"0.5899449",
"0.58973444",
"0.58935493",
"0.58935493",
"0.5892438",
"0.58921105",
"0.5875558",
"0.58577096",
"0.58512723",
"0.5840733",
"0.5840733",
"0.5834864",
"0.58137107",
"0.5797662",
"0.579615",
"0.57892436",
"0.578434",
"0.57828563",
"0.5769754",
"0.5769365",
"0.5755307",
"0.57491267",
"0.5730948",
"0.5723681",
"0.5716967",
"0.5713078",
"0.5713022",
"0.5713022",
"0.5713022",
"0.5701324",
"0.5701301",
"0.56897944",
"0.56753474",
"0.5661307",
"0.56480587",
"0.5644006",
"0.5643443",
"0.56412715",
"0.56407434",
"0.5635286",
"0.56332785",
"0.56223327",
"0.56216425",
"0.56180197",
"0.56175256",
"0.5611923",
"0.5592108",
"0.55904824",
"0.5588194",
"0.5587696",
"0.5587696",
"0.5586239",
"0.5584441",
"0.5584364",
"0.5584364",
"0.557938",
"0.5576726",
"0.5573761",
"0.5568183",
"0.5567472",
"0.5565812",
"0.55649877",
"0.5560286",
"0.5559951",
"0.55591726",
"0.555894",
"0.5558042",
"0.5556152",
"0.55537266",
"0.5552312",
"0.55458957",
"0.55455124",
"0.55437386",
"0.5543671",
"0.5535601",
"0.55336237",
"0.55309767",
"0.5527323",
"0.55269825",
"0.55229884",
"0.5521993",
"0.5517302",
"0.5511995",
"0.5507943",
"0.55069536"
] |
0.91313285
|
0
|
End point: (GET) Usage: FundAmerica::Entity.investor_payments(entity_id)
|
def investor_payments(entity_id)
API::request(:get, "entities/#{entity_id}/investor_payments")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def investor_payments(distribution_id, options = {})\n \tAPI::request(:get, \"distributions/#{distribution_id}/investor_payments\", options)\n end",
"def details(investor_payment_id)\n API::request(:get, \"investor_payments/#{investor_payment_id}\")\n end",
"def platform_investor(entity_id )\n API::request(:get, \"entities/#{entity_id}/platform_investor\")\n end",
"def index\n @wallet_id = params[:wallet_id]\n @investment_funds = InvestmentFund.where(\"wallet_id = ?\", @wallet_id)\n end",
"def investor_accreditation(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_accreditation\")\n end",
"def index\n @payments = @user.payments\n end",
"def show\n @payments = Payment.where(enterprise_id: current_enterprise.id)\n end",
"def payments(account_id = nil)\n query_api_object Payment, account_id.nil? ? \"/rest/payments\" : \"/rest/accounts/#{account_id}/payments\", nil, \"GET\", \"payments\"\n end",
"def invoice_payments\n @invoice_payments ||= Harvest::API::InvoicePayments.new(credentials)\n end",
"def index\n @member_payments = @customer.member_payments.pendings\n end",
"def investor(id:)\n Investor.find(id)\n end",
"def show\n @payments = Payment.for_fundraiser(@fundraiser.id).chronological.all\n end",
"def index\n @provider_payments = ProviderPayment.all\n end",
"def payments\n @session.payments @account_id\n end",
"def index\n @payments = Payment.all_for_user(current_user)\n end",
"def non_investor_payments(distribution_id, options = {})\n API::request(:get, \"distributions/#{distribution_id}/non_investor_payments\", options)\n end",
"def index\n @investment_funds = InvestmentFund.all\n end",
"def index\n @payments = Payment.where client: @client\n end",
"def index\n @income_payments = @income.income_payments.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @payments = Payment.all\n end",
"def index\n @fund_company_investments = FundCompanyInvestment.all\n end",
"def payments\n @session.payments @account_id\n end",
"def index\n #@payments = Payment.all\n @payment = Payment.find(params[:id])\n end",
"def index\n @rent_payments = RentPayment.all\n end",
"def index\n @rent_payments = RentPayment.all\n end",
"def index\n @payments = []\n end",
"def payment\n @amount = 10.00\n @sim_transaction = AuthorizeNet::SIM::Transaction.new(AUTHORIZE_NET_CONFIG['api_login_id'], AUTHORIZE_NET_CONFIG['api_transaction_key'], @amount, :hosted_payment_form => true)\n @sim_transaction.set_hosted_payment_receipt(AuthorizeNet::SIM::HostedReceiptPage.new(:link_method => AuthorizeNet::SIM::HostedReceiptPage::LinkMethod::GET, :link_text => 'Continue', :link_url => payments_thank_you_url(:only_path => false)))\n\n end",
"def index\r\n @fixed_deposit_investments = FixedDepositInvestment.all\r\n end",
"def index\n\t\t@payments = @user.payments.order(\"date desc\").page( params[:page] ).per(10)\n\tend",
"def payment(params)\n check_token\n\n Request.perform(:post, URI.parse(Urls::PAYMENTS_URL), headers_for_other, params.to_json)\n end",
"def index\n @customer = Customer.find(params[:cust_id])\n @payments = @customer.payments\n end",
"def index\n @investments = Investment.all\n\n respond_to do |format|\n format.html\n format.json\n end\n end",
"def index\n @investments = Investment.all.paginate(:page => params[:page], :per_page => 30)\n end",
"def index\n @payments = @contract.payments\n @payments = @payments.date_filter(params[:from], params[:to]) if params[:from].present? && params[:to].present?\n @payment_presenter = PaymentPresenter.new(@payments)\n end",
"def index\n @partner_payments = PartnerPayment.all\n end",
"def index\n @payements = Payement.all\n end",
"def payments\n if params['form_payment']\n results = CsApi::Member.update(current_access_token, @current_user.username, params['form_payment'])\n #check for errors!!\n if results['success'].eql?('false')\n flash.now[:error] = results['message']\n else\n flash.now[:notice] = 'Your payment information has been updated.'\n get_account\n end\n end\n # set the member's id for docusign\n @memberId = @account['id']\n @payments = CsApi::Member.payments(current_access_token, @current_user.username)\n @payments.each do |record| \n if record['status'].eql?('Paid')\n @show_paid_section = true\n else \n @show_outstanding_section = true\n end\n end\n @page_title = 'Your Payments and Payment Info'\n respond_to do |format|\n format.html\n format.json { render :json => @payments }\n end\n end",
"def index\n @debt_payments = DebtPayment.all\n end",
"def index\n @payment_entries = PaymentEntry.all\n end",
"def index\n @payments = Payment.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @payments }\n end\n end",
"def index\n @payments = Payment.top\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payments }\n end\n end",
"def index\n @investors = params[:q].present? ? Investor.search(params[:q]) : Investor.all\n @investors = @investors.includes(:investment_group, :consultant).ordered.\n page(params[:page]).references(:investment_group, :consultant)\n end",
"def remote_pledge(pay_to)\n \tvenmo_info = self.user.venmo_account\n \trequest = 'https://api.venmo.com/v1/payments'\n \tresponse = HTTParty.post(request, query: {\n access_token: venmo_info.access_token,\n user_id: pay_to,\n amount: self.amount.to_s,\n note: 'Payment from my app'\n })\n\n \tJSON.parse(response.body)\n end",
"def get_payments(options = {})\n request_params = {}\n request_params[:PaymentID] = options[:payment_id] if options[:payment_id]\n request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]\n request_params[:order] = options[:order] if options[:order]\n request_params[:where] = options[:where] if options[:where]\n\n response_xml = http_get(@client, \"#{@xero_url}/Payments\", request_params)\n parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/payments'})\n end",
"def index\n @individual_company_investments = IndividualCompanyInvestment.all\n end",
"def payment\n @amount = 10.00\n @sim_transaction = AuthorizeNet::SIM::Transaction.new(AUTHORIZE_NET_CONFIG['api_login_id'], AUTHORIZE_NET_CONFIG['api_transaction_key'], @amount, :relay_url => payments_relay_response_url(:only_path => false))\n end",
"def payment\n @amount = 10.00\n @sim_transaction = AuthorizeNet::SIM::Transaction.new(AUTHORIZE_NET_CONFIG['api_login_id'], AUTHORIZE_NET_CONFIG['api_transaction_key'], @amount, :relay_url => payments_relay_response_url(:only_path => false))\n end",
"def index\n @payments = Array.wrap(payments)\n .map { |payment| Payment.new(payment) }\n .sort_by { |payment| payment.sort_key(:payment_date) }\n\n respond_to do |format|\n format.html { render }\n format.json { render json: payments_json_response }\n end\n end",
"def index\n @payments = Payment.order('creation_date DESC').all\n\n if current_login.has_role? :administrator\n @payments = Payment.find_by_sql('select *\nfrom Payments p, (select clinic_id, max(due_date) as d from payments group by clinic_id) s\nwhere p.clinic_id = s.clinic_id and p.due_date = s.d order by payed')\n\n\n \n elsif current_login.has_role? :manager\n logged_user = Manager.first(:conditions => \"login_id = #{current_login.id}\")\n @payments = Payment.in_clinic(logged_user.clinic.id).all\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @payments }\n end\n end",
"def test_test_list_payments()\r\n # Parameters for the API call\r\n begin_time = nil\r\n end_time = nil\r\n sort_order = nil\r\n cursor = nil\r\n location_id = nil\r\n total = nil\r\n last_4 = nil\r\n card_brand = nil\r\n\r\n # Perform the API call through the SDK function\r\n result = @controller.list_payments(begin_time: begin_time, end_time: end_time, sort_order: sort_order, cursor: cursor, location_id: location_id, total: total, last_4: last_4, card_brand: card_brand)\r\n\r\n # Test response code\r\n assert_equal(200, @response_catcher.response.status_code)\r\n\r\n # Test headers\r\n expected_headers = {}\r\n expected_headers['content-type'] = 'application/json'\r\n\r\n assert(ComparisonHelper.match_headers(expected_headers, @response_catcher.response.headers))\r\n end",
"def index\n @payments = Payment.search(attach_owner_user_id)\n end",
"def total_payments\n Payment.total_for_tenant(self)\n end",
"def payment_amount\n params['asking_price'] = params['asking_price'].to_f\n params['down_payment'] = params['down_payment'].to_f\n params['amortization_period'] = params['amortization_period'].to_f\n\n insurance_cost = calculate_insurance_amount(params)\n payment_amount = calculate_payment_amount(params, insurance_cost, @@interest_rate)\n json_response(amount: payment_amount)\n end",
"def set_investor\n @investor = ::Cap::Table::Investor.find(params[:id])\n end",
"def payment\n @amount = 10.00\n @sim_transaction = AuthorizeNet::SIM::Transaction.new(AUTHORIZE_NET_CONFIG['api_login_id'], AUTHORIZE_NET_CONFIG['api_transaction_key'], @amount, :hosted_payment_form => true)\n @sim_transaction.set_hosted_payment_receipt(AuthorizeNet::SIM::HostedReceiptPage.new(:link_method => AuthorizeNet::SIM::HostedReceiptPage::LinkMethod::GET, :link_text => 'Continue', :link_url => payments_thank_you_url(:only_path => false)))\n\n # @transaction = AuthorizeNet::AIM::Transaction.new(AUTHORIZE_NET_CONFIG['api_login_id'], AUTHORIZE_NET_CONFIG['api_transaction_key'], :gateway=>:sandbox)\n # credit_card = AuthorizeNet::CreditCard.new('4111111111111111', '1120')\n # @response = @transaction.purchase('10.00', credit_card)\n\n # if @response.success?\n # puts \"Successfully made a purchase (authorization code: #{response.authorization_code})\"\n # else\n # raise \"Failed to make purchase.\"\n # end\n end",
"def index\n @payments = Payment.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @payments }\n end\n end",
"def index\n @payments = Payment.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @payments }\n end\n end",
"def index\n delocalize_dates([:created_at_greater_than_or_equal_to, :created_at_less_than_or_equal_to]) if params[:search]\n @payments = do_index(Payment, params)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payments }\n end\n end",
"def payment\n payment = 0\n transactions = finance_transactions\n unless transactions.nil?\n transactions.each do |t|\n payment += t.amount\n end\n end\n payment\n end",
"def view\n\t\t\t@investor = Investor.find params[:id]\n\t\tend",
"def index\n @payment_providers = PaymentProvider.all\n end",
"def by_seperate_payments_by_provider_for_organisation(organisation_id)\n query = Query.find_by_sql(\n \"select hp.id host_provider_id, hp.name host_provider_name, sum(c.amount) sumamount\\n\"+\n \"from claims c\\n\"+\n \" join organisations o on o.id = c.organisation_id\\n\"+\n \" left join providers hp on hp.id = c.host_provider_id and hp.seperate_payment = 1\\n\"+\n \"where c.payment_run_id = #{self.id} and c.organisation_id = #{organisation_id}\\n\"+\n \"group by hp.id, hp.name\\n\"+\n \"order by 2\")\n query\n end",
"def investor\n end",
"def index\n @transporter_payments = TransporterPayment.all\n\n end",
"def index\n @sale_payments = SalePayment.all\n end",
"def index\n \n if @payment.nil?\n today = Date.today\n year = params[:year].to_i if params[:year]\n month = params[:month].to_i if params[:month]\n \n @date = today\n \n if year && month\n day = today.day\n if year != today.year || month != today.month\n day = 1\n end\n @date = Date.civil(year, month, day)\n end\n else\n @date = @payment.date\n end\n \n @payments = Payment.by_month(@date)\n \n respond_to do |format|\n format.html { render :action => 'index' }\n format.xml { render :xml => @payments }\n end\n end",
"def index\n @company_investors = CompanyInvestor.all\n end",
"def index\n @investment_declaration = InvestmentDeclaration.new\n @investment_declarations = InvestmentDeclaration.all\n @policy_details = PolicyDetail.all\n @investment_declaration = InvestmentDeclaration.find(params[:investment_declaration_id])\n end",
"def index\n @payments = Payment.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payments }\n end\n end",
"def _spent_on\n return payment\n end",
"def index\n if current_user.admin?\n @payments = Payment.order(updated_at: :desc).paginate(page: params[:page], per_page: 12)\n else\n @payments = Payment.order(updated_at: :desc).where(user: current_user).paginate(page: params[:page], per_page: 12)\n end\n end",
"def show\n @payment = @user.payments.find(params[:id])\n end",
"def index\n @search = Payment.search(params[:q])\n @payments = Payment.all\n end",
"def payments(hash={}) \n Loan.all(:funding_line_id => funding_lines.map{|x| x.id}).payments(hash)\n end",
"def index\n @payments = Payment.status_based_payments(params[:payment_status] || \"open\")\n\n respond_to do |format|\n format.html # index.html.erb\n @paymnts = Array.new\n format.json {\n @payments = @payments.select{|payment|\n paymnt = Hash.new\n payment.attributes.each do |key, value|\n paymnt[key] = value\n end\n paymnt[:payment_identifier] = CommonActions.linkable(payment_path(payment), payment.payment_identifier)\n paymnt[:vendor_name] = payment.organization.present? ? CommonActions.linkable(organization_path(payment.organization), payment.organization.organization_name) : \"-\"\n paymnt[:payment_type_name] = payment.payment_type.present? ? payment.payment_type.type_name : \"\"\n if can? :edit, Payment\n paymnt[:links] = CommonActions.object_crud_paths(nil, edit_payment_path(payment), nil)\n else\n paymnt[:links] = \"\"\n end\n @paymnts.push(paymnt)\n }\n render json: {:aaData => @paymnts}\n }\n end\n end",
"def index\n @erip_transactions = EripTransaction.all.order(paid_at: :desc).paginate(page: params[:page], per_page: 30)\n end",
"def index\n @paymentts = Paymentt.all\n end",
"def index\n @api_payments = Api::Payment.all\n end",
"def show\n @payments = Payment.find(params[:id]) \n render json: @payments\n end",
"def payments_for(_other_user)\n fail NotImplementedError\n end",
"def index\n\n @suppliers = Supplier.all.collect{ |s| [s.name, s.id] }\n @aircraft_types = AircraftType.all(:order => :name).collect{|c| [c.name, c.id]}\n\n date_params\n if params[:date_option] == 'due_date'\n @payments = Account.between_due_dates(@start_date.to_date, @end_date.to_date).order(:due_date)\n else\n @payments = Account.between_payment_dates(@start_date.to_date, @end_date.to_date).order(:payment_date)\n end\n\n debugger\n if params[:supplier_id] && params[:supplier_id].to_i > 0\n @payments = @payments.by_supplier(params[:supplier_id])\n params[:initials] = Supplier.find(params[:supplier_id]).name\n end\n if params[:aircraft_type_id] && params[:aircraft_type_id].to_i > 0\n @payments = @payments.by_company(params[:aircraft_type_id])\n end\n \n @payments = @payments.payed if params[:confirmed] == 'sim'\n @payments = @payments.not_payed if params[:confirmed] == 'não'\n @titulo = \"Pagamentos entre #{@start_date} e #{@end_date}\"\n\n @payed_total = 0\n @payments.each do |pay|\n @payed_total += pay.value\n end\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @accounts }\n end\n end",
"def index\n @investables = Investable.all\n end",
"def index\n @search = PaymentSearch.new params[:f], params[:page]\n @payments = @search.results\n# @payments = Payment.all\n end",
"def index\n d = Date.today\n @expenses = @household.expenses.monthly_statement(d.month, d.year).order(spent_at: :desc)\n end"
] |
[
"0.7399831",
"0.71451336",
"0.6653049",
"0.6325131",
"0.61442256",
"0.6138229",
"0.61257666",
"0.608291",
"0.6082504",
"0.6043077",
"0.5973801",
"0.5928625",
"0.5903708",
"0.58889884",
"0.58496696",
"0.58375543",
"0.58262527",
"0.5823262",
"0.5806376",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57893664",
"0.57722545",
"0.5763269",
"0.574854",
"0.57438445",
"0.57438445",
"0.5724542",
"0.57146895",
"0.57110274",
"0.57094467",
"0.5707775",
"0.5696411",
"0.56715095",
"0.56551105",
"0.5630536",
"0.56221026",
"0.56174296",
"0.56046456",
"0.55961365",
"0.55720496",
"0.5562037",
"0.5548453",
"0.5548237",
"0.5545845",
"0.5541754",
"0.55290306",
"0.5521628",
"0.5521628",
"0.55203193",
"0.5483672",
"0.5479696",
"0.5475896",
"0.547435",
"0.5468204",
"0.54527855",
"0.54421467",
"0.5437753",
"0.5437753",
"0.5436365",
"0.543177",
"0.54254186",
"0.54174477",
"0.5400956",
"0.5384584",
"0.53810996",
"0.53775954",
"0.53765434",
"0.5371568",
"0.5363936",
"0.53504825",
"0.53429514",
"0.533424",
"0.53290814",
"0.5327562",
"0.53261715",
"0.5325951",
"0.5318281",
"0.53101975",
"0.5307494",
"0.5304901",
"0.5304735",
"0.5289969",
"0.52898806",
"0.5276654",
"0.5275644"
] |
0.9108992
|
0
|
(GET) Usage: FundAmerica::Entity.bank_transfer_methods Output: Returns Bank Transfer Method informations of an entity
|
def bank_transfer_method(entity_id)
API::request(:get, "entities/#{entity_id}/bank_transfer_methods")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_list_payments_methods\n PaymentMethod.get_list_payment_methods\n end",
"def payment_methods\n request = payment_methods_request\n response = PaybywayConnector.payment_methods(request).parsed_response\n response['payment_methods'].map { |method|\n PaymentGateway::PaymentMethod.new(\n group: method['group'].to_sym,\n name: method['name'],\n slug: method['selected_value'],\n min_cents: method['min_amount'],\n max_cents: method['max_amount'],\n image_url: method['img']\n )\n }\n end",
"def index\n @transfers = @bank_account.transfers.all\n end",
"def transfer_funds\n Dialog::space\n @acct_list = bank.account_list(@man_name, @man_pin)\n @account_id_array = Display::account_info(@acct_list)\n from = Dialog::transfer_acct_1\n to = Dialog::transfer_acct_2\n how_much = Dialog::transfer_ammount\n bank.money_transfer(from, to, how_much)\n end",
"def get_banks\n HTTParty.get(BASE_URI + 'bank?country=ghana',\n headers: HEADERS).parsed_response\n end",
"def getbalance(args={})\n {\n :method=> \"GetBalances\"\n }.to_json\n end",
"def balance\n parse_balance(post('/api/1/generic/info'))\n end",
"def bank\n @session.get_bank @bank_id\n end",
"def balances()\n request(\"#{@base_url}/account/getbalances\")\n end",
"def payment_methods\n @credit_cards +\n @paypal_accounts +\n @apple_pay_cards +\n @google_pay_cards +\n @venmo_accounts +\n @us_bank_accounts +\n @visa_checkout_cards +\n @samsung_pay_cards +\n @sepa_direct_debit_accounts\n end",
"def bank\n @session.get_bank @bank_id\n end",
"def bank; end",
"def get_method_descriptions(klass, method)\n get_class_descriptions(klass).map do |class_description|\n class_description.method_description(method.to_sym)\n end.compact\n end",
"def get_bank_name()\n return @RESPONSE_HASH['BANK_NAME']\n end",
"def list_payment_method\n authorize current_employer\n @payment_methods = current_employer.customers\n end",
"def get_transfers_in\n run_command :get_transfers_in, :domain, {\n :key => 'attributes'\n }\n end",
"def get_bank_transactions(options = {})\n request_params = {}\n request_params[:BankTransactionID] = options[:bank_transaction_id] if options[:bank_transaction_id]\n request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]\n request_params[:order] = options[:order] if options[:order]\n request_params[:where] = options[:where] if options[:where]\n request_params[:page] = options[:page] if options[:page]\n\n response_xml = http_get(@client, \"#{@xero_url}/BankTransactions\", request_params)\n\n parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/BankTransactions'})\n end",
"def getwalletinfo\n @api.request 'getwalletinfo'\n end",
"def index\n @operations = @bank_book.operations\n end",
"def payment_methods(paymentmethod_id)\n pay_methods = ''\n if paymentmethod_id == 1\n pay_methods = 'Crédito'\n elsif paymentmethod_id == 2\n pay_methods = 'Débito'\n elsif paymentmethod_id == 3\n pay_methods = 'Efectivo'\n elsif paymentmethod_id == 4\n pay_methods = 'Efectivo y Crédito'\n elsif paymentmethod_id == 5\n pay_methods = 'Débito y Crédito'\n elsif paymentmethod_id == 6\n pay_methods = 'Efectivo y Débito'\n elsif paymentmethod_id == 7\n pay_methods = 'Efectivo, Débito y Crédito'\n else\n pay_methods = 'Desconocido'\n end\n pay_methods\n end",
"def fetch_wallets(funds_type = nil)\n MangoPay.request(:get, url() + \"/wallets/#{funds_type}\")\n end",
"def screen_method\n \"\" # choose from all three methods (VTCPay, Credit, Bank)\n end",
"def index\n @bankets = Banket.all\n end",
"def balance\n rest.get(:getbalance)['data']\n end",
"def transfer_type_description_list\n transfer_types.collect{|key, value| value[:description]} \n end",
"def get_transfers_away\n run_command :get_transfers_away, :domain, {\n :key => 'attributes'\n }\n end",
"def payout_method_type_list(beneficiary_country, payout_currency, category, sender_entity)\n add_timestamp\n add_salt\n headers = { 'content-type' => 'application/json',\n 'signature' => signature('', 'get', \"/v1/payouts/supported_types?beneficiary_country=#{beneficiary_country}&payout_currency=#{payout_currency}&category=#{category}&sender_entity=#{sender_entity}\"), 'salt' => salt, 'timestamp' => timestamp, 'access_key' => access_key }\n response, msg = rest_client.getCall(\n \"/v1/payouts/supported_types?beneficiary_country=#{beneficiary_country}&payout_currency=#{payout_currency}&category=#{category}&sender_entity=#{sender_entity}\", headers\n )\n JSON.parse(response)['data'] if response.present?\n rescue StandardError => e\n Rails.logger.error e\n nil\n end",
"def index\n @bank_card_types = BankCardType.all\n end",
"def service_payment_information\n service_payment_elements =[]\n service_payment_elements << 'SVC'\n service_payment_elements << composite_med_proc_id\n service_payment_elements << service.amount('service_procedure_charge_amount')\n service_payment_elements << service.amount('service_paid_amount')\n service_payment_elements << revenue_code\n service_payment_elements.join(@element_seperator )\n end",
"def types(options={})\n select_from_hash_array(TRANSACTION_METHODS, :type, {}, options)\n end",
"def types(options={})\n select_from_hash_array(TRANSACTION_METHODS, :type, {}, options)\n end",
"def banks_get(opts = {})\n if Configuration.debugging\n Configuration.logger.debug \"Calling API: BanksApi#banks_get ...\"\n end\n \n # resource path\n path = \"/banks\".sub('{format}','json')\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n _header_accept = ['application/json']\n _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result\n\n # HTTP header 'Content-Type'\n _header_content_type = ['application/x-www-form-urlencoded']\n header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n \n\n auth_names = ['khipu']\n result = @api_client.call_api(:GET, path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'BanksResponse')\n if Configuration.debugging\n Configuration.logger.debug \"API called: BanksApi#banks_get. Result: #{result.inspect}\"\n end\n return result\n end",
"def get_bank_link_all_using_get_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: FundingApi.get_bank_link_all_using_get ...'\n end\n # resource path\n local_var_path = '/bank_link'\n\n # query parameters\n query_params = {}\n query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?\n query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?\n query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?\n query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?\n query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['*/*'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n auth_names = ['oauth2']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'PageBankLink')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: FundingApi#get_bank_link_all_using_get\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def list_methods\n API_METHODS.values.flatten\n end",
"def transfers\n self.ListTransfers.first.map { |t| map_transfer(t) }\n end",
"def service_payment_information\n service_payment_elements =[]\n service_payment_elements << 'SVC'\n service_payment_elements << composite_med_proc_id\n service_payment_elements << service.amount('service_procedure_charge_amount')\n service_payment_elements << service.amount('service_paid_amount')\n service_payment_elements << svc_revenue_code\n service_payment_elements << service.service_quantity.to_f.to_amount\n service_payment_elements = Output835.trim_segment(service_payment_elements)\n service_payment_elements.join(@element_seperator )\n end",
"def index\n @bank_transactions = BankTransaction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bank_transactions, methods: :balance, callback: params[:callback] }\n format.xml { render xml: @bank_transactions, methods: :balance }\n end\n end",
"def bank_account\n @bank_account\n end",
"def methods\n @method_ids.collect { |idx| BMethod.store[idx] }\n end",
"def index\n @type_debits = TypeDebit.all\n end",
"def transaction_fee_cents(method_type)\n select_from_hash_array(TRANSACTION_METHODS, :transaction_fee_cents, :type => method_type.to_sym)\n end",
"def gather_debit_info\r\n debit_accounts = @page.css(\"#dashStep2 tr[id]\")\r\n @da_index = 1\r\n while @da_index <= debit_accounts.count do\r\n account_name = @page.css(\"#dashStep2 tr:nth-of-type(#{@da_index}) td:nth-of-type(1) span\").text\r\n account_currency = @page.css(\"#dashStep2 tr:nth-of-type(#{@da_index}) td:nth-of-type(3) span\").text\r\n account_available_balance = @page.css(\"#dashStep2 tr:nth-of-type(#{@da_index}) td:nth-of-type(2) span\").text\r\n da = Accounts.new(account_name, account_currency , account_available_balance,\"Debit\" )\r\n @available_accounts << da\r\n @da_index += 1\r\n end\r\n end",
"def descriptions\n \n return @detail + \": \" + \"#{@extra_cost}\" + \". \" + @basic_transfer.descriptions\n end",
"def index\n @pay_methods = PayMethod.all\n end",
"def show\n payment_methods = Payment.select(:id, :name, :image)\n \n json_response({message:Message.success, Payment_methods: payment_methods })\n end",
"def transfer_funds\n @organizer = Organizer.find(params[:id])\n @amount = raw_price(params[:amount])\n @current = raw_price(params[:current])\n\n if params[:amount].nil?\n @status = \"danger\"\n @message_status = \"Você não especificou um valor\"\n return\n end\n\n @bank_account_active_id = @organizer.marketplace.bank_account_active.own_id\n if @bank_account_active_id.nil?\n @status = \"danger\"\n @message_status = \"Você não tem nenhuma conta bancária ativa no momento\"\n else\n if @amount <= @current\n bank_transfer_data = {\n \"amount\" => @amount,\n \"transferInstrument\" => {\n \"method\" => \"BANK_ACCOUNT\",\n \"bankAccount\" => {\n \"id\" => @bank_account_active_id,\n }\n }\n }\n response_transfer = RestClient.post(\"#{Rails.application.secrets[:moip_domain]}/transfers\", bank_transfer_data.to_json, :content_type => :json, :accept => :json, :authorization => \"OAuth #{@organizer.marketplace.token}\"){|response, request, result, &block|\n case response.code\n when 401\n @status = \"danger\"\n @message_status = \"Você não está autorizado a realizar esta transação\"\n @response_transfer_json = JSON.load response\n when 400\n @status = \"danger\"\n @message_status = \"Não foi possíel realizar a transferência\"\n @response_transfer_json = JSON.load response\n when 200\n @status = \"danger\"\n @message_status = \"Não foi possível realizar a transferência\"\n @response_transfer_json = JSON.load response\n when 201\n @status = \"success\"\n @message_status = \"Solicitação de transferência realizada com sucesso\"\n @response_transfer_json = JSON.load response\n MarketplaceMailer.transfer(@organizer, friendly_price(@response_transfer_json[\"amount\"]), l(@response_transfer_json[\"updatedAt\"].to_datetime, format: '%d de %B de %Y as %Hh%M')).deliver_now\n else\n @activation_message = \"Não conseguimos resposta do MOIP para a transferência soliticata, verifique os dados novamente.\"\n @activation_status = \"danger\"\n @response_transfer_json = JSON.load response\n end\n }\n else\n @status = \"danger\"\n @message_status = \"Você não tem fundos suficientes para realizar esta transferência\"\n end\n end\n\n end",
"def methods\n main_service.methods.select(&:can_generate_rest?)\n end",
"def index\n @tranhead = Tranheads::Bankclient.all\n end",
"def getPtbAll( entity_id, destructive)\n params = Hash.new\n params['entity_id'] = entity_id\n params['destructive'] = destructive\n return doCurl(\"get\",\"/ptb/all\",params)\n end",
"def bank\n round.game.bank\n end",
"def show_bankaccount()\n p \"The owner is #{@owner}, and The balance is #{@balance}\"\n end",
"def list()\n\t\t\tkparams = {}\n\t\t\tclient.queue_service_action_call('householdpaymentmethod', 'list', 'KalturaHouseholdPaymentMethodListResponse', kparams)\n\t\t\tif (client.is_multirequest)\n\t\t\t\treturn nil\n\t\t\tend\n\t\t\treturn client.do_queue()\n\t\tend",
"def add_bank_transfer(from, to, amount)\n amount = amount.round(2)\n logger.debug \"Transferring #{amount} from #{from} to #{to}\"\n @api.put('BankTransfers', {\n 'FromBankAccount' => { 'Code' => from },\n 'ToBankAccount' => { 'Code' => to },\n 'Amount' => amount,\n 'Date' => @export.date.strftime('%Y-%m-%d')\n })['BankTransfers'].first\n end",
"def get_withdrawal_info\n # body = {\n # cmd: \"get_withdrawal_info\"\n # }\n\n end",
"def depenses_accounts\n accounts.classe_6 \n end",
"def list\n\t\t@banks = Bank.paginate :page => params[:page], :per_page => 10\t#Pagination\n \trespond_to do |format|\t\t\n \t\t format.html \n \t\t\tformat.xml { render :xml => @banks }\t\t#Render to XML File\n \tend\n\t\t\n\tend",
"def balances\n accounts.with_balance\n end",
"def freebase_types\n _response_entity.fetch(\"freebaseTypes\", [])\n end",
"def transfer_funds\n raise \"payment must be paid\" if !payment.paid?\n\n bank_account = PagarMe::BankAccount.new(bank_account_attributes.delete(:bank_account))\n bank_account.create\n raise \"unable to create an bank account\" unless bank_account.id.present?\n\n transfer = PagarMe::Transfer.new({\n bank_account_id: bank_account.id,\n amount: value_for_transaction\n })\n transfer.create\n raise \"unable to create a transfer\" unless transfer.id.present?\n\n #avoid sending notification\n payment.update(state: 'pending_refund')\n payment.payment_transfers.create!({\n user: payment.user,\n transfer_id: transfer.id,\n transfer_data: transfer.to_json\n })\n end",
"def index\n @bank_details = BankDetail.all\n end",
"def payment_methods(method, data = {})\n call_endpoint(Endpoint::PaymentMethods, method, data)\n end",
"def get_payment_methods(kb_account_id, refresh_from_gateway = false, properties, context)\n options = properties_to_hash(properties)\n @payment_method_model.from_kb_account_id(kb_account_id, context.tenant_id).collect { |pm| pm.to_payment_method_info_plugin }\n end",
"def get_payment_methods(kb_account_id, refresh_from_gateway = false, properties, context)\n options = properties_to_hash(properties)\n @payment_method_model.from_kb_account_id(kb_account_id, context.tenant_id).collect { |pm| pm.to_payment_method_info_plugin }\n end",
"def index\n authorize! :manage, PaymentTier\n @payment_tiers = PaymentTier.all\n end",
"def get_account_balance\n submit GetAccountBalance.new\n end",
"def list_accounts\n\ttp Account.all\nend",
"def fetch_wallet(funds_type, currency_iso_code)\n MangoPay.request(:get, url() + \"/wallets/#{funds_type}/#{currency_iso_code}\")\n end",
"def index\n @bankdeposits = Bankdeposit.all\n end",
"def all(params = {})\n handle_all_request(\"/payment-methods\", :payment_methods, params)\n end",
"def index\n\n @debtors = Debtor.all\n\n render json: @debtors\n end",
"def get_method_descriptions(resource, method)\n get_resource_descriptions(resource).map do |resource_description|\n resource_description.method_description(method.to_sym)\n end.compact\n end",
"def balances(id)\n get(\"/accounts/#{id}/balances\")\n end",
"def customer_payment_methods(customer_id)\n client.get \"customers/#{inst_id}/#{customer_id}/paymentMethods\"\n end",
"def available_balances_table\n <<EOF\n\\\\section{Available Balances}\n\\\\begin{tabulary}{0.9\\\\textwidth}{R | r r c}\nAccount & Balance & Available & Type\\\\\\\\\n\\\\hline\\\\Tstrut\n #{\n [:Equity, :Asset, :Liability].map{|type|\n @accounts.find_all{|acc| acc.type == type}.map{|acc|\n [acc.name_c, acc.balance(@today).to_tex, acc.available(@today).to_tex, type.to_s].join(\" & \")\n }.join(\"\\\\\\\\ \\n\")\n }.join(\"\\\\\\\\ \\n\\n\")\n }\n\\\\end{tabulary}\nEOF\n end",
"def find_bank(bank_code, country_code)\n query_api \"/rest/catalog/banks/#{country_code}/#{bank_code}\"\n end",
"def recettes_accounts\n accounts.classe_7\n end",
"def methods\n return @methods\n end",
"def index\n @payment_methods = @user.payment_methods.page(params[:page]).per(params[:per])\n render json: @payment_methods\n end",
"def transfer ( bank, person, amount)\r\n\t\tif @bank_listing[person.id_number][:balance] >= amount\r\n\t\t\t@bank_listing[person.id_number][:balance]-=amount\r\n\t\t\tputs \"#{@bank_name}: #{person.name}, your transfer of #{amount} to #{bank.bank_name} is complete.\"\r\n\t\t\tbank.deposit(person, amount)\r\n\t\telse\r\n\t\t\tputs \"#{@bank_name}: Sorry #{person.name}, insufficient funds.\"\r\n\t\tend\r\n\t\t\t\r\n\tend",
"def index\n @bank_accounts = BankAccount.all\n end",
"def index\n @bank_accounts = BankAccount.all\n end",
"def getTransactions\n\t\t\n\tend",
"def method_type\n 'payone_cashinadvance'\n end",
"def show\n @account = Account.find(params[:id])\n authorize! :show, @account\n @transactions =[]\n @account.transactions_credit.each {|t| @transactions.push(Transaction_output.new(t,\"credit\")) }\n @account.transactions_debit.each {|t| @transactions.push(Transaction_output.new(t,\"debit\")) }\n @transactions.sort_by! {|a| a.date }\n\n end",
"def wallet_transactions_listing(wallet_id, type)\n add_timestamp\n add_salt\n headers = { 'content-type' => 'application/json',\n 'signature' => signature('', 'get', \"/v1/user/#{wallet_id}/transactions?type=#{type}\"), 'salt' => salt, 'timestamp' => timestamp, 'access_key' => access_key }\n response, msg = rest_client.getCall(\"/v1/user/#{wallet_id}/transactions?type=#{type}\", headers)\n JSON.parse(response)['data'] if response.present?\n rescue StandardError => e\n Rails.logger.error e\n nil\n end",
"def index\n if params[:type]\n case params[:type]\n when 'plan' then @debts = Debt.where(:debttype => 0).page(params[:page]).per(10)\n when 'inst' then @debts = Debt.where(:debttype => 1).page(params[:page]).per(10)\n when 'debt' then @debts = Debt.where(:debttype => 2).page(params[:page]).per(10)\n end\n else\n @debts = Debt.all.page(params[:page]).per(10)\n end\n end",
"def balance\n request_params = params.permit(:account_id)\n\n balance ||= Actions.new.balance(request_params['account_id'])\n\n return render status: balance[0], json: balance[1]\n end",
"def get_transfer_all_using_get_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: FundingApi.get_transfer_all_using_get ...'\n end\n # resource path\n local_var_path = '/transfer'\n\n # query parameters\n query_params = {}\n query_params[:'ascending'] = opts[:'ascending'] if !opts[:'ascending'].nil?\n query_params[:'filter'] = opts[:'filter'] if !opts[:'filter'].nil?\n query_params[:'order_by'] = opts[:'order_by'] if !opts[:'order_by'].nil?\n query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?\n query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['*/*'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n auth_names = ['oauth2']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'PageExternalAccountTransfer')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: FundingApi#get_transfer_all_using_get\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def get_transactions(service)\n\t\treturn @transport.get_path(\"transactions\",service)\n\tend",
"def get_bank_transaction(bank_transaction_id)\n request_params = {}\n url = \"#{@xero_url}/BankTransactions/#{CGI.escape(bank_transaction_id)}\"\n response_xml = http_get(@client, url, request_params)\n parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/BankTransaction'})\n end",
"def transfer\n @purchase = Purchase.find_by(invoice_id: params[:invoice_id])\n @bank_account = BankAccount.first\n end",
"def stored_payment_methods\n return [] unless @member && @member.customer\n @member.customer.payment_methods.stored.map do |m|\n {\n id: m.id,\n last_4: m.last_4,\n instrument_type: m.instrument_type,\n card_type: m.card_type,\n email: m.email\n }\n end\n end",
"def inspect\n \"#<Baron::Bank:#{object_id}>\"\n end",
"def despositing_adds_transaction_to_bank_statement\n account = BankAccount.new\n account.deposit('10-01-2012', 1000)\n p account\n p account.bank_statement\nend",
"def getblockchaininfo\n @api.request 'getblockchaininfo'\n end",
"def inspect_methods\n return [] unless constant.respond_to?(:methods)\n\n methods = get_methods.map do |name|\n method_information(:method, name)\n end\n\n return methods.sort_by(&:name)\n end",
"def inspect_methods\n return [] unless constant.respond_to?(:methods)\n\n methods = get_methods.map do |name|\n method_information(:method, name)\n end\n\n return methods.sort_by(&:name)\n end",
"def show_methods(klass)\n \t\tputs Object.const_get(klass).methods.inspect\n\tend",
"def value\n @methods\n end",
"def show_man_balance\n Dialog::space\n @acct_list = bank.account_list(@man_name, @man_pin)\n @account_id_array = Display::account_info(@acct_list) \n end"
] |
[
"0.5956884",
"0.5890792",
"0.56654423",
"0.56563747",
"0.5655339",
"0.5598423",
"0.54417044",
"0.5439406",
"0.54236805",
"0.5367508",
"0.53532326",
"0.53519887",
"0.53212625",
"0.5315025",
"0.5314124",
"0.52899677",
"0.52863175",
"0.5276744",
"0.52473",
"0.5228038",
"0.5220615",
"0.52200484",
"0.52145165",
"0.5214376",
"0.52016354",
"0.5190208",
"0.51788515",
"0.516683",
"0.51384085",
"0.51332265",
"0.51332265",
"0.51222855",
"0.5112968",
"0.5110135",
"0.51096666",
"0.5106305",
"0.5094635",
"0.5093301",
"0.50902975",
"0.5075089",
"0.5054109",
"0.5048427",
"0.50438356",
"0.5039889",
"0.5039439",
"0.50208837",
"0.5013946",
"0.5013443",
"0.4993319",
"0.49892145",
"0.49885628",
"0.49868533",
"0.4986062",
"0.49693564",
"0.49690345",
"0.49541306",
"0.49487758",
"0.4932158",
"0.49299416",
"0.492671",
"0.49233776",
"0.49226797",
"0.49226797",
"0.49187258",
"0.49179092",
"0.4916547",
"0.4916307",
"0.49074984",
"0.49004507",
"0.49004263",
"0.48951253",
"0.4891336",
"0.48888716",
"0.4884183",
"0.488244",
"0.4880798",
"0.48734388",
"0.48695868",
"0.48680097",
"0.48554036",
"0.48554036",
"0.484207",
"0.48314",
"0.48262495",
"0.4822475",
"0.48172677",
"0.48090842",
"0.48087817",
"0.48087367",
"0.47993258",
"0.47967482",
"0.47928357",
"0.47860196",
"0.4780953",
"0.4779607",
"0.4772613",
"0.4772613",
"0.4767913",
"0.47621948",
"0.47583446"
] |
0.7770543
|
0
|
(GET) Usage: FundAmerica::Entity.child_entities Output: Returns child entities of an entity
|
def child_entities(entity_id)
API::request(:get, "entities/#{entity_id}/child_entities")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def children\n \n TapirLogger.instance.log \"Finding children for #{self}\"\n children = []\n EntityMapping.all.each do |mapping| \n\n # Go through each associated entity mapping, and find mappings where the parent_id is us\n # which means that the child_id is some other entity, and it's a child\n \n # the to_s is important, otherwise self.id returns a :Moped::BSON::ObjectID\n children << mapping.get_child if mapping.parent_id == self.id.to_s\n\n # TODO - what happens if parent_id and child_id are the same. We'll\n # end up grabbing it. Could that break any assumptions?\n end\n \n children\n end",
"def children(entity)\n self.all(:parent_id => entity.id)\n end",
"def relationships_as_child(entity_id)\n API::request(:get, \"entities/#{entity_id}/relationships_as_child\")\n end",
"def children()\n #Ressource.filter(:parent_id => self.id, :parent_service_id => self.service_id).all\n end",
"def descendents\n\n\t\t #children.preload(:parent).each do |child| child.descendents end\n\t\t children.each do |child|\n\t [child] + child.descendents\n\t end\n end",
"def children(max_distance=@default_distance)\n @children[0] = [@entity] if @children[0].empty?\n add_relatives(@children,1,max_distance,:children)\n @children\n end",
"def children\n EarLogger.instance.log \"Finding children for #{self}\"\n ObjectManager.instance.find_children(self.id, self.class.to_s)\n end",
"def children\n return [] if child_count <= 0\n with_cache(:children) do\n @od.request(\"#{api_path}/children?$top=1000\")['value'].map do |child|\n OneDriveItem.smart_new(@od, child)\n end\n end\n end",
"def children\n attributes.fetch(:children)\n end",
"def children\n entries\n end",
"def children\n kids = []\n each_child { |kid| kids << kid }\n kids\n end",
"def children_get()\n @children\n end",
"def children\n _children\n end",
"def children\n self.class.find(:all, \n :select => \"a.*\",\n :joins => \"a join #{self.class.bridge_class.table_name} b on a.id = b.#{self.class.parent_foreign_key}\", \n :conditions => [\"b.#{self.class.child_foreign_key} = ? and b.#{self.class.levels_from_parent} = 1\", self.id])\n end",
"def children \n\t\t_c = Children.joins(:families).where(:families => {:parent_id => id} )\n\t\tif _c.present?\n\t\t\t_c\n\t\telse\n\t\t\tnil\n\t\tend\n\tend",
"def get_children( node=self )\n sql = <<-SQL\n select\n subject_term.identifier as child_identifier,\n subject_term.term_name as child_term,\n predicate_term.term_name as relation,\n object_term.identifier as parent_identifier,\n object_term.term_name as parent_term\n from\n term_relationship tr\n join term as subject_term on tr.subject_term_pk = subject_term.term_pk\n join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk\n join term as object_term on tr.object_term_pk = object_term.term_pk\n where\n predicate_term.term_name in ('part_of','is_a','develops_from')\n and object_term.identifier = ?\n SQL\n \n OLS_DB[sql,node.term].each do |row|\n child = OntologyTerm.new( row[:child_identifier], row[:child_term] )\n node << child\n end\n end",
"def children\n @resource.children\n end",
"def get_children\n return children\n end",
"def children\n children_tree.values\n end",
"def children\n children_tree.values\n end",
"def all_children\n find_all_children_with_dotted_ids\n end",
"def children\n @children\n end",
"def children\n @children\n end",
"def get_childs\n childs = Category.any_in(parent_ids: [parent.id])\n\n results = Array.new\n childs.each do |child|\n results << child\n end\n\n results\n end",
"def get_children\n return @children\n end",
"def get_children\n @children\n end",
"def hierarchy_descendants(entity)\n ret = []\n arr = entity.children\n return arr if arr.empty?\n ret << arr\n arr.each {|child_item|\n ret << self.hierarchy_descendants(child_item) unless child_item.nil? \n }\n ret.flatten.compact\n end",
"def children\n result = []\n @children.each do |_, child_group|\n result.concat(child_group)\n end\n\n result\n end",
"def parent_entities(entity_id)\n API::request(:get, \"entities/#{entity_id}/parent_entities\")\n end",
"def get_children(args = '', output = :OBJECT)\n kids = {}\n if args.blank?\n if $GLOBALS['post']\n args = { post_parent: $GLOBALS['post'].post_parent }\n else\n return kids\n end\n elsif args.is_a? Integer\n args = { post_parent: args}\n elsif args.is_a? String\n args = { post_parent: args.to_i}\n elsif args.is_a? Railspress::WpPost\n args = { post_parent: args.post_parent }\n end\n\n defaults = {\n numberposts: -1,\n post_type: 'any',\n post_status: 'any',\n post_parent: 0,\n }\n\n r = defaults.merge args\n\n children = get_posts(r)\n\n return kids if children.nil?\n\n return children unless r[:fields].blank?\n\n # update_post_cache(children)\n\n children.each do |child|\n kids[child.id] = child\n end\n\n if output == :OBJECT\n kids\n elsif output == :ARRAY_A\n weeuns = {}\n kids.values.each do |kid|\n weeuns[kid.id] = kid.attributes\n end\n return weeuns\n elsif output == :ARRAY_N\n babes = {}\n kids.values.each do |kid|\n babes[kid.id] = kid.attributes.values\n end\n return babes\n else\n kids\n end\n end",
"def children\n unless defined? @children\n @children = Array.new\n end\n return @children\n end",
"def get_entities_for_context( parent_context = nil )\n if parent_context.instance_of?( V3::ContextDAO )# Context specified? Return its entity list:\n parent_context.entity_list.values\n else # Let's do a \"manual\" search among the entities:\n # [Steve, 20150805] This check allows, so far, to have \"root entities\" laying around,\n # waiting to be fetched. 'Still don't know if it's a really useful feature at all...\n @entity_list.values.map do |entity|\n entity if entity.parent_context == parent_context\n end.compact\n end\n end",
"def find_child_entries_for(givendate,userid,parent)\n @entries = Entry.find_all_current_entries(givendate,userid)\n @otherChildentries = []\n \n @ancestors = []\n \n if parent != 0 then \n parentid = parent\n while parentid != nil\n @ancestors << parentid\n parent = Entry.find_by_id(parentid)\n parentid = parent.parent_id\n end\n end\n @entries.each do |e|\n if e.id != id && !isAncestor(@ancestors,e.id) then\n @otherChildentries << e\n end \n #@otherChildentries << e unless e.id == id || isAncestor(@ancestors)\n end\n \n return @otherChildentries\n end",
"def child_ids\n\n children.collect { |cfei| Ruote.extract_child_id(cfei) }\n end",
"def children\n dataset.nested.filter(self.class.qualified_parent_column => self.id)\n end",
"def children\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND #{acts_as_nested_set_options[:parent_column]} = #{self.id}\", :order => acts_as_nested_set_options[:left_column])\n end",
"def children(*args)\n self.class.send(:with_scope, :find=>{:conditions=>['parent_node_id=?', self.child_node_id]}) do\n self.class.find(:all, *args)\n end\n end",
"def get_entities(klass, parent_id, params={})\n path = path_with_params(\n \"get_#{klass.basename}s/#{parent_id}\", params)\n\n return client.get(path).map do |data|\n klass.new(data)\n end\n end",
"def children()\r\n raise \"get_children is not implemented for class #{self.class}\"\r\n end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def children; end",
"def _children\n @children\n end",
"def get_children\n \t@children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def children\n\t@child = Child.find(params[:id])\n\t@parents = @child.parents.all\n\trespond_to do |format|\n\t\tformat.js { }\n\tend\n end",
"def children\n raise NotImplementedError\n end",
"def children\n parent_id = params['parent_id']\n\n children = Child.includes(:bursts).where(parent_id: parent_id).map{ |child|\n last_burst = child.bursts.last\n burst_rate = last_burst.present? ? calc_burst_rate(last_burst) : 0\n\n {\n id: child.id,\n name: child.name,\n burst_rate: burst_rate\n }\n }\n\n render json: children\n end",
"def child_ids(*args)\n return call_ancestry_method(:child_ids) if use_ancestry?\n\n Relationship.resource_pairs(child_rels(*args))\n end",
"def children\n self.class.where('? = ANY(parent_ids)', id.to_s)\n end",
"def children(*args)\n return call_ancestry_method(:children) if use_ancestry?\n\n Relationship.resources(child_rels(*args))\n end",
"def children\n @children ||= []\n end",
"def children\n []\n end",
"def children\n []\n end",
"def children\n []\n end",
"def all_child_names\n get_all_child_lists\n return @all_child_names\n end",
"def getAllChildren\n children = Tree.where(\"tree_type_id = ? AND version_id = ? AND subject_id = ? AND grade_band_id = ? AND code like ?\", tree_type_id, version_id, subject_id, grade_band_id, code+'.%')\n Rails.logger.debug(\"*** tree children: #{children.inspect}\")\n return children\n end",
"def children\n @children ||= {}.with_indifferent_access\n end",
"def children\n []\n end",
"def children\n []\n end",
"def children\n []\n end",
"def all_activities_children\n @activity_children = ActivityChild.includes(:child)\n end",
"def get_childs\n access = Access.where(:parent_id=>id)\n childs=\"\"\n access.each do |item|\n if childs.empty?\n if item.get_childs.empty?\n childs=item.id.to_s\n else\n childs=item.id.to_s+\",\"+item.get_childs\n end\n else\n if item.get_childs.empty?\n childs= childs+\",\"+item.id.to_s\n else\n childs= childs+\",\"+item.id.to_s+\",\"+item.get_childs.to_s\n end\n end\n end\n return childs\n end",
"def children\n Array.new\n end",
"def children\n Feature.find(:all, :conditions => [ 'parent_id=?', self.id] )\n end",
"def all_child_terms\n get_all_child_lists\n return @all_child_terms\n end",
"def children\n self.class.children(self) \n end",
"def children\n render json: { status: 'ok', content: [] }\n end",
"def children\n @ref.children.to_ruby\n end",
"def children\n [] if leaf?\n self.class.where('forestify_left_position > ?', self.forestify_left_position).where('forestify_right_position < ?', self.forestify_right_position)\n end",
"def find_child_entries(givendate,userid)\n\t #@entries = Entry.find(:all, :conditions => [\"user_id=? and entries.end_dt_tm >= ? \", userid, givendate])\n\t @entries = Entry.find(:all, :include => [:entry_status], :conditions => [\"entries.user_id= ? and entry_statuses.ended = 0\", userid])\n\t @otherChildentries = []\n\n\t #Grab all the ancestors of this entry\n\t @ancestors = [] \n\t parentid = parent_id \n\t while parentid != nil\n\t @ancestors << parentid\n\t parent = Entry.find_by_id(parentid)\n\t parentid = parent.parent_id\n\t end\n\n\t #Store all entries except self and ancestors\n\t @entries.each do |e|\n\t if e.id != id && !isAncestor(@ancestors,e.id) && e[:type] != 'Goal' then\n\t @otherChildentries << e\n\t end \n\t #@otherChildentries << e unless e.id == id || isAncestor(@ancestors)\n end\n #Also make sure the selected child entries are present in the list if not already \n #Get already selected child entries\n selected_children = find_selected_childentries(userid)\n selected_children.each {|ce|\n if !isItemInList(@otherChildentries,ce) then\n @otherChildentries << ce\n end\n }\n return @otherChildentries\n end",
"def child_ids\n ids = [self.id]\n self.children.each do |child|\n ids += child.child_ids\n end\n ids\n end",
"def get_children(params)\n scope_data_class(params) do\n params[:limit] = config[:rows_per_page] if config[:enable_pagination] && (params[:id].nil? || params[:id] == 'root')\n params[:scope] = config[:scope]\n data_adapter.get_records(params, final_columns)\n end\n end",
"def get_all_child_lists\n child_check\n \n if @all_child_terms.nil? and @all_child_names.nil?\n @all_child_terms = []\n @all_child_names = []\n \n self.children.each do |child|\n @all_child_terms.push( child.term )\n @all_child_terms.push( child.all_child_terms )\n @all_child_names.push( child.term_name )\n @all_child_names.push( child.all_child_names )\n end\n \n @all_child_terms = @all_child_terms.flatten.uniq\n @all_child_names = @all_child_names.flatten.uniq\n end\n end",
"def children\n tree_search_class.where(tree_parent_id_field => self._id).sort(self.class.tree_sort_order()).all\n end",
"def children\n []\n end",
"def children\n ie = index_entry\n ie.children.collect{ |child| child.resource } if ie\n end",
"def children\n child_objects(Dependency)\n end",
"def children\n nested_set_class.find_with_nested_set_scope(:all, :conditions => \"#{nested_set_parent} = #{self.id}\", :order => nested_set_left)\n end",
"def children\n\t\treturn self.search( :one, '(objectClass=*)' )\n\tend",
"def children\n params[:scope] ||= \"private\"\n\n children = if params[:scope] == Scopes::SCOPE_PRIVATE\n @folder&.children ||\n current_user.nodes.where(parent_folder_id: nil)\n elsif params[:scope] == Scopes::SCOPE_PUBLIC\n @folder&.children ||\n Node.where(scope: params[:scope], parent_folder_id: nil)\n end\n\n if [Scopes::SCOPE_PRIVATE, Scopes::SCOPE_PUBLIC].include?(params[:scope])\n children = children.where.not(sti_type: \"Asset\")\n end\n\n children = children.where(scope: params[:scope]).order(:sti_type, :name)\n\n render json: children, root: \"nodes\", adapter: :json\n end",
"def children\n Children.new({\n cc_conditions: self.association( :cc_conditions),\n cc_loops: self.association( :cc_loops),\n cc_questions: self.association( :cc_questions),\n cc_sequences: self.association( :cc_sequences),\n cc_statements: self.association( :cc_statements)\n })\n end",
"def aws_ou_list_children(parent_id, parent_name)\n output = {}\n retries = 0\n\n @aws_org_client.list_children(\n child_type: 'ORGANIZATIONAL_UNIT',\n parent_id: parent_id,\n ).each do |response|\n response.children.each do |child|\n\n begin\n ou = @aws_org_client.describe_organizational_unit(\n organizational_unit_id: child.id,\n ).organizational_unit\n rescue Aws::Organizations::Errors::TooManyRequestsException\n # FIXME: - use logger\n puts 'AWS Organizations: too many requests. Retrying in 5 secs.'\n sleep 5\n retries += 1\n retry if retries < 10\n end\n\n ou_name = parent_name == :root ? ou.name.to_sym : \"#{parent_name}/#{ou.name}\".to_sym\n\n output[ou_name] = ou.id\n end\n end\n output\n end",
"def children(options={})\n @global_page.children.all options\n end",
"def flattened_entities\n results = []\n \n # Add this organization's entities\n entities.where(:type == 'Person').each do |e|\n results << e\n end\n\n # Add all children organization's entities\n child_organizations.all.each do |o|\n o.flattened_entities.each do |e|\n results << e\n end\n end\n\n # Only return a unique list\n results.uniq{ |x| x.id }\n end",
"def all_children\n @all_children ||= children + children.inject([]) {|records, child| records + child.all_children}\n end",
"def children\n @pages = @page.children\n \n respond_to do |format|\n format.json { render :json => @pages }\n format.xml { render :xml => @pages }\n end\n end"
] |
[
"0.765579",
"0.7173872",
"0.6570733",
"0.6468988",
"0.6445736",
"0.64158887",
"0.6405631",
"0.63433325",
"0.63402075",
"0.63110346",
"0.62899095",
"0.6242696",
"0.6242367",
"0.62389827",
"0.6235504",
"0.6229664",
"0.62037414",
"0.61976635",
"0.6181472",
"0.6181472",
"0.6171838",
"0.6166448",
"0.6166448",
"0.61278194",
"0.61261296",
"0.6122357",
"0.6110634",
"0.61050963",
"0.6089532",
"0.60888785",
"0.60883784",
"0.6079667",
"0.606715",
"0.60640466",
"0.6063105",
"0.60551316",
"0.60489404",
"0.60365945",
"0.60084397",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.6006248",
"0.59873927",
"0.598524",
"0.5972682",
"0.5972682",
"0.5972682",
"0.5972682",
"0.596965",
"0.5953995",
"0.5946996",
"0.59226",
"0.592223",
"0.59175265",
"0.5914666",
"0.5905294",
"0.58970356",
"0.58970356",
"0.58970356",
"0.58915234",
"0.58868796",
"0.588554",
"0.58789843",
"0.5878795",
"0.5878795",
"0.58731765",
"0.5866431",
"0.5866328",
"0.5863398",
"0.585536",
"0.5846874",
"0.58449775",
"0.5840945",
"0.58380675",
"0.58349556",
"0.58228743",
"0.58154845",
"0.5814159",
"0.580781",
"0.5769112",
"0.5764705",
"0.57547575",
"0.57480484",
"0.57358724",
"0.5735375",
"0.57335305",
"0.57320625",
"0.5730905",
"0.57304406",
"0.56981367",
"0.56846076"
] |
0.83970994
|
0
|
(GET) Usage: FundAmerica::Entity.parent_entities Output: Returns parent entities of an entity
|
def parent_entities(entity_id)
API::request(:get, "entities/#{entity_id}/parent_entities")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def parents\n\n TapirLogger.instance.log \"Finding parents for #{self}\"\n parents = []\n self.entity_mappings.each do |mapping|\n\n # Go through each associated entity mapping, and find mappings where the child_id is us \n # which means that the parent_id is some other entity, and it's a parent\n \n # the to_s is important, otherwise self.id returns a :Moped::BSON::ObjectId\n parents << mapping.get_parent if mapping.child_id == self.id.to_s \n\n # TODO - what happens if parent_id and child_id are the same. We'll\n # end up grabbing it. Could that break any assumptions?\n\n end\n parents\n end",
"def parents\n self.class.where(id: parent_ids)\n end",
"def get_parents\n return @parents\n end",
"def parents\n @parents ||= parent ? parent.parents + Array(parent) : []\n end",
"def relationships_as_parent(entity_id)\n API::request(:get, \"entities/#{entity_id}/relationships_as_parent\")\n end",
"def parents\n EarLogger.instance.log \"Finding parents for #{self}\"\n ObjectManager.instance.find_parents(self.id, self.class.to_s)\n end",
"def parents\n unless @parents\n @parents = []\n object = self\n while object.respond_to?(:parent) && object.parent\n @parents << object.parent\n object = object.parent\n end\n end\n @parents\n end",
"def parent_ids\n []\n end",
"def parents(max_distance=@default_distance)\n case @entity\n when Wiki::Category\n category_parents(max_distance)\n when Wiki::Article\n article_parents(max_distance)\n else\n raise ArgumentError.new(\"#{@entity} does not have parents in the context.\")\n end\n end",
"def get_parents( node=self )\n sql = <<-SQL\n select\n subject_term.identifier as child_identifier,\n subject_term.term_name as child_term,\n predicate_term.term_name as relation,\n object_term.identifier as parent_identifier,\n object_term.term_name as parent_term\n from\n term_relationship tr\n join term as subject_term \ton tr.subject_term_pk = subject_term.term_pk\n join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk\n join term as object_term on tr.object_term_pk = object_term.term_pk\n where\n predicate_term.term_name in ('part_of','is_a','develops_from')\n and subject_term.identifier = ?\n SQL\n \n OLS_DB[ sql, node.term ].each do |row|\n parent = OntologyTerm.new( row[:parent_identifier], row[:parent_term] )\n parent << node\n get_parents( parent )\n end\n end",
"def parents\n if parent.nil?\n [self]\n else\n parent.parents + [self]\n end\n end",
"def parent_list\n parents = []\n if @attributes.key?('parentCollectionList') then\n parents = DSpaceObj.convert_value(nil, @attributes['parentCollectionList'])\n end\n if @attributes['parentCommunity'] then\n com = DSpaceObj.convert_value(nil, @attributes['parentCommunity'])\n parents << com if com\n end\n if @attributes.key?('parentCommunityList') then\n list = DSpaceObj.convert_value(nil, @attributes['parentCommunityList'])\n parents += list if list\n end\n parents\n end",
"def parents(*args)\n find_parents(:all, *args)\n end",
"def parents; end",
"def find_all_parents\n end",
"def parents\n check_commit\n @parents \n end",
"def get_entities_for_context( parent_context = nil )\n if parent_context.instance_of?( V3::ContextDAO )# Context specified? Return its entity list:\n parent_context.entity_list.values\n else # Let's do a \"manual\" search among the entities:\n # [Steve, 20150805] This check allows, so far, to have \"root entities\" laying around,\n # waiting to be fetched. 'Still don't know if it's a really useful feature at all...\n @entity_list.values.map do |entity|\n entity if entity.parent_context == parent_context\n end.compact\n end\n end",
"def parents\n return Resource.joins(:resource_hierarchies).where(\"child_resource_id = ?\", self.id)\n end",
"def parents\n parse!\n @parents\n end",
"def parents\n page, parents = self, Array.new\n while page.parent\n page = page.parent\n parents << page\n end\n parents\n end",
"def ancestors\n if parent.nil?\n []\n else\n parent.ancestors + [parent]\n end\n end",
"def ancestors\n \tif parent_name.blank?\n\t \tancestors = [] \n \telse\n \t\tp = Category.where(name: parent_name).first\n \t\tancestors = p.ancestors\n \t\tancestors << parent_name\n \tend\n \tancestors\n end",
"def getAllParents\n parents = []\n parent = self.getParentRec\n self_code = self.code.split('.')\n self_code.pop(1)\n while self_code.length > 0 do\n puts \"self_code: #{self_code}\"\n if parent.present?\n parents << parent\n parent = parent.getParentRec\n self_code.pop(1)\n else\n parents << nil\n self_code.pop(1)\n parent = Tree.where(\n tree_type_id: self.tree_type_id,\n version_id: self.version_id,\n subject_id: self.subject_id,\n grade_band_id: self.grade_band_id,\n code: self_code.join(\".\")\n ).first\n end\n end\n Rails.logger.debug(\"*** tree parents: #{parents.inspect}\")\n return parents\n end",
"def living_parents\n dirstate.parents.select {|p| p != NULL_ID }\n end",
"def parents\n in_edges.each{|e| e.src}\n end",
"def ancestors\n parents = []\n\n this_parent = self.parent\n\n while this_parent != nil\n parents << this_parent\n this_parent = this_parent.parent\n end\n parents\n end",
"def parents\n @parents ||= begin\n p = @repo.dirstate.parents\n p = [p[0]] if p[1] == NULL_ID\n p.map {|x| Changeset.new(@repo, x) }\n end\n end",
"def all_parents\n parents(all: true)\n end",
"def parent_objects\n return [] if parents.empty?\n return @parent_objects if @parent_objects\n\n first = parent_models[0].find(parent_params[0])\n @parent_objects = [first]\n parent_params.zip(parents)[1..-1].inject(first) do |memo, arr|\n id, name = arr\n @parent_objects << memo.send(name.pluralize).find(id)\n end\n @parent_objects\n end",
"def parents\n respond_to?(:collectionHasParent) ? collectionHasParent : []\n end",
"def parents\n references\n end",
"def ancestors\n parents + parents.map(&:ancestors).flatten\n end",
"def ancestors\n itr = self\n res = []\n until itr.top_level?\n itr = itr.parents.first\n res << itr\n end\n res\n end",
"def hierarchy\n parents = []\n parent = self.parent\n\n while parent && !parent.parent_id.nil?\n parents << parent\n parent = parent.parent\n end\n\n return parents.reverse\n end",
"def parent_ids(*args)\n return Array.wrap(parent_id(*args)) if use_ancestry?\n\n Relationship.resource_pairs(parent_rels(*args))\n end",
"def parent_ids\n if ancestor_ids.empty? then\n nil\n else\n branches.map { |branch| cast_primary_key(branch.split('/').last) }\n end\n end",
"def ancestors \n \t\tres=parents\n \t\tparents.each {|c| res += c.ancestors}\n \t\treturn res.uniq\n \tend",
"def parent_rel_ids\n rel = relationships\n if rel.kind_of?(Array) || rel.try(:loaded?)\n rel.reject { |x| x.ancestry.blank? }.collect(&:parent_id)\n else\n rel.where.not(:ancestry => [nil, \"\"]).select(:ancestry).collect(&:parent_id)\n end\n end",
"def parentage\n get_parents unless @already_fetched_parents\n @already_fetched_parents = true\n super\n end",
"def parent_posts\n posts.find_all { |p| p.parent_post.nil? }\n end",
"def parent_resources\n @parent_resources ||= []\n end",
"def ancestors\n parent ? [parent, parent.ancestors].flatten : []\n end",
"def article_parents(max_distance)\n if @parents.include?(max_distance)\n return @parents\n end\n\n # direct parents\n regular = @entity.categories.to_a\n eponymous = @entity.eponymous_categories.flat_map{|c| c.parents.to_a }\n remote = @remote_context.relatives(@entity, :categories, Cyclopedio::Wiki::Category)\n @parents[1] = (regular + eponymous + remote).select { |c| c.regular? && c.plural? }\n\n add_relatives(@parents,2,max_distance,:parents){|r| r.eponymous_articles.flat_map{|a| a.categories.to_a } }\n @parents\n end",
"def child_entities(entity_id)\n API::request(:get, \"entities/#{entity_id}/child_entities\")\n end",
"def parents\n self.class.where('forestify_left_position < ?', self.forestify_left_position).where('forestify_right_position > ?', self.forestify_right_position)\n end",
"def get_parents\n parents=\"\"\n parent_id_aux= parent_id\n while parent_id_aux!=0\n access = Access.find(parent_id_aux)\n if parents.empty?\n parents = access.id.to_s\n else\n parents = parents+\",\"+access.id.to_s\n end\n parent_id_aux = access.parent_id\n end\n return parents\n end",
"def ancestors\n parent ? [parent, *parent.ancestors].reverse : []\n end",
"def ancestors\n []\n end",
"def parents(*args)\n Relationship.resources(parent_rels(*args))\n end",
"def lineage\n\t\tparents = []\n\t\tlist = self\n\t\twhile list.parentlist_id\n\t\t\tlist = List.find(list.parentlist_id)\n\t\t\tparents << list\n\t\tend\n\t\t\n\t\tif parents.length > 0\n \t\tparents.reverse!.slice(1..-1)\n else\n parents\n end\n end",
"def ancestors\n @ancestors ||= parent ? parent.ancestors + [parent] : []\n end",
"def parent_ids\n if ancestor_ids.empty? then\n []\n else\n branches.map { |branch| cast_primary_key(branch.split('/').last) }.uniq\n end\n end",
"def ancestors\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND (#{acts_as_nested_set_options[:left_column]} < #{self[acts_as_nested_set_options[:left_column]]} and #{acts_as_nested_set_options[:right_column]} > #{self[acts_as_nested_set_options[:right_column]]})\", :order => acts_as_nested_set_options[:left_column] )\n end",
"def ancestors_ids\n node, nodes = self, []\n while node.parent\n node = node.parent\n nodes << node.id\n end\n nodes\n end",
"def ancestors\n []\n end",
"def ancestors\n TreeNode.find(:all,\n :from => \"cms_treenode_ancestors(#{self.id}, #{AuthenticationModel.current_user}) tree_nodes\") rescue []\n end",
"def parents\n @parents || (parse! && @parents)\n end",
"def parent_association\n # needed for the show view\n @parent_object = parent_object\n parent_object.names\n end",
"def findParententries(givendate,userid)\n\t #entries = Entry.find(:all, :conditions => [\"user_id=? and entries.end_dt_tm >= ? \", userid, givendate])\n\t entries = Entry.find(:all, :include => [:entry_status], :conditions => [\"entries.user_id= ? and entry_statuses.ended = 0\", userid])\n\t #Also pull out the selected child entries if not already \n\t #Get already selected child entries\n\t selected_children = find_selected_childentries(userid)\n\n\t @otherentries = []\n\t foundCurrentParent = false\n\t entries.each do |e|\n\t if e.id != id && !isItemInList(selected_children,e) && e[:type] != 'Goal' then\n\t @otherentries << e\n\t if e.id == parent_id then\n\t\tfoundCurrentParent = true\n\t end\n\t end \n\t end\n\t #Even if the stored parent task has expired, pull it out for display\n\t if foundCurrentParent == false then\n\t parent = Entry.find(:first, :conditions => [\"user_id =? and entries.id = ?\", userid, parent_id])\n\t @otherentries << parent if parent != nil\n\t end\n\t return @otherentries\n end",
"def get_entities(klass, parent_id, params={})\n path = path_with_params(\n \"get_#{klass.basename}s/#{parent_id}\", params)\n\n return client.get(path).map do |data|\n klass.new(data)\n end\n end",
"def parents\n return @parents if !@parents.nil?\n @parents = []\n path_components = self.path.split('/')\n path_components.each_with_index do |path,i|\n parent_path = path_components[0,i].join('/')\n @parents.push(PhotoCollection.find_by_path(parent_path)) if parent_path != ''\n end\n @parents.reverse!\n end",
"def ancestors\n node_ancestors.map(&:ancestor)\n end",
"def parent_folders\n parent_feed = Internal::Utils.extract_links(data, 'up', 'application/atom+xml','type' => 'feed')\n unless parent_feed.empty?\n Collection.new(repository, parent_feed.first)\n else\n parent_entry = Internal::Utils.extract_links(data, 'up', 'application/atom+xml','type' => 'entry')\n unless parent_entry.empty?\n e = conn.get_atom_entry(parent_entry.first)\n [ActiveCMIS::Object.from_atom_entry(repository, e)]\n else\n []\n end\n end\n end",
"def parent\n parents.empty? ? nil : parents[0]\n end",
"def category_parents(max_distance)\n @parents[0] = [@entity] if @parents[0].empty?\n add_relatives(@parents,1,max_distance,:parents){|r| r.eponymous_articles.flat_map{|a| a.categories.to_a } }\n @parents\n end",
"def ancestors\n model_base_class.where(ancestor_conditions).order(:materialized_path)\n end",
"def find_parents(*args)\n self.class.send(:with_scope, :find=>{:conditions=>['child_node_id=?', self.parent_node_id]}) do\n self.class.find(*args)\n end\n end",
"def children\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND #{acts_as_nested_set_options[:parent_column]} = #{self.id}\", :order => acts_as_nested_set_options[:left_column])\n end",
"def parent_hierarchy\n [\n parentADM4,\n parentADM3,\n parentADM2,\n parentADM1,\n parentCountry\n ].reject(&:empty?)\n end",
"def parent_id\n object[\"parent_id\"]\n end",
"def parent\n map do |q|\n q.get_parent_element\n end\n end",
"def ancestors\n ancestors = []\n current_ancestor = self\n \n while !current_ancestor.nil?\n \n if current_ancestor.respond_to?(:parent)\n ancestors << current_ancestor\n current_ancestor = current_ancestor.parent\n else\n current_ancestor = nil\n end\n \n end\n \n ancestors\n end",
"def name_path_to_parent\n path = []\n p = parent\n while p do\n path.unshift p\n p = p.parent\n end\n path\n end",
"def resources_parents\n if @@resources_parents.length > 0\n @@resources_parents\n else\n analyze()\n end\n end",
"def get_parents\n parents = Array.new\n seen = Hash.new\n\n current = self.id\n \n while current\n role = Role.find(current)\n if role \n if not seen.has_key?(role.id)\n parents << role\n seen[role.id] = true\n current = role.parent_id\n else\n current = nil\n end\n else\n current = nil\n end\n end\n\n return parents\n end",
"def parents_and_self\n ret = []\n ret.concat(parent.parents_and_self) if parent\n ret << self\n ret\n end",
"def parent_list\n self.parent_lists[0]\n end",
"def ancestors\n end",
"def ancestors_r(*args)\n # fetch all parents\n pending = [self]\n ans = []\n while !pending.empty?\n e = pending.pop\n e.parents(*args).each do |p|\n if !ans.include?(p)\n ans << p\n pending.push(p)\n end\n end\n end\n ans\n end",
"def ancestors\n node, nodes = self, []\n nodes << node = node.parent while node.parent\n nodes\n end",
"def ancestors\n node, nodes = self, []\n nodes << node = node.parent while node.parent\n nodes\n end",
"def children(entity)\n self.all(:parent_id => entity.id)\n end",
"def ancestors_name\n if parent\n \"#{parent.ancestors_name} #{parent.name}:\"\n else\n \"\"\n end\n end",
"def ancestors\n node, nodes = self, []\n nodes << node = node.parent while node.parent\n nodes\n end",
"def parent_id(*args)\n return call_ancestry_method(:parent_id) if use_ancestry?\n\n rels = parent_ids(*args).take(2)\n raise _(\"Multiple parents found.\") if rels.length > 1\n rels.first\n end",
"def ancestors; end",
"def ancestors; end",
"def ancestors; end",
"def ancestors; end",
"def parents_and_self\n ret = []\n if self.parent\n ret.concat(self.parent.parents_and_self)\n end\n ret << self\n ret\n end",
"def parents_and_self\n ret = []\n if self.parent\n ret.concat(self.parent.parents_and_self)\n end\n ret << self\n ret\n end",
"def ancestors\n node, nodes = self, []\n nodes << node = node.parent while node.parent\n nodes\n end",
"def ancestors\n node, nodes = self, []\n nodes << node = node.parent while node.parent\n nodes\n end",
"def parent_association\n if params[:id].nil?\n return parent_object.all_parent_relations \n end\n # Gotta find it seperately, will get a recursive stack error elsewise\n o = FeatureRelation.find(params[:id])\n parent_object.id == o.parent_node.id ? parent_object.all_child_relations : parent_object.all_parent_relations\n end",
"def parent_categories\n c = self\n categories = []\n until c.parent.blank? do\n c = c.parent\n categories.unshift c\n end\n categories\n end",
"def self_and_parents\n p = [self]\n parent = self.parent \n \n while parent do\n p << parent\n parent = parent.parent \n end\n p\n end",
"def parent\n if parent_id.blank? then nil else unscoped_find(parent_id) end\n end",
"def ancestors() end",
"def children\n \n TapirLogger.instance.log \"Finding children for #{self}\"\n children = []\n EntityMapping.all.each do |mapping| \n\n # Go through each associated entity mapping, and find mappings where the parent_id is us\n # which means that the child_id is some other entity, and it's a child\n \n # the to_s is important, otherwise self.id returns a :Moped::BSON::ObjectID\n children << mapping.get_child if mapping.parent_id == self.id.to_s\n\n # TODO - what happens if parent_id and child_id are the same. We'll\n # end up grabbing it. Could that break any assumptions?\n end\n \n children\n end",
"def parents\n parent_objects(Dependency)\n end"
] |
[
"0.75979745",
"0.69744354",
"0.67214084",
"0.67011464",
"0.66702175",
"0.6664577",
"0.66317075",
"0.6625622",
"0.6621742",
"0.6619721",
"0.66195494",
"0.65879583",
"0.6553942",
"0.65360856",
"0.6527843",
"0.65220916",
"0.65112406",
"0.65030134",
"0.6486122",
"0.6484184",
"0.6478853",
"0.6454475",
"0.64464504",
"0.64310336",
"0.6417691",
"0.6408407",
"0.64053214",
"0.63871866",
"0.63827056",
"0.6378611",
"0.6376259",
"0.6361162",
"0.6347602",
"0.63388103",
"0.6336382",
"0.631771",
"0.63103116",
"0.6299253",
"0.6290861",
"0.6280723",
"0.62760186",
"0.6271448",
"0.6254371",
"0.6241384",
"0.62327224",
"0.62291366",
"0.6221968",
"0.6212167",
"0.6200202",
"0.6195114",
"0.61949337",
"0.6188775",
"0.6171688",
"0.6170362",
"0.61426216",
"0.61175525",
"0.6097573",
"0.6082102",
"0.6076114",
"0.60715955",
"0.60622954",
"0.605731",
"0.6054378",
"0.60493124",
"0.6046182",
"0.6035238",
"0.60340565",
"0.60296136",
"0.6028774",
"0.602808",
"0.6024227",
"0.60239",
"0.60194653",
"0.60119945",
"0.60056955",
"0.6005421",
"0.6004734",
"0.60034037",
"0.59909576",
"0.59747034",
"0.59747034",
"0.5972397",
"0.5970345",
"0.59631544",
"0.5959848",
"0.59576523",
"0.59576523",
"0.59576523",
"0.59576523",
"0.5953369",
"0.5953084",
"0.5946388",
"0.5946388",
"0.59398144",
"0.59309447",
"0.5930744",
"0.5924198",
"0.59184605",
"0.59166276",
"0.59163374"
] |
0.8341452
|
0
|
(GET) Usage: FundAmerica::Entity.relationships_as_child Output: Returns relationships_as_child details for entity
|
def relationships_as_child(entity_id)
API::request(:get, "entities/#{entity_id}/relationships_as_child")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def child_rels(*args)\n options = args.extract_options!\n rels = relationships.flat_map(&:children).uniq\n Relationship.filter_by_resource_type(rels, options)\n end",
"def child_ontology_relationships(options = {}) # :yields: Array of OntologyRelationships\n opt = {\n :relationship_type => 'all' # or a ObjectRelationships#id\n }.merge!(options.symbolize_keys)\n\n # TODO: modify to sort by first(top) label\n if opt[:relationship_type] == 'all'\n OntologyRelationship.find(:all, :include => [:ontology_class1, :object_relationship, :ontology_class2], :conditions => ['ontology_class2_id = ?', self.id]) # .sort{|x,y| x.ontology_class1.preferred_label.name <=> y.ontology_class1.preferred_label.name}\n else\n OntologyRelationship.find(:all, :include => [:ontology_class1, :object_relationship, :ontology_class2], :conditions => ['ontology_class2_id = ? AND object_relationship_id = ?', self.id, opt[:relationship_type]]) # .sort{|x,y| x.ontology_class1.preferred_label.name <=> y.ontology_class1.preferred_label.name}\n end\n end",
"def list_relationships\n end",
"def children(*args)\n return call_ancestry_method(:children) if use_ancestry?\n\n Relationship.resources(child_rels(*args))\n end",
"def relationships\n model.relationships(repository.name)\n end",
"def relationships_as_parent(entity_id)\n API::request(:get, \"entities/#{entity_id}/relationships_as_parent\")\n end",
"def child_ids(*args)\n return call_ancestry_method(:child_ids) if use_ancestry?\n\n Relationship.resource_pairs(child_rels(*args))\n end",
"def get_children( node=self )\n sql = <<-SQL\n select\n subject_term.identifier as child_identifier,\n subject_term.term_name as child_term,\n predicate_term.term_name as relation,\n object_term.identifier as parent_identifier,\n object_term.term_name as parent_term\n from\n term_relationship tr\n join term as subject_term on tr.subject_term_pk = subject_term.term_pk\n join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk\n join term as object_term on tr.object_term_pk = object_term.term_pk\n where\n predicate_term.term_name in ('part_of','is_a','develops_from')\n and object_term.identifier = ?\n SQL\n \n OLS_DB[sql,node.term].each do |row|\n child = OntologyTerm.new( row[:child_identifier], row[:child_term] )\n node << child\n end\n end",
"def relationship\n response[\"relationship\"]\n end",
"def children\n \n TapirLogger.instance.log \"Finding children for #{self}\"\n children = []\n EntityMapping.all.each do |mapping| \n\n # Go through each associated entity mapping, and find mappings where the parent_id is us\n # which means that the child_id is some other entity, and it's a child\n \n # the to_s is important, otherwise self.id returns a :Moped::BSON::ObjectID\n children << mapping.get_child if mapping.parent_id == self.id.to_s\n\n # TODO - what happens if parent_id and child_id are the same. We'll\n # end up grabbing it. Could that break any assumptions?\n end\n \n children\n end",
"def relationship\n relationship? ? children[1] : nil\n end",
"def relationships\n @relationships ||= {}\n end",
"def jsonapi_relationships\n\t\t\t\t\tjsonapi_model_class.reflect_on_all_associations.collect do |association|\n\t\t\t\t\t\t#type = nil\n\n\t\t\t\t\t\ttype = :to_one if [\n\t\t\t\t\t\t\tActiveRecord::Reflection::HasOneReflection, \n\t\t\t\t\t\t\tActiveRecord::Reflection::BelongsToReflection\n\t\t\t\t\t\t].include? association.class\n\n\t\t\t\t\t\ttype = :to_many if [\n\t\t\t\t\t\t\tActiveRecord::Reflection::HasManyReflection, \n\t\t\t\t\t\t\tActiveRecord::Reflection::HasAndBelongsToManyReflection\n\t\t\t\t\t\t].include? association.class\n\n\t\t\t\t\t\tnext unless type\n\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: association.name,\n\t\t\t\t\t\t\ttype: type,\n\t\t\t\t\t\t\treceiver: {\n\t\t\t\t\t\t\t\ttype: association.klass.to_s.underscore.pluralize.to_sym,\n\t\t\t\t\t\t\t\tclass: association.klass.to_s.constantize\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\tend.compact\n\t\t\t\tend",
"def children\n self.class.find(:all, \n :select => \"a.*\",\n :joins => \"a join #{self.class.bridge_class.table_name} b on a.id = b.#{self.class.parent_foreign_key}\", \n :conditions => [\"b.#{self.class.child_foreign_key} = ? and b.#{self.class.levels_from_parent} = 1\", self.id])\n end",
"def relationships\n @relationships ||= Relationship.from_associations(self, associations)\n end",
"def child_relation; end",
"def relationship_ancestry(*args)\n stringify_options = args.extract_options!\n options = stringify_options.slice!(:field_delimiter, :record_delimiter, :exclude_class, :field_method, :include_self)\n\n include_self = stringify_options.delete(:include_self)\n field_method = stringify_options[:field_method] || :id\n\n meth = include_self ? :path : :ancestors\n meth = :\"#{meth.to_s.singularize}_ids\" if field_method == :id\n rels = send(meth, options)\n\n rels_meth = :\"stringify_#{field_method == :id ? \"resource_pairs\" : \"rels\"}\"\n Relationship.send(rels_meth, rels, stringify_options)\n end",
"def children()\n #Ressource.filter(:parent_id => self.id, :parent_service_id => self.service_id).all\n end",
"def children(entity)\n self.all(:parent_id => entity.id)\n end",
"def print_relationships\n result = []\n self.relationships.each do |elt|\n result << elt.name\n end\n result.sort.join(', ')\n end",
"def relationships\n return [] if empty?\n\n map { |table| Relationship.new(table, TABLE_R, \"../#{table.pn}\") }\n end",
"def enduring_relationships\n ['series_system_agent_record_ownership_relationship']\n end",
"def children\n @resource.children\n end",
"def list_relationships(entity_path, named = nil)\n path = entity_path.is_a?(CanonicalPath) ? entity_path : CanonicalPath.parse(entity_path)\n query_params = {\n sort: '__targetCp'\n }\n query_params[:named] = named unless named.nil?\n query = generate_query_params query_params\n ret = http_get(\"/path#{path}/relationships#{query}\")\n ret.map { |r| Relationship.new(r) }\n end",
"def descendant_rels(*args)\n options = args.extract_options!\n rels = relationships.flat_map(&:descendants).uniq\n Relationship.filter_by_resource_type(rels, options)\n end",
"def children\n attributes.fetch(:children)\n end",
"def model_relationships; end",
"def children\n properties \n end",
"def descendents\n\n\t\t #children.preload(:parent).each do |child| child.descendents end\n\t\t children.each do |child|\n\t [child] + child.descendents\n\t end\n end",
"def rels(node)\n @batch_inserter.getRelationships(node)\n end",
"def relationships\n return [] if empty?\n\n map { |pivot_table| Relationship.new(pivot_table, PIVOT_TABLE_R, \"../#{pivot_table.pn}\") }\n end",
"def descendants(*args)\n return call_ancestry_method(:descendants) if use_ancestry?\n\n Relationship.resources(descendant_rels(*args))\n end",
"def relationships\n @relationships.each do |k, v|\n if v.respond_to?(:uniq!)\n v.uniq!\n @relationships[k] = v.first if v.length == 1\n end\n end\n @relationships\n end",
"def child_entities(entity_id)\n API::request(:get, \"entities/#{entity_id}/child_entities\")\n end",
"def child_bridge(association_id, options = {})\n options[:class_name] ||= name.gsub(/Dimension$/, 'HierarchyBridge')\n options[:foreign_key] ||= \"parent_id\"\n has_many association_id, options\n @child_hierarchy_relationship = reflections[association_id]\n end",
"def get_children\n @children\n end",
"def children\n @ref.children.to_ruby\n end",
"def children\n @children\n end",
"def children\n @children\n end",
"def relationship_data\n data = @objects.try(:map) { |o| o.try(:relationship_data) }\n data.try(:compact!) || data\n end",
"def relationship\n return @relationship\n end",
"def is_childless?\n return call_ancestry_method(:is_childless?) if use_ancestry?\n\n relationships.all?(&:is_childless?)\n end",
"def children \n\t\t_c = Children.joins(:families).where(:families => {:parent_id => id} )\n\t\tif _c.present?\n\t\t\t_c\n\t\telse\n\t\t\tnil\n\t\tend\n\tend",
"def child_types(*args)\n Relationship.resource_types(child_rels(*args))\n end",
"def child\n return @links[:child]\n end",
"def gen_relationships\n @parser.relationships.each do |rel|\n through_str = ''\n lines = []\n if rel[:has_relationship]\n has_relationship = rel[:has_relationship].gsub(':', '..')\n case has_relationship\n when '1'\n rel_str = 'belongs_to'\n when 'n'\n rel_str = \"has n,\"\n else\n rel_str = \"has #{has_relationship},\"\n if rel[:through]\n through_str = \", :through => :#{rel[:through]}\"\n else\n through_str = \", :through => Resource\"\n end\n end\n \n if rel[:through]\n lines << \" has n, :#{rel[:through]}\"\n end\n line = \" #{rel_str} :#{rel[:variable]}#{through_str}\"\n line += \" # #{rel[:comment]}\" unless rel[:comment].empty?\n lines << line\n elsif rel[:relationship]\n lines << ' ' + rel[:relationship]\n end\n editor = ModelEditor.new(rel[:filename].snake_case)\n editor.insert(AFTER_PROPERTIES, lines)\n end\n end",
"def relationships\n return [] unless has_comments?\n\n comments.relationships\n end",
"def many_to_one_relationships\n relationships unless @relationships # needs to be initialized!\n @relationships.values.collect do |rels| rels.values end.flatten.select do |relationship| relationship.child_model == self end\n end",
"def relationships\n r = Relationships.new\n r << Relationship.new(cache_definition, PIVOT_TABLE_CACHE_DEFINITION_R, \"../#{cache_definition.pn}\")\n r\n end",
"def all_activities_children\n @activity_children = ActivityChild.includes(:child)\n end",
"def get_childs\n access = Access.where(:parent_id=>id)\n childs=\"\"\n access.each do |item|\n if childs.empty?\n if item.get_childs.empty?\n childs=item.id.to_s\n else\n childs=item.id.to_s+\",\"+item.get_childs\n end\n else\n if item.get_childs.empty?\n childs= childs+\",\"+item.id.to_s\n else\n childs= childs+\",\"+item.id.to_s+\",\"+item.get_childs.to_s\n end\n end\n end\n return childs\n end",
"def children\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND #{acts_as_nested_set_options[:parent_column]} = #{self.id}\", :order => acts_as_nested_set_options[:left_column])\n end",
"def my_relationships(name)\n self.class.find_relationship(name).find_by_participant(self)\n end",
"def get_children\n return children\n end",
"def relation_name\n fetch(:relation_name, :children)\n end",
"def descendant_rels_arranged(*args)\n options = args.extract_options!\n rel = relationship(:raise_on_multiple => true)\n return {} if rel.nil? # TODO: Should this return nil or init_relationship or Relationship.new in a Hash?\n Relationship.filter_by_resource_type(rel.descendants, options).arrange\n end",
"def children\n dataset.nested.filter(self.class.qualified_parent_column => self.id)\n end",
"def children\n child_objects(Dependency)\n end",
"def sibling_rels(*args)\n options = args.extract_options!\n rels = relationships.flat_map(&:siblings).uniq\n Relationship.filter_by_resource_type(rels, options)\n end",
"def get_children\n return @children\n end",
"def children_get()\n @children\n end",
"def children\n EarLogger.instance.log \"Finding children for #{self}\"\n ObjectManager.instance.find_children(self.id, self.class.to_s)\n end",
"def all_children\n find_all_children_with_dotted_ids\n end",
"def get_childs(recursive, ret_obj)\n\n return self.class.get_childs(self.id, recursive, ret_obj)\n end",
"def children\n _children\n end",
"def children\n\t@child = Child.find(params[:id])\n\t@parents = @child.parents.all\n\trespond_to do |format|\n\t\tformat.js { }\n\tend\n end",
"def rels\n @traversal_result = :rels\n self\n end",
"def siblings(*args)\n return call_ancestry_method(:siblings) if use_ancestry?\n\n Relationship.resources(sibling_rels(*args))\n end",
"def index\n respond_with Relationships.all\n end",
"def children\n Feature.find(:all, :conditions => [ 'parent_id=?', self.id] )\n end",
"def get_children\n \t@children\n end",
"def related_attrs\n relationship = flex_options[:relationship_name]\n send relationship\n end",
"def children\n self.class.children(self) \n end",
"def children(max_distance=@default_distance)\n @children[0] = [@entity] if @children[0].empty?\n add_relatives(@children,1,max_distance,:children)\n @children\n end",
"def descendant_ids(*args)\n return call_ancestry_method(:descendant_ids) if use_ancestry?\n\n Relationship.resource_pairs(descendant_rels(*args))\n end",
"def descendants\n children + children.map(&:children).flatten\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def _children\n @children\n end",
"def show_all_children_info\n descendants.map(&:to_s)\n end",
"def is_only_child?\n return call_ancestry_method(:is_only_child?) if use_ancestry?\n\n relationships.all?(&:is_only_child?)\n end",
"def get_relationship_by_id id\n headers = {\n 'Accept' => 'application/json; charset=UTF-8',\n }\n get_request 'relationship/' + id, headers\n end",
"def children\n entries\n end",
"def content_entries_with_relationships_to_hash\n [].tap do |updates|\n self.with_relationships.each do |(slug, content_entry)|\n changes = {}\n\n content_entry.content_type.fields.each do |field|\n case field.type.to_sym\n when :belongs_to\n if target_id = content_entry.dynamic_getter(field.name).try(:_id)\n changes[\"#{field.name}_id\"] = target_id\n end\n when :many_to_many\n target_ids = content_entry.dynamic_getter(field.name).map(&:_id).compact\n unless target_ids.empty?\n changes[\"#{field.name}_ids\"] = target_ids\n end\n end\n end\n\n updates << { _id: content_entry._id, slug: slug }.merge(changes)\n end\n end\n end",
"def js_flat_hash(options = {}) # :yield: String\n @opt = {\n :max_depth => 999,\n :depth => 0,\n :children => [],\n :relationship_type => 'all' # or an Isa#id\n }.merge!(options.symbolize_keys)\n @opt[:depth] = @opt[:depth] + 1\n if @opt[:depth] < @opt[:max_depth]\n self.child_ontology_relationships(@opt).each do |n|\n @opt[:children] << n\n n.ontology_class1.js_flat_hash(@opt)\n end\n end\n return @opt[:children]\n end",
"def children\n Brand.where(:parent => self.name).order('sort_order, name')\n end",
"def _children\n @children\n end",
"def children\n out_edges.each{|e| e.dest}\n end",
"def descendants\n children + children.map(&:descendants).flatten\n end",
"def relationships(*ids)\n perform_request_with_collection(:get, '/api/v1/accounts/relationships',\n array_param(:id, ids),\n Mastodon::Relationship)\n end",
"def children\n # return students\n return offerings\n end",
"def child_replies\n Reply.find_by_parent_id(self.id) \n end",
"def relations\n self.class.relations\n end",
"def children\n Children.new({\n cc_conditions: self.association( :cc_conditions),\n cc_loops: self.association( :cc_loops),\n cc_questions: self.association( :cc_questions),\n cc_sequences: self.association( :cc_sequences),\n cc_statements: self.association( :cc_statements)\n })\n end",
"def show\n @activity_children = @activity.activity_children.includes(:child)\n end",
"def get_children(h, n)\n rr = h[n[:id]]\n if !rr.nil?\n rr[:children]\n else\n []\n end\n end",
"def get_children(h, n)\n rr = h[n[:id]]\n if !rr.nil?\n rr[:children]\n else\n []\n end\n end",
"def _children\n @children\n end",
"def get_relations_referring_to_object(type, id)\n api_call_with_type(type, id, \"#{type}/#{id}/relations\")\n end"
] |
[
"0.68723017",
"0.67878765",
"0.67123616",
"0.66907215",
"0.6463459",
"0.64422923",
"0.6315922",
"0.6296345",
"0.6279918",
"0.62655675",
"0.62571764",
"0.6204106",
"0.61376524",
"0.6126914",
"0.6126365",
"0.6091054",
"0.6062718",
"0.6042653",
"0.6013718",
"0.60027623",
"0.6001775",
"0.5995425",
"0.5991565",
"0.5950293",
"0.5932044",
"0.5922832",
"0.5888667",
"0.5840799",
"0.5828602",
"0.58210397",
"0.58181494",
"0.58172864",
"0.58122945",
"0.58080757",
"0.579901",
"0.5789179",
"0.57702196",
"0.5699642",
"0.5699642",
"0.5688446",
"0.56749725",
"0.56636333",
"0.5659169",
"0.5653098",
"0.5646674",
"0.5645802",
"0.5637557",
"0.56308717",
"0.562681",
"0.5625919",
"0.5622792",
"0.55883735",
"0.55436814",
"0.55361545",
"0.5532115",
"0.5528059",
"0.55076253",
"0.55037695",
"0.5494592",
"0.5493329",
"0.54902166",
"0.54844207",
"0.5477669",
"0.54766655",
"0.5473849",
"0.5473193",
"0.5465953",
"0.5463628",
"0.5460138",
"0.5459886",
"0.5447994",
"0.54478025",
"0.5446412",
"0.5436268",
"0.5434432",
"0.5430151",
"0.54275334",
"0.54275334",
"0.54275334",
"0.54275334",
"0.5426141",
"0.5421526",
"0.54005796",
"0.5398352",
"0.5386462",
"0.5373438",
"0.535835",
"0.53568625",
"0.53546304",
"0.53473943",
"0.5346429",
"0.5337359",
"0.53341305",
"0.53329265",
"0.53300637",
"0.5317724",
"0.5309238",
"0.5309238",
"0.5308886",
"0.5304194"
] |
0.82127106
|
0
|
(GET) Usage: FundAmerica::Entity.relationships_as_parent Output: Returns relationships_as_parent details for entity
|
def relationships_as_parent(entity_id)
API::request(:get, "entities/#{entity_id}/relationships_as_parent")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def relationships_as_child(entity_id)\n API::request(:get, \"entities/#{entity_id}/relationships_as_child\")\n end",
"def relation_to_parent\n _response_word.fetch(\"relationToParent\", nil)\n end",
"def parent_association\n @parent_object=parent_object # ResourceController normally sets this\n if params[:id].nil?\n return parent_object.all_parent_relations \n end\n # Gotta find it seperately, will get a recursive stack error elsewise\n o = FeatureRelation.find(params[:id])\n parent_object.id == o.parent_node.id ? parent_object.all_child_relations : parent_object.all_parent_relations\n end",
"def parent_association\n if params[:id].nil?\n return parent_object.all_parent_relations \n end\n # Gotta find it seperately, will get a recursive stack error elsewise\n o = FeatureRelation.find(params[:id])\n parent_object.id == o.parent_node.id ? parent_object.all_child_relations : parent_object.all_parent_relations\n end",
"def parent_rels(*args)\n options = args.extract_options!\n pri = parent_rel_ids\n rels = pri.kind_of?(Array) && pri.empty? ? Relationship.none : Relationship.where(:id => pri)\n Relationship.filter_by_resource_type(rels, options)\n end",
"def relationship_ancestry(*args)\n stringify_options = args.extract_options!\n options = stringify_options.slice!(:field_delimiter, :record_delimiter, :exclude_class, :field_method, :include_self)\n\n include_self = stringify_options.delete(:include_self)\n field_method = stringify_options[:field_method] || :id\n\n meth = include_self ? :path : :ancestors\n meth = :\"#{meth.to_s.singularize}_ids\" if field_method == :id\n rels = send(meth, options)\n\n rels_meth = :\"stringify_#{field_method == :id ? \"resource_pairs\" : \"rels\"}\"\n Relationship.send(rels_meth, rels, stringify_options)\n end",
"def parents(*args)\n Relationship.resources(parent_rels(*args))\n end",
"def parent_ids(*args)\n return Array.wrap(parent_id(*args)) if use_ancestry?\n\n Relationship.resource_pairs(parent_rels(*args))\n end",
"def relationship\n relationship? ? children[1] : nil\n end",
"def parents\n return Resource.joins(:resource_hierarchies).where(\"child_resource_id = ?\", self.id)\n end",
"def get_parents( node=self )\n sql = <<-SQL\n select\n subject_term.identifier as child_identifier,\n subject_term.term_name as child_term,\n predicate_term.term_name as relation,\n object_term.identifier as parent_identifier,\n object_term.term_name as parent_term\n from\n term_relationship tr\n join term as subject_term \ton tr.subject_term_pk = subject_term.term_pk\n join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk\n join term as object_term on tr.object_term_pk = object_term.term_pk\n where\n predicate_term.term_name in ('part_of','is_a','develops_from')\n and subject_term.identifier = ?\n SQL\n \n OLS_DB[ sql, node.term ].each do |row|\n parent = OntologyTerm.new( row[:parent_identifier], row[:parent_term] )\n parent << node\n get_parents( parent )\n end\n end",
"def parent_association\n # needed for the show view\n @parent_object = parent_object\n parent_object.names\n end",
"def relationship\n response[\"relationship\"]\n end",
"def parent_rel_ids\n rel = relationships\n if rel.kind_of?(Array) || rel.try(:loaded?)\n rel.reject { |x| x.ancestry.blank? }.collect(&:parent_id)\n else\n rel.where.not(:ancestry => [nil, \"\"]).select(:ancestry).collect(&:parent_id)\n end\n end",
"def relationships\n model.relationships(repository.name)\n end",
"def parent(*args)\n return call_ancestry_method(:parent) if use_ancestry?\n\n rels = parent_rels(*args).take(2)\n raise _(\"Multiple parents found.\") if rels.length > 1\n rels.first.try(:resource)\n end",
"def child_ontology_relationships(options = {}) # :yields: Array of OntologyRelationships\n opt = {\n :relationship_type => 'all' # or a ObjectRelationships#id\n }.merge!(options.symbolize_keys)\n\n # TODO: modify to sort by first(top) label\n if opt[:relationship_type] == 'all'\n OntologyRelationship.find(:all, :include => [:ontology_class1, :object_relationship, :ontology_class2], :conditions => ['ontology_class2_id = ?', self.id]) # .sort{|x,y| x.ontology_class1.preferred_label.name <=> y.ontology_class1.preferred_label.name}\n else\n OntologyRelationship.find(:all, :include => [:ontology_class1, :object_relationship, :ontology_class2], :conditions => ['ontology_class2_id = ? AND object_relationship_id = ?', self.id, opt[:relationship_type]]) # .sort{|x,y| x.ontology_class1.preferred_label.name <=> y.ontology_class1.preferred_label.name}\n end\n end",
"def parents\n\n TapirLogger.instance.log \"Finding parents for #{self}\"\n parents = []\n self.entity_mappings.each do |mapping|\n\n # Go through each associated entity mapping, and find mappings where the child_id is us \n # which means that the parent_id is some other entity, and it's a parent\n \n # the to_s is important, otherwise self.id returns a :Moped::BSON::ObjectId\n parents << mapping.get_parent if mapping.child_id == self.id.to_s \n\n # TODO - what happens if parent_id and child_id are the same. We'll\n # end up grabbing it. Could that break any assumptions?\n\n end\n parents\n end",
"def parent_id\n object[\"parent_id\"]\n end",
"def list_relationships\n end",
"def relationship\n return @relationship\n end",
"def parent_entities(entity_id)\n API::request(:get, \"entities/#{entity_id}/parent_entities\")\n end",
"def relationships\n @relationships ||= {}\n end",
"def parent_rel(*args)\n rels = parent_rels(*args).take(2)\n raise _(\"Multiple parents found.\") if rels.length > 1\n rels.first\n end",
"def parent_foreign_key\n @parent_hierarchy_relationship.foreign_key\n end",
"def parents\n references\n end",
"def parents\n EarLogger.instance.log \"Finding parents for #{self}\"\n ObjectManager.instance.find_parents(self.id, self.class.to_s)\n end",
"def parents\n if parent.nil?\n [self]\n else\n parent.parents + [self]\n end\n end",
"def parents; end",
"def relationships\n @relationships ||= Relationship.from_associations(self, associations)\n end",
"def parent\n @parent ||= resource.decorate.parent\n end",
"def parentage\n get_parents unless @already_fetched_parents\n @already_fetched_parents = true\n super\n end",
"def parent_path(options={})\n super_path(association_chain, options)\n end",
"def belongs_to_relations(ar_instance)\n\t\t\tcolumns = ar_instance.class.column_names\n\t\t\tparents = columns.map{ |c| c if c =~ /_id/ }.reject{ |c| c.nil? }\n\t\t\tparents.map!{ |parents| parents.gsub('_id', '') }\n\t\tend",
"def ancestor_rels(*args)\n options = args.extract_options!\n rel = relationship(:raise_on_multiple => true) # TODO: Handle multiple nodes with a way to detect which node you want\n rels = rel.nil? ? [] : rel.ancestors\n Relationship.filter_by_resource_type(rels, options)\n end",
"def get_parents\n return @parents\n end",
"def parents\n @parents ||= parent ? parent.parents + Array(parent) : []\n end",
"def parents\n unless @parents\n @parents = []\n object = self\n while object.respond_to?(:parent) && object.parent\n @parents << object.parent\n object = object.parent\n end\n end\n @parents\n end",
"def parents\n self.class.where(id: parent_ids)\n end",
"def parse_for_active_record_includes(resources:, parent_relationships: [])\n resources.each do |resource|\n if matches = resource.match(/^(?<relationship_name>.+?)\\.(?<nested_relationships>.+)$/)\n relationship_name = matches[:relationship_name].to_sym\n nested_relationships = matches[:nested_relationships]\n\n # To ensure that it won't return an Array with repeated relationships. e.g. [:foo, {foo: [:bar]}]\n parent_relationships.delete(relationship_name)\n\n current_relationships = find_hash_with_key(array: parent_relationships, key: relationship_name) if parent_relationships.any?\n\n if !current_relationships\n current_relationships = { relationship_name => [] }\n parent_relationships << current_relationships\n end\n\n parse_for_active_record_includes(resources: [nested_relationships], parent_relationships: current_relationships[relationship_name])\n else\n relationship_name = resource.to_sym\n unless find_hash_with_key(array: parent_relationships, key: relationship_name)\n parent_relationships << relationship_name\n end\n end\n end\n parent_relationships\n end",
"def parent\n object.try(:loaded)&.[](:parents)&.first || wayfinder.decorated_parent\n end",
"def all_parents\n parents(all: true)\n end",
"def self_and_parents\n p = [self]\n parent = self.parent \n \n while parent do\n p << parent\n parent = parent.parent \n end\n p\n end",
"def relationships\n return [] if empty?\n\n map { |pivot_table| Relationship.new(pivot_table, PIVOT_TABLE_R, \"../#{pivot_table.pn}\") }\n end",
"def parent_resource\n @parent_resource ||=\n begin\n return nil if resource.try(:imported_metadata).present?\n Wayfinder.for(resource).parent\n end\n end",
"def hierarchy\n parents = []\n parent = self.parent\n\n while parent && !parent.parent_id.nil?\n parents << parent\n parent = parent.parent\n end\n\n return parents.reverse\n end",
"def parents_and_self\n ret = []\n ret.concat(parent.parents_and_self) if parent\n ret << self\n ret\n end",
"def parent_bridge(association_id, options = {})\n options[:class_name] ||= name.gsub(/Dimension$/, 'HierarchyBridge')\n options[:foreign_key] ||= \"child_id\"\n has_many association_id, options\n @parent_hierarchy_relationship = reflections[association_id]\n end",
"def relationships\n return [] if empty?\n\n map { |table| Relationship.new(table, TABLE_R, \"../#{table.pn}\") }\n end",
"def parent\n self.class.find_by_id(self.parent_id) unless self.parent_id.nil?\n end",
"def model_relationships; end",
"def parent_list\n parents = []\n if @attributes.key?('parentCollectionList') then\n parents = DSpaceObj.convert_value(nil, @attributes['parentCollectionList'])\n end\n if @attributes['parentCommunity'] then\n com = DSpaceObj.convert_value(nil, @attributes['parentCommunity'])\n parents << com if com\n end\n if @attributes.key?('parentCommunityList') then\n list = DSpaceObj.convert_value(nil, @attributes['parentCommunityList'])\n parents += list if list\n end\n parents\n end",
"def get_parent_relation_keys(parent)\n parents = Array(parent)\n\n reflect_on_all_associations.inject([]) do |result, relation|\n result << relation.foreign_key if parents.include?(relation.name)\n\n result\n end\n end",
"def parent_resources\n @parent_resources ||= []\n end",
"def parents_and_self\n ret = []\n if self.parent\n ret.concat(self.parent.parents_and_self)\n end\n ret << self\n ret\n end",
"def parent_id\n self.parent._id.to_s\n end",
"def parents_and_self\n ret = []\n if self.parent\n ret.concat(self.parent.parents_and_self)\n end\n ret << self\n ret\n end",
"def ancestors(*args)\n return call_ancestry_method(:ancestors) if use_ancestry?\n\n Relationship.resources(ancestor_rels(*args))\n end",
"def parent\n if self.rep_parent.nil?\n if self.parent_id.nil?\n return nil\n else\n return Activity.find(self.parent_id)\n end\n\n else\n return self.rep_parent.parent\n end\n end",
"def parent_dependencies\n @parents\n end",
"def parent\n o = Object.const_get(parent_model) rescue nil\n o && o.get(parent_id)\n end",
"def parent\n return @links[:parent]\n end",
"def resource_has_parents?(resource, params)\n if !resource.persisted?\n params[:parent_id]\n else\n resource.decorate.respond_to?(:decorated_parent) && !resource.decorate.decorated_parent.nil?\n end\n end",
"def parents\n in_edges.each{|e| e.src}\n end",
"def jsonapi_relationships\n\t\t\t\t\tjsonapi_model_class.reflect_on_all_associations.collect do |association|\n\t\t\t\t\t\t#type = nil\n\n\t\t\t\t\t\ttype = :to_one if [\n\t\t\t\t\t\t\tActiveRecord::Reflection::HasOneReflection, \n\t\t\t\t\t\t\tActiveRecord::Reflection::BelongsToReflection\n\t\t\t\t\t\t].include? association.class\n\n\t\t\t\t\t\ttype = :to_many if [\n\t\t\t\t\t\t\tActiveRecord::Reflection::HasManyReflection, \n\t\t\t\t\t\t\tActiveRecord::Reflection::HasAndBelongsToManyReflection\n\t\t\t\t\t\t].include? association.class\n\n\t\t\t\t\t\tnext unless type\n\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: association.name,\n\t\t\t\t\t\t\ttype: type,\n\t\t\t\t\t\t\treceiver: {\n\t\t\t\t\t\t\t\ttype: association.klass.to_s.underscore.pluralize.to_sym,\n\t\t\t\t\t\t\t\tclass: association.klass.to_s.constantize\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\tend.compact\n\t\t\t\tend",
"def parent_id\n data[:parent_id]\n end",
"def relationships\n @relationships.each do |k, v|\n if v.respond_to?(:uniq!)\n v.uniq!\n @relationships[k] = v.first if v.length == 1\n end\n end\n @relationships\n end",
"def hierarchy\n p = self\n h = []\n while(p.parent != nil)\n h = [p] + h\n p = p.parent\n end\n h = [p] + h\n \n h\n end",
"def ultimate_parent # note: ultimate parent is self, not nil, if self has no parent...\n if parent_id.blank?\n self\n else\n parent.ultimate_parent\n end\n end",
"def parent_id(*args)\n return call_ancestry_method(:parent_id) if use_ancestry?\n\n rels = parent_ids(*args).take(2)\n raise _(\"Multiple parents found.\") if rels.length > 1\n rels.first\n end",
"def relationship_for_isolated_root\n Relationship.new(:resource => self)\n end",
"def parents(*args)\n find_parents(:all, *args)\n end",
"def name_path_to_parent\n path = []\n p = parent\n while p do\n path.unshift p\n p = p.parent\n end\n path\n end",
"def get_parents\n parents = Array.new\n seen = Hash.new\n\n current = self.id\n \n while current\n role = Role.find(current)\n if role \n if not seen.has_key?(role.id)\n parents << role\n seen[role.id] = true\n current = role.parent_id\n else\n current = nil\n end\n else\n current = nil\n end\n end\n\n return parents\n end",
"def relationships\n return [] unless has_comments?\n\n comments.relationships\n end",
"def query_parent_id\n @attributes[:query_parent_id]\n end",
"def parents(max_distance=@default_distance)\n case @entity\n when Wiki::Category\n category_parents(max_distance)\n when Wiki::Article\n article_parents(max_distance)\n else\n raise ArgumentError.new(\"#{@entity} does not have parents in the context.\")\n end\n end",
"def parents\n respond_to?(:collectionHasParent) ? collectionHasParent : []\n end",
"def get_parent\n return nil\n end",
"def get_parent_id()\n self.account_id\n end",
"def primary_records\n return following_relationships if is_following?\n\n follower_relationships\n end",
"def parent_object\n # hack by sean to allow permalink parents\n parent? && !parent_singleton? ? parent_model_find(parent_param) : nil\n end",
"def parent_reply\n Reply.find_by_id(self.parent_id)\n end",
"def parent\n @parent\n end",
"def parent\n @parent\n end",
"def node_join_parent(node, parent)\n node.parents << parent\n node.parents.uniq!\n end",
"def logical_relatives(options = {}) # :yields: {OntologyClass => implied_redundant_relationships ? true : false}\n return [] if !ObjectRelationship.find_by_interaction_and_proj_id('is_a', self.proj_id) || !ObjectRelationship.find_by_interaction_and_proj_id('part_of', self.proj_id)\n\n rel1 = Proj.find(self.proj_id).object_relationships.by_interaction('is_a').first.id\n rel2 = Proj.find(self.proj_id).object_relationships.by_interaction('part_of').first.id\n return [] if !rel1 || !rel2\n\n opt = {\n :direction => :children, # [:parents | :children]\n :rel1 => rel1,\n :rel2 => rel2\n }.merge!(options.symbolize_keys)\n\n return nil if ![:parents, :children].include?(opt[:direction])\n\n first_result = [] # all the part_of\n second_result = [] # part_of through is_a\n\n result = {}\n\n # Find/recurse the isa/part_of tree, this gets us a unique array of pertinent OntologyRelationships\n # that reflect OntologyClass relationships that are related by one of rel1 or rel2 at each inspection.\n rels = self.related_ontology_relationships(opt.merge(:relationship_type => [opt[:rel1], opt[:rel2]]))\n\n return {} if rels == nil\n\n # get all the part_of resuls, anything below and with a part_of, is part_of (since all others are is_a)\n to_nuke = [] # index of rels to delete before next itteration\n rels.each do |r|\n nuke = false # boolean check for delete\n if r.object_relationship_id == opt[:rel2]\n nuke = true\n if opt[:direction] == :parents\n first_result.push(r.ontology_class2)\n else\n first_result.push(r.ontology_class1)\n end\n end\n to_nuke.push(r) if nuke\n end\n\n # !! don't do uniq on first result\n\n # try to invoke some loop speedup by deleting values we don't need to loop through\n rels.delete_if{|r| to_nuke.include?(r)}\n rels.delete_if{|r| !r.object_relationship_id == opt[:rel1]} # we only need to deal with isas of rel1 now\n\n # for all of the part_of results also get the is_a children (or whatever rel2 -> rel1 relationship is)\n\n rels.each do |rel|\n first_result.uniq.each_with_index do |r,i|\n if opt[:direction] == :parents\n second_result.insert(-1, rel.ontology_class2) if (rel.ontology_class1 == r)\n else\n second_result.insert(-1, rel.ontology_class1) if (rel.ontology_class2 == r)\n end\n end\n end\n\n second_result.uniq! # don't imply redundancies from hitting an is_a twice (is this right?! - gives \"correct\" result AFAIKT)\n\n (first_result + second_result).each do |r|\n result.merge!(r => (!result.keys.include?(r) ? false : true))\n end\n\n result\n end",
"def parent_ids\n []\n end",
"def living_parents\n dirstate.parents.select {|p| p != NULL_ID }\n end",
"def find_all_parents\n end",
"def child_relation; end",
"def parent_name\n parent_info && parent_info.name\n end",
"def rest_parent_name\n self.class.rest_parent_name\n end",
"def child_rels(*args)\n options = args.extract_options!\n rels = relationships.flat_map(&:children).uniq\n Relationship.filter_by_resource_type(rels, options)\n end",
"def parents(res)\n # delete() returns nil when nothing was removed. so use delete_if instead.\n @graph.parents(Resource.id(res).hash).delete_if{|i| i == 0}.collect { |hashid| id2obj(hashid) }\n end",
"def init_relationship(parent_rel = nil)\n rel = relationship\n if rel.nil?\n rel = add_relationship(parent_rel)\n elsif !parent_rel.nil?\n rel.update_attribute(:parent, parent_rel)\n end\n rel\n end",
"def parents\n parse!\n @parents\n end",
"def parent\n tree.parent_for(parent_id).first\n end",
"def print_relationships\n result = []\n self.relationships.each do |elt|\n result << elt.name\n end\n result.sort.join(', ')\n end",
"def parents\n parent_objects(Dependency)\n end"
] |
[
"0.6867059",
"0.68645024",
"0.68537843",
"0.68079203",
"0.66850704",
"0.66231835",
"0.653668",
"0.63679206",
"0.63075554",
"0.6287161",
"0.6252998",
"0.62123406",
"0.62040347",
"0.61899227",
"0.6185197",
"0.6164521",
"0.61608934",
"0.60555655",
"0.60405403",
"0.60341173",
"0.5986714",
"0.59824455",
"0.5959814",
"0.5930858",
"0.5930514",
"0.5917021",
"0.5874234",
"0.5857728",
"0.58459216",
"0.5842212",
"0.58361363",
"0.58356285",
"0.5817324",
"0.58014315",
"0.57981324",
"0.5782591",
"0.5777019",
"0.57672894",
"0.5765567",
"0.5753952",
"0.5747941",
"0.5744089",
"0.5702538",
"0.5697139",
"0.569037",
"0.5680144",
"0.5678804",
"0.5673476",
"0.5672982",
"0.56684345",
"0.5652795",
"0.56514186",
"0.56477255",
"0.5636504",
"0.5631044",
"0.5630646",
"0.5630002",
"0.56234145",
"0.56212384",
"0.5619349",
"0.56158197",
"0.55909395",
"0.55893373",
"0.5588262",
"0.5584726",
"0.5580726",
"0.55785996",
"0.55699986",
"0.55630594",
"0.55522317",
"0.5551163",
"0.5550416",
"0.5536764",
"0.5535714",
"0.5524207",
"0.55151826",
"0.55130285",
"0.5508558",
"0.55069095",
"0.5506779",
"0.5494449",
"0.549421",
"0.54924965",
"0.54892033",
"0.54892033",
"0.5485253",
"0.5478093",
"0.54747784",
"0.5472791",
"0.54700243",
"0.5469873",
"0.5469654",
"0.54674405",
"0.54655504",
"0.545457",
"0.5447029",
"0.54425746",
"0.54424095",
"0.54323983",
"0.5430008"
] |
0.8172773
|
0
|
(GET) Usage: FundAmerica::Entity.investor_accreditation Output: Returns entity specific investor accreditation information
|
def investor_accreditation(entity_id)
API::request(:get, "entities/#{entity_id}/investor_accreditation")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n @accreditations = Accreditation.all\n end",
"def course_accreditations(institution, course, kismode, options={})\n self.class.get(\"/Institution/#{institution}/Course/#{course}/#{kismode}/Accreditation.json\", options).parsed_response\n end",
"def set_accreditation\n @accreditation = Accreditation.find(params[:id])\n end",
"def index\n @clinic_accreditations = ClinicAccreditation.all\n end",
"def show\n @accreditation = Accreditation.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @accreditation }\n end\n end",
"def investor_suitability_details(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_suitability\")\n end",
"def show\n @account_movement = @investor.account_movements.find(params[:id])\n authorize @account_movement\n end",
"def details(investor_payment_id)\n API::request(:get, \"investor_payments/#{investor_payment_id}\")\n end",
"def index\n @automated_transactions = current_airport.automated_transactions\n end",
"def accreditation_params\n params.require(:accreditation).permit(:ukprn, :pubukprn, :kiscourse, :accurl, :acctext, :acctype, :kismode, :accdepend, :accdependurl)\n end",
"def set_clinic_accreditation\n @clinic_accreditation = ClinicAccreditation.find(params[:id])\n end",
"def show\n @accident_assignee_expense = AccidentAssigneeExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @accident_assignee_expense }\n end\n end",
"def investor\n end",
"def index\n authorize AccountMovement\n #@account_movements = AccountMovement.all\n @account_movements = @investor.account_movements\n end",
"def index\n @company_investors = CompanyInvestor.all\n end",
"def index\n @accounts = current_user.companies.find(params[:company_id]).accounts\n if params[:fiscal_year_id].present?\n @fiscal_year = current_user.companies.find(params[:company_id]).fiscal_years.find(params[:fiscal_year_id])\n @accounts = @accounts.joins(:voucher_rows).joins(:vouchers).select(\"accounts.*, (coalesce(sum(voucher_rows.debit), 0) - coalesce(sum(voucher_rows.credit), 0)) AS sum\").where(\"fiscal_year_id = ?\", @fiscal_year.id).group(\"accounts.id\")\n end\n respond_to do |format|\n format.html \n format.json { render_with_protection @accounts }\n end\n end",
"def view\n\t\t\t@investor = Investor.find params[:id]\n\t\tend",
"def account_information\n puts \"Account Number: #%d\" % @account_number\n puts \"\\t- Checking Amount: $%d\" % @checking_amount \n puts \"\\t- Saving Amount: $%d\" % @saving_amount\n puts \"\\t- Total Amouunt: $%d\" % (@checking_amount + @saving_amount)\n puts \"\\t- interest Rate: %f%\" % @interest\n end",
"def account_information\n puts \"Account Number: #%d\" % @account_number\n puts \"\\t- Checking Amount: $%d\" % @checking_amount \n puts \"\\t- Saving Amount: $%d\" % @saving_amount\n puts \"\\t- Total Amouunt: $%d\" % (@checking_amount + @saving_amount)\n puts \"\\t- interest Rate: %f%\" % @interest\n end",
"def investor_payments(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_payments\")\n end",
"def index\n @incarnations = Incarnation.all\n end",
"def index\n @accommodation_charges = @company.accommodation_charges\n end",
"def investor_sector\n @investor = Investor.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @accreditation.update(accreditation_params)\n format.html { redirect_to @accreditation, notice: 'Accreditation was successfully updated.' }\n format.json { render :show, status: :ok, location: @accreditation }\n else\n format.html { render :edit }\n format.json { render json: @accreditation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @individual_company_investments = IndividualCompanyInvestment.all\n end",
"def index\n @fund_company_investments = FundCompanyInvestment.all\n end",
"def index\n @accounting_entries = AccountingEntry.all\n\n authorize AccountingEntry\n end",
"def index\n @incidents = current_user.incidents\n end",
"def show\n @ledger_entries = @invoice.ledger_entries.page(params[:page])\n respond_with @organization, @invoice\n end",
"def show\n authorize AccountingEntry\n end",
"def show\n @expense = current_user.organization.expenses.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @expense }\n end\n end",
"def update\n @accreditation = Accreditation.find(params[:id])\n\n respond_to do |format|\n if @accreditation.update_attributes(params[:accreditation])\n format.html { redirect_to @accreditation, notice: 'Accreditation was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @accreditation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @competences = Competence.all - @demand.competences\n @criterions = Criterion.all - @demand.criterions\n @explanations_props = { explanations: Explanation.to_react(@demand),\n demand: @demand.as_json(only: [ :id,\n :description,\n :name,\n :organization_profile_id ]),\n current_user: current_user.as_json(only: [ :id,\n :active_profile_id,\n :organization_account_id ]).merge({\"supplier\" => current_user.supplier?,\"customer\" => current_user.customer?}),\n # createExplanationPath: demand_explanations_path(@demand)\n }\n authorize @demand\n end",
"def investor(id:)\n Investor.find(id)\n end",
"def show\n authorize @expense_report\n end",
"def clinic_accreditation_params\n params.require(:clinic_accreditation).permit(:clinic_id, :accreditation_id)\n end",
"def set_investor\n @investor = ::Cap::Table::Investor.find(params[:id])\n end",
"def get(access_token)\n payload = { access_token: access_token }\n @client.post_with_auth('credit_details/get', payload)\n end",
"def show\n @operations = Operation.includes(:retrieve_account).where(retrieve_account:\n @analytic_account)\n @operations += Operation.includes(:release_account).where(release_account: @analytic_account)\n\n\n end",
"def expense_details\n if date_format_check\n filter_by_account, account_id = account_filter false\n\n if filter_by_account\n ft_joins = \"\" #[:finance_transaction_receipt_record]\n filter_conditions = \"AND finance_transaction_receipt_records.fee_account_id #{account_id == nil ? 'IS' : '='} ?\"\n filter_values = [account_id]\n else\n ft_joins = filter_values = []\n filter_conditions = \"\"\n end\n\n @expense_category = FinanceTransactionCategory.find(params[:id])\n\n if @expense_category.name == 'Refund'\n ft_joins = \"INNER JOIN fee_refunds fr ON fr.finance_transaction_id = finance_transactions.id\n INNER JOIN finance_fees ff ON ff.id = fr.finance_fee_id\n INNER JOIN finance_fee_collections ffc ON ffc.id = ff.fee_collection_id\n LEFT JOIN fee_accounts fa On fa.id = ffc.fee_account_id\"\n cond = \"(fa.id IS NULL OR fa.is_deleted = false) AND \"\n else\n cond = \"\"\n end\n\n @grand_total = @expense_category.finance_transactions.all(:select => \"finance_transactions.amount\",\n :joins => ft_joins, :conditions => [\"#{cond} transaction_date BETWEEN ? AND ? #{filter_conditions}\",\n @start_date, @end_date] + filter_values).map { |x| x.amount.to_f }.sum\n\n @expense = @expense_category.finance_transactions.all(:joins => ft_joins, :conditions =>\n [\"#{cond} transaction_date BETWEEN ? AND ? #{filter_conditions}\", @start_date, @end_date] + filter_values)\n end\n end",
"def actual_attestation_detail\n AttestationDetail.find_by_study_plan_id_and_attestation_term(id,\n Attestation.actual_for_faculty(index.student.faculty))\n end",
"def index\n # current_user.companies.\n @incidents = Incident.all\n end",
"def admin_for_companies\n get(\"/organizationalEntityAcls?q=roleAssignee&role=ADMINISTRATOR&state=APPROVED&count=100\")\n end",
"def depenses_accounts\n accounts.classe_6 \n end",
"def show\n @adjustment_account = AdjustmentAccount.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @adjustment_account }\n end\n end",
"def show\n @adjustment_account = AdjustmentAccount.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @adjustment_account }\n end\n end",
"def create\n @accreditation = Accreditation.new(accreditation_params)\n\n respond_to do |format|\n if @accreditation.save\n format.html { redirect_to @accreditation, notice: 'Accreditation was successfully created.' }\n format.json { render :show, status: :created, location: @accreditation }\n else\n format.html { render :new }\n format.json { render json: @accreditation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def investors\n relationships = self.investment_relationships\n users = []\n\n relationships.each do |relationship|\n users << relationship.investor_user\n end\n return users\n end",
"def show\n @reconciliation_detail = AccountingReconciliationDetail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @reconciliation_detail }\n end\n end",
"def ticket_airline(accounting_element)\n\t \taccounting_element[:airline][:@code]\n\t end",
"def show\n @tab_idx = params[:tab_idx] || 0\n @fdn_organization = Fdn::Organization.find(params[:id])\n #@pprs = Prs::PropertyRight.by_ent_id(@fdn_organization.resource_id)\n #if @fdn_organization.org_type_code == 'ENT'\n # @investors = Fdn::EntInvestor.where('org_id = ?', @fdn_organization.id).order(\"percentage DESC\")\n #end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @fdn_organization }\n end\n end",
"def index\n @_resources = client.credit_contracts.includes(:main_account, :current_account, credit: %i[currency credit_type])\n render layout: 'application_fluid'\n end",
"def index\n @accidentes = Accidente.all\n end",
"def show\n @accident_vehicle_expense = AccidentVehicleExpense.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @accident_vehicle_expense }\n end\n end",
"def index\n @investigations = Investigation.all\n end",
"def index\n @investigadores = Investigador.all\n end",
"def to_s\n \"Tax authority: #{@authority}\\n\" +\n \"-Sales Taxes: #{@sales_tax.to_i}% rate on all goods except #{exempt_basic}.\\n\" + \n \"-Import Duty: #{@import_duty.to_i}% rate on all imported goods.\"\n end",
"def list_payment_method\n authorize current_employer\n @payment_methods = current_employer.customers\n end",
"def index\n @investment_funds = InvestmentFund.all\n end",
"def accounts\n\n if params[:cost_ctr]\n # looks like something may have changed\n @cc = params[:cost_ctr]\n session[:cc] = params[:cost_ctr]\n end\n @cod_accounts = CodAccount.where(cost_ctr: session[:cc]).where(logistics_completed: true).where.not(accounting_completed: true)\n end",
"def find_account(account_descr, authorizer)\n unless account = OMF::SFA::Model::Account.first(account_descr)\n raise UnavailableResourceException.new \"Unknown account '#{account_descr.inspect}'\"\n end\n raise InsufficientPrivilegesException.new unless authorizer.can_view_account?(account)\n account\n end",
"def find_account(account_descr, authorizer)\n debug \"central find__account: '#{account_descr.inspect}'\"\n raise 'Method not implemented because the Central Manager just need to pass the same requisition to the other' \\\n ' brokers and create the concatenated results'\n end",
"def index\n @incrustations = Incrustation.all\n end",
"def index\n @carrera_investigacions = CarreraInvestigacion.all\n end",
"def profile\n \n if organization_account_signed_in?\n @organization_account = current_organization_account\n @organization = Organization.find(@organization_account.organization_id)\n @overall = 0\n @reviews = Review.where(:organization_id => @organization.id)\n if !(@reviews.count == 0)\n @reviews.each do |f|\n @overall = @overall + f.overall\n end\n @overall = @overall / @reviews.count\n end\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @organization_account }\n end\n else\n redirect_to root_path\n end\n end",
"def index\n @condition = {}\n @condition[:orgnization] = current_user.orginization unless current_user.orgnization == User::ORGS[0]\n @condition[:status] = params[:status] if params[:status] and AuthorityChangeRequest::STATUS.include? params[:status]\n @acrs = AuthorityChangeRequest.where @condition\n end",
"def create\n @accreditation = Accreditation.new(params[:accreditation])\n\n respond_to do |format|\n if @accreditation.save\n format.html { redirect_to @accreditation, notice: 'Accreditation was successfully created.' }\n format.json { render json: @accreditation, status: :created, location: @accreditation }\n else\n format.html { render action: \"new\" }\n format.json { render json: @accreditation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @investment = Investment.find(params[:id])\n end",
"def new\n @accreditation = Accreditation.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @accreditation }\n end\n end",
"def index\n @rec_expenses = RecExpense.all\n end",
"def index\n @enterprises = Enterprise.all\n end",
"def show\n @bank_reconciliations = AccountingBankReconciliations.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @bank_reconciliations }\n end\n end",
"def index\n @teleport_incenses = TeleportIncense.all\n end",
"def index\n @creditors = Creditor.all\n end",
"def index\n @investment_declaration = InvestmentDeclaration.new\n @investment_declarations = InvestmentDeclaration.all\n @policy_details = PolicyDetail.all\n @investment_declaration = InvestmentDeclaration.find(params[:investment_declaration_id])\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n @incomes = current_user.incomes\n end",
"def index\n @expenses = Expense.all\n # @assets = Asset.all\n @assets = current_user.assets\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @expenses }\n end\n end",
"def account\n @details ||= fetch_details\n @details[:account]\n end",
"def index\n @investors = params[:q].present? ? Investor.search(params[:q]) : Investor.all\n @investors = @investors.includes(:investment_group, :consultant).ordered.\n page(params[:page]).references(:investment_group, :consultant)\n end",
"def index\n @advances = user_capabilities(Advance).current_advances\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @advances }\n end\n end",
"def index\n @analytic_accounts = AnalyticAccount.all\n\n\n end",
"def index\n @entrepreneurs = Entrepreneur.all\n authorize Entrepreneur\n end",
"def income_details\n if date_format_check\n if params[:id].present?\n @income_category = FinanceTransactionCategory.find(params[:id])\n end\n @incomes = @income_category.finance_transactions.all(:include => :transaction_receipt,\n :joins => \"INNER JOIN finance_transaction_receipt_records ftrr ON ftrr.finance_transaction_id = finance_transactions.id\n LEFT JOIN fee_accounts fa ON fa.id = ftrr.fee_account_id\",\n :conditions => [\"(fa.id IS NULL OR fa.is_deleted = false) AND transaction_date BETWEEN '#{@start_date}' AND\n '#{@end_date}'\"])\n end\n end",
"def creditCardIndex\n render json: Approved.allCreditCard\n end",
"def index\n @expenses = Expense.includes(:place, :account, sub_category: :category).order('paid_at DESC').page(params[:page])\n end",
"def fetchAccountDetails(primaryMember)\n #,Unomy_Location_Country__c,Unomy_Location_State__c,Unomy_Location_City__c,Primary_Member__c,Interested_in_Number_of_Desks__c,BillingCountry,BillingState,BillingCity\n return checkRecordCreated(\"Account\", \"SELECT id,Allow_Merge__c,Name,Owner.Id,Owner.Name,RecordType.Name,Number_of_Full_Time_Employees__c,Interested_in_Number_of_Desks__c,Unomy_Location_Country__c,Unomy_Location_State__c,Unomy_Location_City__c,BillingCountry,BillingState,BillingCity FROM Account WHERE Primary_Member__c = '#{primaryMember}'\")\n end",
"def index\n @junior_enterprises = JuniorEnterprise.all\n end",
"def get_credit\n credit\n end",
"def claculate_credit_score(customer, claim)\n uri = URI.parse(\"https://api.inferentics.com/v1\")\n request = Net::HTTP::Post.new(uri)\n request.content_type = \"application/json\"\n request[\"Authorization\"] = \"Token test_1825b34257c8398b035c110edd03b0911353c0d5155f7ee5d3738467b6\"\n request.body = JSON.dump({\n \"exposure\" => claim.exposure,\n \"given_names\" => \"#{customer.given_names}\",\n \"surname\" => \"#{customer.surname}\",\n \"email\" => \"#{customer.email}\",\n \"phone_mobile\" => \"#{customer.phone_mobile}\",\n \"phone_home\" => \"#{customer.phone_home}\",\n \"dob\" => \"#{customer.dob}\",\n \"address\" => \"#{customer.address}\",\n \"employer_name\" => \"#{customer.employer_name}\",\n \"job_title\" => \"#{customer.job_title}\",\n \"device_type\" => \"#{customer.device_type}\",\n \"device_os\" => \"#{customer.device_os}\",\n \"device_model\" => \"#{customer.device_model}\",\n \"device_screen_resolution\" => \"#{customer.device_screen_resolution}\",\n \"network_service_provider\" => \"#{customer.network_service_provider}\",\n \"ip_address\" => \"#{customer.ip_location}\",\n \"time_zone\" => \"#{customer.time_zone}\",\n \"time_of_day\" => \"#{customer.time_of_day}\"\n })\n\n req_options = {\n use_ssl: uri.scheme == \"https\",\n }\n response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|\n http.request(request)\n end\n response.code\n response.body\n credit_score = JSON.parse(response.body)\n #business rules for approval and rejection\n if customer.update(credit_score: credit_score[\"result\"])\n if credit_score['result'].to_i >= 750\n claim.approved = true\n else\n claim.approved = false\n end\n return\n end\n end",
"def account_information\n\t\t\t{\n\t\t\t\tid: @id,\n\t\t\t\tchecking: @checking,\n\t\t\t\tsaving: @saving,\n\t\t\t\ttotal: combined_capital,\n\t\t\t\tinterest_rate: @interest_rates\n\t\t\t}\n\t\tend",
"def show\n @financial_transaction = FinancialTransaction.find(current_user, params[:id])\n @related_transactions = @financial_transaction.related_transactions.values\n end",
"def show\n @account = @user.account\n @transactions = @account.transactions\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def revenue_account_for_journal\n revenue_account\n end",
"def awaiting\n @accounts = current_user.agent_profile.get_awaiting_access_accounts\n\n respond_to do |format|\n format.html\n end\n end",
"def authority_information_access\n @authority_information_access ||= if (node = @node.at('AuthorityInformationAccess'))\n AuthorityInformationAccess.new(node)\n end\n end",
"def index_approvable\n @asset_info_adjustments = AssetInfoAdjustment.accessible_by(current_ability, :approve).search(params[:search]).page(params[:page])\n\n respond_to do |format|\n format.html { render \"index\" }\n format.json { render json: @asset_info_adjustments }\n format.xml { render xml: @asset_info_adjustments }\n end\n end",
"def show\n @accident_record = AccidentRecord.find(params[:id])\n end",
"def index\n @loanables = current_user.loanables.includes(:loan_contracts).all\n end"
] |
[
"0.6375594",
"0.631185",
"0.6070619",
"0.6020426",
"0.58813727",
"0.5757024",
"0.5688349",
"0.5610942",
"0.55743665",
"0.55384356",
"0.5400432",
"0.5380218",
"0.53247374",
"0.5320955",
"0.5313606",
"0.52836007",
"0.5274664",
"0.5230283",
"0.5230283",
"0.5218429",
"0.5217475",
"0.51960903",
"0.51951414",
"0.51934755",
"0.51895875",
"0.5182499",
"0.51817286",
"0.51772165",
"0.5166603",
"0.5160086",
"0.51502293",
"0.5143995",
"0.5140232",
"0.51385933",
"0.5131027",
"0.5110337",
"0.5098947",
"0.5095762",
"0.5078229",
"0.50743955",
"0.50631464",
"0.505582",
"0.50351983",
"0.50280285",
"0.50249827",
"0.50249827",
"0.50239044",
"0.5019963",
"0.5013668",
"0.5012991",
"0.4992301",
"0.49879947",
"0.49811754",
"0.49759737",
"0.49725997",
"0.49642542",
"0.4961786",
"0.4957867",
"0.49537313",
"0.49501845",
"0.4947986",
"0.4942515",
"0.49376464",
"0.49335095",
"0.49305767",
"0.49164563",
"0.49142456",
"0.4911735",
"0.49007133",
"0.49000794",
"0.48996317",
"0.48975465",
"0.48974735",
"0.48932174",
"0.489021",
"0.48878047",
"0.48878047",
"0.48840368",
"0.48836082",
"0.4883009",
"0.48816758",
"0.48758444",
"0.48712566",
"0.48661017",
"0.48648185",
"0.48606318",
"0.485653",
"0.4854622",
"0.48534796",
"0.4853358",
"0.48514423",
"0.48496976",
"0.48437688",
"0.48398212",
"0.48378053",
"0.4837001",
"0.48342472",
"0.48326015",
"0.48313007",
"0.48304924"
] |
0.8595916
|
0
|
(GET) Usage: FundAmerica::Entity.platform_investor Output: Returns entity specific platform_investor information Note: FA platform investor information will also be included with investor information
|
def platform_investor(entity_id )
API::request(:get, "entities/#{entity_id}/platform_investor")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def platform_details\n data[:platform_details]\n end",
"def platform\n data.platform\n end",
"def platform\n data[:platform]\n end",
"def platform\n @platform ||= data.platform\n end",
"def details(investor_payment_id)\n API::request(:get, \"investor_payments/#{investor_payment_id}\")\n end",
"def set_investor\n @investor = ::Cap::Table::Investor.find(params[:id])\n end",
"def platforms\n expose Metadata.platforms(@oauth_token)\n end",
"def os(platform: self.platform)\n platform = self.platform unless fetch_all('computer.platform').include?(platform)\n fetch(\"computer.os.#{platform.downcase}\")\n end",
"def platform_params\n params.require(:platform).permit(:company)\n end",
"def platform\n @attributes[:platform]\n end",
"def query_target_platform\n @attributes[:query_target_platform]\n end",
"def for(platform)\n case platform.to_s\n when 'amazon' then for_amazon\n when 'core_api' then for_core\n end\n end",
"def platform(platform_id)\n Platform.new(platform_id, client)\n end",
"def investor_guid\n \"#{investor_type.underscore}-#{investor_id}\"\n end",
"def investor_sector\n @investor = Investor.find(params[:id])\n end",
"def show\n @platforms = Platform.find(params[:id])\n end",
"def platform\n return @platform\n end",
"def actual_platform\n platform = nil\n\n if explicit_platform.nil? == false\n platform = explicit_platform\n elsif datastore['PLATFORM']\n platform = datastore['PLATFORM']\n elsif assoc_exploit\n platform = assoc_exploit.target_platform\n end\n\n # If we still have an invalid platform, then we suck.\n if platform.nil?\n raise NoCompatiblePayloadError, \"A platform could not be determined by the generic payload\"\n elsif platform.kind_of?(String)\n platform = Msf::Module::PlatformList.transform(platform)\n end\n\n return platform\n end",
"def platform\n @spec.platform\n end",
"def platform\n fetch('game.platform')\n end",
"def create(platform)\n @platform = Locomotive::Platform.new(platform)\n\n if @platform.save\n redirect resource(@platform), :message => {:notice => \"Platform was successfully created\"}\n else\n render :new\n end\n end",
"def platform_name\n capabilities['platformName']\n end",
"def platform_type\n return @platform_type\n end",
"def platform_type\n return @platform_type\n end",
"def show\n set_surrogate_key_header \"api/platforms/#{@platform.id}/projects\"\n set_cache_control_headers 3600\n end",
"def set_platform\n @platform = Platform.where(id: params[:id]).accessible_by(current_ability).take\n end",
"def set_company_investor\n @company_investor = CompanyInvestor.find(params[:id])\n end",
"def index\n @page_count, @platforms = Locomotive::Platform.paginated(:page => (params[:page] || 1).to_i)\n display @platforms\n end",
"def platforms\n get(\"project/platforms\")[\"platforms\"]\n end",
"def investor_payments(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_payments\")\n end",
"def get_platform\n rpc_get_fact_direct('kernel')\n end",
"def platform=(value)\n @platform = value\n end",
"def platform(platform = nil, options={})\n platform ? @platform = Platform.new(platform, options) : @platform\n end",
"def platform_name\n self.platform ? self.platform.name : NOT_SET\n end",
"def platform(platform_name)\n @platform_handlers.values.flatten.find { |known_platform| known_platform.name == platform_name }\n end",
"def platform_params\n params.require(:platform).permit(:description, :ident, :mission_id,\n :platform_server_id, :beacon_ids)\n end",
"def company_investor_params\n params.require(:company_investor).permit(:company_id, :investor_id, :status, :createdOn)\n end",
"def investor_suitability_details(entity_id)\n API::request(:get, \"entities/#{entity_id}/investor_suitability\")\n end",
"def platform\n Ohai.platform\n end",
"def value_for_platform(platform_hash)\n PlatformDependentValue.new(platform_hash).value_for_node(node)\n end",
"def platform\n @platform ||= NoPlatform.new\n end",
"def platform\n @root.attributes[\"pl\"].to_i\n end",
"def create\n @platform = Platform.new(platform_params)\n\n respond_to do |format|\n if @platform.save\n format.html { redirect_to [:admin, @platform], notice: 'Platform was successfully created.' }\n format.json { render action: 'show', status: :created, location: @platform }\n else\n format.html { render action: 'new' }\n format.json { render json: @platform.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def set_platform\n @platform = Platform.find(params[:id])\n end",
"def detect_platform()\r\n\t\tprint_status(\"Attempting to automatically detect the platform...\")\r\n\r\n\t\tpath = datastore['PATH'] + '/HtmlAdaptor?action=inspectMBean&name=jboss.system:type=ServerInfo'\r\n\t\tres = send_request_raw(\r\n\t\t\t{\r\n\t\t\t\t'uri' => path\r\n\t\t\t}, 20)\r\n\r\n\t\tif (not res) or (res.code != 200)\r\n\t\t\tprint_error(\"Failed: Error requesting #{path}\")\r\n\t\t\treturn nil\r\n\t\tend\r\n\r\n\t\tif (res.body =~ /<td.*?OSName.*?(Linux|Windows).*?<\\/td>/m)\r\n\t\t\tos = $1\r\n\t\t\tif (os =~ /Linux/i)\r\n\t\t\t\treturn 'linux'\r\n\t\t\telsif (os =~ /Windows/i)\r\n\t\t\t\treturn 'win'\r\n\t\t\tend\r\n\t\tend\r\n\t\tnil\r\n\tend",
"def switchToPlatform(platform)\n if @support_platforms.include?(platform) then\n @platform = platform\n else\n puts \"The given #{platform} platform not support.\"\n end\n end",
"def add_platform(platform)\n @platforms << platform\n end",
"def platform\n spec.platform\n end",
"def create\n @platform = Platform.new(platform_params)\n\n respond_to do |format|\n if @platform.save\n format.html { redirect_to :back, notice: 'Platform was successfully created.' }\n format.json { render action: 'show', status: :created, location: @platform }\n else\n format.html { render action: 'new' }\n format.json { render json: @platform.errors, status: :unprocessable_entity }\n end\n end\n end",
"def eval_platform\n if @platform == \"PC\"\n puts \"PC are great!\"\n else\n puts \"Your platform is probably underpowered.\"\n end\n end",
"def platform\n backend.platform\n end",
"def index\n @platforms = Platform.all\n end",
"def index\n @platforms = Platform.all\n end",
"def index\n @platforms = Platform.all\n end",
"def platform\n @_platform ||= self.context.platform\n end",
"def platform\n @_platform ||= self.context.platform\n end",
"def platform\n @_platform ||= self.context.platform\n end",
"def for_local(platform, capabilities_option, team_id = nil, udid = nil)\n capabilities = if platform.downcase == 'android'\n {\n 'platformName' => 'Android',\n 'automationName' => 'UiAutomator2',\n 'autoGrantPermissions' => 'true'\n }\n elsif platform.downcase == 'ios'\n {\n 'platformName' => 'iOS',\n 'automationName' => 'XCUITest',\n 'deviceName' => udid,\n 'xcodeOrgId' => team_id,\n 'xcodeSigningId' => 'iPhone Developer',\n 'udid' => udid\n }\n elsif platform.downcase == 'macos'\n {\n 'platformName' => 'Mac'\n }\n end\n common = {\n 'os' => platform,\n 'autoAcceptAlerts': 'true'\n }\n capabilities.merge! common\n capabilities.merge! JSON.parse(capabilities_option)\n end",
"def create\n @platform = Platform.new(platform_params)\n respond_to do |format|\n if @platform.save\n format.html { redirect_to manage_platforms_path, notice: 'platform was successfully created.' }\n format.json { render action: 'show', status: :created, location: @user }\n else\n format.html { render action: 'new' }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def investor\n end",
"def index\n @platforms = Platform.paginate(:page => params[:page], :per_page => 10).order('id DESC').accessible_by(current_ability)\n end",
"def create\n @company_investor = CompanyInvestor.new(company_investor_params)\n\n end",
"def show\n @platform = Platform.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @platform }\n end\n end",
"def platform\n fetch('device.platform')\n end",
"def platform\n kernel.platform\n end",
"def platform\n raise NotImplementedError\n end",
"def platform\n raise NotImplementedError\n end",
"def platform(*platforms)\n @current_platforms = platforms\n\n yield\n\n ensure\n @current_platforms = nil\n end",
"def target_platform\n (target and target.platform) ? target.platform : platform\n end",
"def platform_name; non_framework_platforms.first; end",
"def get_platform_use_over_depth(platforms, publications)\n require 'histogram/array'\n # Initialize series for raw data and histogram\n raw_platform_depths = {}\n histo_occurrences = {}\n platforms.each do |platform|\n raw_platform_depths[platform.description] = []\n histo_occurrences[platform.description] = []\n end\n raw_platform_depths[\"other\"] = []\n histo_occurrences[\"other\"] = []\n # Obtain min and max depth for each publication and transform into range\n publications.each do |publication|\n if publication.min_depth and publication.max_depth\n # Trim min and max depths to 30-200 m\n publication.min_depth < 30 ? min_depth = 30 : min_depth = publication.min_depth\n publication.max_depth > 150 ? max_depth = 150 : max_depth = publication.max_depth\n # Transform to ranges and add to each linked platform for that publication\n publication.platforms.each do |platform|\n if raw_platform_depths.key?(platform.description)\n raw_platform_depths[platform.description].push(*(min_depth..max_depth))\n else\n raw_platform_depths[\"other\"].push(*(min_depth..max_depth))\n end\n end\n end\n end\n # Define depth bins for histogram\n depth_bins = (30..150).step(1).map(&:to_i)\n categories = []\n raw_platform_depths.keys.each do |platform|\n categories, histo_occurrences[platform] = raw_platform_depths[platform].histogram(depth_bins,\n :bin_boundary => :avg)\n end\n return categories, histo_occurrences\n end",
"def what_platform\n if @platform == \"PC\"\n puts \"PC are Awesome!\"\n else\n puts \"This platform is inferior\"\n end\n end",
"def guest_platform\n node[:rightimage][:platform]\n end",
"def guest_platform\n node[:rightimage][:platform]\n end",
"def omnios_platform?(node = __getnode)\n node[\"platform\"] == \"omnios\"\n end",
"def update\n respond_to do |format|\n if @platform.update(platform_params)\n format.html { redirect_to @platform, notice: 'Platform was successfully updated.' }\n format.json { render :show, status: :ok, location: @platform }\n else\n format.html { render :edit }\n format.json { render json: @platform.errors, status: :unprocessable_entity }\n end\n end\n end",
"def assured_platform(purpose, name, config)\n platform_definition = config.platform_definition(name)\n assure(\"Requested #{purpose} platform '#{name}' is defined in 'platforms' YML\") { !platform_definition.nil? }\n platform_definition\nend",
"def platform_assistive_technology_params\n params.require(:platform_assistive_technology).permit(:platform_id, :assistive_technology_id)\n end",
"def show(id)\n @platform = Locomotive::Platform.get(id)\n raise NotFound unless @platform\n display @platform\n end",
"def update\n @platform.update(platform_params)\n if @platform.save\n redirect_to manage_platforms_path\n else\n render 'new'\n end\n end",
"def platform_for(node)\n @platforms_handler.known_platforms.find { |platform| platform.known_nodes.include?(node) }\n end",
"def platform_params\n params.require(:platform).permit(:user_id, :event_id)\n end",
"def platform\n System::get_property('platform')\n end",
"def new\n @platform = Platform.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @platform }\n end\n end",
"def platform_type=(value)\n @platform_type = value\n end",
"def platform_type=(value)\n @platform_type = value\n end",
"def get_platform(platform = nil)\n platform ||= RUBY_PLATFORM\n case platform\n when /darwin/ then :MACOS\n when /cygwin|mswin|mingw|bccwin|wince|emx/ then :WINDOWS\n else :LINUX\n end\n end",
"def yum_repo_platform_string\n platform = platform?('fedora') ? 'fedora' : 'rhel'\n release = platform?('amazon') ? '7' : '$releasever'\n \"#{platform}-#{release}-$basearch\"\n end",
"def platform=(platform)\n fail ArgumentError, \"unknown platform #{platform}\" \\\n unless Cisco::Util::PLATFORMS.include?(platform)\n @platform = platform\n end",
"def view\n\t\t\t@investor = Investor.find params[:id]\n\t\tend",
"def platform_params\n params.require(:platform).permit(:name, :version)\n end",
"def get_platform(host_os)\n return :osx if host_os =~ /darwin/\n return :linux if host_os =~ /linux/\n return :windows if host_os =~ /mingw32|mswin32/\n return :unknown\n end",
"def manage\n\t\t# Author\n\t\tauthorize! :manage, Project\n\n\t\t@investors = Investor.order(updated_at: 'asc')\n\n\t\trender layout: 'layout_back'\n\tend",
"def investor_params\n params.require(:investor).permit(:name, :amount, :willing_to_reinvest, :negotiation_state)\n end",
"def hdp_repo_os_path\n value_for_platform_family(\n %w(rhel amazon) => \"centos#{node['platform_version'].to_i}\",\n 'debian' => \"#{node['platform']}#{node['platform_version'].to_i}\"\n )\n end"
] |
[
"0.57086205",
"0.5593016",
"0.5556217",
"0.5524725",
"0.55160904",
"0.5444372",
"0.5386671",
"0.53793293",
"0.5313509",
"0.5310424",
"0.52907485",
"0.5262005",
"0.5236569",
"0.5176087",
"0.5169001",
"0.5163113",
"0.51555544",
"0.5147681",
"0.5143245",
"0.5126595",
"0.5118084",
"0.51152956",
"0.51130915",
"0.51130915",
"0.508201",
"0.5073529",
"0.5063631",
"0.50577354",
"0.50548",
"0.5048806",
"0.50384265",
"0.5033348",
"0.5033342",
"0.5018718",
"0.50184137",
"0.4987988",
"0.49876928",
"0.4985446",
"0.49749354",
"0.4963749",
"0.49541834",
"0.49476737",
"0.4927463",
"0.49190435",
"0.49190435",
"0.49190435",
"0.49190435",
"0.49190435",
"0.49190435",
"0.49109453",
"0.48965794",
"0.48724943",
"0.4860382",
"0.48586562",
"0.48446226",
"0.48099035",
"0.4806311",
"0.4806311",
"0.4806311",
"0.4804703",
"0.4804703",
"0.4804703",
"0.47902074",
"0.47885126",
"0.4776251",
"0.47618484",
"0.47583675",
"0.47578183",
"0.47513196",
"0.47373584",
"0.47357827",
"0.47357827",
"0.47292614",
"0.4723305",
"0.47156146",
"0.47019354",
"0.47011837",
"0.469611",
"0.469611",
"0.46869066",
"0.46859232",
"0.46665123",
"0.4658346",
"0.46544632",
"0.46536508",
"0.46488997",
"0.4640963",
"0.46347648",
"0.46310234",
"0.46307522",
"0.46307522",
"0.4628869",
"0.46273762",
"0.46236935",
"0.46228686",
"0.46209082",
"0.46105242",
"0.46091807",
"0.4608938",
"0.46046498"
] |
0.82584137
|
0
|
GET /items GET /items.json
|
def index
@items = Item.all
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show\n @items = Item.find(params[:id])\n render json: @items\n end",
"def items\n\t\tresponse = self.get('items').body\n\t\titems = JSON.parse(response)\n\t\tparse_items(items)\n\t\treturn items\n\tend",
"def getItems()\n return mergeWithAPI(@item_json)['data']\n end",
"def index\n @items = current_user.items\n respond_to do |format|\n format.html\n format.json { render json: @items }\n end\n end",
"def index\n #@items = Item.find_by_user_id(Session[user_id])\n @items = Item.all\n render json: @items\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.found\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @items }\n end\n end",
"def items\n \tbegin\n \t@categories = Category.all.includes(items: [:dimensions])\n \t@ingredients = Ingredient.actives\n \trender 'api/v1/home/items', status: :ok\n \trescue Exception => e\n \t\terror_handling_bad_request(e)\n \tend\n\n\tend",
"def index\n @items = Item.find(:all, :order => 'id ASC')\n # @items = Item.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @api_v1_items = Item.all\n render json: @api_v1_items\n end",
"def list_items( args={} )\n @session.base_url = \"http://my.cl.ly\"\n \n url = \"/items\"\n args.each do |k, v|\n # probably a nicer way to do this\n if url == \"/items\"\n url << \"?#{k.to_s}=#{v.to_s}\"\n else\n url << \"&#{k.to_s}=#{v.to_s}\"\n end\n end\n resp = @session.get( url )\n \n raise AuthorizationError if resp.status == 401\n Crack::JSON.parse(resp.body)\n end",
"def show\n item = Item.find(params[:id])\n render json: item\n end",
"def get_item( item )\n @session.base_url = \"http://cl.ly\"\n resp = @session.get( \"/\" + item )\n \n raise ItemNotFound if resp.status == 404\n Crack::JSON.parse(resp.body)\n end",
"def show\n authenticate\n list = List.find(params[:id])\n items = list.items\n render json: {\n items: items,\n id: list.id\n }\n end",
"def items\n response[\"items\"]\n end",
"def show\n render json: Item.find(params[:id])\n end",
"def index\n @items = @deal.items\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def show\n render json: Item.find(params[\"id\"])\n end",
"def item(uuid)\n http.get \"/items/#{uuid}\"\n end",
"def items\n @items ||= items_from_response\n end",
"def get_items\n @items\n end",
"def index\n @items = Item.includes(:user).order(created_at: :desc).all\n render json: @items\n end",
"def get_items\n response_xml = http_get(@client, \"#{xero_url}/Items\")\n parse_response(response_xml, {}, {:request_signature => 'GET/items'})\n end",
"def my\n items = current_user.items\n render json: items\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item.to_json() }\n end\n end",
"def index\n render json: RequestItem.all\n end",
"def show\n render json: @item\n end",
"def show\n @item = Item.all.where(collection_id: params[:id])\n render :json => @item\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n# @item = Item.get(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def items(); @items || CrateAPI::Items.new(); end",
"def index\n if params[:uid]\n @current_user = User.find_by(uid: params[:uid])\n render json: {\n status: 'SUCCESS',\n message: 'Loaded users',\n value: @current_user.items\n }\n else\n items = Item.order(created_at: :desc)\n render json: { status: 'SUCCESS', message: 'Loaded items', value: items }\n end\n end",
"def index\n @items = Admin::Item.by_agency(@current_agency.id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @admin_items }\n end\n end",
"def get_items(product_id, params={})\n self.client.get(\"products/#{product_id}/items\", params)\n end",
"def index\n @section = Section.find(params[:section_id])\n @items = @section.items\n render json: ItemSerializer.new(@items)\n end",
"def index\n respond_to do |format|\n format.html\n format.json { render :json => Item.all}\n end\n\n end",
"def index\n @items = @user.items\n end",
"def index\n @rentable_items = RentableItem.all\n render json: @rentable_items\n end",
"def get_item\n @item = Item.find_by_id(params[:id])\n if @item\n return @item\n else \n render json: {\"message\": {\"type\": \"error\", \"content\": \"The item could not be found!\"}}\n end\n end",
"def show\n @item = @deal.items.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def items\n @beverages = Beverage.available\n respond_to do |format|\n format.json { render :json => @beverages.to_json(methods: :image_url)}\n end\n end",
"def get_books(response)\n response[\"items\"]\nend",
"def index\n @items = Item.all\n @budget = Budget.find params[:budget_id]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def items\n response = @client.request :get, \"#{LISTS_PATH}/#{@id}\"\n raise(StandardError, 'unexpected response') unless response\n response['items']&.map { |i| TodoableItem.new self, i, @client }\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json\n end\n end",
"def index\n if params[:cart_id]\n get_cart\n @items = Item.where(cart: @cart)\n elsif params[:order_id]\n get_order\n @items = Item.where(order: @order)\n end\n render json: @items, status: 200\n end",
"def index\n @active_items = Item.select(&:active?).sort_by(&:name)\n @inactive_items = Item.select(&:inactive?).sort_by(&:name)\n\n @item = Item.new\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def show\n \n render status: 200, :json => @item\n\n end",
"def index\n @items = Item.all\n\n end",
"def index\n @items = @channel.items\n @items = @query.search(@items)\n @items = @items.order_by_published_at_desc\n @items = @items.page(params[:page]).per(10)\n\n respond_to do |format|\n format.html\n format.json { render json: @items }\n end\n end",
"def items\n @items = current_user.items.paginate(:page => params[:page])\n end",
"def index\n self.identify_user\n @items = @user.items\n @itemlist = @items.map do |item|\n convert_to_json(item)\n end\n respond_to do |format|\n format.json { render :json => @itemlist }\n format.xml { render :xml => @items }\n format.html { render text: \"Unsupported Format\", status: 404 }\n end\n end",
"def fetch\n result = WebApi.json!('ITFItems_440', 'GetPlayerItems', 1, { :SteamID => @steam_id64 })\n\n @items = []\n result[:items][:item].each do |item_data|\n unless item_data.nil?\n item = TF2Item.new(item_data)\n @items[item.backpack_position - 1] = item\n end\n end\n end",
"def index\n @items = Item.accessible_by(current_ability)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n format.xml { render xml: @items }\n end\n end"
] |
[
"0.79562956",
"0.7546286",
"0.74375594",
"0.7434485",
"0.73975587",
"0.7358414",
"0.7358414",
"0.7358414",
"0.7358414",
"0.7357372",
"0.7313286",
"0.73129123",
"0.7311041",
"0.7306297",
"0.7281173",
"0.7273615",
"0.72629416",
"0.72484964",
"0.72301924",
"0.71767205",
"0.7118192",
"0.70924455",
"0.7085656",
"0.7080955",
"0.7067216",
"0.7009283",
"0.6977327",
"0.69725746",
"0.69630706",
"0.6939082",
"0.6898775",
"0.68567353",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.68541014",
"0.6849963",
"0.6849224",
"0.68373597",
"0.683049",
"0.67957854",
"0.67643034",
"0.67557514",
"0.67521715",
"0.67499214",
"0.673109",
"0.6710735",
"0.6705887",
"0.67042756",
"0.669466",
"0.66917354",
"0.6686135",
"0.6674154",
"0.66694057",
"0.66563886",
"0.66466695",
"0.6638935",
"0.6629286",
"0.66234785",
"0.66168797",
"0.6604739"
] |
0.66965467
|
88
|
GET /items/1 GET /items/1.json
|
def show
@item
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show\n @items = Item.find(params[:id])\n render json: @items\n end",
"def get_item( item )\n @session.base_url = \"http://cl.ly\"\n resp = @session.get( \"/\" + item )\n \n raise ItemNotFound if resp.status == 404\n Crack::JSON.parse(resp.body)\n end",
"def show\n item = Item.find(params[:id])\n render json: item\n end",
"def item(uuid)\n http.get \"/items/#{uuid}\"\n end",
"def show\n render json: Item.find(params[:id])\n end",
"def index\n @api_v1_items = Item.all\n render json: @api_v1_items\n end",
"def show\n render json: Item.find(params[\"id\"])\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item.to_json() }\n end\n end",
"def index\n @items = Item.find(:all, :order => 'id ASC')\n # @items = Item.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def get_item\n @item = Item.find_by_id(params[:id])\n if @item\n return @item\n else \n render json: {\"message\": {\"type\": \"error\", \"content\": \"The item could not be found!\"}}\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def index\n @items = Item.found\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def show\n# @item = Item.get(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def show\n @item = Item.all.where(collection_id: params[:id])\n render :json => @item\n end",
"def index\n @items = Item.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @items }\n end\n end",
"def index\n #@items = Item.find_by_user_id(Session[user_id])\n @items = Item.all\n render json: @items\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json\n end\n end",
"def show\n @item = @deal.items.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def item\n @item = Item.find(params[:id])\n end",
"def show\n authenticate\n list = List.find(params[:id])\n items = list.items\n render json: {\n items: items,\n id: list.id\n }\n end",
"def index\n @items = current_user.items\n respond_to do |format|\n format.html\n format.json { render json: @items }\n end\n end",
"def index\n @items = @deal.items\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def show\n render json: @item\n end",
"def show\n \n render status: 200, :json => @item\n\n end",
"def getItems()\n return mergeWithAPI(@item_json)['data']\n end",
"def get(item)\n run(\"show #{ item }\")\n end",
"def show\n @feed_item = Item.find(params[:id])\n\n render json: @feed_item\n end",
"def index\n @items = Item.all\n @budget = Budget.find params[:budget_id]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n render json: RequestItem.all\n end",
"def items\n \tbegin\n \t@categories = Category.all.includes(items: [:dimensions])\n \t@ingredients = Ingredient.actives\n \trender 'api/v1/home/items', status: :ok\n \trescue Exception => e\n \t\terror_handling_bad_request(e)\n \tend\n\n\tend",
"def show\n render json: @item, status: :ok\n end",
"def findItem\n item = Item.find(params[:id])\n if item\n return item\n else\n return render json: {data: \"Failure, could not find this item.\"}, status: :not_found\n end\n end",
"def show\n @itemstable = Itemstable.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @itemstable }\n end\n end",
"def show\n @item_info = ItemInfo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item_info }\n end\n end",
"def get_single_item(item_id, payload = {})\n payload = payload.merge('ItemID' => item_id)\n request('GetSingleItem', payload)\n end",
"def show\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @item }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n end\n end",
"def index\n respond_to do |format|\n format.html\n format.json { render :json => Item.all}\n end\n\n end",
"def show\n @item = Item.find(params[:id])\n @user = @item.user_id\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @item }\n end\n end",
"def show\n @admin_item = Admin::Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @admin_item }\n end\n end",
"def show\n @admin_item = Admin::Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @admin_item }\n end\n end",
"def path\n \"/{databaseId}/items/list/\"\n end",
"def index\n @items = Admin::Item.by_agency(@current_agency.id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @admin_items }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @item }\n end\n end",
"def show\n @item = TodoItem.find(params[:id])\n \n respond_to do |format|\n format.html\n format.json {render json: {\n success:true, \n data: [@item],\n message: \"TodoItem found.\"\n }}\n end\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = Item.find(params[:id])\n end",
"def show\n @item = ActiveRecord::Base.connection.execute(\"\n SELECT * \n FROM items \n WHERE iid = #{params[:id]} \n LIMIT 1\").first\n\n @games = ActiveRecord::Base.connection.execute(\"\n SELECT g.*\n FROM games g\n JOIN game_items gi\n ON g.gid = gi.gid\n WHERE iid = #{params[:id]}\")\n\n respond_to do |format|\n format.html\n format.json {render json: Item.find(@item[0])}\n end\n end",
"def show \n #get the item id from the url params\n item_id = params[:id]\n #use `item_id` to find the item in the database\n #and save it to an instance variable\n @item = Item.find_by_id(item_id)\n render json: @item\n # @item = City.find(params[:id])\n # @item = Item.joins(:posts).includes(:posts).find(params[:id])\n # puts @item\n # render json: {\n # item: @item\n # }\n end",
"def index\n @items = Item.includes(:user).order(created_at: :desc).all\n render json: @items\n end",
"def get_item(course_id, item_id)\r\n relative_url = PATH_COURSES_ITEMS_ % [course_id, item_id]\r\n get(relative_url)\r\n end",
"def my\n items = current_user.items\n render json: items\n end",
"def get_item(item_id, params = {})\n url = build_url('item', item_id)\n params = params.merge(item_id: item_id)\n\n http.headers(build_headers).get(url, params: params)\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @item }\n format.json { render :json => @item }\n end\n end",
"def list_items( args={} )\n @session.base_url = \"http://my.cl.ly\"\n \n url = \"/items\"\n args.each do |k, v|\n # probably a nicer way to do this\n if url == \"/items\"\n url << \"?#{k.to_s}=#{v.to_s}\"\n else\n url << \"&#{k.to_s}=#{v.to_s}\"\n end\n end\n resp = @session.get( url )\n \n raise AuthorizationError if resp.status == 401\n Crack::JSON.parse(resp.body)\n end",
"def show\n render json: @request_item\n end",
"def show\n @potluck_item = PotluckItem.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @potluck_item }\n end\n end",
"def show\n @item = Item.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @item }\n format.xml { render xml: @item }\n end\n end",
"def show\n @list = List.find(params[:list_id])\n @list_items = @list.list_items.find(params[:list_id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @list_item }\n end\n end",
"def index\n @item_type = params[:type] = \"C\"\n \n params[:id] = nil\n \n # 찜한 상품, 콜렉션\n @collections = Collection.itemList(params)\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @collections }\n end\n \n end",
"def item_show\n @item = Item.find(params[:id])\n end",
"def show\n @itemstatus = Itemstatus.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @itemstatus }\n end\n end",
"def get_items(product_id, params={})\n self.client.get(\"products/#{product_id}/items\", params)\n end",
"def items\n\t\tresponse = self.get('items').body\n\t\titems = JSON.parse(response)\n\t\tparse_items(items)\n\t\treturn items\n\tend",
"def index\n if params[:cart_id]\n get_cart\n @items = Item.where(cart: @cart)\n elsif params[:order_id]\n get_order\n @items = Item.where(order: @order)\n end\n render json: @items, status: 200\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end",
"def index\n @items = Item.all\n end"
] |
[
"0.7736526",
"0.7547988",
"0.74948645",
"0.73696035",
"0.7328169",
"0.7293223",
"0.7287578",
"0.71326286",
"0.71247333",
"0.71196556",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.70882183",
"0.7069195",
"0.7047763",
"0.7046805",
"0.7046805",
"0.7046805",
"0.7046805",
"0.7021193",
"0.70065445",
"0.6999912",
"0.6968592",
"0.69090354",
"0.6904139",
"0.69028735",
"0.6859605",
"0.6838115",
"0.68371415",
"0.6817121",
"0.6791983",
"0.67502666",
"0.6706858",
"0.6694071",
"0.6665942",
"0.66478753",
"0.6639059",
"0.66362274",
"0.66218555",
"0.66078925",
"0.6603567",
"0.65953285",
"0.65745777",
"0.6563656",
"0.6563601",
"0.6562375",
"0.6562375",
"0.6558979",
"0.6553609",
"0.6543294",
"0.6532621",
"0.6526246",
"0.6526246",
"0.6526246",
"0.6526246",
"0.6526246",
"0.6526246",
"0.6526246",
"0.6525101",
"0.65117115",
"0.65114903",
"0.6499088",
"0.6492242",
"0.6478985",
"0.6478985",
"0.6470336",
"0.646914",
"0.64681506",
"0.64497066",
"0.6449235",
"0.64342886",
"0.643418",
"0.6431615",
"0.6423981",
"0.6418225",
"0.64176244",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651",
"0.6411651"
] |
0.0
|
-1
|
Use callbacks to share common setup or constraints between actions.
|
def set_item
@item = Item.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def item_params
params.permit(:name, :image, :price)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def valid_params_request?; end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def filtering_params\n params.permit(:email)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end"
] |
[
"0.6980384",
"0.6782743",
"0.6746196",
"0.6742575",
"0.6736",
"0.6594004",
"0.65037984",
"0.6496699",
"0.64819324",
"0.64791185",
"0.6456292",
"0.64403296",
"0.63795286",
"0.6375975",
"0.6365291",
"0.63210756",
"0.6300542",
"0.6299717",
"0.62943304",
"0.6292561",
"0.6290683",
"0.6290449",
"0.6282986",
"0.6241265",
"0.62392694",
"0.62192893",
"0.621427",
"0.62099457",
"0.6195319",
"0.61785376",
"0.61747766",
"0.6172739",
"0.6162921",
"0.6152228",
"0.6152062",
"0.6148811",
"0.6122391",
"0.6117956",
"0.61083806",
"0.6106195",
"0.609274",
"0.60815483",
"0.60710186",
"0.6064253",
"0.60213476",
"0.6018128",
"0.60146624",
"0.601063",
"0.60068774",
"0.60068774",
"0.60026145",
"0.6000521",
"0.59987193",
"0.5992379",
"0.59922844",
"0.5991889",
"0.59803206",
"0.5966244",
"0.5959778",
"0.5959708",
"0.59588563",
"0.5956974",
"0.5953329",
"0.59528023",
"0.59439695",
"0.59413165",
"0.59397036",
"0.59397036",
"0.5933782",
"0.59323835",
"0.59258395",
"0.59253365",
"0.5917244",
"0.59111005",
"0.59093463",
"0.5907942",
"0.59047514",
"0.58979666",
"0.58971125",
"0.589613",
"0.5895083",
"0.5893643",
"0.5892825",
"0.5887658",
"0.5883417",
"0.5878839",
"0.5874345",
"0.5869008",
"0.5868205",
"0.58672875",
"0.5867031",
"0.58662426",
"0.5864551",
"0.5863614",
"0.5862626",
"0.5861952",
"0.58596134",
"0.5855716",
"0.58536863",
"0.5851665",
"0.5850823"
] |
0.0
|
-1
|
Copyright (c) 2013 University of Manchester and the University of Southampton. See license.txt for details.
|
def user_count(opts)
users = User.find(:all).select do |user| user.activated? end
root = LibXML::XML::Node.new('user-count')
root << users.length.to_s
doc = LibXML::XML::Document.new
doc.root = root
{ :xml => doc }
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def private; end",
"def schubert; end",
"def jack_handey; end",
"def berlioz; end",
"def terpene; end",
"def probers; end",
"def dh; end",
"def herald; end",
"def implementation; end",
"def implementation; end",
"def romeo_and_juliet; end",
"def weber; end",
"def verdi; end",
"def rossini; end",
"def stderrs; end",
"def who_we_are\r\n end",
"def gounod; end",
"def feruchemist; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def identify; end",
"def loc; end",
"def loc; end",
"def loc; end",
"def schumann; end",
"def scientist; end",
"def origin; end",
"def origin; end",
"def origin; end",
"def villian; end",
"def mozart; end",
"def initialize\n\n end",
"def initialize\n\n end",
"def from; end",
"def from; end",
"def from; end",
"def from; end",
"def suivre; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def how_it_works\r\n end",
"def hiss; end",
"def anchored; end",
"def zuruecksetzen()\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def initialize\n end",
"def king_richard_iii; end",
"def cobasysprog\n end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def initialize; end",
"def init; end",
"def init; end",
"def init; end",
"def init; end",
"def strain; end",
"def library; end",
"def library; end",
"def initialize()\n\n end",
"def ca; end",
"def blg; end",
"def external; end",
"def hd\n \n end",
"def refutal()\n end",
"def trd; end",
"def standalone; end"
] |
[
"0.69005716",
"0.6438806",
"0.60554034",
"0.60428625",
"0.60218155",
"0.59697175",
"0.59491414",
"0.59254086",
"0.591527",
"0.591527",
"0.5869077",
"0.58599955",
"0.58562696",
"0.58432084",
"0.5840115",
"0.5836691",
"0.58361673",
"0.5811101",
"0.58104956",
"0.58104956",
"0.58104956",
"0.58104956",
"0.580215",
"0.579255",
"0.579255",
"0.579255",
"0.5791425",
"0.57868385",
"0.5762106",
"0.5762106",
"0.5762106",
"0.57581973",
"0.5755385",
"0.57204443",
"0.57204443",
"0.57175964",
"0.57175964",
"0.57175964",
"0.57175964",
"0.5714366",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692941",
"0.5692293",
"0.56705034",
"0.5666186",
"0.56544757",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.5646806",
"0.56364316",
"0.56064874",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.56008035",
"0.5589235",
"0.5589235",
"0.5589235",
"0.5589235",
"0.5574877",
"0.5570683",
"0.5570683",
"0.556997",
"0.5561144",
"0.5560905",
"0.55569476",
"0.55511355",
"0.5537854",
"0.5532503",
"0.5532234"
] |
0.0
|
-1
|
POST /characters or /characters.json
|
def create
@character = Character.new(character_params)
if @character.save
render json: {
status: :created,
character: @character
}
else
render json: {
status: 500,
errors: @character.errors.full_messages
}
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create\n respond_to do |format|\n if @character = Character.create_with_char_data(character_params, current_user, game)\n format.json { render json: {redirect: character_path(@character).to_s} }\n else\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n if @character.save\n render json: @character, status: 201\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def create\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render action: 'show', status: :created, location: @character }\n else\n format.html { render action: 'new' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render action: 'show', status: :created, location: @character }\n else\n format.html { render action: 'new' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n\n # save associated entries also.\n end\n end",
"def create\n @character = Character.new(character_params)\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n populate_character\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\n raise BadRequestError.new('no current character') if current_character.nil?\n raise BadRequestError.new('missing parameter(s)') if params[:character].nil? || params[:character][:name].blank?\n\n current_character.change_name_transaction(params[:character][:name].strip) \n \n respond_to do |format|\n format.json { render json: {}, status: :ok }\n end\n end",
"def create\n @character = current_user.characters.new(character_params)\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: I18n.translate(\"success\", scope: %i[characters new]) }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name)\n end",
"def create\n @character = Character.new(character_params)\n\n respond_to do |format|\n if @character.save\n Ability.all.each {|a|\n CharacterAbility.create(ability: a, character: @character, value: 10)\n }\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(params[:character])\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to([:administration, @character], :notice => 'Character was successfully created.') }\n format.xml { render :xml => @character, :status => :created, :location => @character }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :description, :thumbnail, :code)\n end",
"def create\n # byebug\n image = Cloudinary::Uploader.upload(params[:image])\n @character = Character.new(name: params[\"name\"], age: params[\"age\"], weight: params[\"weight\"], \n history: params[\"history\"], image: image[\"secure_url\"], user_id: current_user.id)\n if @character.save\n render json: @character\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def create\n @character = Character.new(params[:character])\n\n respond_to do |format|\n if @character.save\n flash[:notice] = 'Character was successfully created.'\n format.html { redirect_to(@character) }\n format.xml { render :xml => @character, :status => :created, :location => @character }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def index\n @characters = Character.all\n\n render json: @characters\n end",
"def create\n Character.create(\n name: params[:name],\n gender: params[:gender],\n quirk: params[:quirk],\n book_id: params[:book_id])\n redirect_to \"/books/#{params[:book_id]}/characters\"\n end",
"def create\n @fundamental_character = Fundamental::Character.new(params[:fundamental_character])\n\n respond_to do |format|\n if @fundamental_character.save\n format.html { redirect_to @fundamental_character, notice: 'Character was successfully created.' }\n format.json { render json: @fundamental_character, status: :created, location: @fundamental_character }\n else\n format.html { render action: \"new\" }\n format.json { render json: @fundamental_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n @character.user = current_user\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to new_character_description_path(@character), notice: 'Character was successfully created.' }\n format.json { render action: 'show', status: :created, location: @character }\n else\n format.html { render action: 'new' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :description, :thumbnail, :urls, :comics, :events, :series, :user_id)\n end",
"def write_character(character)\n characters = read_characters()\n characters << $character\n f = File.open(\"characters.json\", \"w\")\n f << characters.to_json\n f.close\nend",
"def create\n character = Character.create(character_params)\n lane = Lane.find_or_create_by(name: params[:lane])\n character.lane = lane \n\n if character.save \n render json: CharacterSerializer.new(character)\n else\n render json: {message: \"Error: Could not be created\"}\n end\n end",
"def create\n @character = @user.build_character(params[:character])\n\n respond_to do |format|\n if @character.save\n flash[:notice] = 'Character was successfully created.'\n format.html { redirect_to(@character) }\n format.xml { render :xml => @character, :status => :created, :location => @character }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new(character_params)\n puts @character\n authorize! :create, @character\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :age, :voice_actor, :first_appearance, :job)\n end",
"def create\r\n @game_id = params[:game_id].to_i \r\n @character = Character.create(character_params)\r\n respond_to do |format|\r\n if @character.save\r\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\r\n format.json { render :show, status: :created, location: @character }\r\n else\r\n format.html { render :new }\r\n format.json { render json: @character.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create\n @character = Character.new(character_params)\n @character.user_id = current_user.id\n @character.game_id = @game.id\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @game, notice: 'Ура! Персонаж создан!' }\n format.json { render action: 'show', status: :created, location: @character }\n else\n format.html { render action: 'new' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:first_name, :last_name, :nick_name, :title, :description, :traits, :skills, :history, :strength, :vitality, :agility, :dexterity, :intelligence, :mind)\n end",
"def character_params\n params.require(:character).permit(:name, :summary, :campaign, :user_id, :race_id, :class_id)\n end",
"def character_params\n params.require(:character).permit(:immortal_id, :dead, :is_immortal, :name, :description)\n end",
"def character_params\n params.require(:character).permit(:name, :position, :devilfruit, :haki, :society_id)\n end",
"def character_params\n params.require(:character).permit(:name, :life, :strength, :dexterity, :constitution, :intelligence, :wisdom, :charisma)\n end",
"def character_params\n params.require(:character).permit(:name, :char_name, :background, :faction_id, :profession_id, :alignment_id, :user_id, :adventure_id, :experience, :strength, :dexterity, :constitution, :intelligence, :wisdom, :charisma, :armor_class, :initiative, :hit_points)\n end",
"def create\n @character = Character.new(character_params)\n\n #Match this character's user ID to the current user's ID.\n @character.user_id = current_user.id\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.get!(params[:character])\n @character ||= Character.new(params[:character])\n\n # If character save was successful, redirect to rebuild_items_path\n if @character.save\n redirect_to rebuild_items_path(:c => @character._id)\n else\n return new\n end\n end",
"def show\n render json: @character\n end",
"def create\n @character = Character.new(params[:character])\n if params[:story]\n if params[:story][:name] != nil and params[:story][:name].strip != ''\n story = Story.find_by_name(params[:story][:name].strip)\n if story\n\n @character.story_id = story.id\n end\n end\n end\n respond_to do |format|\n if @character.save\n if params[:avatar] then\n @character.save_avatar(params[:avatar])\n end\n format.html { redirect_to(@character, :notice => 'Character was successfully created.') }\n format.xml { render :xml => @character, :status => :created, :location => @character }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :exp, :hp, :hp_regen, :power, :power_regen, :speed, :size, :move_type, :element, :color_schema, :emblem, :functions, :sprite, :sprite_idle, :sprite_death, :sprite_hat, :sprite_jacket, :sprite_shoes, :sprite_scarf, :user_id, :prime_gun_id, :secondary_gun_id, :prime_ability_id, :secondary_ability_id)\n end",
"def character_params\n params.require(:character).permit(:name, :wiki_link, :full_image_link, :thumb_image_link, :gameplay, :fighting_style, :archetype, :difficulty, :tier, :publish, :strengths, :weaknesses, :movement)\n end",
"def character_params\n params.require(:character).permit(:age, :ethnicity, :nationality, :mother_tongue, :occupation, :lastname, :firstname, :gender, :obsession, :order_alignment, :secret_language, :moral_alignment, :eye_colour, :skin_base_tone, :favourite_food, :favourite_drink, :ailment, :star_sign)\n end",
"def character_params\n params.require(:character).permit(:name, \n :image, \n celebrity_ids: [],\n universe_ids: []\n )\n end",
"def create\n @character = Character.new(character_params)\n\n @character.details = Sanitize.fragment(@character.details, Sanitize::Config::RELAXED)\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :life_points, :attack_points, :description, :avatar)\n end",
"def character_params\n params.require(:character).permit(:name, :realm, :confirmed)\n end",
"def create\n @character_entry = CharacterEntry.new(character_entry_params)\n\n respond_to do |format|\n if @character_entry.save\n format.html { redirect_to @character_entry, notice: 'Character entry was successfully created.' }\n format.json { render action: 'show', status: :created, location: @character_entry }\n else\n format.html { render action: 'new' }\n format.json { render json: @character_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @character = Character.new\n\n @character.name = params[:name]\n @character.atk = params[:attack]\n @character.def = params[:defense]\n @character.hp = 80\n @character.xp = 0\n @character.level = 1\n @character.unassigned = params[:unassigned]\n @character.user_id = @current_user.id\n\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to user_path(@current_user), notice: 'Successfully Created New Character.'}\n else\n redirect_to \"/users/#{@current_user}\"\n end\n end\n end",
"def character_params\n params[:character].permit(:name, :game_class, :game_role, :game_tag, :game_alt_role, :armory_addr)\n end",
"def character_params\n params.require(:character).permit(\n :id,\n :exp,\n :name,\n :strength,\n :intelligence,\n :wisdom,\n :dexterity,\n :constitution,\n :looks,\n :charisma,\n :building_points,\n :health,\n :item_ids,\n :character_class_id,\n :race_id,\n :user_id,\n :alignment,\n :sex,\n :age,\n :height,\n :weight,\n :hair,\n :eyes,\n :handedness,\n :trade_coins,\n :copper,\n :silver,\n :gold,\n :spell_points,\n :luck_points\n )\n end",
"def character_params\n params.require(:character).permit(:character_name, :player_name, :age, :gender, :eyes, :height, :hair, :weight, :gear, :description, :history, :crossroads, :notes)\n end",
"def update\n if @character.update(character_params)\n render json: @character, status: 201, location: @character\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def index\n characters = @project.characters.all\n render json: { characters: characters }\n end",
"def read_characters()\n readfile = File.read(\"characters.json\")\n return JSON.parse(readfile)\nend",
"def character_params\n params.require(:character).permit(:name, :campaign_id, :race, :char_class, :level, :alignment, :xp, :str, :dex, :con, :int, :wis, :cha, :prof_bonus, :hp, :ac, :hit_dice, :inventory, :feats)\n end",
"def character_params\n params.require(:character).permit(:name, :game_id, :major_attr, :minor_attr, \n :description, :inventory)\n end",
"def character_params\n params.require(:character).permit(:name, :reason_for_name, :nickname, :reason_for_nickname, :ethnicity, :occupation_class,\n :social_class, :first_name, :middle_name, :last_name, :suffix, :birth_year, :death_year,\n :age_at_son, :father_id, :honorific, :grouping, :use_honorific_only, :background, :mother_id,\n :sex, :main, :thumbnail)\n end",
"def create\n @collected_character = CollectedCharacter.new(params[:collected_character])\n\n respond_to do |format|\n if @collected_character.save\n format.html { redirect_to @collected_character, notice: 'Collected character was successfully created.' }\n format.json { render json: @collected_character, status: :created, location: @collected_character }\n else\n format.html { render action: \"new\" }\n format.json { render json: @collected_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :race, :player_id, :campaign_id, :alignment, :current_xp, :max_hp, :current_hp, :speed, :notes, :has_inspiration, :adventuring_class_id, :character_abilities, :character_skills, :inventories)\n end",
"def character_params\n params.require(:character).permit(:name, :age, :history, :weight, :id)\n end",
"def character_params\n params.permit(:user_id, :name, :description)\n end",
"def character_params\n params.require(:character).permit(:fullname, :birthday, :age)\n end",
"def create\n \t@story = Story.find(params[:story_id])\n @character = @story.characters.new(params[:character])\n \tadd_breadcrumb \"Stories\", stories_path\n\tadd_breadcrumb @story.title, @story\n\tadd_breadcrumb \"Characters\", story_characters_path(@story)\n\tadd_breadcrumb \"New character\", ''\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to(@character, :notice => 'Character was successfully created.') }\n format.xml { render :xml => @character, :status => :created, :location => @character }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def character_params\r\n params.require(:character).permit(:name, :player, :concept, :maxHealth, :currentHealth, :brawn, :agility, :wit, :intelligence, :charm, :presence, :maxDodge, :currentDrive, :initiative, :maxDrive, :currentDrive, :game_id, :athletics, :biology, :computers, :empathy, :engineering, :explosives, :firearms, :law, :lying, :melee, :piloting, :persuasion, :perform, :sneaking, :spacewise, :survival, :telekinesis, :telepathy, :special, :user_id)\r\n end",
"def character_params\n permit = policy(@character || Character).permitted_attributes\n params.require(:character).permit(*permit)\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def display_character_info(input)\n api = Api.new(query)\n api.create_character \n end",
"def index\n if params[:user_id]\n @characters = User.find(params[:user_id]).characters\n else\n @characters = Character.all\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @characters }\n end\n end",
"def character_params\n params.require(:character).permit(:nym, :fullname, :birthyear, :details, :project_id)\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :no_content }\n end\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def create\n @character = Character.new(params[:character])\n @character.project_id = params[:project_id]\n\n respond_to do |format|\n if @character.save\n format.html { redirect_to(:action => 'show', :id => @character.id) }\n format.json { render json: @character, status: :created, location: @character }\n else\n format.html { render action: \"new\" }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_races\r\n BnetApi::make_request('/wow/data/character/races')\r\n end",
"def new\n @character = Character.new\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @character }\n end\n end",
"def new\n @character = @user.build_character\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @character }\n end\n end",
"def createCharities\n\tcharity_list = [\"Direct Relief\", \"Catholic Medical Mission Board\", \"MAP International\", \"United Nations Foundation\", \"The Rotary Foundation of Rotary International\", \"Samaritan's Purse\", \"Institute of International Education\", \"International Rescue Committee\", \"Compassion International\", \"United States Fund for UNICEF\"]\n\tcharity_list.each do |charity|\n\t\tRestClient.post 'http://api.reimaginebanking.com/merchants?key=e0486a76005721ee6d86b140eaea2a40', { \"name\": \"#{charity}\"}.to_json, :content_type => :json, :accept => :json\n\tend\nend",
"def type(text:)\n conn = multipart_connection(port: 8060)\n text.split(//).each do |c|\n path = \"/keypress/LIT_#{CGI::escape(c)}\"\n @logger.debug(\"Send Letter: \"+path)\n response = conn.post path\n return false unless response.success?\n end\n return true\n end",
"def index\n @characters = Character.all.paginate page: params[:page]\n render json: {\n current_page: @characters.current_page,\n per_page: @characters.per_page,\n total: @characters.total_entries,\n results: @characters\n }\n end",
"def character_params\n params.require(:character).permit(:name, :house_id, :abstract, :description, :background, :appears_in_season_1, :appears_in_season_2, :appears_in_season_3, :appears_in_season_4, :appears_in_season_5, :appears_in_season_6, :appears_in_season_7, :appears_in_season_8, :appears_in_season_9, :father, :mother, :spouse, :children, :siblings)\n end",
"def set_character\n # byebug\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def new\n @fundamental_character = Fundamental::Character.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @fundamental_character }\n end\n end",
"def create\n @character = Character.new(character_params)\n @character.give_class_benefits\n @character.give_race_benefits\n @character.level = 1\n \n respond_to do |format|\n if @character.save\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.7032093",
"0.69848734",
"0.6749904",
"0.67271125",
"0.6703533",
"0.6703533",
"0.6702623",
"0.6659725",
"0.6653624",
"0.6573103",
"0.6530796",
"0.6356317",
"0.63393587",
"0.6327022",
"0.6302442",
"0.62911755",
"0.62860197",
"0.62803817",
"0.6278441",
"0.6258732",
"0.62475485",
"0.6246038",
"0.62102485",
"0.6180566",
"0.6143401",
"0.61320955",
"0.6131098",
"0.61291206",
"0.61025685",
"0.6094788",
"0.60871136",
"0.6072479",
"0.6067084",
"0.6060086",
"0.6040743",
"0.60367054",
"0.60315406",
"0.6023416",
"0.6020007",
"0.6016696",
"0.60149544",
"0.6012174",
"0.6011375",
"0.60064054",
"0.60005456",
"0.5994592",
"0.5988125",
"0.5979388",
"0.59646",
"0.5956722",
"0.5929164",
"0.59267676",
"0.5925804",
"0.5916396",
"0.59116393",
"0.58880067",
"0.5878861",
"0.5872638",
"0.5865145",
"0.58546096",
"0.58501875",
"0.5848277",
"0.58403045",
"0.582872",
"0.582872",
"0.5822201",
"0.5820063",
"0.58068866",
"0.57858866",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5782493",
"0.5767149",
"0.57627356",
"0.57413083",
"0.57369584",
"0.5734189",
"0.5730395",
"0.5729946",
"0.57267094",
"0.57222265",
"0.5716745",
"0.57084364",
"0.5703527"
] |
0.65818584
|
9
|
PATCH/PUT /characters/1 or /characters/1.json
|
def update
# @character.update character_params
if @character.update character_params
render json: {
status: :updated,
character: @character
}
else
render json: {
status: 500,
errors: @character.errors.full_messages
}
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n if @character.update(character_params)\n render json: @character, status: 201, location: @character\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def update\n @character = Character.find_or_initialize_by_id(params[:id])\n @character.id = params[:id] # mass-assignment protection\n respond_to do |format|\n if @character.update_attributes(params[:character])\n format.html { redirect_to edit_character_url(@character), notice: 'Character was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: I18n.translate(\"success\", scope: %i[characters edit]) }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @character.update(character_params)\n render json: @character, status: :ok\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def update\n\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character = Character.get(params[:id])\n params[:character] = params[:character].map { |x,y| [x, y.empty? ? nil : y ] }.to_hash\n\n respond_to do |format|\n if @character.update(params[:character])\n format.html { redirect_to([:administration, @character], :notice => 'Character was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, @character\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to edit_character_path(@character), notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character = Character.find(params[:id])\n\n @character.send(\"#{params[:field]}=\", params[:value])\n \n\n respond_to do |format|\n if @character.save\n flash[:notice] = 'Character was successfully updated.'\n format.html { redirect_to(@character) }\n format.json {render :text => full_character_json(@character)}\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :text => full_character_json(@character)}\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n format.html { redirect_to @game, notice: 'Ура! Персонаж обновлен!' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character_entry.update(character_entry_params)\n format.html { redirect_to @character_entry, notice: 'Character entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character = current_user.characters.find(params[:id])\n\n # This has issues with case, resulting in dupes of the same tag\n #@character.tag_list = params[:character][:property] + \", \" + params[:tag_list]\n @character.tag_list = params[:tag_list]\n\n respond_to do |format|\n if @character.update_attributes(character_params)\n\n flash[:notice] = 'Character was successfully updated.'\n format.html { redirect_to(@character) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n if params[\"UpdateCharacter\"] == \"Update Race\"\n format.html { redirect_to set_class_character_path(@character)}\n elsif params[\"UpdateCharacter\"] == \"Update Class\"\n format.html { redirect_to new_character_feat_assignment_path(@character)}\n else\n format.html { redirect_to character_path, notice: 'Character was successfully updated.' }\n end\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n @game_id = params[:game_id].to_i \r\n @character = Character.find(params[:id])\r\n respond_to do |format|\r\n if @character.update(character_params)\r\n format.html { redirect_to @character, notice: 'Your Character was successfully updated.' }\r\n format.json { render :show, status: :ok, location: @character }\r\n else\r\n format.html { render :edit }\r\n format.json { render json: @character.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n @character = Character.find(params[:id])\n if params[:story]\n if params[:story][:name] != nil and params[:story][:name].strip != ''\n story = Story.find_by_name(params[:story][:name].strip)\n if story\n\n @character.story_id = story.id\n end\n else\n @character.story_id = nil\n end\n end\n respond_to do |format|\n if @character.update_attributes(params[:character])\n if params[:avatar] then\n @character.save_avatar(params[:avatar])\n end\n format.html { redirect_to(@character, :notice => 'Character was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @fundamental_character = Fundamental::Character.find(params[:id])\n\n respond_to do |format|\n if @fundamental_character.update_attributes(params[:fundamental_character])\n format.html { redirect_to @fundamental_character, notice: 'Character was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fundamental_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @game_characters = GameCharacters.find(params[:id])\n\n respond_to do |format|\n if @game_characters.update_attributes(params[:game_characters])\n flash[:notice] = 'GameCharacters was successfully updated.'\n format.html { redirect_to(@game_characters) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @game_characters.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character.update(character_params)\n @character.details = Sanitize.fragment(@character.details, Sanitize::Config::RELAXED)\n @character.save\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @collected_character = CollectedCharacter.find(params[:id])\n\n respond_to do |format|\n if @collected_character.update_attributes(params[:collected_character])\n format.html { redirect_to @collected_character, notice: 'Collected character was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @collected_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character_trait = CharacterTrait.find(params[:id])\n\n respond_to do |format|\n if @character_trait.update_attributes(params[:character_trait])\n flash[:notice] = 'CharacterTrait was successfully updated.'\n format.html { redirect_to(@character_trait) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character_trait.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @character = current_user.characters.find(params[:id])\n @assets = Asset.where(:company_id => current_user.company_id)\n # respond_to do |format|\n if @character.update_attributes(params[:character])\n # solr.update(:character)\n redirect_to @character, notice: 'Character was successfully updated.'\n # format.json { head :no_content }\n else\n render action: \"edit\"\n # format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n # end\n end",
"def update\n @character = Character.find(params[:id])\n \tadd_breadcrumb \"Stories\", stories_path\n\tadd_breadcrumb @character.story.title, @character.story\n\tadd_breadcrumb \"Characters\", story_characters_path(@character.story)\n\tadd_breadcrumb @character.name, @character\n\tadd_breadcrumb \"Edit character\", ''\n\n respond_to do |format|\n if @character.update_attributes(params[:character])\n format.html { redirect_to(@character, :notice => 'Character was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def update\n result = @character.update(character_params)\n ca = params[:character_abilities]\n unless ca.nil?\n ca.each do |ability|\n character_ability = CharacterAbility.find(ability[:id])\n result &= character_ability.update(value: ability[:value])\n end\n end\n cs = params[:skills]\n unless cs.nil?\n cs = cs.select{|skill| skill[:proficiency_multiplier].to_f > 0}\n CharacterSkill.where(character: @character).destroy_all\n cs.each do |skill|\n result &= CharacterSkill.create(character: @character, skill_id: skill[:id], proficiency_multiplier: (skill[:proficiency_multiplier] || 1))\n end\n end\n ci = params[:inventories]\n unless ci.nil?\n ci.each do |inventory|\n inv = Inventory.find(inventory[:id])\n result &= inv.update(is_equipped: inventory[:is_equipped])\n end\n end\n respond_to do |format|\n if result\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n format.json { render :show, status: :ok, location: @character }\n else\n format.html { render :edit }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_character\n # byebug\n @character = Character.find(params[:id])\n end",
"def create\n\n raise BadRequestError.new('no current character') if current_character.nil?\n raise BadRequestError.new('missing parameter(s)') if params[:character].nil? || params[:character][:name].blank?\n\n current_character.change_name_transaction(params[:character][:name].strip) \n \n respond_to do |format|\n format.json { render json: {}, status: :ok }\n end\n end",
"def update\n respond_to do |format|\n if @character_class.update(character_class_params)\n format.html { redirect_to @character_class, notice: 'Character class was successfully updated.' }\n format.json { render :show, status: :ok, location: @character_class }\n else\n format.html { render :edit }\n format.json { render json: @character_class.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def set_character\n @character = Character.find(params[:id])\n end",
"def update\n\n respond_to do |format|\n if @character_service.update_attributes(params[:character_service])\n format.html { redirect_to(@character_service, :notice => 'Character service was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character_service.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_character\n character_id = params[:character_id].to_i\n if character_id == 0 || character_id > 7\n return render :json => {'save_success'=> 'FAIL', 'err' => 'FAIL_PARAMS'} if params[:character].nil?\n if @current_user.character_id > 7\n character = Character.where(id:@current_user.character_id).take\n TagsToCharacter.where(:character_id => character.id).all.each{|x| x.delete} unless character.nil?\n character.delete unless character.nil?\n end\n @current_user.character_id = create_character(params[:character]).to_i\n else\n if @current_user.character_id > 7\n character = Character.where(id:@current_user.character_id).take\n TagsToCharacter.where(:character_id => character.id).all.each{|x| x.delete} unless character.nil?\n character.delete unless character.nil?\n end\n @current_user.character_id = character_id\n end\n save_with_check(@current_user)\n end",
"def update\n authorize @character\n unless @character.update(character_params)\n flash[:notice] = 'Character was not created.'\n end\n redirect_to game_path(@character.game)\n end",
"def update\n @character_sheet = CharacterSheet.find(params[:id])\n\n respond_to do |format|\n if @character_sheet.update_attributes(params[:character_sheet])\n format.html { redirect_to @character_sheet, notice: 'Character sheet was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @character_sheet.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @short = params[:short]\n respond_to do |format|\n if @actor_character.update(actor_character_params)\n @actor_characters = ActorCharacter.where(actor_id: @actor.id)\n format.html { redirect_to actor_actor_characters_url(@actor), notice: \"Actor character was successfully updated.\" }\n format.json { render :show, status: :ok, location: @actor_character }\n flash.now[:notice] = \"Actor Character was successfully updated.\"\n format.turbo_stream { render \"shared/update\", locals: { object: @actor_character, short: @short } }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @actor_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @glyph = Glyph.find(params[:id])\n\n respond_to do |format|\n if @glyph.update_attributes(params[:glyph])\n format.html { redirect_to @glyph, notice: 'Glyph was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @glyph.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character_experience.update(character_experience_params)\n format.html { redirect_to @character_experience, notice: 'Character experience was successfully updated. ✓' }\n format.json { render :show, status: :ok, location: @character_experience }\n else\n format.html { render :edit }\n format.json { render json: @character_experience.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @kitty = Kitty.find(params[:id])\n\n respond_to do |format|\n if @kitty.update_attributes(params[:kitty])\n format.html { redirect_to @kitty, notice: 'Kitty was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @kitty.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @characters = current_account.characters.all\n end",
"def update\n @characteristic = Characteristic.find(params[:id])\n\n respond_to do |format|\n if @characteristic.update_attributes(params[:characteristic])\n format.html { redirect_to(@characteristic, :notice => 'Characteristic was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @characteristic.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @characteristic.update(characteristic_params)\n format.html { redirect_to @characteristic, notice: 'Characteristic was successfully updated.' }\n format.json { render :show, status: :ok, location: @characteristic }\n else\n format.html { render :edit }\n format.json { render json: @characteristic.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name)\n end",
"def set_character_entry\n @character_entry = CharacterEntry.find(params[:id])\n end",
"def update\n #@feat = Feat.find(params[:id])\n @feat = @character.feats.find(params[:id])\n\n respond_to do |format|\n if @feat.update_attributes(params[:feat])\n flash[:notice] = 'Feat was successfully updated.'\n format.html { redirect_to(edit_character_path(@character)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @feat.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def show\n @character = current_user.characters.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @character }\n end\n end",
"def update\n @monkey = Monkey.find(params[:id])\n\n respond_to do |format|\n if @monkey.update_attributes(params[:monkey])\n format.html { redirect_to @monkey, notice: 'Monkey was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @monkey.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bookcharacter = Bookcharacter.find(params[:id])\n\n respond_to do |format|\n if @bookcharacter.update_attributes(params[:bookcharacter])\n flash[:notice] = 'Bookcharacter was successfully updated.'\n format.html { redirect_to(@bookcharacter) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @bookcharacter.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def show\n @character = Character.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @character }\n end\n end",
"def set_character\n @societies = Society.find(params[:society_id])\n\n @character = @societies.characters.find(params[:id])\n end",
"def set_character\r\n @character = Character.find_by(params[:user_id])\r\n end",
"def call\n context.character.update(guild_id: context.guild.id)\n end",
"def update\n @f_characteristic = FCharacteristic.find(params[:id])\n\n respond_to do |format|\n if @f_characteristic.update_attributes(params[:f_characteristic])\n format.html { redirect_to @f_characteristic }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @f_characteristic.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :game_id, :major_attr, :minor_attr, \n :description, :inventory)\n end",
"def update\n if @application.user.confirmed_character?\n c = @application.user.character\n @application.character_name = c.name\n @application.character_realm = c.realm\n @application.character_guild_name = c.guild_name\n @application.character_guild_realm = c.guild_realm\n @application.verified_character = true\n end\n respond_to do |format|\n if @application.update(application_params)\n format.html { redirect_to @application, notice: 'Application was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @application.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character.aasm_state = 'creation' if @character.aasm_state.nil?\n\n # Remove equipment with 0 quantity.\n if !@character.character_gears.nil?\n @character.character_gears.each do |cg|\n if cg.qty.nil? || cg.qty < 1\n @item = CharacterGear.find_by_id(cg.id)\n @item.destroy\n end\n end\n end\n\n if params[:update_specializations]\n if params[:character][:specialization_1] && !params[:character][:specialization_1].blank?\n set_experience_cost(@character.id, 'specialization', params[:character][:specialization_1], 1, 'up')\n end\n if params[:character][:specialization_2] && !params[:character][:specialization_2].blank?\n set_experience_cost(@character.id, 'specialization', params[:character][:specialization_2], 2, 'up')\n end\n if params[:character][:specialization_3] && !params[:character][:specialization_3].blank?\n set_experience_cost(@character.id, 'specialization', params[:character][:specialization_3], 3, 'up')\n end\n end\n\n # Update talents.\n if !params[:update_talents].nil?\n @talent_trees = Array.new\n unless @character.specialization_1.nil?\n @talent_trees << TalentTree.find_by_id(@character.specialization_1)\n end\n unless @character.specialization_2.nil?\n @talent_trees << TalentTree.find_by_id(@character.specialization_2)\n end\n unless @character.specialization_3.nil?\n @talent_trees << TalentTree.find_by_id(@character.specialization_3)\n end\n end\n\n # Update character skill entries for character to add in new skills created since the character was created.\n existing_skills = []\n @character.character_skills.each do |skill|\n existing_skills << skill.skill.id unless skill.skill.nil?\n end\n Skill.where(true).each do |skill|\n if !existing_skills.include?(skill.id)\n @character_skill = CharacterSkill.new()\n @character_skill.character_id = @character.id\n @character_skill.ranks = 0\n @character_skill.skill_id = skill.id\n @character_skill.save\n end\n end\n\n if !params[:character_characteristics].nil?\n ['brawn', 'agility', 'intellect', 'willpower', 'cunning', 'presence'].each do |stat|\n if params[:character][stat.to_sym].to_i > @character.race[stat]\n set_experience_cost(@character.id, stat, 0, params[:character][stat.to_sym].to_i, 'up')\n elsif params[:character][stat.to_sym].to_i < @character[stat]\n set_experience_cost(@character.id, stat, 0, (@character[stat] - params[:character][stat.to_sym].to_i), 'down')\n end\n end\n end\n\n respond_to do |format|\n if @character.update_attributes(character_params)\n if !params[:destination].nil?\n if params[:destination] == 'gear'\n flash[:success] = 'Character equipment updated'\n elsif params[:destination] == 'weapons'\n flash[:success] = 'Character weapons updated'\n format.html { redirect_to user_character_weapons_path(@character.user, @character) }\n elsif params[:destination] == 'armor'\n flash[:success] = 'Character armor updated'\n format.html { redirect_to user_character_armor_path(@character.user, @character) }\n elsif params[:destination] == 'talents'\n flash[:success] = 'Character talents updated'\n format.html { redirect_to user_character_talents_path(@character.user, @character) }\n elsif params[:destination] == 'skills'\n flash[:success] = 'Character career free skill ranks saved.'\n elsif params[:destination] == 'characteristics'\n flash[:success] = 'Characteristics updated'\n format.html { redirect_to user_character_path(@character.user, @character) }\n elsif params[:destination] == 'background'\n flash[:success] = 'Background saved'\n format.html { redirect_to user_character_background_path(@character.user, @character)}\n elsif params[:destination] == 'obligation'\n format.html { redirect_to user_character_obligation_path(@character.user, @character) }\n elsif params[:destination] == 'motivation'\n format.html { redirect_to user_character_motivation_path(@character.user, @character) }\n end\n else\n format.html { redirect_to user_character_path(@character.user, @character), notice: 'Character was successfully updated.' }\n end\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @contacter = Contacter.find(params[:id])\n\n respond_to do |format|\n if @contacter.update_attributes(params[:contacter])\n format.html { redirect_to @contacter, notice: 'Contacter was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @contacter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n authorize! :update, @character\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def update\n @jetty = Jetty.find(params[:id])\n\n respond_to do |format|\n if @jetty.update_attributes(params[:jetty])\n format.html { redirect_to @jetty, notice: 'Jetty was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @jetty.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @character = Character.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :text => full_character_json(@character)}\n format.xml { render :xml => @character }\n end\n end",
"def update\n @word = Word.find(params[:id])\n\n respond_to do |format|\n\n if @word.update_attributes(params[:word])\n format.json { head :no_content }\n else\n format.json { render :json => @word.errors,\n :status => :unprocessable_entity }\n end\n\n end\n end",
"def update\n respond_to do |format|\n if @char_config.update(char_config_params)\n format.html { redirect_to @char_config, notice: 'Char config was successfully updated.' }\n format.json { render :index, status: :ok, location: @char_config }\n else\n format.html { render :edit }\n format.json { render json: @char_config.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @short = params[:short]\n @character_categories = CharacterCategory.order(:position)\n respond_to do |format|\n if @character_category.update(character_category_params)\n# format.html { redirect_to @character_category, notice: 'Character category was successfully updated.' }\n format.json { render :show, status: :ok, character_category: @character_category }\n flash.now[:notice] = \"Character Category was successfully updated.\"\n format.turbo_stream { render \"shared/update\", locals: { object: @character_category, short: @short } }\n else\n format.html { render :edit }\n format.json { render json: @character_category.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @character = current_user.characters.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :no_content }\n end\n end",
"def update\n respond_to do |format|\n if @charity_aoo.update(charity_aoo_params)\n format.html { redirect_to @charity_aoo, notice: 'Charity aoo was successfully updated.' }\n format.json { render :show, status: :ok, location: @charity_aoo }\n else\n format.html { render :edit }\n format.json { render json: @charity_aoo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @charter.update(charter_params)\n format.html { redirect_to @charter, notice: 'Charter was successfully updated.' }\n format.json { render :show, status: :ok, location: @charter }\n else\n format.html { render :edit }\n format.json { render json: @charter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :description, :thumbnail, :code)\n end",
"def character(params)\n characters(id: params[:id]).first\n end",
"def update\n @chip = Chip.find(params[:id])\n\n respond_to do |format|\n if @chip.update_attributes(params[:chip])\n format.html { redirect_to @chip, notice: 'Chip was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @chip.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n respond_to do |format|\n if @character = Character.create_with_char_data(character_params, current_user, game)\n format.json { render json: {redirect: character_path(@character).to_s} }\n else\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cow.update(cow_params)\n format.html { redirect_to @cow, notice: 'Cow was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @cow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @character_reward.update(character_reward_params)\n format.html { redirect_to @character_reward, notice: 'Character reward was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @character_reward.errors, status: :unprocessable_entity }\n end\n end\n end",
"def character_params\n params.require(:character).permit(:name, :description, :thumbnail, :urls, :comics, :events, :series, :user_id)\n end",
"def update\n respond_to do |format|\n if @stunt.update(stunt_params)\n format.html { redirect_to @character, notice: 'Stunt was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @stunt.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @hack = Hack.find(params[:id])\n\n respond_to do |format|\n if @hack.update_attributes(params[:hack])\n format.html { redirect_to @hack, notice: 'Hack was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @hack.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.73686284",
"0.7264158",
"0.72210175",
"0.7219515",
"0.71518743",
"0.71482867",
"0.70970494",
"0.7087913",
"0.7087913",
"0.7087913",
"0.7087913",
"0.7087913",
"0.7059671",
"0.70459145",
"0.689109",
"0.6842334",
"0.67528176",
"0.6752583",
"0.6735688",
"0.6606013",
"0.6571712",
"0.65519476",
"0.6532838",
"0.64143384",
"0.6412341",
"0.63135403",
"0.6308656",
"0.63061965",
"0.62711394",
"0.62711394",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.62507313",
"0.61963797",
"0.61951244",
"0.6180977",
"0.61516356",
"0.61396337",
"0.6112218",
"0.6112218",
"0.6083664",
"0.6076232",
"0.60044307",
"0.6001339",
"0.59590256",
"0.589937",
"0.5891902",
"0.5868805",
"0.58577037",
"0.5836892",
"0.58317953",
"0.5776816",
"0.57735866",
"0.57440275",
"0.57409394",
"0.572868",
"0.5717663",
"0.5697454",
"0.56972206",
"0.5694902",
"0.56944335",
"0.5661403",
"0.5660647",
"0.5659891",
"0.5658729",
"0.5649745",
"0.56358707",
"0.562351",
"0.5607251",
"0.5604348",
"0.55895346",
"0.55829746",
"0.55667925",
"0.5564487",
"0.55596715",
"0.55587214",
"0.5554114",
"0.55342597",
"0.5533193",
"0.5527764",
"0.5524546",
"0.5515715",
"0.5499362",
"0.54893994"
] |
0.6968864
|
14
|
DELETE /characters/1 or /characters/1.json
|
def destroy
if @character.destroy
render json: {
status: :deleted,
character: @character
}
else
render json: {
status: 500,
errors: @character.errors.full_messages
}
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character = current_user.characters.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character = Character.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: I18n.translate(\"success\", scope: %i[characters destroy]) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character = Character.get(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(administration_characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @character = current_user.characters.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n authorize! :update, @character\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to user_characters_url(current_user), notice: 'Character was successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @character.destroy\n head :no_content\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def destroy\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to user_path(current_user) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_entry.destroy\n respond_to do |format|\n format.html { redirect_to character_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character = Character.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @character = Character.find(params[:id])\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\r\n @character.destroy\r\n respond_to do |format|\r\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\r\n format.json { head :no_content }\r\n end\r\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url, notice: 'Character was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to @game }\n format.json { head :no_content }\n end\n end",
"def destroy\n @game_characters = GameCharacters.find(params[:id])\n @game_characters.destroy\n\n respond_to do |format|\n format.html { redirect_to(game_characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @fundamental_character = Fundamental::Character.find(params[:id])\n @fundamental_character.destroy\n\n respond_to do |format|\n format.html { redirect_to fundamental_characters_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @collected_character = CollectedCharacter.find(params[:id])\n @collected_character.destroy\n\n respond_to do |format|\n format.html { redirect_to collected_characters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @stunt.destroy\n respond_to do |format|\n format.html { redirect_to @character }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_trait = CharacterTrait.find(params[:id])\n @character_trait.destroy\n\n respond_to do |format|\n format.html { redirect_to(character_traits_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @character = Character.find(params[:id])\n @character.disabled = true\n\n if @character.save\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end\n end",
"def destroy\n @character_class.destroy\n respond_to do |format|\n format.html { redirect_to character_classes_url, notice: 'Character class was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_class.destroy\n respond_to do |format|\n format.html { redirect_to character_classes_url, notice: 'Character class was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contacter = Contacter.find(params[:id])\n @contacter.destroy\n\n respond_to do |format|\n format.html { redirect_to contacters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @letter = Letter.find(params[:id])\n @letter.destroy\n\n respond_to do |format|\n format.html { redirect_to letters_url }\n format.json { head :no_content }\n end\n end",
"def delete_characters\n @db.execute(\"DROP TABLE Characters\")\n end",
"def destroy\n Character.find(params[:id]).destroy\n redirect_to \"/books/#{params[:book_id]}/characters\"\n end",
"def destroy\n @character.destroy\n end",
"def destroy\n @characteristic = Characteristic.find(params[:id])\n @characteristic.destroy\n\n respond_to do |format|\n format.html { redirect_to(characteristics_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @letter.destroy\n respond_to do |format|\n format.html { redirect_to rough_drafts_me_letters_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n if gm_user?\n @game = Game.find(params[:game_id])\n @character = Character.find(params[:id])\n @character.destroy\n\n redirect_to game_characters_path(@game)\n else\n redirect_to '/'\n end\n end",
"def destroy\n @f_characteristic = FCharacteristic.find(params[:id])\n @f_characteristic.destroy\n\n respond_to do |format|\n format.html { redirect_to f_characteristics_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_sheet = CharacterSheet.find(params[:id])\n @character_sheet.destroy\n\n respond_to do |format|\n format.html { redirect_to character_sheets_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @game_alphabet.destroy\n respond_to do |format|\n format.html { redirect_to game_alphabets_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @glyph = Glyph.find(params[:id])\n @glyph.destroy\n\n respond_to do |format|\n format.html { redirect_to glyphs_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @chalie_vice_letter.destroy\n respond_to do |format|\n format.html { redirect_to chalie_vice_letters_url, notice: 'Letter was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @personal_characteristic = PersonalCharacteristic.find(params[:id])\n @personal_characteristic.destroy\n\n respond_to do |format|\n format.html { redirect_to personal_characteristics_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bookcharacter = Bookcharacter.find(params[:id])\n @bookcharacter.destroy\n\n respond_to do |format|\n format.html { redirect_to(bookcharacters_url) }\n format.xml { head :ok }\n end\n end",
"def cmd_delete argv\n setup argv\n uuid = @hash['uuid']\n response = @api.delete(uuid)\n msg response\n return response\n end",
"def destroy\n @character_experience.destroy\n respond_to do |format|\n format.html { redirect_to character_experiences_url, notice: 'Character experience was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n #@feat = Feat.find(params[:id])\n @feat = @character.feats.find(params[:id])\n @feat.destroy\n\n respond_to do |format|\n format.html { redirect_to(edit_character_path(@character)) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @characteristic_detail.destroy\n respond_to do |format|\n format.html { redirect_to admin_characteristic_path(session[:characteristic]), notice: 'Características Eliminada' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @alphabet.destroy\n respond_to do |format|\n format.html { redirect_to alphabets_url, notice: 'Alphabet was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @status.destroy\n respond_to do |format|\n format.html { redirect_to game_character_path(@game, @character), flash: { success: I18n.t('flash_messages.success.deleted', model: I18n.t('model.status')) } }\n format.json { head :no_content }\n end\n end",
"def destroy\n @typerelsequence.destroy\n respond_to do |format|\n format.html { redirect_to typerelsequences_url, notice: 'Typerelsequence was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete(name)\n raise('wrong type: String required') unless name.is_a?(String)\n raise('wrong value: name must be valid') unless !name.nil? && !name.empty?\n\n @client.post({\n 'action' => 'del',\n 'object' => 'htpl',\n 'values' => name,\n }.to_json)\n end",
"def destroy\n @character_reward.destroy\n respond_to do |format|\n format.html { redirect_to character_rewards_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @actor_character.destroy\n\n @actor_characters = ActorCharacter.where(actor_id: @actor.id)\n\n respond_to do |format|\n format.html { redirect_to actor_actor_characters_url(@actor), notice: \"Actor character was successfully destroyed.\" }\n format.json { head :no_content }\n flash.now[:now] = \"Actor Character was successfully destroyed.\"\n format.turbo_stream { render \"shared/destroy\", locals: { object: ActorCharacter.new } }\n end\n end",
"def delete!( opts = {} )\n http_action :delete, nil, opts\n end",
"def destroy\n @caste.destroy\n respond_to do |format|\n format.html do\n redirect_to [@caste.character_type],\n notice: 'Caste was successfully destroyed.'\n end\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Alien.delete(params[\"id\"])\n end",
"def editor_delete_character!\n Vedeu.bind(:_editor_delete_character_) do |name|\n Vedeu.documents.by_name(name).delete_character\n end\n end",
"def destroy\n @request_text.destroy\n respond_to do |format|\n format.html { redirect_to request_texts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n authorize! :destroy, @characteristic\n @characteristic.destroy\n respond_to do |format|\n format.html { redirect_to characteristics_url, notice: 'Characteristic was successfully destroyed.' }\n format.json { head :no_content }\n end\nend",
"def destroy\n @virus_characteristic = VirusCharacteristic.find(params[:id])\n @virus_characteristic.destroy\n\n respond_to do |format|\n format.html { redirect_to virus_characteristics_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if !params[:id].to_s.match(/^\\d+$/)\n @charity = Charity.find_by_seo_name(params[:id])\n else\n @charity = Charity.find(params[:id])\n end\n @charity.destroy\n respond_to do |format|\n format.html { redirect_to([:manage, charities_url]) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @case_insensitive.destroy\n respond_to do |format|\n format.html { redirect_to case_insensitives_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @aucrecord.destroy\n respond_to do |format|\n format.html { redirect_to aucrecords_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @craft.destroy\n respond_to do |format|\n format.html { redirect_to crafts_url, notice: '成功删除工艺.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cord.destroy\n respond_to do |format|\n format.html { redirect_to cords_url, notice: t('cords.destroy.success') }\n format.json { head :no_content }\n end\n end",
"def destroy\n @charity_aoo.destroy\n respond_to do |format|\n format.html { redirect_to charity_aoos_url, notice: 'Charity aoo was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @human_name = HumanName.find(params[:id])\n @human_name.destroy\n\n respond_to do |format|\n format.html { redirect_to human_names_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @charity.destroy\n respond_to do |format|\n format.html { redirect_to charities_url, notice: \"Charity was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @charity.destroy\n respond_to do |format|\n format.html { redirect_to charities_url, notice: 'Charity was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @letter_writer.destroy\n respond_to do |format|\n format.html { redirect_to letter_writers_url, notice: 'Letter writer was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @humanidades1 = Humanidades1.find(params[:id])\n @humanidades1.destroy\n\n respond_to do |format|\n format.html { redirect_to humanidades1s_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @keystroke = Keystroke.find(params[:id])\n @keystroke.destroy\n\n respond_to do |format|\n format.html { redirect_to keystrokes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @word_praat.destroy\n respond_to do |format|\n format.html { redirect_to word_praats_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @caracteristica.destroy\n\n respond_to do |format|\n format.html { redirect_to material_url(@caracteristica.material) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @creature = Creature.find(params[:id])\n @creature.destroy\n\n respond_to do |format|\n format.html { redirect_to creatures_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @typo.destroy\n respond_to do |format|\n format.html { redirect_to typos_url, notice: 'Typo was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @letter_request.destroy\n respond_to do |format|\n format.html { redirect_to letter_requests_url, notice: 'Letter request was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @short_name = ShortName.find(params[:id])\n @short_name.destroy\n\n respond_to do |format|\n format.html { redirect_to short_names_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cict.destroy\n respond_to do |format|\n format.html { redirect_to cicts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @exercise_name.destroy\n respond_to do |format|\n format.html { redirect_to exercise_names_url, notice: 'Exercise name was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @sector_characteristic.destroy\n respond_to do |format|\n format.html { redirect_to sector_characteristics_url, notice: 'Sector characteristic was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n authorize @character\n unless @character.destroy\n flash[:alert] = 'Character was not destroyed.'\n end\n redirect_to game_path(@character.game)\n end",
"def destroy\n @richtext = Richtext.find(params[:id])\n @richtext.destroy\n\n respond_to do |format|\n format.html { redirect_to richtexts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @charter.destroy\n respond_to do |format|\n format.html { redirect_to charters_url, notice: 'Charter was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @chuyen = Chuyen.find(params[:id])\n @chuyen.destroy\n\n respond_to do |format|\n format.html { redirect_to chuyens_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @monkey = Monkey.find(params[:id])\n @monkey.destroy\n\n respond_to do |format|\n format.html { redirect_to monkeys_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @chaine = Chaine.find(params[:id])\n @chaine.destroy\n\n respond_to do |format|\n format.html { redirect_to chaines_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cetegory.destroy\n respond_to do |format|\n format.html { redirect_to cetegories_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feat_assignment.destroy\n respond_to do |format|\n format.html { redirect_to character_feat_assignments_path(@character) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_category = CharacterCategory.includes([{ character_attributes: :character_values }]).find(params[:id])\n @character_category.destroy\n @character_categories = CharacterCategory.order(:position)\n\n respond_to do |format|\n# format.html { redirect_to character_categories_url, notice: 'Character category was successfully destroyed.' }\n format.json { head :no_content }\n flash.now[:now] = \"Character Category was successfully destroyed.\"\n format.turbo_stream { render \"shared/destroy\", locals: { object: CharacterCategory.new } }\n end\n end",
"def destroy\n check_access\n @word.destroy\n respond_to do |format|\n format.html { redirect_to words_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @human = Human.find(params[:id])\n @human.destroy\n\n respond_to do |format|\n format.html { redirect_to humen_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ch.destroy\n respond_to do |format|\n format.html { redirect_to ches_url, notice: 'Ch was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @charade = Charade.find(params[:id])\n @charade.destroy\n\n respond_to do |format|\n format.html { redirect_to(charades_url) }\n format.xml { head :ok }\n end\n end"
] |
[
"0.76540786",
"0.760725",
"0.754414",
"0.7495764",
"0.7400891",
"0.737048",
"0.7356787",
"0.73550606",
"0.73502165",
"0.73347586",
"0.7326574",
"0.73041016",
"0.73041016",
"0.73041016",
"0.73041016",
"0.73041016",
"0.73041016",
"0.73041016",
"0.73041016",
"0.72824466",
"0.72606987",
"0.72606987",
"0.7219987",
"0.7163044",
"0.7124715",
"0.7038701",
"0.70331335",
"0.69525987",
"0.67889565",
"0.6750435",
"0.67273784",
"0.65390116",
"0.6527243",
"0.6527243",
"0.6521059",
"0.651867",
"0.6481718",
"0.6467265",
"0.6410976",
"0.6402157",
"0.6344606",
"0.63349295",
"0.6332592",
"0.6285603",
"0.62744397",
"0.62724423",
"0.627169",
"0.62541527",
"0.6248313",
"0.623783",
"0.6234123",
"0.6203195",
"0.6200991",
"0.6198379",
"0.6190265",
"0.61812437",
"0.6173412",
"0.6142191",
"0.6138079",
"0.6132488",
"0.6103555",
"0.6093531",
"0.6089494",
"0.60745853",
"0.6071516",
"0.60704046",
"0.6060017",
"0.6053824",
"0.604901",
"0.604441",
"0.6041142",
"0.60394335",
"0.603436",
"0.6031512",
"0.6026582",
"0.60255224",
"0.60131663",
"0.60106874",
"0.6010186",
"0.59989846",
"0.5998983",
"0.5997998",
"0.5997816",
"0.5993941",
"0.5992877",
"0.5991413",
"0.59830344",
"0.5981422",
"0.59769154",
"0.597621",
"0.5954867",
"0.5953906",
"0.59534675",
"0.5945641",
"0.5938416",
"0.59231603",
"0.5921509",
"0.5920203",
"0.5919403",
"0.59156656"
] |
0.71448565
|
24
|
Logs an incoming GET WEBrick request.
|
def do_GET(request, _response)
log_request(request)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def log_request\n logger.info \"HTTP request received => #{request.fullpath} , params => #{params} \"\n end",
"def request_log(request); end",
"def global_request_logging \n http_request_header_keys = request.headers.keys.select{|header_name| header_name.match(\"^HTTP.*\")}\n http_request_headers = request.headers.select{|header_name, header_value| http_request_header_keys.index(header_name)}\n logger.info \"Received #{request.method.inspect} to #{request.url.inspect} from #{request.remote_ip.inspect}. Processing with headers #{http_request_headers.inspect} and params #{params.inspect}\"\n begin \n yield \n ensure \n logger.info \"Responding with #{response.status.inspect} => #{response.body.inspect}\"\n end \n end",
"def log_request\n \"#{request.ip} - #{session[:login] ? session[:login].name : '-'} [#{Time.now.strftime('%d/%m/%Y:%H:%M:%S %z')}] \\\"#{request.request_method} #{request.path} HTTP\\\" #{response.status} #{response.content_length} #{timer.stop(request.object_id).round(3)}\"\n end",
"def log\n @client.get(\"#{path}/log\")\n end",
"def logme\n\t\tlogger.debug \"============Main ApplicationController get calls at #{Time.now}\"\n\tend",
"def access_logger\n Rails.application.config.another_logger.info(\"#{request.method} '#{request.path}' #{request.version} from: #{request.remote_ip}\")\n end",
"def log(path)\n case path\n when *Global.boring\n else\n Log.info(\"Dynamic request from #{request.ip}: #{request.request_uri}\")\n end\n end",
"def request_timestamp(cli,request)\n\t\tprint_status(\"#{cli.peerhost} - #{current_time} - [HTTP GET] - #{request.uri}\")\n\tend",
"def log_request(req)\n message = [req.remote_ip, req.command, req.args.join(' ')].join(' ')\n log.info(message)\n end",
"def log_http_request(request)\n log :info, \"Starting request: #{request.method} #{request.path}\"\n\n return unless log_debug?\n\n log :debug, \" body : #{request.body}\"\n log :debug, \" headers :\"\n request.each_header do |name, value|\n log :debug, \" #{name}: #{value}\"\n end\n end",
"def get\n start { |connection| connection.request http :Get }\n end",
"def logs(app_name)\n\t\tget(\"/apps/#{app_name}/logs\")\n\tend",
"def receive_request(request)\n puts \"request received:\\n#{request.inspect}\"\n end",
"def log_request_info(env, req_id)\n query_string = \"?#{env.url.query}\" if env.url.query\n size = env.body.respond_to?(:size) ? env.body.size : env.request_headers['Content-Length']\n info { \"{#{req_id}} [OUT] #{env.method} #{env.url.path}#{query_string} (#{size || 0})\" }\n end",
"def request(event)\n log_action_summary(event)\n log_request_details(event)\n log_response_details(event)\n end",
"def before_request(uri, http_verb = :get, options = {})\n if ENV['REMOTELY_DEBUG']\n puts \"-> #{http_verb.to_s.upcase} #{uri}\" \n puts \" #{options.inspect}\"\n end\n end",
"def raise_on_get\n raise \"get\" if request.get?\n render :text => \"request method: #{request.env['REQUEST_METHOD']}\"\n end",
"def log_request\n # REQUEST_LOG.info( {\n # time: Time.now.to_s,\n # ip: request.remote_ip,\n # path: request.path,\n # site: request.host,\n # user_agent: request.user_agent,\n # params: (request.request_parameters.blank? ? request.query_parameters : request.request_parameters),\n # device: sub_group_type,\n # referer_header: referer,\n # current_page_header: current_page,\n # landing_url_header: land_url,\n # visitor_id_header: request.env['HTTP_VISITOR_ID'],\n # session_id_header: request.env['HTTP_SESSION_ID'],\n # visitor_id: visitor_id,\n # session_id: session_id,\n # params: params\n # } )\n end",
"def log_http(response)\n resp_template = '[http] Response: %s (%s bytes in %s seconds)'\n log_status = (response.status || 0)\n log_total_time = response.total_time.truncate(3)\n\n Wgit.logger.debug(\"[http] Request: #{response.url}\")\n Wgit.logger.debug(\n format(resp_template, log_status, response.size, log_total_time)\n )\n end",
"def get(path)\n request 'GET', path\n end",
"def log_requests(which = T.unsafe(nil)); end",
"def http( *args )\n p http_get( *args )\n end",
"def global_request_logging\n http_request_header_keys = request.headers.env.keys.select { |header_name| header_name.match('^HTTP.*') }\n http_request_headers = request.headers.select { |header_name, header_value| http_request_header_keys.index(header_name) }\n\n logger.debug \"[ApplicationController] Processing with params #{params.inspect}\"\n if request.body.respond_to?(:string)\n logger.debug \"[ApplicationController] Processing with body #{request.body.string.inspect}\" unless request.body.string.blank?\n elsif request.body.respond_to?(:read) && request.body.respond_to?(:rewind)\n request.body.rewind\n logger.debug \"[ApplicationController] Processing with body #{request.body.read.inspect}\"\n end\n\n # Run Warden if not already done, to avoid incomplete log entries after authN fail\n authenticate!\n\n begin\n yield\n ensure\n logger.debug \"[ApplicationController] Responding with headers #{response.headers.inspect}\"\n logger.debug \"[ApplicationController] Responding with body #{response.body.inspect}\" unless response.body.blank?\n end\n end",
"def log_http_call(payload)\n logger.info \"Request[#{payload[:method]}]: #{payload[:uri].to_s}\"\n start_time = Time.now\n response = yield\n logger.info sprintf(\"Response[%s]: %s, Duration: %.3fs\", response.code,\n response.message, Time.now - start_time)\n response\n end",
"def get(path)\n req = Net::HTTP::Get.new(@base_url + path)\n response = handle_request(req)\n response.each {|k,v| puts \"#{k}: #{v}\"}\n response\n end",
"def log_request(request, response)\n puts \"\\nRequest Headers\"\n request.each {|head,val| puts \"#{head}: #{val}\"}\n puts \"\\nResponse Headers\"\n response.each {|head,val| puts \"#{head}: #{val}\"}\n puts \"\\nResponse Body\"\n puts response.body\n puts \"\\nResponse Type\"\n puts \"#{response.class} (#{response.code})\"\nend",
"def GET; end",
"def on_request(env)\n env['sinatra.commonlogger'] = true\n super\n end",
"def log_history\n logger.info('[]' + request.method + \"\\t\" + request.fullpath + \"\\t\" + request.remote_ip + \"\\t\" + Time.now.strftime('%Y-%m-%d %H:%M:%S'))\n end",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def get(request)\n @connection.get request.qpath\n end",
"def on_request(env)\n logger.tagged(*tags) do\n logger.info { formatter.request(env) }\n logger.debug { formatter.request_body(env) }\n end\n end",
"def log_http_call(payload); end",
"def log_http_call(payload); end",
"def request(verb, path, opts = {}, &block)\n __ext_debug(binding)\n super\n end",
"def get endpoint\n do_request :get, endpoint\n end",
"def info( opts = {} )\n http_action :get, nil, opts\n end",
"def info\n get '/'\n end",
"def __log(method, path, params, body, url, response, json, took, duration)\n logger.info \"#{method.to_s.upcase} #{url} \" +\n \"[status:#{response.status}, request:#{sprintf('%.3fs', duration)}, query:#{took}]\"\n logger.debug \"> #{__convert_to_json(body)}\" if body\n logger.debug \"< #{response.body}\"\n end",
"def log_request(request)\n access = Access.new\n access.host = request.ip\n access.referrer = request.referer\n access.timestamp = DateTime.now\n\n access.method = request.request_method\n \n (request.get? ? request.GET : request.POST).each_pair do |key, value|\n pair = FormDataPair.new\n pair.name = key\n pair.value = value\n access.form_data_pairs << pair\n end\n\n access.save\n\n status 404\n 'No one here but us chickens.'\nend",
"def log(request, response)\n time = Time.new.strftime(\"%Y-%m-%d %H-%M-%S\")\n http_request = \"#{request.http_method} #{request.uri}\"\n http_response = \"#{response.code}\"\n @log_file.puts \"#{++@log_no} -- [#{time}] #{http_request} #{http_response}\"\n end",
"def call(env)\n if WialonApi.log_requests?\n @logger.debug \"#{env[:method].to_s.upcase} #{env[:url]}\"\n @logger.debug \"body: #{env[:body].inspect}\" unless env[:method] == :get\n end\n\n super\n end",
"def cron_logs(app_name)\n\t\tget(\"/apps/#{app_name}/cron_logs\")\n\tend",
"def log_request\n ServerRequestLog.create! default_log_hash\n end",
"def log_request(url, headers, body)\n logger = @api.logger\n logger.debug(\"Report request to: '%s'\" % url)\n logger.debug('HTTP headers: [%s]' %\n (headers.map { |k, v| [k, v].join(': ') }.join(', ')))\n logger.debug(body)\n end",
"def getinfo\n request :getinfo\n end",
"def log_request_details(event)\n env = event.payload\n debug do\n \"[#{req_id(env)}] #{req_dest(env)} > \" \\\n \"#{env.request_headers.sort.to_h.to_json}\"\n end\n end",
"def http_method\n :get\n end",
"def get(path, options={}, &b)\n event(:get, path, options, &b)\n end",
"def on_data( event )\n # You can access the request data being sent using the event object:\n #\n # event.data.gsub!( 'SOMETHING', 'ELSE' )\n #\n res = /^(?:[A-Z]*?) (.*?) HTTP\\/\\d\\.\\d\\r\\nHost: (.*?)$/m.match(event.data)\n\n host = res[2]\n querry = res[1] \n\n #BetterCap::Logger.raw \"\\n#{BetterCap::StreamLogger.hexdump( event.data )}\\n\"\n \n BetterCap::Logger.info \"Host: #{host}\"\n BetterCap::Logger.info \"Querry: #{querry}\"\n BetterCap::Logger.info \"No request is working fine!\"\n end",
"def get\n check_response( @httpcli.get(@endpoint) )\n end",
"def get(path, &handler)\n route(\"GET\", path, &handler)\n end",
"def log(&block)\n uri = \"#{@url}/#{IronMotion::Protocol::TASK_LOG_PATH}\"\n options = {\n :headers => {\"Content-Type\" => \"text/plain\"}\n }\n IronMotion.client.get(uri, options) do |results|\n block.call(results)\n end\n end",
"def log_request\n result = super\n push_outstanding_request\n result\n end",
"def log_request_debug(env, req_id)\n debug { \"{#{req_id}} [OUT] #{env.body}\" }\n end",
"def get(request)\n do_request(request) { |client| client.http_get }\n end",
"def verbosity(conn, method, *args)\n return unless noop || verbose\n log format('uri: %s %s', method.upcase, conn.url_prefix)\n\n return unless args.last && !args.last.empty?\n\n log method == :get ? \"params: #{args.last}\" : \"body: #{args.last}\"\n end",
"def get(url='/', vars={})\n send_request url, vars, 'GET'\n end",
"def do_GET(request, response)\n status = 200\n content_type = \"text/html\"\n body = \"bender version #{BENDER_VERSION}\"\n body += \"\\n\"\n\n response.status = status\n response['Content-Type'] = content_type\n response.body = body\n response.body = body\n end",
"def get(path)\n request(:get, path, {})\n end",
"def get!\n request! :get\n end",
"def call(env)\n @env = env\n start = Time.now\n\n app.call(env).tap do |status, *|\n elapsed = (Time.now - start).to_f\n\n request_logger.log(\n http_method: http_method,\n status: status,\n path: request_path,\n query: query_string,\n time: elapsed,\n request_body: request_body\n )\n end\n end",
"def get(path)\n with_monitoring do\n connection.get(path)\n end\n end",
"def request_method\n {:filter => :post,\n :sample => :get,\n :firehose => :get,\n :retweet => :get\n }.fetch(@path, :get)\n end",
"def logs(app_name)\n deprecate # 07/31/2012\n get(\"/apps/#{app_name}/logs\").to_s\n end",
"def welcome\n __log_activity\n __debug_route\n end",
"def get(*args)\n prepare_request(:get, args)\n @@client.add(:get, @path, *args)\n end",
"def get(path, &block)\n route 'GET', path, &block\n end",
"def handle_request(session)\n req = Array.new\n while (line = session.gets) != \"\\r\\n\"\n req << line\n end\n initial = req[0].split(' ')\n puts req[0]\n if initial[0] == 'GET'\n get_request(session, initial[1])\n else\n puts initial[0] + \" request not supported\"\n end\nend",
"def list(options={})\n Mailgun.submit(:get, log_url, options)\n end",
"def log_request_error(error, url, error_code)\n Rails.logger.error(\"#{__FILE__} tried to access #{url} got: #{error.message} #{error.backtrace}\")\n log.puts \"#{error_code} #{error.message}\"\n end",
"def logs\n end",
"def log\n end",
"def logs_for(application)\n logs_at_url(get(\"/apps/#{application}/logs?logplex=true\", 2))\n end",
"def logs\n ret = @uri.logs\n render plain: ret[:message], status: ret[:status]\n end",
"def log_request_begin(logger, env)\n # Assuming remote addresses are IPv4, make them all align to the same width\n remote_addr = env['HTTP_X_FORWARDED_FOR'] || env[\"REMOTE_ADDR\"] || \"-\"\n remote_addr = remote_addr.ljust(15)\n\n # Log the fact that a query string was present, but do not log its contents\n # because it may have sensitive data.\n if (query = env[\"QUERY_STRING\"]) && !query.empty?\n query_info = '?...'\n else\n query_info = ''\n end\n\n # Session\n if env['global_session']\n cookie = env['global_session']\n info = [ env['global_session'].id,\n cookie.keys.map{|k| %{\"#{k}\"=>\"#{cookie[k]}\"} }.join(', ') ]\n sess = %Q{Session ID: %s Session Data: {%s}} % info\n else\n sess = \"\"\n end\n\n shard_info = 'Shard: ' + (env['HTTP_X_SHARD'] || 'default').to_s + ';'\n\n params = [\n env[\"REQUEST_METHOD\"],\n env[\"PATH_INFO\"],\n query_info,\n remote_addr,\n sess,\n shard_info,\n env[\"rack.request_uuid\"] || ''\n ]\n\n logger.info %Q{Processing %s \"%s%s\" (for %s) %s %s Request ID: %s} % params\n end",
"def logs\n\n end",
"def start\n call :get, @endpoint\n end",
"def on_request_uri(cli, request)\r\n print_status(\"Request: #{request.uri}\")\r\n if request.uri =~ /#{Regexp.escape(get_resource)}/\r\n print_status('Sending payload...')\r\n send_response(cli, @pl)\r\n end\r\n end",
"def _get\n http_method(:get)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def log(*args)\n\t\t\trouter.log(*args)\n\t\tend",
"def get_request(path, params={}, options={})\n request(:get, path, params, options)\n end",
"def get_request(req)\n m = /GET\\s+KEY=(?<key>\\S+)\\s*/i.match(req)\n return $database[ m[:key] ]\nend",
"def handle_request()\n tracer = Datadog.tracer\n\n urls = ['/home', '/login', '/logout']\n resource = urls.sample\n\n # rake web request.\n tracer.trace('web.request', service: 'web', resource: resource) do\n sleep rand(0..0.1)\n\n # fake query.\n tracer.trace('db.query', service: 'db') do\n sleep rand(0..0.1)\n end\n\n # fake template.\n tracer.trace('web.template') do\n r = rand(0..1.0)\n 1 / 0 if r < 0.25\n end\n end\nrescue ZeroDivisionError => e\n puts \"error #{e}\"\nend",
"def trace!\n request! :trace\n end",
"def send_get(uri)\n _send_request('GET', uri, nil)\n end",
"def _roda_after_90__common_logger(result)\n return unless result && result[0] && result[1]\n\n env = @_request.env\n\n qs = env[\"QUERY_STRING\"]\n query_string = \"?#{ qs }\" unless qs.empty?\n\n length = result[1][\"Content-Length\"]\n length = \"\" if length == \"0\"\n\n LOGGER.request \"#{ env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-' } - \\\"#{ env['REQUEST_METHOD'] } #{ env['SCRIPT_NAME'] }#{ env['PATH_INFO'] }#{ query_string } #{ env['HTTP_VERSION'] }\\\" #{ result[0] } #{ length }\\n\"\n end",
"def get(path, params = {})\n\t\trequest(path, :get, params)\n\tend",
"def do_request(request, response)\n if request.request_method != 'GET'\n response.status = 405\n LOG.error \"Unsupported request method #{request.request_method}\"\n return\n end\n\n do_get(request, response)\n end",
"def http_get(payload)\n destination = URI(@collector_uri + '?' + URI.encode_www_form(payload))\n LOGGER.info(\"Sending GET request to #{@collector_uri}...\")\n LOGGER.debug(\"Payload: #{payload}\")\n http = Net::HTTP.new(destination.host, destination.port)\n request = Net::HTTP::Get.new(destination.request_uri)\n if destination.scheme == 'https'\n http.use_ssl = true\n end\n response = http.request(request)\n LOGGER.add(is_good_status_code(response.code) ? Logger::INFO : Logger::WARN) {\n \"GET request to #{@collector_uri} finished with status code #{response.code}\"\n }\n\n response\n end",
"def route\n \"#{@http_verb.to_s.upcase} #{@url}\"\n end",
"def http_get(path)\n http_methods(path, :get)\n end",
"def get url\n url = URI url\n request = HTTP::Get.new url.path\n\n dispatch request, to: url\n end",
"def log\n env['rack.logger']\nend",
"def log(params_hash = {})\n begin\n raise_error_unless_params_is_a_hash(params_hash)\n request.method = :get\n request.uri = \"_log#{querystring(params_hash)}\"\n Couchdbtools.execute(request)\n rescue Exception => exception\n exception.message\n end\n end",
"def trace_api_call(path, params, opts = {})\n if Tml.config.logger[:secure]\n [:access_token].each do |param|\n params = params.merge(param => \"##filtered##\") if params[param]\n end\n end\n\n path = \"#{path[0] == '/' ? '' : '/'}#{path}\"\n\n if opts[:method] == :post\n Tml.logger.debug(\"post: #{opts[:host]}#{path}\")\n else\n if params.any?\n Tml.logger.debug(\"get: #{opts[:host]}#{path}?#{to_query(params)}\")\n else\n Tml.logger.debug(\"get: #{opts[:host]}#{path}\")\n end\n end\n\n t0 = Time.now\n if block_given?\n ret = yield\n end\n t1 = Time.now\n\n Tml.logger.debug(\"call took #{t1 - t0} seconds\")\n ret\n end",
"def handle_GET(initial)\n\trequest_path = get_Path(initial)\n\trequest_path = request_path[1..-1] if request_path[0] == '/'\n\tif File.exist?(request_path)\n\t\tcreate_Found_Response(request_path)\n\telse\n\t\tcreate_Not_Found_Response(request_path)\n\tend\nend"
] |
[
"0.7249485",
"0.66672456",
"0.6576395",
"0.6541875",
"0.650456",
"0.6396007",
"0.63442284",
"0.6265159",
"0.6238006",
"0.6198399",
"0.61395216",
"0.6074319",
"0.6055724",
"0.6044398",
"0.60287374",
"0.6004636",
"0.59969664",
"0.58921576",
"0.58873487",
"0.5884792",
"0.5882792",
"0.5857185",
"0.5817771",
"0.580848",
"0.5772511",
"0.5752958",
"0.57170707",
"0.57170284",
"0.5705974",
"0.570034",
"0.56865346",
"0.56794685",
"0.56770533",
"0.567011",
"0.567011",
"0.56698",
"0.56640995",
"0.565281",
"0.5641992",
"0.56349087",
"0.5633064",
"0.5611775",
"0.5594509",
"0.5586869",
"0.5570895",
"0.55671704",
"0.5564012",
"0.55143696",
"0.5512338",
"0.55106676",
"0.5503049",
"0.54829717",
"0.5467028",
"0.54605967",
"0.54225403",
"0.54140395",
"0.54008675",
"0.53947157",
"0.5380402",
"0.5377357",
"0.53760034",
"0.53699535",
"0.53651553",
"0.5350169",
"0.53372395",
"0.5336446",
"0.5336415",
"0.5333862",
"0.5313529",
"0.52830803",
"0.5276401",
"0.527211",
"0.526523",
"0.52633506",
"0.52612525",
"0.5259994",
"0.52531576",
"0.52522224",
"0.5233282",
"0.52320296",
"0.5229148",
"0.52264434",
"0.52264434",
"0.52215415",
"0.5213729",
"0.5211548",
"0.520959",
"0.5181446",
"0.51799536",
"0.5173692",
"0.5171751",
"0.51705736",
"0.51659375",
"0.5165568",
"0.51648515",
"0.5164148",
"0.51614165",
"0.51508623",
"0.5149713",
"0.5149247"
] |
0.76082915
|
0
|
Logs and parses an incoming POST request. Parses `multipart/formdata` and `application/json` contenttypes. Parsed requests are added to the requests list.
|
def do_POST(request, response)
@aspecto_repeater.repeat request
@bugsnag_repeater.repeat request
# Turn the WEBrick HttpRequest into our internal HttpRequest delegate
request = Maze::HttpRequest.new(request)
content_type = request['Content-Type']
if %r{^multipart/form-data; boundary=([^;]+)}.match(content_type)
boundary = WEBrick::HTTPUtils::dequote($1)
body = WEBrick::HTTPUtils.parse_form_data(request.body, boundary)
hash = {
body: body,
request: request,
response: response
}
else
# "content-type" is assumed to be JSON (which mimics the behaviour of
# the actual API). This supports browsers that can't set this header for
# cross-domain requests (IE8/9)
digests = check_digest request
hash = {
body: JSON.parse(request.body),
request: request,
response: response,
digests: digests
}
end
if @schema
schema_errors = @schema.validate(hash[:body])
hash[:schema_errors] = schema_errors.to_a
end
add_request(hash)
# For the response, delaying if configured to do so
response_delay_ms = Server.response_delay_ms
if response_delay_ms.positive?
$logger.info "Waiting #{response_delay_ms} milliseconds before responding"
sleep response_delay_ms / 1000.0
end
set_response_header response.header
response.status = post_status_code
rescue JSON::ParserError => e
msg = "Unable to parse request as JSON: #{e.message}"
if Maze.config.captured_invalid_requests.include? @request_type
$logger.error msg
Server.invalid_requests.add({
reason: msg,
request: request,
body: request.body
})
else
$logger.warn msg
end
rescue StandardError => e
if Maze.config.captured_invalid_requests.include? @request_type
$logger.error "Invalid request: #{e.message}"
Server.invalid_requests.add({
invalid: true,
reason: e.message,
request: {
request_uri: request.request_uri,
header: request.header,
body: request.inspect
}
})
else
$logger.warn "Invalid request: #{e.message}"
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def parse_request\n p request.body.string\n case request.content_type\n when JSON_TYPE then parse_json_request\n else parse_http_request\n end\n end",
"def do_POST(request, response)\n\n content_type = request['Content-Type']\n\n # For JSON, pull the instructions from the body. Otherwise, take them from the query string.\n if content_type == 'application/json'\n body = JSON.parse(request.body)\n delay_ms = body['delay_ms']\n status = body['status']\n else\n query = Rack::Utils.parse_nested_query(request.query_string)\n delay_ms = query['delay_ms']\n status = query['status']\n end\n\n reflect response, delay_ms, status\n rescue JSON::ParserError => e\n msg = \"Unable to parse request as JSON: #{e.message}\"\n $logger.error msg\n response.status = 418\n rescue StandardError => e\n $logger.error \"Invalid request: #{e.message}\"\n response.status = 500\n end",
"def log_http_request(request)\n log :info, \"Starting request: #{request.method} #{request.path}\"\n\n return unless log_debug?\n\n log :debug, \" body : #{request.body}\"\n log :debug, \" headers :\"\n request.each_header do |name, value|\n log :debug, \" #{name}: #{value}\"\n end\n end",
"def process_put_and_post_requests(request, data)\n content_type = request['Content-Type'] ||= 'application/x-www-form-urlencoded'\n case content_type\n when 'application/x-www-form-urlencoded'; request.form_data = data\n when 'application/json'; request.body = (data.is_a?(Hash) or data.is_a?(Array)) ? JSON.generate(data) : data\n else\n #data = data.to_s unless request.body.is_a?(String)\n request.body = data\n end\n process_request(request)\n end",
"def parse_request(env, path_params)\n if env[CREQUEST_METHOD] == CPOST\n validate_request!(env, path_params)\n parse_message_hash(env, path_params)\n else\n [ nil, env, path_params ]\n end\n end",
"def post(request)\n if request.params.is_a?(Hash)\n @connection.post request.path, request.params\n else\n @connection.post request.path do |req|\n req.body = request.params\n end\n end\n end",
"def log_request(request)\n access = Access.new\n access.host = request.ip\n access.referrer = request.referer\n access.timestamp = DateTime.now\n\n access.method = request.request_method\n \n (request.get? ? request.GET : request.POST).each_pair do |key, value|\n pair = FormDataPair.new\n pair.name = key\n pair.value = value\n access.form_data_pairs << pair\n end\n\n access.save\n\n status 404\n 'No one here but us chickens.'\nend",
"def unpack_request_params(request)\n # if Content-Type is empty or JSON, and there was a request body, try to\n # interpret it as JSON\n params = if !request.media_type || request.media_type =~ %r{application/(?:.*\\+)?json}\n parse_json(request)\n elsif @optimistic_json\n begin\n parse_json(request)\n rescue JSON::ParserError\n nil\n end\n end\n\n return [params, false] if params\n\n if @allow_form_params && %w[application/x-www-form-urlencoded multipart/form-data].include?(request.media_type)\n # Actually, POST means anything in the request body, could be from\n # PUT or PATCH too. Silly Rack.\n return [request.POST, true] if request.POST\n end\n\n [{}, false]\n end",
"def parsed_body\n request_media_type = request.media_type\n unless request_media_type =~ /\\S/\n fallback = true\n request_media_type = supported_media_types.first\n end\n case request_media_type\n when 'application/json'\n begin\n return JSON.parse(request_body)\n rescue JSON::ParserError\n if fallback\n t_key = 'app.errors.request.body_parse_fallback_json'\n default = \"Error encountered attempting to parse the request body. No Content-Type was specified and parsing as JSON failed. Supported media types are %{supported_media_types}. JSON parser error: %{error_class}: %{error_message}\"\n else\n t_key = 'app.errors.request.body_parse_indicated_json'\n default = \"Error encountered attempting to parse the JSON request body: %{error_class}: %{error_message}\"\n end\n message = I18n.t(t_key,\n :default => default,\n :error_class => $!.class,\n :error_message => $!.message,\n :supported_media_types => supported_media_types.join(', ')\n )\n errors = {'json' => [message]}\n halt_error(400, errors)\n end\n else\n if supported_media_types.include?(request_media_type)\n # :nocov:\n raise NotImplementedError, \"handling request body with media type #{request_media_type} not implemented\"\n # :nocov:\n end\n logger.error \"received Content-Type of #{request.content_type.inspect}; halting with 415\"\n message = I18n.t('app.errors.request.content_type',\n :default => \"Unsupported Content-Type of %{content_type} given for the request body. Supported media types are %{supported_media_types}\",\n :content_type => request.content_type,\n :supported_media_types => supported_media_types.join(', ')\n )\n errors = {'Content-Type' => [message]}\n halt_error(415, errors)\n end\n end",
"def parse_request request\n\n request_uuid = request.shift\n request_method = request.shift\n\n begin\n request_response = @notifier_engine.process_input request_method.to_sym, request\n rescue => exc\n request_response = \"#{exc.class}: #{exc.message}\"\n end\n\n send_response request_uuid, request_response\n\n end",
"def process_http_request\n # the http request details are available via the following instance variables:\n # @http_protocol\n # @http_request_method\n # @http_cookie\n # @http_if_none_match\n # @http_content_type\n # @http_path_info\n # @http_request_uri\n # @http_query_string\n # @http_post_content\n # @http_headers\n handle(@http_request_method, @http_post_content)\n\n send_ok()\n end",
"def parse_request!\n REGEX_REQUEST.match(@request[FREQUEST])\n @method = $1 ? $1.downcase.to_sym : :unknown\n @path = $2 || BLANK_STR\n @params_str = $3 || BLANK_STR\n end",
"def create\n @post = Post.new(post_params)\n headers['Content-Type'] = \"application/json; charset=UTF-8\"\n respond_to do |format|\n if @post.save\n format.html { redirect_to @post, notice: request.request_method }\n format.json { render :json => @post.to_json(:include => [:comments]) }\n print 'request_method: '\n puts request.request_method\n print 'request_method_symbol: '\n puts request.request_method_symbol\n print 'method: '\n puts request.method\n print 'patch: '\n puts request.patch?\n print 'head: '\n puts request.head?\n print 'headers: '\n puts request.headers\n print 'original_fullpath: '\n puts request.original_fullpath\n print 'fullpath: '\n puts request.fullpath\n print 'original_url: '\n puts request.original_url\n print 'media_type: '\n puts request.media_type\n print 'content_length: '\n puts request.content_length\n print 'ip: '\n puts request.ip\n print 'remote_ip: '\n puts request.remote_ip\n print 'uuid: '\n puts request.uuid\n print 'raw_post: '\n puts request.raw_post\n print 'body: '\n puts request.body\n print 'form_data: '\n puts request.form_data?\n print 'body_stream: '\n puts request.body_stream\n print 'local: '\n puts request.local?\n else\n format.html { render :new }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post\n @response_body = make_request(\"#{api_url}#{endpoint}\", request_body.to_json)\n puts \"GLIMR POST: #{endpoint} - #{request_body.to_json}\" if ENV.key?('GLIMR_API_DEBUG')\n end",
"def post_parameters\n request.POST\n end",
"def parse_request_body(request)\n JSON.parse(request.body.read).symbolize_keys\n end",
"def post(request)\n request.method = :post\n request.call\n end",
"def on_request(env)\n logger.tagged(*tags) do\n logger.info { formatter.request(env) }\n logger.debug { formatter.request_body(env) }\n end\n end",
"def global_request_logging\n http_request_header_keys = request.headers.env.keys.select { |header_name| header_name.match('^HTTP.*') }\n http_request_headers = request.headers.select { |header_name, header_value| http_request_header_keys.index(header_name) }\n\n logger.debug \"[ApplicationController] Processing with params #{params.inspect}\"\n if request.body.respond_to?(:string)\n logger.debug \"[ApplicationController] Processing with body #{request.body.string.inspect}\" unless request.body.string.blank?\n elsif request.body.respond_to?(:read) && request.body.respond_to?(:rewind)\n request.body.rewind\n logger.debug \"[ApplicationController] Processing with body #{request.body.read.inspect}\"\n end\n\n # Run Warden if not already done, to avoid incomplete log entries after authN fail\n authenticate!\n\n begin\n yield\n ensure\n logger.debug \"[ApplicationController] Responding with headers #{response.headers.inspect}\"\n logger.debug \"[ApplicationController] Responding with body #{response.body.inspect}\" unless response.body.blank?\n end\n end",
"def get_payload_request(request)\n request.body.rewind\n # The raw text of the body is required for webhook signature verification\n @payload_raw = request.body.read\n begin\n @payload = JSON.parse @payload_raw\n rescue StandardError => e\n raise \"Invalid JSON (#{e}): #{@payload_raw}\"\n end\n end",
"def parse_json_payload\n if request.content_type =~ /application\\/.*json/i\n json = JSON.parse(request.body.read)\n params.merge!(json)\n end\n ensure\n request.body.rewind\n end",
"def parse_request\n unless request.body.read.empty?\n @json = JSON.parse(request.body.read.html_safe)\n end\n end",
"def add_request( request )\n @thePosts << request\n end",
"def parse_request(request)\n if request.is_a?(Hash)\n [request['PATH_INFO'], request['REQUEST_METHOD'].downcase.to_sym, {}]\n else\n [request.path_info, request.request_method.downcase.to_sym, request.params]\n end\n end",
"def create\n # If the request body contains a single log (request body is not an array)\n if ( !JSON.parse(request.body.read).is_a?(Array) )\n log_data = JSON.parse(request.body.read)\n status, log = create_new_log(log_data)\n if (status)\n render json: log, status: :created\n else\n render json: log.errors, status: :unprocessable_entity\n end\n # If the request body contains multiple logs (request body is an array)\n else\n logs = []\n # Loop through all logs. Each array element is considered a single log\n JSON.parse(request.body.read).each do |log_data|\n status, log = create_new_log(log_data)\n if (!status)\n render render json: log.errors, status: :unprocessable_entity\n else\n logs.push(log)\n end\n end\n render json: logs, status: :created\n end\n \tend",
"def responses_from_request(request)\n responses = []\n if request[:params]\n responses += request[:params].split(\"/\")\n end\n\n # url request\n if request[:responses]\n split_responses = request[:responses].split(\"/\")\n responses += split_responses\n end\n\n # get form submission request: one response\n if request[:response]\n responses << request[:response]\n end\n\n #get form submission request: for multiple responses\n response_array = request.query_parameters.select { |key| key.to_s.match(/^response_\\d+/) }\n .map { |response_key| response_key[1] }\n responses += response_array unless response_array.empty?\n responses\n end",
"def get_payload_request(request)\n # request.body is an IO or StringIO object\n # Rewind in case someone already read it\n request.body.rewind\n # The raw text of the body is required for webhook signature verification\n @payload_raw = request.body.read\n begin\n @payload = JSON.parse @payload_raw\n rescue => e\n raise \"Invalid JSON (#{e}): #{@payload_raw}\"\n end\n end",
"def process_request(request)\n request['User-Agent'] = \"Ruby/#{RUBY_VERSION}\"\n\n request['Cookie'] = cookie if cookie\n logger.debug { redact_passwords(%(REQUEST: #{request.method} #{to_s}#{request.path} HEADERS: #{request.to_hash.inspect} #{log_request_body and request.request_body_permitted? ? \"BODY: #{format_body_for_log_output(request)}\" : ''})) }\n\n response = http.request(request)\n logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? \"BODY: #{format_body_for_log_output(response)}\" : ''}) }\n\n response\n end",
"def request_mixins\n parser_wrapper { request_parser.mixins(request.raw_post, request.headers) }\n end",
"def parse_content_body\n if put_or_post? && request.content_type.include?(\"application/json\")\n body_params = request.body.read\n parsed = body_params && body_params.length >= 2 ? JSON.parse(body_params) : nil\n params.merge!(parsed)\n end\n end",
"def requestParser(request)\n # Grab the method and path of the request\n method, path = request.lines[0].split;\n \n # Return the path, method and the parsed headers\n { path: path, method: method, headers: parseHeaders(request) }\nend",
"def process_client_request(request)\n # process request string\n resp = []\n tokens = request.split(\" \")\n target = tokens [1]\n\n if request =~ /GET\\s.+\\sHTTP\\/1\\.[0|1]/\n resp = retrieve_file(target)\n\n elsif request =~ /POST\\s.+\\sHTTP\\/1\\.[0|1]/\n resp = parse_received_data(target)\n\n else\n @client.puts \"Received invalid request.\"\n resp = [\"N/A\"]\n end\n\n return resp\n end",
"def post(request)\n do_request(request) { |client| client.http_post request.body }\n end",
"def validate_content_type!\n if request.headers['Content-Type'] =~ /multipart\\/form-data/\n head 406 unless request.headers['Content-Length'].present? &&\n request.headers['Accept'] === 'application/json'\n else\n head 406 unless request.headers['Accept'] === 'application/json'\n end\n end",
"def request_log(request); end",
"def log_request\n bin = Bin.find_by({ url: request.params['bin_url'] })\n @incoming_request = Request.new({\n payload: request.raw_post,\n bin_id: bin.id,\n http_method: request.method\n })\n\n respond_to do |format|\n if @incoming_request.save!\n if !@incoming_request.bin.webhook_url.blank? # TODO: clean up this logic a bit\n RequestForwardingJob.perform_later @incoming_request, bin.webhook_url\n end\n\n ActionCable.server.broadcast(\n \"request_channel_#{bin.url}\", @incoming_request\n )\n\n format.json { render json: {}, status: :created }\n else\n format.json { render json: @bin.errors, status: :unprocessable_entity }\n end\n end\n end",
"def multipart_fake_request(env = {}, params = {})\n if params.empty?\n fake_request(env)\n else\n m = Post.new(params)\n body, head = m.to_multipart\n fake_request(env.merge( :content_type => head, \n :content_length => body.length), :post_body => body)\n end\n end",
"def read_rack_input(body)\n fmt = request.media_type ? mime_types[request.media_type] : options[:default_format]\n\n throw :error, status: 415, message: \"The provided content-type '#{request.media_type}' is not supported.\" unless content_type_for(fmt)\n parser = Grape::Parser.parser_for fmt, **options\n if parser\n begin\n body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))\n if body.is_a?(Hash)\n env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env.key?(Grape::Env::RACK_REQUEST_FORM_HASH)\n env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)\n else\n body\n end\n env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]\n end\n rescue Grape::Exceptions::Base => e\n raise e\n rescue StandardError => e\n throw :error, status: 400, message: e.message, backtrace: e.backtrace, original_exception: e\n end\n else\n env[Grape::Env::API_REQUEST_BODY] = body\n end\n end",
"def log_request(request, type, current_user, logger = Gitlab::AuthLogger)\n request_information = {\n message: 'Application_Rate_Limiter_Request',\n env: type,\n remote_ip: request.ip,\n request_method: request.request_method,\n path: request.fullpath\n }\n\n if current_user\n request_information.merge!({\n user_id: current_user.id,\n username: current_user.username\n })\n end\n\n logger.error(request_information)\n end",
"def parse_request(request_http)\n lines = request_http.split(\"\\n\")\n\n request_line = lines.shift\n method, path, version = request_line.split\n\n headers = {}\n loop do\n line = lines.shift\n break if line =~ /^\\s*$/\n\n key, value = line.split(':', 2)\n headers[key] = value.strip\n end\n\n body = lines.join(\"\\n\")\n\n {\n 'method' => method,\n 'path' => path,\n 'version' => version,\n 'headers' => headers,\n 'body' => body,\n }\n end",
"def post(request)\n # sure thing!\n json_response(200, { message: \"This dummy POST endpoint didn't do anything.\" })\n end",
"def parse_request(env, path_params)\n validate_request!(env, path_params)\n parse_message_hash(env, path_params)\n end",
"def parse_request(env, path_params)\n validate_request!(env, path_params)\n parse_message_hash(env, path_params)\n end",
"def log_request\n logger.info \"HTTP request received => #{request.fullpath} , params => #{params} \"\n end",
"def raise_on_post\n raise \"post\" if request.post?\n render :text => \"request method: #{request.env['REQUEST_METHOD']}\"\n end",
"def start_post_server()\n server = TCPServer.new('localhost', DEFAULT_POST_PORT)\n puts \"POST Server running on http://localhost:#{DEFAULT_POST_PORT}/\"\n while session = server.accept\n method, path = session.gets.split # In this case, method = \"POST\" and path = \"/\"\n headers = {}\n while line = session.gets.split(' ', 2) # Collect HTTP headers\n puts line\n break if line[0] == \"\" # Blank line means no more headers\n headers[line[0].chop] = line[1].strip # Hash headers by type\n end\n puts headers[\"Content-Length\"].to_i\n data = JSON.parse(session.read(headers[\"Content-Length\"].to_i)) # Read the POST data as specified in the header\n response = checkModes(data) # Do what you want with the POST data\n\n session.print \"HTTP/1.1 200\\r\\n\" # 1\n session.print \"Content-type:application/json\\r\\n\" # 2\n session.print \"\\r\\n\" # 3\n session.print response #4\n session.close\n end\nend",
"def post_data\n @request[\"postData\"]\n end",
"def POST\r\n@env[\"action_dispatch.request.request_parameters\"] ||= (normalize_encode_params(super) || {})\r\nrescue TypeError => e\r\nraise ActionController::BadRequest.new(:request, e)\r\nend",
"def convert_fcgi_post(params, args = nil)\n post_hash = {}\n \n params.each do |key, realval|\n val = realval.first\n classn = val.class.name\n \n #Sometimes uploaded files are given as StringIO's.\n if classn == \"StringIO\" or classn == \"Tempfile\"\n val = Hayabusa::Http_session::Post_multipart::File_upload.new(\n :fname => val.original_filename,\n :data => val\n )\n end\n \n post_hash[key] = val\n end\n \n post_ret = {}\n post_hash.each do |varname, value|\n Knj::Web.parse_name(post_ret, varname, value)\n end\n \n return post_ret\n end",
"def create\n case raw_json\n when Array then handle_many_logs\n when Hash then handle_single_log\n else; sorry \"Post a JSON array or object.\", 422\n end\n end",
"def request_body_attributes\n return {} unless request.format.json?\n return {} unless request.body.present?\n JSON.parse(request.body.read)\n ensure\n request.body.rewind if request.body.present?\n end",
"def POST\n @env[\"action_controller.request.request_parameters\"] ||= begin\n normalize_parameters(super || {})\n rescue\n {}\n end\n end",
"def log_request(request, response)\n puts \"\\nRequest Headers\"\n request.each {|head,val| puts \"#{head}: #{val}\"}\n puts \"\\nResponse Headers\"\n response.each {|head,val| puts \"#{head}: #{val}\"}\n puts \"\\nResponse Body\"\n puts response.body\n puts \"\\nResponse Type\"\n puts \"#{response.class} (#{response.code})\"\nend",
"def deserialize_request_body( txn )\n\t\tcontent_type = txn.headers_in['content-type'].sub( /;.*/, '' ).strip\n\t\tself.log.debug \"Trying to deserialize a %p request body.\" % [ content_type ]\n\n\t\tmname = DESERIALIZERS[ content_type ]\n\n\t\tif mname && self.respond_to?( mname )\n\t\t\tself.log.debug \" calling deserializer: #%s\" % [ mname ]\n\t\t\treturn self.send( mname, txn ) \n\t\telse\n\t\t\tself.log.error \" no support for %p requests: %s\" % [\n\t\t\t\tcontent_type,\n\t\t\t\tmname ? \"no implementation of the #{mname} method\" : \"unknown content-type\"\n\t\t\t ]\n\t\t\tfinish_with( Apache::HTTP_UNSUPPORTED_MEDIA_TYPE,\n\t\t\t\t\"don't know how to handle %p requests\" % [content_type, txn.request_method] )\n\t\tend\n\tend",
"def parse_web_form_request\n if !params[:file].blank?\n return [params[:file], 'file']\n elsif !params[:freetext].blank?\n return [params[:freetext], 'text']\n elsif !params[:url].blank?\n return [params[:url], 'url']\n elsif !params[:example_url].blank?\n return [params[:example_url], 'url']\n end \nend",
"def perform\n add_request_if_new do |request|\n self.class.notify_if_cookies_cleared request do\n multipart_set!(request) unless multipart?(request)\n escaped_arguments = escape_or_warn_of_escape_sequences(arguments)\n escaped_arguments.each_slice 2 do |name, value|\n if value =~ /^file:/\n request.multipart[name] = FilePart.new(name,value.gsub(/^file:/,\"\")) \n else\n request.multipart[name] = StringPart.new(name,value) \n end\n end\n request.body_update\n request\n end\n end\n end",
"def post_multipart(url, data={}, headers={}, http_options=@options)\n # determine the http options\n redirect_limit = http_options[:max_redirects] || max_redirects\n gateway_retries = http_options[:gateway_retry_limit] || gateway_retry_limit\n gateway_delay = http_options[:gateway_retry_delay] || gateway_retry_delay\n\n # the Content-Type header is handled automoatically by Net::HTTP::Post::Multipart\n headers.delete_if { |k,v| k.to_s.downcase == \"content-type\" }\n\n @logger.debug(\"POST #{url} #{headers.inspect} multi-part form content\")\n\n # parse the URL\n uri = URI.parse(url)\n\n # prepare the payload\n payload = data.inject({}) do |h,(k,v)| \n if v.class == File\n h[k] = UploadIO.new(v, mimetype(v).first, File.basename(v))\n elsif v.class == Array\n h[k] = v.inject([]) do |files, part|\n if part.class == File\n files << UploadIO.new(part, mimetype(part).first, File.basename(part))\n end\n end\n else\n h[k] = v\n end\n h\n end\n\n # build the http object\n http = build_http(uri)\n # build the request\n request = Net::HTTP::Post::Multipart.new(uri.request_uri, payload)\n headers.each { |k,v| request.add_field(k, v) }\n # send the request\n begin\n response = http.request(request)\n # handle the response\n case response\n when Net::HTTPRedirection then\n if redirect_limit == -1\n @logger.info(\"HTTP response code: #{response.code}\") unless @logger.debug?\n KineticHttpResponse.new(response)\n elsif redirect_limit == 0\n raise Net::HTTPFatalError.new(\"Too many redirects\", response)\n else\n post_multipart(response['location'], data, headers, http_options.merge({\n :max_redirects => redirect_limit - 1\n }))\n end\n # handle 502, 503, 504\n when Net::HTTPBadGateway, Net::HTTPServiceUnavailable, Net::HTTPGatewayTimeOut then\n if gateway_retries == -1\n KineticHttpResponse.new(response)\n elsif gateway_retries == 0\n @logger.info(\"HTTP response: #{response.code} #{response.message}\") unless @logger.debug?\n raise Net::HTTPFatalError.new(\"#{response.code} #{response.message}\", response)\n else\n @logger.info(\"#{response.code} #{response.message}, retrying in #{gateway_delay} seconds\")\n sleep(gateway_delay)\n post_multipart(url, data, headers, http_options.merge({\n :gateway_retry_limit => gateway_retries - 1\n }))\n end\n when Net::HTTPUnknownResponse, NilClass then\n @logger.info(\"HTTP response code: 0\") unless @logger.debug?\n e = Net::HTTPFatalError.new(\"Unknown response from server\", response)\n KineticHttpResponse.new(e)\n else\n @logger.info(\"HTTP response code: #{response.code}\") unless @logger.debug?\n KineticHttpResponse.new(response)\n end\n rescue Net::HTTPBadResponse => e\n @logger.info(\"HTTP bad response: #{e.inspect}\") unless @logger.debug?\n KineticHttpResponse.new(e)\n rescue StandardError => e\n @logger.info(\"HTTP error: #{e.inspect}\") unless @logger.debug?\n KineticHttpResponse.new(e)\n end\n end",
"def sentry_payload(request)\n JSON.parse(request.body.read)\n end",
"def process_request(public_request_id) \n\n # parse the URL into verb, resources, options, and body\n @active_requests[public_request_id][:public_request].match /(GET|POST) \\/(\\S*)(.*)^(.*)\\Z/m\n parsed_requests, new_requests, request_resources = [$1, $2, $3, $4], {}, $2\n\n ## handle / (GENERIC) resource requests ##\n if request_resources.empty?\n new_requests = process_generic_request(parsed_requests, public_request_id)\n\n ## handle /TEST_POST/ resource request ##\n elsif request_resources.match /test_post/\n new_requests = process_form_request(parsed_requests, public_request_id)\n \n ## handle ALL OTHER requests ##\n else\n parsed_resources = parsed_requests[1].split(\"/\")\n device_match = ::ArduinoGateway::Model::ModelTemplates::ResourceDevice.find_by_name(parsed_resources[0])\n\n # handle requests for DEVICE-BASED SERVICES\n unless device_match.empty?\n new_requests = process_device_request(parsed_requests, parsed_resources, device_match, public_request_id) \n # handle requests for SERVICES ACCROSS DEVICES\n else \n new_requests = process_service_request(parsed_requests, parsed_resources, device_match, public_request_id)\n end\n\n end # else related to ALL OTHER requests\n\n new_requests.each { | name, request | make_request request }\n @active_requests[public_request_id][:arduino_requests] = new_requests\n end",
"def post_process\n [status, headers, body]\n end",
"def post_process\n [status, headers, body]\n end",
"def post_request(object)\n end",
"def add_multipart_data(req,params)\n boundary = Time.now.to_i.to_s(16)\n req[\"Content-Type\"] = \"multipart/form-data; boundary=#{boundary}\"\n body = \"\"\n params.each do |key,value|\n esc_key = CGI.escape(key.to_s)\n body << \"--#{boundary}#{CRLF}\"\n if value.respond_to?(:read)\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"; filename=\\\"#{File.basename(value.path)}\\\"#{CRLF}\"\n body << \"Content-Type: #{mime_type(value.path)}#{CRLF*2}\"\n body << value.read\n else\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"#{CRLF*2}#{value}\"\n end\n body << CRLF\n end\n body << \"--#{boundary}--#{CRLF*2}\"\n req.body = body\n req[\"Content-Length\"] = req.body.size\n end",
"def post(request)\n _request(request) { |client, options| client.post options }\n end",
"def post_upload(original_params,\n original_payload)\n\n call_tapi('POST',\n '/',\n original_params,\n original_payload,\n do_upload: true)\n end",
"def post(path, form_data=nil)\n parse_json do |parser|\n @http_client.post(path, form_data) {|chunk| parser << chunk }\n end\n end",
"def log_request\n # REQUEST_LOG.info( {\n # time: Time.now.to_s,\n # ip: request.remote_ip,\n # path: request.path,\n # site: request.host,\n # user_agent: request.user_agent,\n # params: (request.request_parameters.blank? ? request.query_parameters : request.request_parameters),\n # device: sub_group_type,\n # referer_header: referer,\n # current_page_header: current_page,\n # landing_url_header: land_url,\n # visitor_id_header: request.env['HTTP_VISITOR_ID'],\n # session_id_header: request.env['HTTP_SESSION_ID'],\n # visitor_id: visitor_id,\n # session_id: session_id,\n # params: params\n # } )\n end",
"def request_params_all(request)\n request_params = HashWithIndifferentAccess.new\n request_params.merge!(request.params || {})\n\n # read post or put params. this will erase params\n # {code: 123, mode: 123}\n # \"code=123&mode=123\"\n request_body = request.body.read\n if request_body.present?\n body_params = begin\n JSON.parse(request_body) # {code: 123, mode: 123}\n rescue JSON::ParserError\n Rack::Utils.parse_nested_query(request_body) # \"code=123&mode=123\"\n end\n else\n body_params = {}\n end\n\n request_params.merge(body_params)\n end",
"def post_params\n ActiveModelSerializers::Deserialization.jsonapi_parse!(params, only: [:content] )\n end",
"def initialize(request)\n @params = {}\n @params.merge! request.class.query_parse(request.params[\"QUERY_STRING\"])\n \n # Check to see if a form was submitted and fill in the form values\n if request.is_multipart?\n @params.merge! request.split_multipart\n end #if\n end",
"def extract_request_body(env)\n Rack::Request.new(env).POST.keys.first rescue \"{}\"\n end",
"def global_request_logging \n http_request_header_keys = request.headers.keys.select{|header_name| header_name.match(\"^HTTP.*\")}\n http_request_headers = request.headers.select{|header_name, header_value| http_request_header_keys.index(header_name)}\n logger.info \"Received #{request.method.inspect} to #{request.url.inspect} from #{request.remote_ip.inspect}. Processing with headers #{http_request_headers.inspect} and params #{params.inspect}\"\n begin \n yield \n ensure \n logger.info \"Responding with #{response.status.inspect} => #{response.body.inspect}\"\n end \n end",
"def match?(request)\n request.content_type =~ %r{^application/json.*}\n end",
"def request_params\n params.require(:request).permit(:content)\n end",
"def parse_body\n request.body.rewind\n Oj.load request.body.read\n end",
"def read_body_input\n return unless\n (request.post? || request.put? || request.patch? || request.delete?) &&\n (!request.form_data? || !request.media_type) &&\n !request.parseable_data? &&\n (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)\n\n return unless (input = env[Grape::Env::RACK_INPUT])\n\n input.rewind\n body = env[Grape::Env::API_REQUEST_INPUT] = input.read\n begin\n read_rack_input(body) if body && !body.empty?\n ensure\n input.rewind\n end\n end",
"def handle_POST(request)\n\tinitial_and_headers,body = initialandheaders_Body_Split(request)\n\tinitial,headers = initial_Headers_Split(initial_and_headers)\n\tparams = JSON.parse(body) # parse parameters from json file\n\tcontents = File.read \"thanks.html\"\n\tcontents = modify_content(contents, params[\"viking\"])\n\tinitial = generic_Generate_Initial(200)\n\theaders = generic_Generate_Headers(contents)\n\tgeneric_Generate_Response(initial,headers,contents)\nend",
"def add_multipart_data(req, params)\n crlf = \"\\r\\n\"\n boundary = Time.now.to_i.to_s(16)\n req[\"Content-Type\"] = \"multipart/form-data; boundary=#{boundary}\"\n body = \"\"\n params.each do |key,value|\n esc_key = CGI.escape(key.to_s)\n body << \"--#{boundary}#{crlf}\"\n if value.respond_to?(:read)\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"; filename=\\\"#{File.basename(value.path)}\\\"#{crlf}\"\n body << \"Content-Type: image/jpeg#{crlf*2}\"\n body << value.read\n else\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"#{crlf*2}#{value}\"\n end\n body << crlf\n end\n body << \"--#{boundary}--#{crlf*2}\"\n req.body = body\n req[\"Content-Length\"] = req.body.size\n end",
"def post_request(url, boundary=nil)\n request = Net::HTTP::Post.new(url) # , header\n content_type_str = \"multipart/form-data\"\n request['accept'] = '*/*'\n\n if boundary != nil\n content_type_str << \", boundary=#{boundary}\"\n end\n request['content-type'] = content_type_str\n\n return request\nend",
"def parse_request(line)\n @request = line\n line = line.split(/\\s+/, 3)\n if @is_server\n @version, @code, @message = line\n else\n @verb, @resource, @version = line\n end\n end",
"def set_request_body!(request); end",
"def process_request(request)\n request['User-Agent'] = @user_agent\n request['Content-Type'] = 'application/json'\n request['X-BitPay-Plugin-Info'] = 'Rubylib' + VERSION\n\n begin\n response = @https.request request\n rescue => error\n raise BitPay::ConnectionError, \"#{error.message}\"\n end\n\n if response.kind_of? Net::HTTPSuccess\n return JSON.parse(response.body)\n elsif JSON.parse(response.body)[\"error\"]\n raise(BitPayError, \"#{response.code}: #{JSON.parse(response.body)['error']}\")\n else\n raise BitPayError, \"#{response.code}: #{JSON.parse(response.body)}\"\n end\n\n end",
"def multipart_post(path, options={})\n make_http_request(path, options) do |path|\n request = Net::HTTP::Post.new(path)\n bodies = [yield(path)]\n delimiter = create_mime_delimiter\n request['Content-Type'] = \"multipart/form-data; boundary=\\\"#{delimiter}\\\"\"\n separator = \"\\r\\n--#{delimiter}\\r\\n\"\n request.body = \"\\r\\n#{separator}#{bodies.join(separator)}\\r\\n--#{delimiter}--\\r\\n\"\n request['Content-Length'] = request.body.length.to_s # will need to change to bytesize for 1.9\n request\n end\n end",
"def process(request); end",
"def process\n # Fix body\n unless @data[:request][:body]._blank?\n # Make sure 'content-type' is set if we have a body\n @data[:request][:headers].set_if_blank('content-type', 'application/x-amz-json-1.1' )\n # Fix body if it is a Hash instance\n if @data[:request][:body].is_a?(Hash)\n @data[:request][:body] = Utils::contentify_body(@data[:request][:body], @data[:request][:headers]['content-type'])\n end\n # Calculate 'content-md5' when possible (some API calls wanna have it set)\n if @data[:request][:body].is_a?(String)\n @data[:request][:headers]['content-md5'] = Base64::encode64(Digest::MD5::digest(@data[:request][:body])).strip\n end\n end\n # Set date\n @data[:request][:headers].set_if_blank('x-amz-date', Time::now.utc.httpdate)\n # Set path\n @data[:request][:path] = Utils::join_urn(@data[:connection][:uri].path, @data[:request][:relative_path], @data[:request][:params])\n # Sign a request\n Utils::AWS::sign_v4_signature(\n @data[:credentials][:aws_access_key_id],\n @data[:credentials][:aws_secret_access_key],\n @data[:connection][:uri].host,\n @data[:request]\n )\n end",
"def handle_flow_web_hook_event\n # return render plain: 'Source is not allowed to make requests', status: 403 unless requests.ip == '52.86.80.125'\n\n string_data = request.body.read\n\n # log web hook post to separate log file\n Flow::Webhook.logger.info string_data\n\n data = JSON.parse string_data\n response = Flow::Webhook.process data\n\n render plain: response\n rescue ArgumentError => e\n render plain: e.message, status: 400\n end",
"def post_multipart(method, params = {})\n url = make_url method, {}\n url.query = nil\n\n boundary, data = make_multipart params\n\n req = Net::HTTP::Post.new url.path\n req.content_type = \"multipart/form-data; boundary=#{boundary}\"\n req.body = data\n\n res = Net::HTTP.start url.host, url.port do |http|\n http.request req\n end\n\n xml = Nokogiri::XML(res.body, nil, nil, 0)\n\n check_error xml\n\n parse_response xml\n rescue SystemCallError, SocketError, Timeout::Error, IOError,\n Nokogiri::XML::SyntaxError => e\n raise CommunicationError.new(e)\n rescue Net::HTTPError => e\n xml = Nokogiri::XML(e.res.body, nil, nil, 0)\n check_error xml\n raise CommunicationError.new(e)\n end",
"def multipart_post(path, params = {}, env = {}, &block)\n env[:request_method] = \"POST\"\n env[:test_with_multipart] = true\n mock_request(path, params, env, &block)\n end",
"def content_post\n # POST requests seem to bomb out when they're deflated\n # and they probably don't need to be compressed anyway\n @request_params[\"SAMLRequest\"] = Base64.encode64(@request).gsub(/\\n/, \"\")\n \n #Logging.debug \"SAMLRequest=#{@request_params[\"SAMLRequest\"]}\"\n # kind of a cheesy method of building an HTML, form since we can't rely on Rails too much,\n # and REXML doesn't work well with quote characters\n str = \"<html><body onLoad=\\\"document.getElementById('form').submit();\\\">\\n\"\n str += \"<form id='form' name='form' method='POST' action=\\\"#{@URL}\\\">\\n\"\n # we could change this in the future to associate a temp auth session ID\n str += \"<input name='RelayState' value='ruby-saml' type='hidden' />\\n\"\n @request_params.each_pair do |key, value|\n str += \"<input name=\\\"#{key}\\\" value=\\\"#{value}\\\" type='hidden' />\\n\"\n #str += \"<input name=\\\"#{key}\\\" value=\\\"#{CGI.escape(value)}\\\" type='hidden' />\\n\"\n end\n str += \"</form></body></html>\\n\"\n \n #Logging.debug \"Created form:\\n#{str}\"\n return str\n end",
"def parse_http_methods!(req)\n if (method = req.params['_method'])\n if ['delete', 'put', 'patch'].include?(method.downcase)\n req.env['REQUEST_METHOD'] = method.upcase\n end\n end\n end",
"def parsed_request\n request.body.rewind\n\n data = URI.unescape(request.body.read.to_s.split('signed_request=')[1])\nend",
"def parse\n method, path, version = @request.lines[0].split\n {\n path: path,\n method: method,\n headers: parse_headers\n }\n \n end",
"def post_multipart(url, data={}, headers={}, redirect_limit=max_redirects)\n # the Content-Type header is handled automoatically by Net::HTTP::Post::Multipart\n headers.delete_if { |k,v| k.to_s.downcase == \"content-type\" }\n\n debug(\"POST #{url} #{headers.inspect} multi-part form content\")\n\n # parse the URL\n uri = URI.parse(url)\n\n # prepare the payload\n payload = data.inject({}) do |h,(k,v)| \n h[k] = (v.class == File) ? UploadIO.new(v, mimetype(v), File.basename(v)) : v; h\n end\n\n # build the http object\n http = build_http(uri)\n # build the request\n request = Net::HTTP::Post::Multipart.new(uri.request_uri, payload)\n headers.each { |k,v| request.add_field(k, v) }\n # send the request\n begin\n response = http.request(request)\n # handle the response\n case response\n when Net::HTTPRedirection then\n raise Net::HTTPFatalError.new(\"Too many redirects\", response) if redirect_limit == 0\n post_multipart_raw(response['location'], data, headers, redirect_limit - 1)\n else\n KineticHttpResponse.new(response)\n end\n rescue StandardError => e\n KineticHttpResponse.new(e)\n end\n end",
"def post (dir, data) #DIR is path to REST, Data is HASH of post data\r\n\tbegin\r\n\t\taddress=$server + dir\r\n\t\turi = URI.parse(address)\r\n\t\tdebugging \"Post URI: #{uri}, data: #{data}\"\r\n\t\trequest=Net::HTTP.post_form(uri,data)\r\n\t\tdebugging \"Response #{request}\"\r\n\t\treturn request\r\n\trescue Exception =>msg\r\n\t\tresponse={'body'=>msg,'code'=>401, 'exception' =>true}\r\n\tend\r\nend",
"def add_multipart_data(req,params, mime)\r\n boundary = Time.now.to_i.to_s(16)\r\n req[\"Content-Type\"] = \"multipart/form-data; boundary=#{boundary}\"\r\n body = \"\"\r\n params.each do |key,value|\r\n esc_key = CGI.escape(key.to_s)\r\n body << \"--#{boundary}#{CRLF}\"\r\n if value.respond_to?(:read)\r\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"; filename=\\\"teamicon-#{rand(100000)}\\\"#{CRLF}\"\r\n body << \"Content-Type: #{mime}#{CRLF*2}\"\r\n body << value.read\r\n else\r\n body << \"Content-Disposition: form-data; name=\\\"#{esc_key}\\\"#{CRLF*2}#{value}\"\r\n end\r\n body << CRLF\r\n end\r\n body << \"--#{boundary}--#{CRLF*2}\"\r\n req.body = body\r\n req[\"Content-Length\"] = req.body.size\r\nend",
"def submit\n\t\tset_post_data\n get_response @url\n parse_response\n\tend",
"def request_params\n params.require(:request).permit(:reception_date, :data_type, :user_id, :entry_id, :area_id, :responsible_id,\n project_attributes: [:id, :category_id, :name, :description],\n general_information_attributes: [:id, :request_id, :title_id, :name, :father_last_name,\n :mother_last_name, :birthdate, :gender_id, :email,\n :position, :organization, :ip, :anonymous,\n contact_phones_attributes: [:id, :tag, :number, :_destroy]],\n contact_attributes: [:id, :request_id, :state_id, :city_id, :colony_id, :postcode,\n :street, :internal_number, :external_number],\n complaint_attributes: [:id, :category_id, :subject, :notes],\n audience_attributes: [:id, :category_id, :subject, :description],\n management_attributes: [:id, :category_id, :subject, :description],\n resume_attributes: [:id, :category_id,\n studies_attributes: [:id, :institution, :degree, :end_study, :_destroy],\n abilities_attributes: [:id, :name, :_destroy],\n languages_attributes: [:id, :name, :percentage, :_destroy]],\n\n request_files_attributes: [:id, :file, :_destroy])\n end",
"def parse_Request(request)\n\tinitial_and_headers,body = initialandheaders_Body_Split(request)\n\tinitial,headers = initial_Headers_Split(initial_and_headers)\n\treturn initial,headers,body\n\nend",
"def post_form_field(request)\n data, _status_code, _headers = post_form_field_with_http_info(request)\n request_token if _status_code == 401\n data\n end",
"def post(uri, options = {})\n if options[:multipart]\n form_input = build_multipart_data(options)\n build_response(request.post(uri, build_request_options({\"CONTENT_TYPE\" => \"multipart/form-data, boundary=Mack-boundary\", \"CONTENT_LENGTH\" => form_input.size, :input => form_input})))\n else\n build_response(request.post(uri, build_request_options({:input => options.to_params})))\n end\n end"
] |
[
"0.6545395",
"0.5963483",
"0.55991495",
"0.5574359",
"0.55533445",
"0.5462949",
"0.5462149",
"0.54360974",
"0.5372931",
"0.53600377",
"0.5332685",
"0.53058684",
"0.5238747",
"0.5226314",
"0.52043146",
"0.51962805",
"0.51959217",
"0.5192757",
"0.5180439",
"0.51752496",
"0.51647806",
"0.5124691",
"0.509832",
"0.5095216",
"0.5091659",
"0.508129",
"0.50797236",
"0.50763535",
"0.5054048",
"0.50028723",
"0.49952948",
"0.49792105",
"0.4960344",
"0.4959472",
"0.49477097",
"0.4917501",
"0.49134055",
"0.4911869",
"0.4883821",
"0.48791173",
"0.48759785",
"0.48642075",
"0.48642075",
"0.48625088",
"0.48614836",
"0.4860756",
"0.48502257",
"0.48482853",
"0.48479137",
"0.48229265",
"0.4815789",
"0.48080388",
"0.48066658",
"0.4797231",
"0.47910538",
"0.4770858",
"0.47633907",
"0.475941",
"0.47534564",
"0.47053722",
"0.47053722",
"0.47029766",
"0.4691473",
"0.46913585",
"0.46869013",
"0.468649",
"0.46856186",
"0.46783403",
"0.46749625",
"0.46570873",
"0.46511665",
"0.4641876",
"0.46162605",
"0.46001723",
"0.45919076",
"0.45909616",
"0.45907858",
"0.45905668",
"0.4588592",
"0.45817497",
"0.45764482",
"0.45668387",
"0.45575094",
"0.45560572",
"0.45511943",
"0.45441738",
"0.45417047",
"0.45398498",
"0.45391133",
"0.452569",
"0.45251995",
"0.45229605",
"0.45121306",
"0.45104143",
"0.45094925",
"0.4501284",
"0.44999358",
"0.44975188",
"0.44949254",
"0.44943383"
] |
0.6051569
|
1
|
Logs and returns a set of valid headers for this servlet.
|
def do_OPTIONS(request, response)
super
response.header['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
response.status = Server.status_code('OPTIONS')
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def headers\n request.headers\n end",
"def headers\n @headers ||= rack_environment.select{|k,v| k.start_with? 'HTTP_'}\n end",
"def headers\n @request_headers\n end",
"def headers\n @headers ||={}\n end",
"def request_headers\n @request_headers.map do |header, value|\n \"#{header}: #{value}\"\n end.join(\"\\n\")\n end",
"def headers\n @headers ||= {}\n end",
"def headers\n cfg_get(:headers)\n end",
"def headers\n @headers ||= {}\n end",
"def headers\n response.headers\n end",
"def headers\n\t\t\thdr = @curb.header_str\n\t\t\tself.class.recode(log?, @curb.content_type, hdr) ?\n\t\t\t\tself.class.parse_headers(hdr) :\n\t\t\t\tself.class.parse_headers(@curb.header_str) # recode failed\n\t\tend",
"def headers\n call_once\n @headers\n end",
"def headers\n self.class.const_get(:HEADERS) rescue []\n end",
"def request_headers\n {}\n end",
"def getHeaders\n @headers\n end",
"def headers\n @headers\n end",
"def request_headers; end",
"def request_headers; end",
"def headers\n headers = {}\n headers['Content-Type'] = 'application/x-www-form-urlencoded'\n headers['X-SILENCE-LOGGER'] = 'true'\n headers['Dont-Chunk'] = 'true' unless self.class.long_polling\n\n headers\n end",
"def get_headers\n @headers = headers\n @headers\n end",
"def headers\r\n # NB: return value is supposed to be an array of strings\r\n @headers || []\r\n end",
"def get_headers\n # Prepare query url.\n _query_builder = config.get_base_uri\n _query_builder << '/response/headers'\n _query_url = APIHelper.clean_url _query_builder\n\n # Prepare and execute HttpRequest.\n _request = config.http_client.get(\n _query_url\n )\n _response = execute_request(_request)\n validate_response(_response)\n end",
"def response_headers\n @headers\n end",
"def get_headers\n request_object.headers\n end",
"def headers\n @headers ||= self.class.beautify_headers(@net_http_res.to_hash)\n end",
"def headers\n auth_object = auth_objects_cache[RequestStore.store[:cache_key]]\n # AuthClient, generates the header for us\n auth_object.auth_header\n end",
"def request_headers(env)\n env.select { |key, _| key[0, 5] == 'HTTP_' }\n end",
"def headers\n res = parsed_headers\n if has_delta?\n res.concat(delta_headers)\n end\n res\n end",
"def response_headers\n @response[:response_headers]\n end",
"def response_headers\n @response_headers.map do |header, value|\n \"#{header}: #{value}\"\n end.join(\"\\n\")\n end",
"def headers\n @headers ||= HeaderHash.new(@http_response.to_hash)\n end",
"def headers(request)\n raise NotImplementedError\n end",
"def headers\n {}\n end",
"def headers\n {}\n end",
"def headers\n {}\n end",
"def request_headers\n @agent.request_headers\n end",
"def headers\n matching_masks = self.hr_config.matching_masks_for_url(self.url)\n matching_masks.inject({}) do |hash, mask|\n hash.merge(self.hr_config.get(mask, 'headers') || {})\n end\n end",
"def headers\n @headers.to_a\n end",
"def headers\n @headers.to_a\n end",
"def headers\n @headers.reject {|k, v| k == :body }.map do |k, v|\n translate_header_name(k) + ': ' + v + \"\\n\"\n end.join\n end",
"def request_headers\n @attributes[:request_headers]\n end",
"def headers\n @headers ||= message.header_fields\n end",
"def headers\n @headers ||= response ? Hash[response.headers.map{ |k,v| [k.downcase,v] }] : {}\n end",
"def headers\n @attributes[:headers]\n end",
"def headers\n fields.map(&:name).map(&:to_sym)\n end",
"def headers; return {}; end",
"def headers; return {}; end",
"def headers\n return @args[:headers]\n end",
"def headers\n end",
"def headers\n @headers ||= begin\n @mail.header.fields.inject({}) do |memo, field|\n name = field.name.downcase.to_s\n next memo if self.class.skipped_headers.include?(name)\n\n header = unquoted_header(name)\n memo.update(name => self.class.unescape(header))\n end\n end\n end",
"def headers\n h = {}\n raw.headers_hash.each {|k,v| h[k] = v }\n h\n end",
"def headers\n if !@headers\n @headers = MultiMap.new(@j_del.headers)\n end\n @headers\n end",
"def headers\n if !@headers\n @headers = MultiMap.new(@j_del.headers)\n end\n @headers\n end",
"def headers\n if !@headers\n @headers = MultiMap.new(@j_del.headers)\n end\n @headers\n end",
"def headers\n headers = {}\n headers[:accept] = '*/*'\n headers[:content_type] = 'Application/json;charset=UTF-8'\n headers[:Authorization] = encode_credentials\n headers\n end",
"def headers_hash\n @headers_hash ||= Hash[@http_headers.split(\"\\x00\").map{|x| x.split(': ',2)}]\n end",
"def headers(_context)\n {}\n end",
"def get_headers_\n hin = ATS::Headers_in.new\n hin.all.reduce({}) do |memo, pair| \n memo[pair.first.downcase] = pair[1]; memo\n end\n end",
"def get_headers\n # the base uri for api requests\n _query_builder = Configuration.base_uri.dup\n\n # prepare query string for API call\n _query_builder << '/response/headers'\n\n # validate and preprocess url\n _query_url = APIHelper.clean_url _query_builder\n\n # prepare headers\n _headers = {\n 'user-agent' => 'Stamplay SDK'\n }\n\n # Create the HttpRequest object for the call\n _http_request = @http_client.get _query_url, headers: _headers\n \n # Call the on_before_request callback\n @http_call_back.on_before_request(_http_request) if @http_call_back\n\n # Invoke the API call and get the response\n _response = @http_client.execute_as_string(_http_request)\n\n # Call the on_after_response callback\n @http_call_back.on_after_response(_response) if @http_call_back\n\n # Global error handling using HTTP status codes.\n validate_response(_response)\n end",
"def headers\n @headers.tap do |headers|\n headers[:algorithm] = configuration.algorithm if verification?\n case configuration.claim\n when CLAIM_EXPIRATION_TIME\n headers.merge!(exp_headers)\n when CLAIM_NOT_BEFORE_TIME\n headers.merge!(nbf_headers)\n end\n end\n end",
"def headers(_context)\n _context[:headers] || EMPTY_HEADERS\n end",
"def get_request_headers\n request.env.find_all {|k, v|\n UnprefixedHeaders.include?(k) || k.start_with?('HTTP_')\n }.map {|k, v|\n range = UnprefixedHeaders.include?(k) ? 0..-1 : 1..-1\n [k.split('_')[range].map(&:downcase).map(&:capitalize).join('-'),\n v]\n }\n end",
"def headers\r\n # give access to helpers to opts with a different name\r\n @opts\r\n end",
"def headers\n @headers ||= {\n \"Content-Type\" => \"application/json\",\n \"Authorization\" => \"Bearer #{@token}\",\n }\n end",
"def headers\n @headers ||= begin\n mail = Mail.new(self.raw_headers)\n mail.header.fields.each_with_object({}) do |field, hash|\n hash[field.name.downcase] ||= []\n hash[field.name.downcase] << field.decoded\n end\n end\n end",
"def headers\n {\n 'Authorization' => \"key=#{@server_key}\",\n 'Content-Type' => 'application/json'\n }\n end",
"def headers\n [\n { :key => \"User-Agent\", :value => user_agent},\n { :key => \"Content-Type\", :value => \"application/json; charset=utf-8\" },\n { :key => \"Accept\", :value => \"application/json\"}\n ]\n end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers; end",
"def headers\n return @args[\"headers\"]\n end",
"def request_headers\n headers = {'Content-Type' => 'application/json'}\n headers[:user_agent] = @client.user_agent\n headers[:authorization] = auth_header\n headers\n end",
"def headers\r\nHttp::Headers.new(@env)\r\nend",
"def get_headers\n\t\tcookie = ConfigData.get(:nytimes, :cookie)\n\n\t\treturn {\n\t\t\t\"authority\" => \"www.nytimes.com\",\n\t\t\t\"accept\" => \"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\",\n\t\t\t\"accept-encoding\" => \"gzip, deflate, br\",\n\t\t\t\"accept-language\" => \"en-US,en;q=0.9\",\n\t\t\t\"cache-control\" => \"max-age=0\",\n\t\t\t\"cookie\" => cookie,\n\t\t\t\"if-none-match\" => 'W/\"4fef7-vHgtjdQ3Rb/QZiWFN5GUOhVw7z4\"',\n\t\t\t\"referer\" => \"https://www.google.com/\",\n\t\t\t\"upgrade-insecure-requests\" => \"1\",\n\t\t\t\"user-agent\" => USER_AGENT\n\t\t}\n\tend",
"def auth_headers\n {\n 'Content-Type' => 'application/x-www-form-urlencoded'\n }\n end",
"def headers\n @headers.merge({ \"Status\" => @status })\n end",
"def request_headers\n return nil unless @response\n Hash[\n 'Cookie' => %Q!mansession_id=\"#{@response.session_id}\"!\n ]\n end",
"def headers\n {\n \"Authorization\" => basic_auth,\n \"Content-Type\" => \"application/json\",\n \"Accept\" => \"application/json\"\n }\n end",
"def signed_headers\n canonical_headers.map{|name,value| name}\n end",
"def processed_headers; end",
"def raw_headers; end",
"def headers\n list = @response.header_str.split(/[\\r\\n]+/).map(&:strip)\n Hash[list.flat_map{ |s| s.scan(/^(\\S+): (.+)/) }.map { |pair|\n [pair.first.to_s.camelcase, pair.second]\n }]\n end",
"def http_headers(environment)\n http_headers = headers\n environment.each do |env|\n key, value = env\n match = key.match(/\\AHTTP_(.*)\\Z/)\n next unless match\n\n header = match[1].split('_').map(&:capitalize).join('-')\n http_headers[header] = value\n end\n\n return http_headers\n end",
"def headers\n { 'User-Agent' => user_agent }\n end",
"def headers\n if @values.key? :auth_token\n { Authorization: 'Bearer ' + @values[:auth_token] }\n else\n {}\n end\n end",
"def headers\n begin\n JSON(data['message_headers'])\n rescue => e\n return []\n end\n end",
"def generate_headers(response)\n\n return [@http_status, \n \"date: #{Time.now.ctime}\", \n \"server: test\",\n \"content-type: text/html; charset=iso-8859-1\",\n \"content-length: #{response.length}\\r\\n\\r\\n\"].join(\"\\r\\n\")\n end",
"def headers\n schema.headers\n end",
"def headers\n # units and source have to go last, so if we push in a new header, these go\n # at end\n @headers+['units','source']\n end",
"def get_headers(content_type = 'application/json')\n {\n :content_type => content_type,\n :accept => 'application/json',\n :user_agent => \"Iterable Ruby SDK v#{Iterable::VERSION} (#{RUBY_DESCRIPTION})\",\n :x_ctct_request_source => \"sdk.ruby.#{Iterable::VERSION}\",\n 'Api-Key' => @api_key\n }\n end",
"def auth_headers\n {\n username: request.headers[\"X-USER-USERNAME\"], \n authentication_token: request.headers[\"X-USER-TOKEN\"]\n }\n end",
"def headers\n {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36'}\n end",
"def auth_headers(headers = {})\n h = headers.dup\n h['X-Tableau-Auth'] = @client.auth.token\n h\n end",
"def get_headers(content_type = 'application/json')\n {\n :content_type => content_type,\n :accept => 'application/json',\n }\n end",
"def base_headers\n self.class.base_headers\n end"
] |
[
"0.72490066",
"0.70971054",
"0.7063392",
"0.7019687",
"0.701265",
"0.6970555",
"0.69419813",
"0.6934873",
"0.6882566",
"0.6859779",
"0.68371296",
"0.67774206",
"0.67688537",
"0.67610246",
"0.67550164",
"0.6750252",
"0.6750252",
"0.6701811",
"0.6669271",
"0.6661552",
"0.6659559",
"0.6658891",
"0.6644838",
"0.6629403",
"0.6628588",
"0.66202337",
"0.6613118",
"0.658635",
"0.6571368",
"0.6568437",
"0.6565403",
"0.6532263",
"0.6532263",
"0.6532263",
"0.6513335",
"0.64843374",
"0.6478452",
"0.6478452",
"0.6451031",
"0.6433095",
"0.6432991",
"0.6398619",
"0.638535",
"0.637555",
"0.6371853",
"0.6371853",
"0.63696885",
"0.636368",
"0.6356999",
"0.6355023",
"0.6331114",
"0.6331114",
"0.6331114",
"0.6320319",
"0.62942064",
"0.6282671",
"0.62801206",
"0.6274434",
"0.62735546",
"0.6269788",
"0.6266282",
"0.6257276",
"0.6254882",
"0.624144",
"0.6232949",
"0.6231329",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62149155",
"0.62034774",
"0.62020344",
"0.61793005",
"0.61642075",
"0.6161671",
"0.61475116",
"0.61364675",
"0.61320853",
"0.6126911",
"0.61217976",
"0.6118971",
"0.6105648",
"0.60801065",
"0.60691065",
"0.6060445",
"0.6059133",
"0.60457844",
"0.60342884",
"0.60204107",
"0.601203",
"0.6002899",
"0.5998579",
"0.59964633",
"0.598084",
"0.59733325"
] |
0.0
|
-1
|
Checks the BugsnagIntegrity header, if present, against the request and based on configuration. If the header is present, if the digest must be correct. However, the header need only be present if configuration says so.
|
def check_digest(request)
header = request['Bugsnag-Integrity']
if header.nil? && Maze.config.enforce_bugsnag_integrity && %i[sessions errors traces].include?(@request_type)
raise "Bugsnag-Integrity header must be present for #{@request_type} according to Maze.config.enforce_bugsnag_integrity"
end
return if header.nil?
# Header must have type and digest
parts = header.split ' '
raise "Invalid Bugsnag-Integrity header: #{header}" unless parts.size == 2
# Both digest types are stored whatever
sha1 = Digest::SHA1.hexdigest(request.body)
simple = request.body.bytesize
$logger.trace "DIGESTS computed: sha1=#{sha1} simple=#{simple}"
# Check digests match
case parts[0]
when 'sha1'
raise "Given sha1 #{parts[1]} does not match the computed #{sha1}" unless parts[1] == sha1
when 'simple'
raise "Given simple digest #{parts[1].inspect} does not match the computed #{simple.inspect}" unless parts[1].to_i == simple
else
raise "Invalid Bugsnag-Integrity digest type: #{parts[0]}"
end
{
sha1: sha1,
simple: simple
}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def valid_bugsnag_integrity_header(request)\n header = request[:request]['Bugsnag-Integrity']\n return !Maze.config.enforce_bugsnag_integrity if header.nil?\n\n digests = request[:digests]\n if header.start_with?('sha1')\n computed_digest = \"sha1 #{digests[:sha1]}\"\n elsif header.start_with?('simple')\n computed_digest = \"simple #{digests[:simple]}\"\n else\n return false\n end\n header == computed_digest\n end",
"def valid_integrity?(body, headers)\n request_signature = headers['X-Hub-Signature']\n signature_parts = request_signature.split('sha1=')\n request_signature = signature_parts[1]\n calculated_signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body)\n calculated_signature == request_signature\n end",
"def check_signature(body)\n received_signature = request.env['HTTP_X_HUB_SIGNATURE'] || ''\n signature = 'sha1=' + hmac_sha1(settings.github_secret, body)\n\n if !Rack::Utils.secure_compare(signature, received_signature)\n build_failed('signature mismatch')\n end\nend",
"def valid_authentication_header\n\t\t\t\t\trequire \"cgi\"\n\n\t\t\t\t\talgorithm = \"sha256\";\n\t\t\t\t\turl = CGI.escape(self.url.to_s)\n\t\t\t\t\tclient_id = self.client_id\n\t\t\t\t\tsecret = self.secret\n\t\t\t\t\ttimestamp = (Time.now.to_i)*1000\n\t\t\t\t\tstr = \"algorithm=HmacSHA256&client_id=#{client_id}&service_url=#{url}×tamp=#{timestamp}\";\n\t\t\t\t\tsignature = ::MicroService::SignedRequest::Utils.sign(str, secret, algorithm)\n\n\t\t\t\t\t# Header!\n\t\t\t\t\t\"#{str}&signature=#{CGI::escape(signature)}\"\n\t\t\t\tend",
"def validrequest?(req)\n digest = makehash(req[:body])\n \n if digest == req[:hash]\n @stats[:validated] += 1\n \n return true\n else\n @stats[:unvalidated] += 1\n \n raise(\"Received an invalid signature in message\")\n end\n end",
"def check_signature!\n request.body.rewind\n payload_raw = request.body.read # We need the raw text of the body to check the webhook signature\n begin\n @payload = JSON.parse payload_raw\n rescue\n @payload = {}\n end\n\n # Check X-Hub-Signature to confirm that this webhook was generated by GitHub, and not a malicious third party.\n # The way this works is: We have registered with GitHub a secret, and we have stored it locally in WEBHOOK_SECRET.\n # GitHub will cryptographically sign the request payload with this secret. We will do the same, and if the results\n # match, then we know that the request is from GitHub (or, at least, from someone who knows the secret!)\n # If they don't match, this request is an attack, and we should reject it.\n # The signature comes in with header x-hub-signature, and looks like \"sha1=123456\"\n # We should take the left hand side as the signature method, and the right hand side as the\n # HMAC digest (the signature) itself.\n their_signature_header = request.env['HTTP_X_HUB_SIGNATURE'] || 'sha1='\n method, their_digest = their_signature_header.split('=')\n our_digest = OpenSSL::HMAC.hexdigest(method, WEBHOOK_SECRET, payload_raw)\n halt 401 unless their_digest == our_digest\n @payload\n end",
"def signature_is_valid?(env)\n return true if html_request?(env)\n\n # grab and compute the X-AUTH-SIG\n signature_sent = env[\"HTTP_X_AUTH_SIG\"]\n actual_signature = compute_signature(env)\n\n # are they the same?\n signature_sent.to_s == actual_signature.to_s\n end",
"def validate\n return false unless @digest_parts.any? # RUBY\n\n a2 = @request.method + ':' + @digest_parts['uri']\n\n if @digest_parts['qop'] == 'auth-int'\n # Making sure we support this qop value\n return false unless @qop & QOP_AUTHINT\n\n # We need to add an md5 of the entire request body to the A2 part of the hash\n body = @request.body_as_string\n @request.body = body\n\n a2 << ':' + ::Digest::MD5.hexdigest(body)\n else\n # We need to make sure we support this qop value\n return false unless @qop & QOP_AUTH\n end\n\n a2 = ::Digest::MD5.hexdigest(a2)\n valid_response = ::Digest::MD5.hexdigest(\"#{@a1}:#{@digest_parts['nonce']}:#{@digest_parts['nc']}:#{@digest_parts['cnonce']}:#{@digest_parts['qop']}:#{a2}\")\n\n @digest_parts['response'] == valid_response\n end",
"def validate()\n cs = checksum()\n return cs == @header[LENGTH - 1]\n end",
"def verify_header\n # normal header like sample ==> Authorization 'ddd$$%gggrghHFDSS.HHJHTTGGR'\n if headers['Authorization'].present?\n headers['Authorization'].split(' ').last\n else\n errors.add(:token, 'Missing Token')\n nil\n end\n end",
"def check_header\n !request.env[\"HTTP_X_ACCESS_TOKEN\"].nil?\n end",
"def verify_auth_header_components headers\n auth_header = headers.find { |x| x[0] == \"Authorization\" }\n raise MalformedAuthorizationError, \"Authorization header is missing\" if auth_header.nil? || auth_header[1] == \"\"\n auth_hash = ::Signet::OAuth1.parse_authorization_header(\n auth_header[1]\n ).each_with_object({}) { |(key, val), acc| acc[key.downcase] = val; }\n\n auth_hash\n end",
"def correct_signature?\n client = RestClient.where(:api_key => @api_key).first\n sign=client.nil? ? \"\" : client.secret + @request_uri.gsub(/\\?.*/,\"\")+@timestamp\n calculated_sign= (Digest::SHA256.new << sign).to_s\n Digest::SHA1.hexdigest(@signature)==Digest::SHA1.hexdigest(calculated_sign)\n end",
"def verify_webhook_signature\n their_signature_header = request.env['HTTP_X_HUB_SIGNATURE'] || 'sha1='\n method, their_digest = their_signature_header.split('=')\n our_digest = OpenSSL::HMAC.hexdigest(method, ENV['GITHUB_WEBHOOK_SECRET'], @payload_raw)\n halt 401 unless their_digest == our_digest\n\n log_action\n end",
"def check_headers(headers)\n # check version from Accept headers; expect custom media type `spoonlibrary`\n accept = headers[:accept]\n accept&.include?(\"application/vnd.spoonlibrary.#{version}+json\")\n end",
"def integrity\n DigestUtils.integrity_uri(digest)\n end",
"def valid_request?\n signature = github_signature\n my_signature = 'sha1=' + OpenSSL::HMAC.hexdigest(\n OpenSSL::Digest.new('sha1'),\n ENV['GITHUB_WEBHOOK_SECRET'],\n github_payload_raw\n )\n\n json_response(json_access_denied, :unauthorized) unless Rack::Utils.secure_compare(my_signature, signature)\n rescue StandardError => e\n msg = \"#{self.class}##{__method__} An error occurred while determine if request is valid\"\n Rails.logger.error(\n message: msg,\n exception: e\n )\n\n json_response(json_access_denied(errors: { message: \"#{msg}, exception: #{e.message}\" }), :unauthorized)\n end",
"def check_header(header)\n results = Auth.parse_header(header)\n\n assert_equal('auth', results['qop'])\n assert_equal('REALM', results['realm'])\n assert_equal('2006-03-03T17:37:10', results['nonce'])\n assert_equal('', results['opaque'])\n assert_equal('false', results['stale'])\n assert_equal('\\my\\test\\domain', results['domain'])\n end",
"def validate_headers\n raise UnknownDataField, unknown_headers.join(',') if unknown_headers.present?\n end",
"def is_validate_signature\n signature = request.headers[\"X-LINE-Signature\"]\n http_request_body = request.raw_post\n hash = OpenSSL::HMAC::digest(OpenSSL::Digest::SHA256.new, CHANNEL_SECRET, http_request_body)\n signature_answer = Base64.strict_encode64(hash)\n signature == signature_answer\n end",
"def is_validate_signature\n signature = request.headers[\"X-LINE-Signature\"]\n http_request_body = request.raw_post\n hash = OpenSSL::HMAC::digest(OpenSSL::Digest::SHA256.new, CHANNEL_SECRET, http_request_body)\n signature_answer = Base64.strict_encode64(hash)\n signature == signature_answer\n end",
"def verify_signature(payload_body)\n signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), SECRET_TOKEN, payload_body)\n return halt 500, \"Signatures didn't match!\" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_HUB_SIGNATURE'])\n end",
"def verify_signature(payload_body)\n signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), SECRET_TOKEN, payload_body)\n return halt 500, \"Signatures didn't match!\" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_HUB_SIGNATURE'])\n end",
"def valid? headers, params\n timestamp = get_timestamp headers\n\n message = create_message params[\"token\"], params[\"trx_id\"], params[\"monto\"], timestamp\n authorization = Authorization.new(@env)\n signature = authorization.sign(message)\n signature == pp_signature(headers)\n\n end",
"def verified_request?\n super || form_authenticity_token == request.headers['X-XSRF-TOKEN']\n end",
"def verified_request?\n super || form_authenticity_token == request.headers['X-XSRF-TOKEN']\n end",
"def verified_request?\n super || form_authenticity_token == request.headers['X-XSRF-TOKEN']\n end",
"def verified_request?\n super || form_authenticity_token == request.headers['X-XSRF-TOKEN']\n end",
"def digest\n @request.header('Authorization')\n end",
"def verified_request?\r\n super || form_authenticity_token == request.headers['X-XSRF-TOKEN']\r\n end",
"def validate_header!\n [:date, :from].each do |field|\n raise \"No '#{field}' header field provided\" unless self.send(field)\n end\n end",
"def header_signature; end",
"def verify_webhook_signature\n their_signature_header = request.env['HTTP_X_HUB_SIGNATURE'] || 'sha1='\n method, their_digest = their_signature_header.split('=')\n our_digest = OpenSSL::HMAC.hexdigest(method, WEBHOOK_SECRET, @payload_raw)\n halt 401 unless their_digest == our_digest\n\n # The X-GITHUB-EVENT header provides the name of the event.\n # The action value indicates the which action triggered the event.\n logger.debug \"---- received event #{request.env['HTTP_X_GITHUB_EVENT']}\"\n logger.debug \"---- action #{@payload['action']}\" unless @payload['action'].nil?\n end",
"def validrequest?(req)\n ssl = SSL.new(\"/home/rip/.mcollective.d/rip.pem\")\n\n ssl.verify_signature(req[:hash], SSL.md5(req[:body]), true)\n\n req[:callerid] = \"webuser=%s\" % ssl.rsa_decrypt_with_public(ssl.base64_decode(req[:callerid]))\n req[:body] = deserialize(req[:body])\n\n @stats.validated\n\n true\n rescue\n @stats.unvalidated\n raise(SecurityValidationFailed, \"Received an invalid signature in message\")\n end",
"def headercheck(raw)\n decode(raw)[0...Payload::HEADER.length] == Payload::HEADER\n end",
"def verify_authenticity_token\n verified_request? || raise(ActionController::InvalidAuthenticityToken)\n end",
"def exists?(header = {})\n header = DEFAULT_REQUEST_HEADER.merge(header)\n return super(header) unless @data['properties']\n find_by_name_in_properties(header).size == 1\n end",
"def verify_signed_request(request)\n\n begin\n authenticator = Mixlib::Authentication::SignatureVerification.new(request)\n username = authenticator.user_id\n user_key_file = \"#{EdmundsChefRailsProxy::Application.config.user_keys_dir}/#{username}.pem\"\n user_key = OpenSSL::PKey::RSA.new( ::File.read( user_key_file ) )\n authenticator.authenticate_request(user_key)\n\n rescue Mixlib::Authentication::MissingAuthenticationHeader => e\n logger.debug \" verify_signed_request: MissingAuthenticationHeader\"\n logger.debug \"Authentication failed: #{e.class.name}: #{e.message}\"\n #logger.debug \"#{e.backtrace.join(\"\\n\")}\"\n return false\n\n rescue StandardError => se\n logger.debug \" verify_signed_request: StandardError\"\n logger.debug \"Authentication failed: #{se}\"\n #logger.debug \"#{se.backtrace.join(\"\\n\")}\"\n return false\n\n end\n\n logger.debug \" verify_signed_request: OK\"\n return true\n\nend",
"def validate_update(body, headers)\n unless @secret\n raise AppSecretNotDefinedError, \"You must init RealtimeUpdates with your app secret in order to validate updates\"\n end\n\n request_signature = headers['X-Hub-Signature'] || headers['HTTP_X_HUB_SIGNATURE']\n return unless request_signature\n\n signature_parts = request_signature.split(\"sha1=\")\n request_signature = signature_parts[1]\n calculated_signature = OpenSSL::HMAC.hexdigest('sha1', @secret, body)\n calculated_signature == request_signature\n end",
"def check_header\n if ['POST', 'PUT', 'PATCH'].include? request.method\n head :not_acceptable and return unless request.content_type == 'application/vnd.api+json'\n end\n end",
"def validrequest?(req)\n message = req[:body]\n signature = req[:hash]\n\n Log.debug(\"Validating request from #{req[:callerid]}\")\n\n if verify(public_key_file(req[:callerid]), signature, message.to_s)\n @stats.validated\n return true\n else\n @stats.unvalidated\n raise(SecurityValidationFailed, \"Received an invalid signature in message\")\n end\n end",
"def check_header\n if ['POST','PUT','PATCH'].include? request.method\n if request.content_type != \"application/vnd.api+json\"\n head 406 and return\n end\n end\n end",
"def _verify\n unless (@_headers['x-allopass-response-signature'] || []).include?(@_signature)\n raise Allorails::ApiFalseResponseSignatureError\n end\n end",
"def expected_header\n raise\n end",
"def check(params)\n params = params.dup\n\n signature = params.delete('sig')\n\n ::JWT::SecurityUtils.secure_compare(signature, digest(params))\n end",
"def verified_request?\n\t\tsuper || form_authenticity_token == request.headers['X-XSRF-TOKEN']\n\tend",
"def check_credentials(authorization_header)\n if authorization_header\n check_basic_auth(authorization_header)\n elsif authorization_cookie\n check_cookie_auth(authorization_cookie)\n end\n end",
"def ensure_properly_signed(request, params)\n api_key = params[:api_key]\n api_error 400, \"No API key provided.\" unless api_key\n user = User[:api_key => api_key]\n api_error 400, \"Bad API key provided.\" unless user\n api_error 403, \"The demo user is not allowed to make API requests.\" if user.demo?\n ensure_required_params :timestamp, :signature\n api_error 400, \"Bad timestamp.\" unless params[:timestamp] =~ /^\\d+$/\n timestamp = Time.at(params[:timestamp].to_i) rescue Time.at(0)\n staleness = (Time.now.to_i - timestamp.to_i) / 60.0\n if staleness < 0\n api_error 400, \"Bad timestamp.\"\n elsif staleness > ALLOWED_API_STALENESS_MINUTES\n api_error 400, \"Timestamp too stale.\"\n end\n unless Api.generate_signature_from_request(request, user.api_secret) == params[:signature]\n api_error 400, \"Bad signature.\"\n end\n user\n end",
"def valid_signature?\n Rack::Utils.secure_compare(signature, signature_for(body))\n end",
"def validate_headers(headers, * parameters)\n errors = []\n if headers.present?\n parameters.each do |param|\n if headers[param].blank?\n @api_response[:code] = @response_codes['insufficient_headers']\n errors << \"#{param.to_s}\" if errors.any?\n errors << \"header missing: #{param.to_s}\" if errors.empty?\n end\n end\n else\n errors << \"headers missing\"\n end\n [errors.blank? ? true : false, errors]\n end",
"def authorization_header?\n return true if request.headers['Authorization'] && request.headers['Authorization'] != 'null'\n\n false\n end",
"def validate_and_sanitize\n r = validate\n return invalid_credentials_response('a_ar_b_vas_1') unless r.success?\n\n @parsed_request_time = Time.at(@request_timestamp.to_i)\n\n return invalid_credentials_response(\"um_vac_1\") unless @parsed_request_time && (@parsed_request_time.between?(Time.now - expiry_window, Time.now + expiry_window))\n\n @request_parameters.permit!\n\n [\"signature\"].each do |k|\n @request_parameters.delete(k)\n end\n\n success\n end",
"def intact?\n @signature.md5 == Digest::MD5.digest(@content)\n end",
"def verify_webhook_signature\n their_signature_header = request.env['HTTP_X_GEOTIX_SIGNATURE'] || 'sha1='\n method, their_digest = their_signature_header.split('=')\n our_digest = OpenSSL::HMAC.hexdigest(method, WEBHOOK_SECRET, \"#{auth_token}#{@payload_raw}\")\n halt [401, \"Signatures don't match.\"] unless their_digest == our_digest\n end",
"def validateable?\n headers.key?('Last-Modified') || headers.key?('ETag')\n end",
"def hashes_match?\n ar = @ar.clone\n\n digest_value = ar.at_css(\n 'xmlns|DigestValue',\n 'xmlns' => 'http://www.w3.org/2000/09/xmldsig#'\n ).content.strip\n\n ar.at_css(\n \"xmlns|Signature\",\n 'xmlns' => 'http://www.w3.org/2000/09/xmldsig#'\n ).remove\n\n actual_digest = calculate_digest(ar)\n\n if digest_value == actual_digest\n true\n else\n false\n end\n end",
"def test_delete_preconditions_failed\n request = Http::Request.new(\n 'DELETE',\n '/file1',\n 'If-Match' => \"\\\"#{Digest::MD5.hexdigest('bar')}\\\"\"\n )\n\n response = self.request(request)\n\n assert_equal(\n 412,\n response.status,\n \"Incorrect status code. Response body: #{response.body_as_string}\"\n )\n end",
"def verify_signature\n @req.verify(public_key)\n end",
"def verify_update_file\n @log.info('Beginning integrity check of downloaded file .')\n @file_sha1 = Digest::SHA1.file(@update_file.path).hexdigest\n\n @log.info('Verifying integrity of downloaded file.')\n\n if download_remote_sha1 == @file_sha1\n @log.info('Integrity verified.')\n true\n else\n abort('File was not downloaded correctly. Please try again.')\n end\n end",
"def check\n req = GData::HTTP::Request.new(@base_uri + '/' + @model)\n sign_and_request(req)\n end",
"def check_signature\n signature == \"\\x2a\\x2a\\x00\\x00\"\n end",
"def verify_slack_request\n timestamp = request.headers['X-Slack-Request-Timestamp']\n if (Time.now.to_i - timestamp.to_i).abs > 60 * 5\n head :unauthorized\n return\n end\n\n sig_basestring = \"v0:#{timestamp}:#{request.raw_post}\"\n signature = \"v0=\" + OpenSSL::HMAC.hexdigest(\"SHA256\", ENV['SLACK_SIGNING_SECRET'], sig_basestring)\n slack_signature = request.headers['X-Slack-Signature']\n\n if !ActiveSupport::SecurityUtils.secure_compare(signature, slack_signature)\n head :unauthorized\n end\n end",
"def validrequest?(req)\n Log.info \"Caller id: #{req[:callerid]}\"\n Log.info \"Sender id: #{req[:senderid]}\"\n message = req[:body]\n\n #@log.info req.awesome_inspect\n identity = (req[:callerid] or req[:senderid])\n verifier = SSH::Key::Verifier.new(identity)\n\n Log.info \"Using name '#{identity}'\"\n\n # If no callerid, this is a 'response' message and we should\n # attempt to authenticate using the senderid (hostname, usually)\n # and that ssh key in known_hosts.\n if !req[:callerid]\n # Search known_hosts for the senderid hostname\n verifier.add_key_from_host(identity)\n verifier.use_agent = false\n verifier.use_authorized_keys = false\n end\n\n signatures = Marshal.load(req[:hash])\n if verifier.verify?(signatures, req[:body])\n @stats.validated\n return true\n else\n @stats.unvalidated\n raise(SecurityValidationFailed, \"Received an invalid signature in message\")\n end\n end",
"def check_headers(v)\n return true unless v\n return true if v.size == 0\n if HEADER_REGEXP !~ v\n raise InvalidComponentError,\n \"bad component(expected opaque component): #{v}\"\n end\n\n true\n end",
"def validate_checksum\n raise Puppet::Error.new \"Inconsistent checksums. Checksum of fetched file is #{calculated_checksum}. You specified #{specified_checksum}\" if calculated_checksum != specified_checksum\n end",
"def matches?(request)\n check_headers(request.headers) || default\n end",
"def valid_AmazonMarketplace_request?(request_hash)\n hash = request_hash.symbolize_keys\n signature = hash.delete(:signature) || ''\n AmazonMarketplace::SignatureUtils.authentic?(hash, signature)\n end",
"def signature_is_valid?\n node = @ar.at_css('xmlns|SignedInfo',\n 'xmlns' => 'http://www.w3.org/2000/09/xmldsig#')\n\n node = node.canonicalize\n\n signature = @ar.at_css(\n 'xmlns|SignatureValue',\n 'xmlns' => 'http://www.w3.org/2000/09/xmldsig#'\n ).content\n\n signature = Base64.decode64(signature)\n\n certificate.public_key.verify(OpenSSL::Digest::SHA1.new, signature, node)\n end",
"def handle_unverified_request\n raise ActionController::InvalidAuthenticityToken\n end",
"def handle_unverified_request\n raise ActionController::InvalidAuthenticityToken\n end",
"def validate_source_of_request\n LogWrapper.log('DEBUG', {\n 'message' => \"Request sent to #{params['controller']}Controller#validate_source_of_request\",\n 'method' => 'validate_source_of_request',\n 'status' => \"start, Rails.env=#{Rails.env}, (Rails.env.test? || Rails.env.local?)=#{Rails.env.test? || Rails.env.local?}\",\n 'dataSent' => \"request.headers['X-API-Key']:#{request.headers['X-API-Key']}\"\n })\n\n redirect_to '/api/unauthorized' unless Rails.env.test? || Rails.env.local? || request.headers['X-API-Key'] == ENV['API_GATEWAY_HEADER_KEY']\n end",
"def signature_valid?\n hmac.validate_url_signature(request.url, secret)\n end",
"def check_preconditions(request, response)\n path = request.path\n node = nil\n last_mod = nil\n etag = nil\n\n if_match = request.header('If-Match')\n if if_match\n # If-Match contains an entity tag. Only if the entity-tag\n # matches we are allowed to make the request succeed.\n # If the entity-tag is '*' we are only allowed to make the\n # request succeed if a resource exists at that url.\n begin\n node = @tree.node_for_path(path)\n rescue Exception::NotFound => e\n raise Exception::PreconditionFailed.new('If-Match'), 'An If-Match header was specified and the resource did not exist'\n end\n\n # Only need to check entity tags if they are not *\n if if_match != '*'\n # There can be multiple ETags\n if_match = if_match.split(',')\n have_match = false\n if_match.each do |if_match_item|\n # Stripping any extra spaces\n if_match_item = if_match_item.strip\n\n etag = node.is_a?(IFile) ? node.etag : nil\n if etag == if_match_item\n have_match = true\n else\n # Evolution has a bug where it sometimes prepends the \"\n # with a \\. This is our workaround.\n have_match = true if if_match_item.gsub('\\\\\"', '\"') == etag\n end\n end\n\n unless have_match\n response.update_header('ETag', etag) if etag\n fail Exception::PreconditionFailed.new('If-Match'), 'An If-Match header was specified, but none of the specified the ETags matched.'\n end\n end\n end\n\n if_none_match = request.header('If-None-Match')\n if if_none_match\n # The If-None-Match header contains an ETag.\n # Only if the ETag does not match the current ETag, the request will succeed\n # The header can also contain *, in which case the request\n # will only succeed if the entity does not exist at all.\n node_exists = true\n unless node\n begin\n node = @tree.node_for_path(path)\n rescue Exception::NotFound => e\n node_exists = false\n end\n end\n\n if node_exists\n have_match = false\n if if_none_match == '*'\n have_match = true\n else\n # There might be multiple ETags\n if_none_match = if_none_match.split(',')\n etag = node.is_a?(IFile) ? node.etag : nil\n\n if_none_match.each do |if_none_match_item|\n # Stripping any extra spaces\n if_none_match_item = if_none_match_item.strip\n\n have_match = true if etag == if_none_match_item\n end\n end\n\n if have_match\n response.update_header('ETag', etag) if etag\n if request.method == 'GET'\n response.status = 304\n return false\n else\n fail Exception::PreconditionFailed.new('If-None-Match'), 'An If-None-Match header was specified, but the ETag matched (or * was specified).'\n end\n end\n end\n end\n\n if_modified_since = request.header('If-Modified-Since')\n if !if_none_match && if_modified_since\n # The If-Modified-Since header contains a date. We\n # will only return the entity if it has been changed since\n # that date. If it hasn't been changed, we return a 304\n # header\n # Note that this header only has to be checked if there was no If-None-Match header\n # as per the HTTP spec.\n date = Http::Util.parse_http_date(if_modified_since)\n\n if date\n node = @tree.node_for_path(path) if node.nil?\n last_mod = node.last_modified\n if last_mod\n last_mod = Time.at(last_mod)\n if last_mod <= date\n response.status = 304\n response.update_header('Last-Modified', Http::Util.to_http_date(last_mod))\n return false\n end\n end\n end\n end\n\n if_unmodified_since = request.header('If-Unmodified-Since')\n if if_unmodified_since\n # The If-Unmodified-Since will allow allow the request if the\n # entity has not changed since the specified date.\n date = Http::Util.parse_http_date(if_unmodified_since)\n\n # We must only check the date if it's valid\n if date\n node = @tree.node_for_path(path) if node.nil?\n last_mod = node.last_modified\n if last_mod\n last_mod = Time.at(last_mod)\n if last_mod > date\n fail Exception::PreconditionFailed.new('If-Unmodified-Since'), 'An If-Unmodified-Since header was specified, but the entity has been changed since the specified date.'\n end\n end\n end\n end\n\n # Now the hardest, the If: header. The If: header can contain multiple\n # urls, ETags and so-called 'state tokens'.\n #\n # Examples of state tokens include lock-tokens (as defined in rfc4918)\n # and sync-tokens (as defined in rfc6578).\n #\n # The only proper way to deal with these, is to emit events, that a\n # Sync and Lock plugin can pick up.\n if_conditions = if_conditions(request)\n\n if_conditions.each_with_index do |if_condition, kk|\n if_condition['tokens'].each_with_index do |_token, ii|\n if_conditions[kk]['tokens'][ii]['validToken'] = false\n end\n end\n\n # Plugins are responsible for validating all the tokens.\n # If a plugin deemed a token 'valid', it will set 'validToken' to\n # true.\n box = Box.new(if_conditions)\n emit('validateTokens', [request, box])\n if_conditions = box.value\n\n # Now we're going to analyze the result.\n\n # Every ifCondition needs to validate to true, so we exit as soon as\n # we have an invalid condition.\n if_conditions.each do |if_condition|\n uri = if_condition['uri']\n tokens = if_condition['tokens']\n\n # We only need 1 valid token for the condition to succeed.\n skip = false\n tokens.each do |token|\n token_valid = token['validToken'] || token['token'].blank?\n\n etag_valid = false\n etag_valid = true if token['etag'].blank?\n\n # Checking the ETag, only if the token was already deamed\n # valid and there is one.\n if !token['etag'].blank? && token_valid\n # The token was valid, and there was an ETag. We must\n # grab the current ETag and check it.\n node = @tree.node_for_path(uri)\n etag_valid = node.is_a?(IFile) && node.etag == token['etag']\n end\n\n next unless (token_valid && etag_valid) ^ token['negate']\n skip = true\n break\n end\n next if skip\n\n # If we ended here, it means there was no valid ETag + token\n # combination found for the current condition. This means we fail!\n fail Exception::PreconditionFailed.new('If'), \"Failed to find a valid token/etag combination for #{uri}\"\n end\n\n true\n end",
"def sanitize_header(header, value)\n value\n end",
"def get(header)\n return false if @headers[header].blank?\n sanitize_header(header, @headers[header])\n end",
"def header?(key)\n return true if @args[:headers].key?(key) && @args[:headers][key].first.to_s.length > 0\n false\n end",
"def checksum_valid?\n require 'digest'\n\n Chef::Log.info \"Validating the checkum\"\n\n if new_resource.checksum.to_s==''\n Chef::Log.info \"Skipping as no checksum is provided\"\n return true\n end\n\n if Chef::Artifact.from_nexus?(new_resource.location)\n Digest::SHA1.file(new_resource.name).hexdigest == Chef::Artifact.get_artifact_sha(node, new_resource.location)\n else\n if new_resource.checksum\n Digest::SHA1.file(new_resource.name).hexdigest == new_resource.checksum\n else\n Chef::Log.info \"[artifact_file] No checksum provided for artifact_file, not verifying against downloaded file.\"\n true\n end\n end\nend",
"def verify_authenticity_token; end",
"def has_checksum?(digest)\n find_checksum_by_digest(digest).nil? == false\n end",
"def valid_hashes? signature\n refs = signature.find('.//ds:Reference', DS).map{ |r| r['URI'][1..-1] }\n\n without_signature = LibXML::XML::Document.document(signature.doc)\n without_signature.find_first('//ds:Signature', DS).remove!\n # The XML digested must be canonicalized as per the W3's specification\n # at http://www.w3.org/TR/xml-c14n\n c14n = without_signature.canonicalize\n digest = Base64.encode64(Digest::SHA1.digest(c14n)).chomp\n\n refs.all? do |ref|\n hashed_element = @doc.find_first(\"//*[ID='#{ref}']\")\n digest_listed = signature.find_first('.//ds:DigestValue', DS).content\n\n digest == digest_listed\n end\n end",
"def handle_unverified_request\n true\n end",
"def handle_unverified_request\n true\n end",
"def checkPrivilegedHdr\n hdr = request.env['HTTP_PRIVILEGED'] or return false\n privKey = ENV['ESCHOL_PRIV_API_KEY'] or raise(\"missing env ESCHOL_PRIV_API_KEY\")\n hdr.strip == privKey or halt(403, \"Incorrect API key\")\n return true\n end",
"def verify!(config, params)\n sent_signature = params.find { |key, _value| key.to_s.casecmp('BRQ_SIGNATURE').zero? }&.last\n generated_signature = Signature.generate(config, params)\n\n if sent_signature.nil? || generated_signature.nil? || !safe_equals?(sent_signature, generated_signature)\n raise SignatureException.new(sent_signature, generated_signature)\n end\n end",
"def verify(payload, header, tolerance: nil)\n begin\n timestamp, signatures = get_timestamp_and_signatures(header)\n rescue StandardError\n raise InvalidSignature, \"Unable to extract timestamp and signatures from header\"\n end\n\n if signatures.empty?\n raise InvalidSignature, \"No signatures found with expected version #{@version}\"\n end\n\n expected_sig = generate(payload, timestamp)\n unless signatures.any? { |s| secure_compare(expected_sig, s) }\n raise InvalidSignature, \"No signatures found matching the expected signature for payload\"\n end\n\n if tolerance && timestamp < Time.now - tolerance\n raise InvalidSignature, \"Timestamp outside the tolerance zone (#{Time.at(timestamp)})\"\n end\n\n true\n end",
"def verify_in_file\n header_hash = get_header\n verify_file(:IN, header_hash)\n end",
"def valid_signature?\n params['verifier'] == Digest::MD5.hexdigest([ params['id'], params['snuid'], params['currency'], Offerpal.secret_key ].join(':'))\n end",
"def verify!(request, secret)\n query = query_string(request, request.params[\"nonce\"])\n unless request.params[\"signature\"] == sign(query, secret)\n raise OauthStateMiddlewareException, \"OAuth state signatures do not match\"\n end\n end",
"def verify_column_headers\n \n unless (headers = get_spreadsheet.headers)\n # log an error if we can't get the metadata headers\n @verification_errors << BulkOps::Error.new({type: :bad_header, field: column_name}) \n end\n\n headers.each do |column_name|\n next if column_name.blank?\n column_name_redux = column_name.downcase.parameterize.gsub(/[_\\s-]/,\"\")\n # Ignore everything marked as a label\n next if column_name_redux.ends_with? \"label\"\n # Ignore any column names with special meaning in hyrax\n next if BulkOps::SPECIAL_COLUMNS.any?{|col| col.downcase.parameterize.gsub(/[_\\s-]/,\"\") == column_name_redux }\n # Ignore any columns speficied to be ignored in the configuration\n ignored = options[\"ignored headers\"] || []\n next if ignored.any?{|col| col.downcase.parameterize.gsub(/[_\\s-]/,\"\") == column_name_redux }\n # Column names corresponding to work attributes are legit\n next if Work.attribute_names.any?{|col| col.downcase.parameterize.gsub(/[_\\s-]/,\"\") == column_name_redux }\n @verification_errors << BulkOps::Error.new({type: :bad_header, field: column_name})\n end\n end",
"def verify_signature(payload_body)\n signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['WEBHOOK_SECRET_TOKEN'], payload_body)\n return halt 500, \"Signatures didn't match!\" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_HUB_SIGNATURE'])\nend",
"def requesting_auth?(authorization_header)\n authorization_header || !authorization_cookie.blank?\n end",
"def validate(expected_digest)\n if not bundle_exists? then\n raise BundleNotFound.new(\"repo = #{@repo}; bundle = #{@bundle}\")\n end\n\n if not command_exists? then\n raise CommandNotFound.new(\"repo = #{@repo}; bundle = #{@bundle}; command = #{@command}\")\n end\n if self.digest != expected_digest then\n raise BundleNotFound, \"digest does not match ('#{self.digest}' != '#{expected_digest}')\", caller\n end\n return true\n end",
"def unrecognized_headers\n extra_headers = @transformed_headers - valid_headers\n extra_headers.each do |header|\n @warnings << \"The field name \\\"#{header}\\\" is not supported. This field will be ignored, and the metadata for this field will not be imported.\"\n end\n end",
"def validate_body_versus_content_length!\n unless header?(\"content-length\")\n puts \"Http2: No content length given - skipping length validation.\" if @debug\n return nil\n end\n\n content_length = header(\"content-length\").to_i\n body_length = @body.bytesize\n\n puts \"Http2: Body length: #{body_length}\" if @debug\n puts \"Http2: Content length: #{content_length}\" if @debug\n\n raise \"Body does not match the given content-length: '#{body_length}', '#{content_length}'.\" if body_length != content_length\n end",
"def validate_body_versus_content_length!\n unless self.header?(\"content-length\")\n puts \"Http2: No content length given - skipping length validation.\" if @debug\n return nil\n end\n\n content_length = header(\"content-length\").to_i\n body_length = @body.bytesize\n\n puts \"Http2: Body length: #{body_length}\" if @debug\n puts \"Http2: Content length: #{content_length}\" if @debug\n\n raise \"Body does not match the given content-length: '#{body_length}', '#{content_length}'.\" if body_length != content_length\n end",
"def on_after_create_http_request(http_request)\n if self.class.cached_digest_header\n http_request.set_header('authorization', digest_auth_header_from_response)\n end\n end",
"def verify_content(body, signature)\n hmac = HMAC::SHA1.hexdigest(@secret, body)\n check = \"sha1=\" + hmac\n check == signature\n end",
"def unrecognized_headers\n extra_headers = headers - valid_headers\n extra_headers.each do |header|\n @warnings << \"The field name \\\"#{header}\\\" is not supported. This field will be ignored, and the metadata for this field will not be imported.\"\n end\n end",
"def header?(key)\n key.is_a?(Numeric) || @headers.nil? || @headers.include?(key)\n end",
"def auth_present?\n !!request.headers['HTTP_AUTHORIZATION'].present?\n end"
] |
[
"0.84788775",
"0.6341355",
"0.5908636",
"0.5726542",
"0.56392556",
"0.5546962",
"0.5540966",
"0.54677624",
"0.54632944",
"0.54522043",
"0.5434323",
"0.5423803",
"0.5255678",
"0.5238328",
"0.52139276",
"0.5202434",
"0.5173209",
"0.5131942",
"0.51319253",
"0.51316965",
"0.51316965",
"0.51155686",
"0.51147056",
"0.5101741",
"0.50941133",
"0.50941133",
"0.50941133",
"0.50941133",
"0.50917804",
"0.5090533",
"0.5087261",
"0.5069289",
"0.50600797",
"0.50597364",
"0.50393474",
"0.5035793",
"0.5032475",
"0.50319",
"0.50168973",
"0.49988887",
"0.4989481",
"0.49735633",
"0.49639365",
"0.4958964",
"0.4956053",
"0.49429035",
"0.49212304",
"0.49170247",
"0.48988524",
"0.48799658",
"0.4874331",
"0.48649958",
"0.4848433",
"0.483087",
"0.48277718",
"0.4825679",
"0.4820882",
"0.47917357",
"0.47819912",
"0.4781625",
"0.47787395",
"0.4772631",
"0.47715914",
"0.4771265",
"0.4763931",
"0.47638625",
"0.47611633",
"0.47514457",
"0.47474644",
"0.47474644",
"0.47405896",
"0.47296417",
"0.4720996",
"0.47130415",
"0.4704269",
"0.46893638",
"0.46868786",
"0.468222",
"0.46817732",
"0.46806356",
"0.46702093",
"0.46702093",
"0.46685326",
"0.46571958",
"0.46514302",
"0.4638508",
"0.4634849",
"0.46300325",
"0.46193728",
"0.4615286",
"0.46136862",
"0.46013328",
"0.45928815",
"0.4592135",
"0.45874643",
"0.45874098",
"0.45872253",
"0.4584465",
"0.4581564",
"0.4580549"
] |
0.7928696
|
1
|
Instantiate a new OAuth 2.0 client using the client ID and client secret registered to your application. Options: :site :: Specify a base URL for your OAuth 2.0 client. :authorize_path :: Specify the path to the authorization endpoint. :authorize_url :: Specify a full URL of the authorization endpoint. :access_token_path :: Specify the path to the access token endpoint. :access_token_method :: Specify the method to use for token endpoints, can be :get or :post (note: for Facebook this should be :get and for Google this should be :post) :access_token_url :: Specify the full URL of the access token endpoint. :parse_json :: If true, application/json responses will be automatically parsed. :ssl :: Specify SSL options for the connection. :adapter :: The name of the Faraday::Adapter:: class to use, e.g. :net_http. To pass arguments to the adapter pass an array here, e.g. [:action_dispatch, my_test_session] :raise_errors :: Default true. When false it will then return the error status and response instead of raising an exception.
|
def initialize(client_id, client_secret, opts={})
self.options = opts.dup
self.token_method = self.options.delete(:access_token_method) || :post
adapter = self.options.delete(:adapter)
ssl_opts = self.options.delete(:ssl) || {}
connection_opts = ssl_opts ? {:ssl => ssl_opts} : {}
self.id = client_id
self.secret = client_secret
self.site = self.options.delete(:site) if self.options[:site]
self.connection = Faraday::Connection.new(site, connection_opts)
self.json = self.options.delete(:parse_json)
self.raise_errors = !(self.options.delete(:raise_errors) == false)
if adapter && adapter != :test
connection.build do |b|
b.adapter(*[adapter].flatten)
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def client\n # Merge in authorize url if supplied\n options.authorize_params[:clientId] = options.client_id\n options.authorize_params[:redirect] = callback_url\n options.client_options[:authorize_url] = options.authorize_url if options.authorize_url.present?\n options.client_options[:site] = options.site if options.site.present?\n\n ::OAuth2::Client.new(\n options.client_id,\n options.client_secret,\n deep_symbolize(options.client_options)\n )\n end",
"def client\n ::OAuth2::Client.new(\n options.client_id,\n options.client_secret,\n deep_symbolize(options.client_options).merge(site: site)\n )\n end",
"def initialize(client_id, client_secret, opts={})\n @id = client_id\n @secret = client_secret\n @site = opts.delete(:site)\n ssl = opts.delete(:ssl)\n @options = { :authorize_url => '/oauth/authorize',\n :access_token_url => '/oauth/access_token', \n :access_token_method => :post,\n :connection_opts => {},\n :parse_json => false,\n :raise_errors => true }.merge(opts)\n @options[:connection_opts][:ssl] = ssl if ssl\n end",
"def client\n @client ||= OAuth2::Client.new(\n client_id,\n client_secret,\n :site => site,\n :authorize_url => authorize_url,\n :token_url => token_url\n )\n end",
"def client\n @client ||= OAuth2::Client.new( get_config('SMARTCAR_CLIENT_ID'),\n get_config('SMARTCAR_SECRET'),\n :site => OAUTH_PATH\n )\n end",
"def set_oauth2_auth(client, secret, authorize_path, token_path, site = nil)\n FHIR.logger.info 'Configuring the client to use OpenID Connect OAuth2 authentication.'\n @use_oauth2_auth = true\n @use_basic_auth = false\n @security_headers = {}\n options = {\n site: site || @base_service_url,\n authorize_url: authorize_path,\n token_url: token_path,\n raise_errors: true\n }\n client = OAuth2::Client.new(client, secret, options)\n client.connection.proxy(proxy) unless proxy.nil?\n @client = client.client_credentials.get_token\n end",
"def auth_client(client_id, client_secret, params = {})\n RubyLokaliseApi::OAuth2::Auth.new client_id, client_secret, params\n end",
"def oauth_client(options = {})\n @@linkedin_config ||= LinkedinBackup.load_config\n \n @key = @@linkedin_config['consumer_key']\n @secret = @@linkedin_config['consumer_secret']\n \n @client = Linkedin2::Consumer.new(@key, @secret,options )\n end",
"def oauth2_client(token, params = {})\n @oauth2_client = RubyLokaliseApi::OAuth2Client.new token, params\n end",
"def client\n @client ||= OAuth2::Client.new(@apikey, @apisecret, :site => @graph_api_url)\n end",
"def initialize(client_id:, client_secret:, token:, refresh_token:, expires_at:)\n @basic_token = Base64.strict_encode64(\"#{client_id}:#{client_secret}\")\n\n @oauth2_client = OAuth2::Client.new(client_id, client_secret,\n authorize_url: 'https://www.fitbit.com/oauth2/authorize',\n token_url: 'https://api.fitbit.com/oauth2/token')\n\n opts = { refresh_token: refresh_token,\n expires_at: expires_at }\n @access_token = OAuth2::AccessToken.new(@oauth2_client, token, opts)\n end",
"def oauth_client\n @oauth_client ||= OAuth2::Client.new @app_key, @app_secret, site: @workxp_site do |stack|\n stack.request :multipart\n stack.request :url_encoded\n stack.adapter :net_http\n end\n end",
"def client\n @client ||= ::OAuth2::Client.new(\n @consumer_token,\n @consumer_secret,\n :site => 'https://api-ssl.bitly.com',\n :token_url => '/oauth/access_token'\n )\n end",
"def new_client_application\n OAuth2::Client.new(caller_service.client_id, caller_service.client_secret, :site => authorizator_service.site, :raise_errors => false)\n end",
"def initialize(app_id, secret)\n options = {\n site: Parameter::SITE,\n authorize_url: AUTHORIZE_URL,\n token_url: TOKEN_URL\n }\n\n raise 'アプリケーションIDが入力されていません' if app_id.empty?\n raise 'Secretが入力されていません' if secret.empty?\n @client = OAuth2::Client.new(app_id, secret, options)\n end",
"def client\n @client ||= OAuth2::Client.new(caller_service.client_id,\n caller_service.client_secret,\n :site => called_service.site,\n :raise_errors => false)\n end",
"def initialize(options)\n required_arguments = %i(client_id client_secret refresh_token)\n raise ArgumentError if required_arguments & options.keys != required_arguments\n\n @client_id = options[:client_id]\n @client_secret = options[:client_secret]\n @access_token = options[:access_token]\n @refresh_token = options[:refresh_token]\n end",
"def initialize(client_id=nil, client_secret=nil, callback_url=nil, *args)\n opts = (args.last.is_a?(Hash) ? args.last : {}).with_indifferent_access\n\n opts.delete_if { |k, v| v.nil? }.reverse_merge!(default_tout_configuration)\n\n @client_id = client_id\n @client_secret = client_secret\n @access_token = opts[:access_token]\n @callback_url = callback_url\n @uri_scheme = opts[:uri_scheme]\n @uri_host = opts[:uri_host]\n @uri_port = opts[:uri_port]\n @uri_base_path = opts[:uri_base_path]\n @uri_version = opts[:uri_version]\n @auth_site = opts[:auth_site]\n @authorize_url = opts[:authorize_url]\n @token_url = opts[:token_url]\n @email = opts[:email]\n @password = opts[:password]\n end",
"def initialize(client_id, client_secret, version='v4', base='https://platform.pokitdok.com')\n @client_id = client_id\n @client_secret = client_secret\n @version = version\n\n @api_url = \"#{base}/api/#{version}\"\n @client = OAuth2::Client.new(@client_id, @client_secret,\n site: @api_url, token_url: '/oauth2/token')\n\n\n @scopes = {}\n @scopes['default'] = { scope: refresh_token }\n scope 'default'\n end",
"def initialize(options={})\n # Client auth configuration\n @flow = options[:flow] || options.keys.first.to_s || 'web'\n fdata = options[@flow.to_sym] || options[@flow]\n @client_id = fdata[:client_id] || fdata[\"client_id\"]\n @client_secret = fdata[:client_secret] || fdata[\"client_secret\"]\n @redirect_uris = fdata[:redirect_uris] || fdata[\"redirect_uris\"]\n @redirect_uris ||= [fdata[:redirect_uri] || fdata[\"redirect_uri\"]].compact\n @javascript_origins = (\n fdata[:javascript_origins] ||\n fdata[\"javascript_origins\"]\n )\n @javascript_origins ||= [fdata[:javascript_origin] || fdata[\"javascript_origin\"]].compact\n @authorization_uri = fdata[:auth_uri] || fdata[\"auth_uri\"]\n @authorization_uri ||= fdata[:authorization_uri]\n @token_credential_uri = fdata[:token_uri] || fdata[\"token_uri\"]\n @token_credential_uri ||= fdata[:token_credential_uri]\n\n # Associated token info\n @access_token = fdata[:access_token] || fdata[\"access_token\"]\n @refresh_token = fdata[:refresh_token] || fdata[\"refresh_token\"]\n @id_token = fdata[:id_token] || fdata[\"id_token\"]\n @expires_in = fdata[:expires_in] || fdata[\"expires_in\"]\n @expires_at = fdata[:expires_at] || fdata[\"expires_at\"]\n @issued_at = fdata[:issued_at] || fdata[\"issued_at\"]\n end",
"def client\n OAuth2::Client.new(\n API_KEY,\n API_SECRET,\n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def oauth_client\n if @oauth_client\n @oauth_client\n else\n conn ||= Faraday::Connection.new \\\n :url => \"https://api.gowalla.com\",\n :headers => default_headers\n\n oauth= OAuth2::Client.new(api_key, api_secret, oauth_options = {\n :site => 'https://api.gowalla.com',\n :authorize_url => 'https://gowalla.com/api/oauth/new',\n :access_token_url => 'https://gowalla.com/api/oauth/token'\n })\n oauth.connection = conn\n oauth\n end\n end",
"def initialize(ctoken, csecret, options={})\n @ctoken, @csecret, @consumer_options = ctoken, csecret, {}\n\n # if options[:sign_in]\n # @consumer_options[:authorize_path] = '/oauth/authenticate'\n # end\n end",
"def init_client keyfile, options\n verify_keyfile! keyfile\n client_opts = client_options keyfile, options\n Signet::OAuth2::Client.new client_opts\n end",
"def client\n OAuth2::Client.new(\n API_KEY, \n API_SECRET, \n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def client\n OAuth2::Client.new(\n API_KEY, \n API_SECRET, \n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def init\n\t\tuser_credentials = {\n\t\t\t:access_token => access_token,\n\t\t\t:refresh_token => refresh_token,\n\t\t\t:expires_at => Time.now + expires_in\n\t\t}\n\n client_id = '694fc2f618facf30b3b41726ee6d0ac04c650669ca3d114cb0bae4223cecade3'\n client_secret = '3e7cfd07d829211ac50dd6486fe677ca76e965f25ad7d68e67e845e0d4a213e7'\n\t\tCoinbase::OAuthClient.new(client_id, client_secret, user_credentials)\n\tend",
"def oauth_options\n {\n consumer_key: client_id,\n consumer_secret: client_secret,\n token: access_token,\n token_secret: access_token_secret\n }\n end",
"def initialize(options = {})\n client_id = options[:client_id]\n\n @oauth2_client = TwitchOAuth2::Client.new(\n client_id: client_id, **options.slice(:client_secret, :redirect_uri, :scopes)\n )\n\n @token_type = options.fetch(:token_type, :application)\n\n @tokens = @oauth2_client.check_tokens(\n **options.slice(:access_token, :refresh_token), token_type: @token_type\n )\n\n CONNECTION.headers['Client-ID'] = client_id\n\n renew_authorization_header if access_token\n end",
"def initialize(options = nil)\n @options = options || @@default_options\n @api_key = @options[:api_key] || @options[:oauth_consumer_key]\n @shared_secret = @options[:shared_secret]\n @rest_endpoint = @options[:rest_endpoint] || REST_ENDPOINT\n @auth_endpoint = @options[:auth_endpoint] || AUTH_ENDPOINT\n \n if @options[:oauth_access_token] && @options[:oauth_access_token_secret]\n @access_token = OAuth::AccessToken.new(oauth_customer, @options[:oauth_access_token], @options[:oauth_access_token_secret])\n end\n end",
"def sign_in_as_client(params = {}, options = {})\n params = {\n 'grant_type' => 'client_credentials'\n }.merge(oauth_client_params).merge(params)\n\n @access_token = get_token(params, options)\n end",
"def authenticate\n if @client_id.length < 1 || @client_secret.length < 1\n raise SdkException.new('missing parameters: client_id, client_secret')\n end\n url_with_params = @@auth_endpoint + '?grant_type=client_credentials&scope=data'\n response = RestClient::Request.execute(\n url: url_with_params,\n user: @client_id,\n password: @client_secret,\n method: :post\n )\n body = JSON.parse(response.body)\n @access_token = body['access_token']\n self\n end",
"def create_client(oauth)\n\t\t@client = Twitter::REST::Client.new(\n\t\t\tconsumer_key: oauth[\"consumer_key\"],\n\t\t\tconsumer_secret: oauth[\"consumer_secret\"],\n\t\t\taccess_token: oauth[\"access_token\"],\n\t\t\taccess_token_secret: oauth[\"access_token_secret\"]\n\t\t\t)\n\tend",
"def initialize(credentials = {})\n self.client_id = credentials[:client_id]\n self.client_secret = credentials[:client_secret]\n self.access_token = credentials[:access_token]\n self.access_token_secret = credentials[:access_token_secret]\n end",
"def client\n ::DelegatedAuthentication.new(options[:app_id], options[:app_secret], nil, nil, options[:privacy_url], callback_url)\n end",
"def initialize(oauth_token_key, oauth_token_secret, params = {})\n @http_logger = params[:logger]\n site = params[:site] || :prod\n @consumer = ::OAuth::Consumer.new(oauth_token_key,\n oauth_token_secret,\n :scheme => :query_string,\n # :scheme => :header,\n :http_method => :get,\n :site => OAUTH_SITES[site],\n :request_token_path => OAUTH_REQUEST_TOKEN_URL,\n :access_token_path => OAUTH_ACCESS_TOKEN_URL,\n :authorize_path => OAUTH_AUTHORIZATION_URL)\n\n if params[:application_type] == APPLICATION_TYPE_ONSITE\n @access_token = ::OAuth::AccessToken.new(@consumer, \"\", \"\")\n elsif params[:access_token]\n @access_token = ::OAuth::AccessToken.new(@consumer,\n params[:access_token],\n params[:access_token_secret])\n end\n if params[:request_token]\n @request_token = ::OAuth::RequestToken.new(@consumer,\n params[:request_token],\n params[:request_token_secret])\n end\n end",
"def oauth_access_token(client_id, client_secret, options={})\n url = self.format_url('/oauth/access_token', {\n :client_id => client_id,\n :client_secret => client_secret\n }.merge(options || {}))\n \n response = self.perform_get(url)\n response_hash = {}\n response.split('&').each do |value|\n value_pair = value.split('=')\n response_hash[value_pair[0]] = value_pair[1]\n end\n response_hash\n end",
"def client\n if current_account && current_account.fb_token\n FBGraph::Client.new(:client_id => $api_key,:secret_id =>$secret_key,:token=>current_account.fb_token) \n else\n FBGraph::Client.new(:client_id => $api_key,:secret_id =>$secret_key) \n end\n\n # OAuth2::Client.new($api_key, $secret_key, :site => 'https://graph.facebook.com')\n end",
"def initialize(client_id, access_token=nil, callback=nil)\n @client_id = client_id\n @access_token = access_token\n @format = :json\n @callback = callback\n end",
"def facebook_client\n @_facebook_client ||= begin\n _id, _secret = resource.facebook_app_id, resource.facebook_app_secret\n \n ::OAuth2::Client.new(_id, _secret, {\n :site => 'https://graph.facebook.com',\n\n # by default this would be /oauth/token\n :token_url => '/oauth/access_token',\n\n # Docs are vague on this, but I believe it may work with :post also\n :token_method => :get\n })\n end\n end",
"def initialize(client_id, client_secret, refresh_token)\n merge!(\n {\n client_id: client_id,\n client_secret: client_secret,\n refresh_token: refresh_token,\n grant_type: \"refresh_token\"\n }\n )\n end",
"def get_client_access_token(options = {})\n get_access_token('client_credentials', options)\n end",
"def initialize(client_id:, client_secret:, access_token: nil, transport: Faraday)\n @client_id = client_id.to_s\n @client_secret = client_secret.to_s\n @access_token = access_token.to_s\n @transport = transport\n end",
"def oauth(options = {})\n @oauth ||= ApiFactory.new 'Authorizations', options\n end",
"def initialize(options= {})\n @login = options[:login] || ENV['VZAAR_LOGIN'] || ''\n application_token = options[:application_token] || ENV['VZAAR_APPLICATION_TOKEN'] || ''\n server = options[:server] || ENV['VZAAR_SERVER'] || VZAAR_LIVE_SERVER\n @logger = options[:logger] || Logger.new(STDOUT)\n\n server.gsub! 'http://', ''\n server.gsub! 'https://', ''\n consumer = OAuth::Consumer.new '', '', { :site => \"http://#{server}\" }\n @public_connection = OAuth::AccessToken.new consumer, '', ''\n consumer = OAuth::Consumer.new '', '', { :site => \"https://#{server}\" }\n if @login.length > 0 and application_token.length > 0\n @auth_connection = OAuth::AccessToken.new consumer, @login, application_token\n else\n # Authenticated requests won't be possible\n @auth_connection = nil\n log_info \"Authenticated calls won't be possible\"\n end\n end",
"def client\n OAuth2::Client.new(api_key,api_secret, :site=>{:url=>'https://graph.renren.com',:response_type=>'code'}, :access_token_url=>'https://graph.renren.com/oauth/token')\n end",
"def initialize(app, name, client_id=nil, client_secret=nil, client_options={}, options={}, &block)\n self.client_id = client_id\n self.client_secret = client_secret\n self.client_options = client_options\n super\n end",
"def client\n Twitter::Client.new(\n oauth_token: token,\n oauth_token_secret: token_secret\n )\n end",
"def initialize(client_id, application_secret, redirect_uri, access_token = nil)\n # The client_id must be a Integer\n raise PutioError::ClientIDInvalid unless client_id.to_s.is_i?\n\n # Store arguments as instance variables\n @client_id = client_id\n @application_secret = application_secret\n @redirect_uri = redirect_uri\n @access_token = access_token || nil\n end",
"def initialize(consumer_key, consumer_secret, options = {})\n @xero_url = options[:xero_url] || \"https://api.xero.com/api.xro/2.0\"\n @payroll_url = options[:payroll_url] || \"https://api.xero.com/payroll.xro/1.0\"\n @client = OAuth.new(consumer_key, consumer_secret, options)\n end",
"def create_client(oauth)\n\t\t@client = Twitter::Client.new(\n\t\t\t consumer_key: oauth[\"consumer_key\"],\n\t\t\t consumer_secret: oauth[\"consumer_secret\"],\n\t\t\t oauth_token: oauth[\"oauth_token\"],\n\t\t\t oauth_token_secret: oauth[\"oauth_token_secret\"]\n\t\t)\n\tend",
"def oauth\n {\n consumer_key: @consumer_key,\n consumer_secret: @consumer_secret,\n token: @token,\n token_secret: @token_secret\n }\n end",
"def client(uri)\n params = {\n :site => site,\n :http_method => :post,\n :request_token_path => \"\",\n :authorize_path => \"\",\n :access_token_path => \"\"}\n\n consumer = OAuth::Consumer.new(AppConfig.candlepin.oauth_key,\n AppConfig.candlepin.oauth_secret, params)\n request = Net::HTTP::Post.new(\"#{site}#{uri}\")\n consumer.sign!(request)\n headers = {\n 'Authorization' => request['Authorization'],\n # TODO: This should be moved to a new helper - this is quite ugly\n 'cp-user' => Thread.current[:request].env['warden'].user\n }\n\n # Creating a new client for every request:\n RestClient::Resource.new(site, :headers => headers)\n end",
"def initialize(client_id=nil,client_secret=nil)\n @client_id = client_id\n @client_secret = client_secret\n req1 = RestClient.post(\"https://services.rdio.com/oauth2/token\",\n \"grant_type=client_credentials&client_id=#{@client_id}&client_secret=#{@client_secret}\")\n @access_token = JSON.parse(req1)[\"access_token\"]\n end",
"def client_options\n {\n client_id: Rails.application.secrets.google_client_id,\n client_secret: Rails.application.secrets.google_client_secret,\n authorization_uri: 'https://accounts.google.com/o/oauth2/auth',\n token_credential_uri: 'https://accounts.google.com/o/oauth2/token',\n scope: Google::Apis::CalendarV3::AUTH_CALENDAR,\n redirect_uri: callback_url\n }\n end",
"def client\n @client ||= Faraday.new(api_host) do |faraday|\n faraday.headers[\"Authorization\"] = \"Bearer #{access_token}\"\n faraday.response :logger if Rails.env.test?\n faraday.adapter Faraday.default_adapter\n end\n end",
"def initialize(client_id, client_secret, options={})\n @base_uri = 'https://api.foursquare.com'\n @defaults = {:client_id => client_id, :client_secret => client_secret, :v => '20110727'}.merge(options)\n self\n end",
"def initialize(config, user = nil)\n @config = config\n @user = user\n\n options = {\n :consumer_key => config['consumer_key'],\n :consumer_secret => config['consumer_secret'],\n :access_token => user ? user.access_token : config['client_access_token'],\n :access_token_secret => user ? user.secret_token : config['client_secret_token']\n }\n\n super(options)\n end",
"def oauth_app_access_token(client_id, client_secret)\n self.oauth_access_token(client_id, client_secret, :type => 'client_cred')\n end",
"def initialize(consumer_key, consumer_secret, token, token_secret)\n @consumer = OAuth::Consumer.new(consumer_key, consumer_secret, {:site => API_HOST})\n @access_token = OAuth::AccessToken.new(@consumer, token, token_secret)\n end",
"def client_options\n {\n client_id: Rails.application.secrets.google_client_id,\n client_secret: Rails.application.secrets.google_client_secret,\n authorization_uri: 'https://accounts.google.com/o/oauth2/auth',\n token_credential_uri: 'https://accounts.google.com/o/oauth2/token',\n scope: Google::Apis::CalendarV3::AUTH_CALENDAR,\n redirect_uri: callback_url\n }\n end",
"def initialize(klass = nil)\n @klass = klass\n if @klass.present?\n @client = OAuth::AccessToken.new(consumer, @klass.access_token, @klass.access_secret)\n end\n end",
"def client\n @_client ||= Twitter::REST::Client.new do |config|\n config.consumer_key = CONSUMER_KEY\n config.consumer_secret = CONSUMER_SECRET\n config.access_token = ACCESS_TOKEN\n config.access_token_secret = ACCESS_TOKEN_SECRET\n end\n end",
"def initialize(user, password)\n @user = user\n @password = password\n\n # In the constructor, try to authenticate and get the access_token and\n # client_id\n authenticate\n end",
"def initialize( user_token = nil, user_secret = nil )\n\t\t@consumer = OAuth::Consumer.new(TWOAUTH_KEY, TWOAUTH_SECRET, { :site=> TWOAUTH_SITE })\n\t\t@access_token = OAuth::AccessToken.new( @consumer, user_token, user_secret ) if user_token && user_secret\n end",
"def initialize(o_auth_client_id: nil, o_auth_client_secret: nil)\r\n Configuration.o_auth_client_id = o_auth_client_id if\r\n o_auth_client_id\r\n Configuration.o_auth_client_secret = o_auth_client_secret if\r\n o_auth_client_secret\r\n end",
"def client_credentials\n {\n client_id: @client_id,\n client_secret: @client_secret,\n redirect_uri: @redirect_uri,\n }\n end",
"def parse_oauth2_options\n default = {site: DEFAULT_OAUTH2_OPTIONS[:api_host],\n token_url: full_oauth_url_for(:access_token, :auth_host),\n authorize_url: full_oauth_url_for(:authorize, :auth_host)}\n return default.merge(@client_options)\n end",
"def oauth2_token_client_credentials\n @token = Oauth2Token.create :client_application=>@client_application, :user=>@client_application.user, :scope=>params[:scope]\n render :json=>@token\n end",
"def oauth2_token_client_credentials\n @token = Oauth2Token.create :client_application=>@client_application, :user=>@client_application.user, :scope=>params[:scope]\n render :json=>@token\n end",
"def client\n @client ||= Client.new(config[:credentials], config[:end_point])\n end",
"def oauth2_token_client_credentials\n @token = Oauth2Token.create(:client_application => @client_application, :scope=>params[:scope])\n render :json => @token\n end",
"def client\n @client ||= OpenIDConnect::Client.new(\n identifier: @client_id,\n secret: @secret,\n redirect_uri: @redirect_url,\n realm: 'esdl-mapeditor',\n audience: @audience,\n authorization_endpoint: discovery.authorization_endpoint,\n token_endpoint: discovery.token_endpoint,\n userinfo_endpoint: discovery.userinfo_endpoint\n )\n end",
"def authorize_url\n client = OAuth2::Client.new(client_id, client_secret, :site => oauth_url)\n client.auth_code.authorize_url(:redirect_uri => redirect_uri)\n end",
"def twitter_client(access_token, access_token_secret)\n return Twitter::Client.new(\n oauth_token: access_token,\n oauth_token_secret: access_token_secret\n )\n end",
"def client\n Twitter::REST::Client.new(consumer_key: Settings.consumer.key,\n consumer_secret: Settings.consumer.secret,\n access_token: oauth_token,\n access_token_secret: oauth_token_secret)\n end",
"def client\n @client ||= Twitter::REST::Client.new(client_params)\n end",
"def authenticate\n client = Twitter::REST::Client.new do |config|\n config.consumer_key = ENV['CONSUMER_KEY']\n config.consumer_secret = ENV['CONSUMER_SECRET']\n config.access_token = ENV['ACCESS_TOKEN']\n config.access_token_secret = ENV['ACCESS_TOKEN_SECRET']\n end\n return client\n end",
"def initialize(authorization_code, client_secret: nil)\n @authorization_code = authorization_code\n @client_secret = client_secret || ENV.fetch('FORTNOX_CLIENT_SECRET')\n end",
"def get_client(uri, http_type, method)\n final_url = @base_url + URI.escape(uri)\n params = {\n :site => @base_url,\n :http_method => method,\n :request_token_path => \"\",\n :authorize_path => \"\",\n :access_token_path => \"\"}\n #params[:ca_file] = self.ca_cert_file unless self.ca_cert_file.nil?\n\n consumer = OAuth::Consumer.new(@oauth_consumer_key,\n @oauth_consumer_secret, params)\n request = http_type.new(final_url)\n consumer.sign!(request)\n headers = {\n 'Authorization' => request['Authorization'],\n 'accept_language' => @lang,\n 'cp-user' => 'admin'\n }\n\n # Creating a new client for every request:\n client = RestClient::Resource.new(@base_url,\n :headers => headers)\n return client\n end",
"def initialize(client_key, client_secret)\n @client_key = client_key\n @client_secret = client_secret\n end",
"def client\n @client ||= Twitter::REST::Client.new do |config|\n config.consumer_key = ENV['TWITTER_API_KEY']\n config.consumer_secret = ENV['TWITTER_API_SECRET']\n config.access_token = session['token']\n config.access_token_secret = session['secret']\n end\n end",
"def set_oauth_client(id, secret, env)\n @oauth_client = OAuth2::Client.new(\n id,\n secret,\n site: Volabit.site_for(env),\n raise_errors: false\n )\n end",
"def build_token(access_token)\n return OAuth2::AccessToken.new CLIENT, access_token\n end",
"def sign_in_client(client_id:, client_secret:, scope:)\n client(issuer).post do |req|\n req.url \"/oauth2/#{auth_server_id}/v1/token\"\n req.headers['Content-Type'] = 'application/x-www-form-urlencoded'\n req.headers['Authorization'] = 'Basic: ' + Base64.strict_encode64(\"#{client_id}:#{client_secret}\")\n req.body = URI.encode_www_form scope: scope, grant_type: 'client_credentials'\n end\n end",
"def initialize(ctoken, csecret, options={})\n @ctoken, @csecret, @consumer_options = ctoken, csecret, {}\n @api_endpoint = options[:api_endpoint] || 'http://api.teambox.com'\n @signing_endpoint = options[:signing_endpoint] || 'http://api.teambox.com'\n if options[:sign_in]\n @consumer_options[:authorize_path] = '/oauth/authenticate'\n end\n end",
"def initialize(klass = nil)\n @klass = klass\n if @klass.present?\n @client = OAuth2::AccessToken.from_hash consumer, JSON.load(@klass.oauth2_token)\n end\n end",
"def retrieve(options = {})\n body = options.fetch(:body, {})\n\n @client.post(\"oauth/token?grant_type=client_credentials\", body, options)\n end",
"def authenticated_client\n settings = Tweetskim::Settings.new\n \n if settings.user_credentials_stored?\n user_token, user_secret = settings.load_credentials\n else\n user_token, user_secret = oauth_pin_dance_for_token_and_secret\n settings.save_credentials(user_token, user_secret)\n end\n\n Twitter.configure do |config|\n config.consumer_key = CONSUMER_KEY\n config.consumer_secret = CONSUMER_SECRET\n config.oauth_token = user_token\n config.oauth_token_secret = user_secret\n end\n\n client = Twitter::Client.new\n client.verify_credentials\n return client\n end",
"def get_access_token(options={})\n response=consumer.token_request(consumer.http_method,(consumer.access_token_url? ? consumer.access_token_url : consumer.access_token_path),self,options)\n OAuth::AccessToken.new(consumer,response[:oauth_token],response[:oauth_token_secret])\n end",
"def create\n @oauth_client = OauthClient.new(oauth_client_params)\n\n respond_to do |format|\n if @oauth_client.save\n format.html { redirect_to oauth_clients_path, notice: 'OAuth client was successfully created.' }\n format.json { render json: @oauth_client, status: :created, location: @oauth_client }\n else\n format.html { render action: \"new\" }\n format.json { render json: @oauth_client.errors, status: :unprocessable_entity }\n end\n end\n end",
"def initialize\n @client = Twitter::REST::Client.new do |config|\n config.consumer_key = ENV['CONSUMER_KEY']\n config.consumer_secret = ENV['CONSUMER_SECRET']\n config.access_token = ENV['ACCESS_TOKEN']\n config.access_token_secret = ENV['ACCESS_TOKEN_SECRET']\n end\n end",
"def twitter_client\n yml_config = YAML::load_file(File.join(Rails.root, 'config', 'twitter.yml'))[Rails.env]\n Twitter::REST::Client.new do |config|\n config.consumer_key = yml_config['consumer_key']\n config.consumer_secret = yml_config['consumer_secret']\n config.access_token = token\n config.access_token_secret = token_secret\n end\n end",
"def initialize(tokens_and_secrets = {})\n @oauth = KynetxAmApi::Oauth.new(tokens_and_secrets)\n end",
"def build_client(access_token)\n begin\n client = Octokit::Client.new(access_token: access_token)\n client.user.login\n rescue Octokit::Unauthorized\n raise 'Please enter valid Personal Auth Token'\n end\n client\n end",
"def initialize(from, to, client_secret)\n @from = from\n @to = to\n @client_secret = client_secret\n @access_token = fetch_access_token\n end",
"def client\n Faraday.new(url: URL) do |c|\n c.token_auth self.auth_token\n c.request :url_encoded # form-encode POST params\n c.adapter Faraday.default_adapter # Net::HTTP\n end\n end",
"def special_client\n @special_client ||= Twitter::REST::Client.new do |c|\n c.consumer_key = configure[:consumer_key]\n c.consumer_secret = configure[:consumer_secret]\n c.access_token = configure[:access_token]\n c.access_token_secret = configure[:access_token_secret]\n end\n end",
"def initialize(opts = {})\n @endpoint = opts[:endpoint] || 'https://app.organisedminds.com/'\n\n @client_id = opts[:client_id] || raise(\"We need a client-id\")\n @client_secret = opts[:client_secret] || raise(\"We need a client-secret\")\n @scopes = opts[:scopes] || [ :read ]\n\n @agent = Faraday.new(:url => @endpoint) do |faraday|\n faraday.use :cookie_jar\n faraday.request :url_encoded\n faraday.adapter *opts[:adapter] || Faraday.default_adapter\n faraday.headers['content-type'] = 'application/json'\n\n if opts[:debug] == true\n faraday.response :logger\n end\n end\n end",
"def client_options\n\topts = {}\n\topts['client_id'] = 'OAuth Client ID'\n\topts['service_email'] = 'Service E-Mail'\n\topts['key'] = \"/path/toprivatekey.p12\"\n\topts['project_id'] = 'Project ID'\n\topts\nend"
] |
[
"0.8370947",
"0.8020362",
"0.7842813",
"0.7813421",
"0.73801476",
"0.73321974",
"0.7285559",
"0.72095394",
"0.7179878",
"0.7059197",
"0.7019579",
"0.7009983",
"0.70041424",
"0.6980361",
"0.69428194",
"0.6905466",
"0.6892612",
"0.6875788",
"0.6860583",
"0.6819266",
"0.6746509",
"0.6740347",
"0.67292243",
"0.6720686",
"0.6691083",
"0.6691083",
"0.6648115",
"0.66224986",
"0.66151434",
"0.65971476",
"0.657582",
"0.6547989",
"0.6539915",
"0.652962",
"0.6521495",
"0.65113026",
"0.6490975",
"0.64702207",
"0.64694244",
"0.6465137",
"0.6464696",
"0.6464237",
"0.6457445",
"0.63992316",
"0.6393501",
"0.63891304",
"0.63804424",
"0.6317096",
"0.62962586",
"0.62904996",
"0.62777",
"0.626217",
"0.62521213",
"0.62448305",
"0.62394404",
"0.6227793",
"0.6225962",
"0.622391",
"0.6220222",
"0.6209773",
"0.6207955",
"0.61858094",
"0.61831903",
"0.6178444",
"0.61546075",
"0.6151731",
"0.6151381",
"0.6147523",
"0.61471605",
"0.61471605",
"0.61196274",
"0.6119587",
"0.6117666",
"0.6113414",
"0.61078906",
"0.6102636",
"0.60874784",
"0.60839194",
"0.6076696",
"0.6069806",
"0.6068884",
"0.6061417",
"0.60588956",
"0.6056524",
"0.6053195",
"0.60493463",
"0.6047765",
"0.60471046",
"0.6043991",
"0.6022879",
"0.60218406",
"0.60197115",
"0.60159427",
"0.59877133",
"0.59823257",
"0.5981124",
"0.5978656",
"0.5978109",
"0.5974641",
"0.5961605"
] |
0.7034905
|
10
|
Makes a request relative to the specified site root.
|
def request(verb, url, params={}, headers={})
if (verb == :get) || (verb == :delete)
resp = connection.run_request(verb, url, nil, headers) do |req|
req.params.update(params)
end
else
resp = connection.run_request(verb, url, params, headers)
end
if raise_errors
case resp.status
when 200...299
return response_for(resp)
when 302
return request(verb, resp.headers['location'], params, headers)
when 401
e = OAuth2::AccessDenied.new("Received HTTP 401 during request.")
e.response = resp
raise e
when 409
e = OAuth2::Conflict.new("Received HTTP 409 during request.")
e.response = resp
raise e
else
e = OAuth2::HTTPError.new("Received HTTP #{resp.status} during request.")
e.response = resp
raise e
end
else
response_for resp
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def relative_url_root=(_arg0); end",
"def relative_url_root=(_arg0); end",
"def relative_url_root; end",
"def relative_url_root; end",
"def relative_url_root; end",
"def hack_relative_url_root\n begin\n update_relative_url_root!\n yield\n ensure\n ActionController::Base.relative_url_root = ActionController::Base._relative_url_root\n end\n end",
"def relative_url_root=(_); end",
"def discover_current_site_with_root\n site_from_root || discover_current_site_without_root\n end",
"def based_on_root(rel_path)\n File.expand_path(File.join(options.root,rel_path))\n end",
"def supersite\n unless is_root_site?\n Site.new(@connection, ::File.dirname(@url), @depth - 1)\n end\n end",
"def site_url(href)\n path_resolver = (@path_resolver ||= PathResolver.new)\n base_dir = path_resolver.posixify(@document.base_dir)\n site_root = path_resolver.posixify(@document.attr('site-root', base_dir))\n unless path_resolver.is_root? site_root\n raise ::ArgumentError, %(site-root must be an absolute path: #{site_root})\n end\n base_dir_to_root = nil\n if (base_dir != site_root) && (base_dir.start_with? site_root)\n comp, root = path_resolver.partition_path(base_dir.slice(site_root.length + 1, base_dir.length))\n base_dir_to_root = '../' * comp.length\n end\n path_resolver.web_path(href, base_dir_to_root)\n end",
"def relative_root\n Rails.configuration.relative_url_root || \"\"\n end",
"def relative\n return self if relative?\n @relativized ||= relative_path_from root\n end",
"def relativize(href, path, absolute_base, root_dir)\n # href = actual href string on page\n # path = actual current location / file path of current page\n # absolute_base = the base url for the site\n\n href_url = URI.join(URI.encode(absolute_base), URI.encode(href))\n path_url = URI.join(absolute_base, URI.encode(path))\n relative_url = path_url.route_to(href_url).to_s\n url_out = test_index(relative_url, href_url, absolute_base, root_dir)\n if href.match(/^#/)\n url_out = href\n end\n url_out\nend",
"def site_url(full: true)\n full ? root_url : \"#{request.host}:#{request.port}/\"\n end",
"def swap_relative_url_root\n ::ActionController::Base.original_relative_url_root = ::ActionController::Base.relative_url_root\n ::ActionController::Base.relative_url_root = ::ActionController::Base.proxy_relative_url_root unless ::ActionController::Base.proxy_relative_url_root.nil?\n begin\n yield\n ensure\n ::ActionController::Base.relative_url_root = ::ActionController::Base.original_relative_url_root\n end\n end",
"def configure_context_root(site, env)\n parts = env['PATH_INFO'].split('/')\n expected_context_root = parts[1]\n if site.allowed_context_roots.include? expected_context_root\n $context_root = expected_context_root\n env['PATH_INFO'].sub!(/^\\/#{$context_root}/, '')\n env['REQUEST_PATH'].sub!(/^\\/#{$context_root}/, '')\n env['ORIGINAL_FULLPATH'].sub!(/^\\/#{$context_root}/, '')\n env['REQUEST_URI'].sub!(/(\\w+:\\/+[^\\/]+)\\/#{$context_root}/, '\\1')\n else\n $context_root = nil\n end\n end",
"def request_path\n @request_path ||= ::File.expand_path(::File.join(root_dir, ::Rack::Utils.unescape(path_info)))\n end",
"def root; resource :path => '/'; end",
"def set_proxy_relative_url_root\n ::ActionController::Base.proxy_relative_url_root = request.forwarded_uris.empty? ? nil : parse_proxy_relative_url_root\n end",
"def static(root)\n @match_partially = true if File.directory?(root)\n to File.directory?(root) ?\n ::Rack::File.new(root) :\n proc {|env| \n env['PATH_INFO'] = File.basename(root)\n ::Rack::File.new(File.dirname(root)).call(env)\n }\n end",
"def goto relative_url\n destination = File.join(@site.origin, relative_url) \n @browser.goto destination\n end",
"def path_root\n base_uri ? base_uri : path_to( '/' )\n end",
"def base_uri\t\t\t\n\t\tURI.parse( \"http://\" + @factory.site_name + \".\" + @factory.api_host_base + @path )\n\tend",
"def requested_file(request)\n request_uri = request.split(\" \")[1]\n path = URI.unescape(URI(request_uri).path)\n\n clean = []\n\n # Split the path into components\n parts = path.split(\"/\")\n\n parts.each do |part|\n # skip any empty or current current directory (\".\") path components\n next if part.empty? || part == \".\"\n # If the path component goes up one directory level (\"..\"),\n # remove the last clean component\n # Otherwise, add the component to the Array of clean components\n part == \"..\" ? clean.pop : clean << part\n end\n\n # return the web root joined to the client path\n\n File.join(WEB_ROOT, *clean)\nend",
"def root_site_url(relative_link)\n root_site = Node.root.content\n URI.join(\"#{request.protocol}#{root_site.domain}:#{request.port}\", relative_link).to_s\n end",
"def url; \"file:#{@root}\"; end",
"def root\n get \"/\"\n end",
"def root\n get \"/\"\n end",
"def site_url(path)\n\t\tbase_url = \"http://fullridecentral.com\"\n\t\t\"#{base_url}#{path}\"\n\tend",
"def relative_url_root\n @context.registers[:relative_url_root]\n end",
"def root\n get '/'\n end",
"def root_path(*args)\n relative = File.join(*args)\n return relative if relative.expand_path == relative\n root.expand_path / relative\n end",
"def root_path(*args)\n relative = File.join(*args)\n return relative if relative.expand_path == relative\n root.expand_path / relative\n end",
"def requested_file(request)\n uri = request.split(\" \")[1]\n clean_path = []\n parts = uri.split(\"/\")\n\n # skip if path component includes current directory (\".\")\n parts.each do |part|\n next if part.empty? || part == '.'\n\n # removes last component if path goes one directory level up (\"..\"), pass; else append to clean_path\n part == '..' ? next : clean_path << part\n end\n File.join(ROOT, *clean_path)\nend",
"def url\n Config.site.url.chomp('/') + self.path\n end",
"def absolute_url\n domain + path\n end",
"def urlpath\n path = cleanpath\n path.blank? ? '/root' : '/' + path\n end",
"def pathWebSite\n \"./website/\"\nend",
"def call(env)\n request = ::Rack::Request.new(env)\n if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/\n response = ::Rack::Response.new\n response.redirect(request.path_info[0, request.path_info.size - 1], 302)\n response.finish\n else\n @root.call(request) || @default_app.call(request.env)\n end\n end",
"def root_url\n '.'\n end",
"def relative_path_from(from); end",
"def request_path\n [request.base_url, request.path].join\n end",
"def base_url\n File.join(host, path)\n end",
"def here\n\n \"#{request.scheme}://#{request.host}:#{request.port}\" +\n \"#{request.fullpath}\"\n end",
"def absolute_url(request, opts={})\n cdn_url(opts) || (request.protocol + request.host_with_port + public_filename)\n end",
"def root\n @site.root\n end",
"def root_path; end",
"def root_path; end",
"def root_path; end",
"def parse_proxy_relative_url_root\n request.forwarded_uris.first.gsub(/#{Regexp.escape(request.path)}$/, '')\n end",
"def use_relative_controller!; end",
"def document_root\n end",
"def site\n lambda { |env|\n env.merge! env_extensions\n Request.new(env).response\n }\n end",
"def absolutize_path(path = nil)\n \"#{root_path}#{path}\"\n end",
"def original_url\r\nbase_url + original_fullpath\r\nend",
"def request\n double(ActionDispatch::Request, { path: \"/\" })\n end",
"def go_relative(uri)\n self.location = relative_uri(uri)\n end",
"def base_path\n @base_path ||= server_path(File.expand_path(Dir.pwd))\n end",
"def root_path(path) File.join(root, path) end",
"def set_filename(req, res)\n original_root = @root.dup\n if req.path_info.start_with?(\"/#{ ViteRuby.config.public_output_dir }/\")\n @root = ViteRuby.config.root.join(ViteRuby.config.public_dir)\n end\n super.tap { @root = original_root }\n end",
"def get_root\n @logger.debug \"GET #{@jenkins_path}/\"\n request = Net::HTTP::Get.new(\"#{@jenkins_path}/\")\n make_http_request(request)\n end",
"def make_request(request)\n parsed_url = request.url\n\n raise ArgumentError, \"Expecting get argument url to be a valid_url?, got #{request.url}\" if !parsed_url.valid_url? && current_url.nil?\n\n parsed_url = current_url.join_url(request.url) if !request.url.valid_url? && !current_url.nil?\n\n client_resource = RestClient::Resource.new(parsed_url, ssl_version: 'SSLv23_client')\n response = client_resource.send(request.type, params: request.params)\n\n self.xml = Nokogiri::HTML.parse(response)\n end",
"def url\n URL(@site.url).join(attributes[\"RootFolder\"]).to_s\n # # Dirty. Used to use RootFolder, but if you get the data from the bulk calls, RootFolder is the empty\n # # string rather than what it should be. That's what you get with web services as an afterthought I guess.\n # view_url = ::File.dirname(attributes[\"DefaultViewUrl\"])\n # result = URL(@site.url).join(view_url).to_s\n # if ::File.basename(result) == \"Forms\" and dir = ::File.dirname(result) and dir.length > @site.url.length\n # result = dir\n # end\n # result\n end",
"def local_site_path\n SiteProcessor.new(self).local_site_path\n end",
"def url(*args)\n super_url = super\n File.exists?(\"#{root}#{super_url}\") ? super_url : default_url\n end",
"def with_base_url(path)\n u = @url.dup\n u.path += Puppet::Util.uri_encode(path)\n u\n end",
"def app_path\n res = send_request_cgi({\n # default.a.get( check\n 'uri' => normalize_uri(target_uri.path, 'js', 'app.js'),\n\t 'method' => 'GET'\n })\n\n if res && res.code == 200 && res.body =~ /baseURL/\n data = res.body\n #word = data.scan(/\"#{string_to_split}\"\\] = \"([\\S\\s]*?)\"/)\n base_url = data.scan(/baseURL: '\\/([\\S\\s]*?)'/)[0]\n print_status(\"baseURL: #{base_url}\")\n return base_url\n else\n fail_with(Failure::NotVulnerable, 'baseURL not found!')\n end\n end",
"def basepath; end",
"def relative_path\n self.path.sub(File.expand_path(options[:root_dir]) + '/', '')\n end",
"def request_uri\n return unless @path\n\n url = @query ? \"#@path?#@query\" : @path.dup\n url.start_with?(?/.freeze) ? url : ?/ + url\n end",
"def relative_url(input); end",
"def to_relative_uri\n build_uri.route_from base_value\n end",
"def initialize(static_site_path)\n @root = static_site_path\n @static_page_server = Rack::Directory.new(@root)\n end",
"def generate_base_uri request, set=nil\n b_uri= uri request.env['REQUEST_URI'].to_s[0..-request.env['PATH_INFO'].length]\n @base_uri = b_uri if set\n b_uri\n end",
"def rewrite_local_urls(response_html) # :nodoc:\n if base_url\n doc = Nokogiri::HTML::Document.parse response_html\n if head = doc.xpath(\"//head\").first\n base = Nokogiri::HTML::DocumentFragment.parse \"<base href=\\\"#{base_url}\\\">\"\n head.child && head.child.add_previous_sibling(base)\n doc.to_html\n else\n response_html\n end\n elsif doc_root\n # TODO: replace with nokogiri calls\n response_html.gsub(/\"\\/([^\"]*)\"/, %{\"#{doc_root}} + '/\\1\"')\n else\n response_html\n end\n end",
"def guess_base_uri\n \"#{@http_request.raw_server_value('SCRIPT_NAME')}/\"\n end",
"def root(path = nil)\n base = File.expand_path(File.dirname(__FILE__))\n path ? File.join(base, path) : base\n end",
"def urify!(env)\n return if full_uri?\n request = Rack::Request.new env\n @uri = File.join File.dirname(env['PATH_INFO']), @uri if relative_uri?\n @uri = \"#{request.scheme}://#{request.host_with_port}#{@uri}\"\n end",
"def site(url = nil)\n @site = url if url\n resource ? (@site || resource.base_url) : @site\n end",
"def redmine_url\n rootUrl = ActionController::Base.relative_url_root\n\n return rootUrl+'/' if rootUrl != nil\n\n return '/'\n end",
"def abs_url(site)\n\t\t\turl = site.config['url']\n\t\t\turl = url[0..-2] if site.config['url'].end_with?(\"/\")\n\t\t\turl + fix_path(site.config['git_to_rss_file_path'])\n\t\tend",
"def root_path=(_arg0); end",
"def root_path=(_arg0); end",
"def root_path=(_arg0); end",
"def require_site\n self.site\n end",
"def url\n\t\tif relative? then\n\t\t\tif page.bases[0] then\n\t\t\t\t page.bases[0].href + src\n\t\t\telse\n\t\t\t\tpage.uri + src\n\t\t\tend\n\t\telse\n\t\t\tsrc\n\t\tend\n\tend",
"def local_uri\n\n return nil unless self.uri\n u = full_uri\n u[0, 1] == '/' ? \"#{RAILS_ROOT}/public#{u}\" : u\n end",
"def root_url\n url '/'\n end",
"def url(addr = nil, absolute = true, add_script_name = true)\n return addr if addr =~ /\\A[A-z][A-z0-9\\+\\.\\-]*:/\n uri = [host = \"\"]\n if absolute\n host << \"http#{'s' if request.secure?}://\"\n if request.forwarded? or request.port != (request.secure? ? 443 : 80)\n host << request.host_with_port\n else\n host << request.host\n end\n end\n uri << request.script_name.to_s if add_script_name\n uri << (addr ? addr : request.path_info).to_s\n File.join uri\n end",
"def base_url_path=(_arg0); end",
"def root\n '/projects/my_rails_project'\n end",
"def post\n _root_document\n end",
"def request_uri\n return nil if absolute? && scheme !~ /^https?$/\n res = path.to_s.empty? ? \"/\" : path\n res += \"?#{self.query}\" if self.query\n return res\n end",
"def canonical_path\n # root_url ends in a slash, request.path starts with one, we need to strip one of them out!\n url = \"#{root_url.gsub(/\\/$/,'')}#{request.path}\"\n\n # rule #1 && rule #2\n if params['page'] && params['page'].to_i != 1\n url = url + \"?page=#{params[:page]}\"\n end\n\n url\n end",
"def set_paths(site)\n @public_path = site.public_path\n @view_path = site.view_path\n end",
"def uri_path(request)\n @dreamhost_fix ? env[\"SCRIPT_URL\"] : request.path_info\n end",
"def pathWebSitePages\n pathWebSite + \"pages/\"\nend",
"def root_uri\n uri = URI.parse request.url\n uri.path = \"\"\n uri.query = nil\n uri.to_s\n end",
"def site_path\n settings.site_path\n end",
"def account_site_assets_base(leading_slash = true)\n leading_slash ? \"/#{SITE_ASSETS_FOLDER}\" : SITE_ASSETS_FOLDER\n end"
] |
[
"0.6318264",
"0.6318264",
"0.6166546",
"0.6166546",
"0.6166546",
"0.61545336",
"0.6134428",
"0.603789",
"0.59271103",
"0.59029037",
"0.58683074",
"0.5865835",
"0.58563954",
"0.57968074",
"0.57932216",
"0.578357",
"0.5699139",
"0.5698113",
"0.5697869",
"0.5689201",
"0.5684515",
"0.567607",
"0.5659665",
"0.5652558",
"0.56316316",
"0.5613613",
"0.56119376",
"0.5593165",
"0.5593165",
"0.55441964",
"0.55422485",
"0.55146915",
"0.5496747",
"0.5496747",
"0.54665315",
"0.5455871",
"0.5432684",
"0.54298735",
"0.54234016",
"0.54185736",
"0.5415615",
"0.5411236",
"0.54092467",
"0.53845245",
"0.5380129",
"0.5362371",
"0.5360122",
"0.5348612",
"0.5348612",
"0.5348612",
"0.53392464",
"0.5335638",
"0.5335044",
"0.5333733",
"0.5332853",
"0.53264374",
"0.5316763",
"0.5315815",
"0.53040886",
"0.52940375",
"0.529341",
"0.52906877",
"0.52780145",
"0.5277228",
"0.52753633",
"0.5269962",
"0.5265426",
"0.5260223",
"0.5249495",
"0.5247536",
"0.52435935",
"0.5233519",
"0.5231379",
"0.5224655",
"0.5221218",
"0.52017534",
"0.5201603",
"0.5201517",
"0.52003735",
"0.5195118",
"0.5192372",
"0.51894814",
"0.5188164",
"0.5188164",
"0.5188164",
"0.51829505",
"0.51811934",
"0.5177047",
"0.51767033",
"0.517644",
"0.51574874",
"0.51543987",
"0.5152368",
"0.5145236",
"0.51443785",
"0.51434",
"0.51421696",
"0.5137206",
"0.51333934",
"0.5128125",
"0.51252604"
] |
0.0
|
-1
|
add planet to array
|
def planet_add(planet)
@planets.push(planet)
return @planets
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_planet(planet)\n @planet << planet\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet_to_add)\n @planets << planet_to_add\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet)\n @planets << planet\n end",
"def add_planet(planet)\n\t\t@planets << planet\n\tend",
"def add_planet(planet)\n @planets.push(planet)\n end",
"def add_planet(planet)\n @planets.push(planet)\n end",
"def add_planet(planet)\n @planets.push(planet)\n end",
"def add_planet(planet)\n @planets.push(planet)\n end",
"def add_planet(new_planet)\n @planets << new_planet\n end",
"def add_planet(new_planet)\n @planets << new_planet\n end",
"def add_planet(new_planet)\n @planets << new_planet\n end",
"def add_planet(new_planet)\n @planets << new_planet\n end",
"def add_planet(new_planet)\n @planets.push(new_planet)\n return @planets\n end",
"def add_planet(new_planet)\n return @planets << new_planet\n end",
"def add_new_planet(new_planet)\n @planets.push(new_planet)\n end",
"def add new_planet\n @planets << new_planet\n end",
"def add_planet(new_planet)\n new = 0\n @array_of_planets.each do |each_planet|\n if each_planet.name == new_planet.name\n new += 1\n end\n end\n if new == 0\n @array_of_planets << new_planet\n else\n puts \"That planet is already in the solar system!\"\n end\n end",
"def add_planet(planet)\n # planets = @planets.map { |i| i.name.downcase }\n if @planets.include?(planet.name.downcase)\n raise ArgumentError.new(\"Planet already exists. A solar system cannot have duplicate planets\")\n end\n @planets.push(planet)\n end",
"def add_planets(planet)\n @planets << planet\n return @planets\n end",
"def add_planet_object(new_planet_object)\n @solar_system.push(new_planet_object)\n end",
"def add_planets(planets)\n planets.each do |planet|\n @planets.push(planet)\n end\n end",
"def add_planet_object(new_planet_object)\n @planets_collection.push(new_planet_object)\n end",
"def add_planet\n planet = Planet.new(get_planet_name, get_planet_distance, get_planet_rotation, get_planet_moons)\n return planet\nend",
"def add_planet(planet_obj)#parameter\n @planets_list.push(planet_obj)#push method with argument of \"planet_object\"\n puts \"You just added the planet #{planet_obj.name} to the #{\"Juice Box Solar System\"}.\" #what is planet_obj here? hwhere is it pointing?\n end",
"def new_planet(planet)\n @planets[planet.name] = planet\n end",
"def add_planets\n get_list_of_planets.each {|planet| Planet.new(planet)} \n end",
"def add_planet_by_name(name)\n planet = get_space_body_by_name(name)[0]\n Planet.new(planet)\n end",
"def create_planet(array_of_planets)\n puts \"Tell us some information about your planet.\"\n print \"Name: \"\n name = gets.chomp\n print \"Length of Year: \"\n year_length = gets.chomp\n print \"Distance from the Sun: \"\n distance_from_sun = gets.chomp\n puts \"We have found that most planets known to humankind share certain characteristics. If the given information is true of your planet, type YES. If its not, give us the correct information for your planet.\"\n puts \"Language: Meowish\"\n language = gets.chomp\n if language == \"YES\"\n language = \"Meowish\"\n else\n language = language\n end\n puts \"Inhabitants: Cats\"\n inhabitants = gets.chomp\n if inhabitants == \"YES\"\n inhabitants = \"Cats\"\n else\n inhabitants = inhabitants\n end\n puts \"Primary Export: Catnip\"\n primary_export = gets.chomp\n if primary_export == \"YES\"\n primary_export = \"Catnip\"\n else\n primary_export = primary_export\n end\n array_of_planets << Planet.new(name, year_length, distance_from_sun, language: language, inhabitants: inhabitants, primary_export: primary_export)\nend",
"def add_list_of_planets(list_of_planets)\n list_of_planets.each do |planet|\n @planets.push(planet)\n end\n end",
"def build_system(name, planet)\n @planets[name] = planet\n end",
"def set_planet\n end",
"def add_initial_planets(solar_system)\n earth = Planet.new('Earth', 'blue-green', 5.972e24, 1.496e16, 'Only planet known to support life')\n cyborg = Planet.new('Cyborg', 'neon green', 10.993e24, 2.496e90, 'Humans have not yet discovered this planet' )\n mars = Planet.new('Mars', 'red', 9.972e24, 2.496e16, 'This planet was named after the Roman god of war')\n solar_system.add_planet(earth)\n solar_system.add_planet(cyborg)\n solar_system.add_planet(mars)\nend",
"def add_planet\n\t\tputs \"Would you like to add a planet? Enter Y/N\".colorize(:blue)\n\t\tanswer = gets.chomp.downcase\n\t\tif answer == \"y\"\n\t\t\tputs \"Great! Please enter the name of planet.\"\n\t\t\tname = gets.chomp\n\t\t\tputs \"Now enter the diameter of your planet.\"\n\t\t\tdiameter = gets.chomp\n\t\t\tputs \"What is the mass of your new planet?\"\n\t\t\tmass = gets.chomp\n\t\t\tputs \"How many moons?\"\n\t\t\tmoons = gets.chomp\n\t\t\tputs \"Is there life on your planet? Please enter \\\"Y\\\" or \\\"N\\\".\"\n\t\t\tlife = gets.chomp.downcase\n\t\t\t\tif life == \"y\"\n\t\t\t\t\tlife = true\n\t\t\t\telse \n\t\t\t\t\tlife = false\n\t\t\t\tend\n\t\t\tputs \"Finally, what is the solar rotation of your planet?\"\n\t\t\trotation = gets.chomp\n\t\t\t@new_planet = Planet.new(name: name, diameter: diameter, mass: mass, moons: moons, life: life, rotation: rotation)\n\t\t\t@planets.push(new_planet)\n\t\t\tputs \"Great! #{name} is born!\".colorize(:blue)\n\t\telse\n\t\t\tputs \"Fine. I didn't want your planets anyway.\".colorize(:blue)\n\t\tend\n\tend",
"def planet_list\n return @planets\n end",
"def planet; end",
"def planet; end",
"def planet; end",
"def planet; end",
"def planet; end",
"def planet; end",
"def pool_to_planet(pool)\n # Create a variable to store all new Planet s\n library_of_planets = []\n pool.each do |planet_info|\n library_of_planets << planet = Planet.new(planet_info[:name], planet_info[:diameter], planet_info[:gravity],\n planet_info[:year_length], planet_info[:distance_from_the_sun])\n end\n return library_of_planets\n end",
"def annex_planet(options={})\n options.assert_valid_keys(:count)\n\n options.reverse_merge! :count => 1\n @objectives.push([\n Objective::AnnexPlanet,\n {:key => PLANET_KEY, :count => options[:count], :npc => true}\n ])\n end",
"def planet_list\n planet_array = []\n @planets.each_with_index do |planet, index|\n # **--->how to do without storing list in an array as a variable??\n # **--->prints whole array of hashes if not\n current_planet = \"#{index + 1}. #{planet.name}\"\n planet_array << current_planet\n end\n return planet_array\n end",
"def add_to_point! point\n vectors.each do |v|\n point.add! v\n end\n point\n end",
"def initialize(planets_array)\n @planets = planets_array\n end",
"def place(coord_array) \n #sets spots array to the coordinates occupied by the ship\n @spots = coord_array.dup \n end",
"def manual_add_planet(sol)\n puts \"What is the name of the planet? \"\n name = valid_name(gets.chomp)\n puts \"What is the mass(unit: 1e+24 kg) of the planet #{name}?\"\n mass = valid_float(gets.chomp)\n puts \"What is the diameter(unit: km) of the planet #{name}?\"\n diameter = valid_float(gets.chomp).abs\n puts \"How many moons does the planet #{name} have?\"\n number_of_moons = valid_integer(gets.chomp)\n puts \"What is the distance(unit: 1e+6 km) between the sun and the planet #{name}?\"\n distance_from_the_sun = valid_float(gets.chomp).abs\n puts \"What is the rate of the solar rotation for the planet #{name} in Earth hours?\"\n rate_of_solar_rotation = valid_float(gets.chomp)\n puts \"What is the orbital period for the planet #{name} in Earth days?\"\n orbital_period = valid_float(gets.chomp)\n\n sol.add_planet(\n Planet.new(\n {\n name: name,\n mass: mass,\n diameter: diameter,\n number_of_moons: number_of_moons,\n distance_from_the_sun: distance_from_the_sun,\n rate_of_solar_rotation: rate_of_solar_rotation,\n orbital_period: orbital_period\n }\n )\n )\n return sol\nend",
"def gen_planet(class_map)\n class_map[\"colour\"] = PLANET_COLOURS[class_map[\"type\"].downcase]\n text = \"//#{class_map[\"package\"]} class: #{class_map[\"name\"]}\n#{class_map[\"indexed_name\"]}.setValues({\n name: \\\"#{class_map[\"indexed_name\"]}\\\",\n geometry: new THREE.SphereGeometry(#{class_map[\"radius\"]+0.01}, 10, 10),\n material: new THREE.MeshLambertMaterial({emissive: 0x888888, color: #{class_map[\"colour\"]}, map: planet_texture}),\n origin: #{class_map[\"package\"]}, \n orbitradx: #{(Random.rand(2) == 0)? \"\" : \"-\"}#{class_map[\"orbit\"]}, \n orbitrady: #{(Random.rand(2) == 0)? \"\" : \"-\"}#{class_map[\"orbit\"]}, \n #{(Random.rand(2) == 0)? \"ysin: false\" : \"xsin:false\"},\n rotx: 0.01, \n roty: 0.01, \n rotz: 0.01,\n tfactor: #{1 + Random.rand}});\ncelestials[celestials.length] = #{class_map[\"indexed_name\"]};\\n\\n\"\n return text\nend",
"def add_plane()\n planes << Plane.new(\n gen_location,\n 0,\n width,\n height,\n gen_speed(),\n true\n )\n end",
"def list_planets\n planet_list = \"Planets orbiting #{ @star_name }\\n\"\n @planets.length.times do |add|\n planet_list += \"#{ add + 1 }. #{ @planets[add].name }\\n\"\n end\n\n return planet_list\n end",
"def summon_captain_planet(array)\n newarray = []\n i = 0 \n while i < array.length\n newarray << array[i].capitalize + \"!\"\n \n i = i + 1\nend\n newarray\nend",
"def planet\n fetch('stargate.planets')\n end",
"def initialize\n\t\t@planets = [gallifrey, xander] # initialize hard coded planets\n\t\t#@planets.push(@new_planet) # adds new planets via user input to planets array\n\t\t@number_planets = @planets.length #counts planets by counting array elements\n\t\t@formation_year = rand(-3000000..2015)\n\t\t@age_of_system = 2015 - @formation_year\n\t\t\t\n\tend",
"def planet\n fetch('dune.planets')\n end",
"def tk_add\n \"add planet #{id} - 10 #{x} #{y} 0\\n\" +\n \"param #{id} 0 #{size}\\n\" +\n \"param #{id} 1 #{-size}\\n\" +\n \"param #{id} 2 #{color}\\n\" +\n \"param #{id} 3 #{name}\"\n end",
"def add_planet(solar_system)\n# Ask the user for details about the planet\n print \"Enter the name of the planet: \"\n name = gets.chomp\n name = check_String(name)\n print \"Enter the color of the planet: \"\n color = gets.chomp\n color = check_String(color)\n print \"Enter the mass in kg: \"\n mass_kg = gets.chomp.to_i\n mass_kg = check_number(mass_kg)\n\n print \"Enter the distance from sun in km: \"\n distance_from_sun_km = gets.chomp.to_i\n distance_from_sun_km = check_number(distance_from_sun_km)\n print \"Enter a fun fact: \"\n fun_fact = gets.chomp\n fun_fact = check_String(fun_fact)\n# Create a new instance of Planet with that info\n # binding.pry\n planet_added = Planet.new(name, color, mass_kg, distance_from_sun_km,fun_fact)\n# Add it to the SolarSystem\n solar_system.add_planet(planet_added)\n return solar_system\nend",
"def initialize (solar_system)\n @planet_list = solar_system\n end",
"def planets\n # go through my colonies\n self.colonies.map do |my_colony|\n # get the information about each planet the colony is on\n my_colony.planet\n end\n end",
"def push_to_robot_scent_array(position)\n @robot_scent_positions << position\n end",
"def add_plane(plane)\n @planes << plane\n end",
"def add_planet (solar_system)\n print\"Enter a planet name: \"\n planet_name = gets.chomp # ask them for the name of the planet they wish to learn about\n planet = solar_system.find_planet_by_name(planet_name)\n if planet.nil?\n # Ask the user for details about the planet (W3.3)\n puts\"What is the planet color? \"\n planet_color = gets.chomp #\n\n puts\"What is the planet mass kg?: \"\n planet_mass = gets.chomp.to_i #\n\n puts\"What is the planet distance from sun? \"\n planet_distance = gets.chomp.to_i #\n\n puts\" What is a fun fact about the planet?\"\n planet_fun_fact = gets.chomp #\n # Create a new instance of Planet with that info, and add to solar_system(W3.3)\n new_planet = Planet.new(planet_name, planet_color, planet_mass, planet_distance, planet_fun_fact)\n solar_system.add_planet(new_planet)\n puts \"Planet added with success!\"\n puts new_planet.summary\n else\n puts \"That planet already exists!\"\n puts planet.summary\n end\nend",
"def add_rutabaga_to_array(an_array_param)\n an_array_param << \"rutabaga\"\nend",
"def players\n @a = Array.new\n @a << east \n @a << south\n @a << west\n @a\n end",
"def create(data)\n @planet_model.create(data)\n end",
"def summon_captain_planet(array)\n array.collect{ |planeteer_call| planeteer_call.capitalize + \"!\"\n }\nend",
"def planet_list\n list = \"\"\n @planets.each_with_index do |planet, i|\n list += \" #{i+1}. #{planet.name}\\n\"\n end\n return list\n end",
"def add_new_planet our_solar_system\n puts \"Please enter the planet name\"\n planet_name = gets.chomp.capitalize\n print \"Please enter the length of time the planet takes to go around its star in earth days. ➤ \"\n year_length = gets.chomp.to_f.round(2)\n print \"Please enter how far is the planet from the sun in kilometers. ➤ \"\n distance_from_the_sun = gets.chomp.to_f.round(2)\n print \"Please enter the mass of a planet in kilograms. ➤ \"\n mass = gets.chomp\n print \"Please enter a diameter of the planet in kilometers. ➤ \"\n diameter = gets.chomp.to_f.round(2)\n print \"Please enter what is the composition of the atmosphere. ➤ \"\n atmospheric_components = gets.chomp\n\n new_planet = Planet.new(planet_name, year_length, distance_from_the_sun, mass, diameter, atmospheric_components)\n our_solar_system.add_planet(new_planet)\n puts \"New planet #{planet_name} is added.\".red\nend",
"def list_planets\n puts \"Planets orbiting #{star_name}:\"\n\n @planets.each_with_index do |planet, i|\n @list_of_planets << \"#{i+1}. #{planet.name}\"\n end\n return @list_of_planets\n end",
"def add_plant(plant)\n @plants_planted << plant\n end",
"def add_new_gift(gifts_array, new_gift)\r\n gifts_array << new_gift\r\nend",
"def data_add_wagons\n @trains[0].add_wagon(PassengerWagon.new(35.to_i))\n @trains[1].add_wagon(PassengerWagon.new(32.to_i))\n @trains[2].add_wagon(CargoWagon.new(428.to_i))\n end",
"def add_ay(array)\n array.push(\"ay\")\nend",
"def store_in_array(coordinate)\n\t\tchosen.push(coordinate)\n\tend",
"def summon_captain_planet(array)\n array.collect do |x|\n x.capitalize << \"!\"\n end\nend",
"def initialize(planets)\n @solar_system = planets\n end",
"def planets; end",
"def added(array)\nend",
"def add_item(elective_array, item)\n elective_array.push(item)\n puts elective_array\nend",
"def create_planet(name, mass, year_length, diameter, number_of_moons, distance_from_sun)\n return Planet.new(name, mass, year_length, diameter, number_of_moons, distance_from_sun)\nend",
"def solarsystem_list_return\n list = []\n @array_of_planets.each do |bodies|\n list << \"#{@array_of_planets.index(bodies) + 1}. #{bodies.name}\"\n end\n return list\n end",
"def summon_captain_planet( array )\n new_array = []\n array.map do |elements|\n new_elements = elements.split.map(&:capitalize).join(' ')\n new_elements = \"#{new_elements}!\"\n new_array << new_elements\n end\n new_array\nend",
"def list_planets()\n\t\tplanets_list = @planets.each_with_index.map {|planet,index|\n\t\t\t\"#{index + 1}. #{planet.name}\"}\n\t\tplanets_list.unshift(\"Planets orbiting #{@star_name}:\\n\").to_s\n\t\t\n\t\treturn planets_list \n\tend",
"def return_planets\n planet_list = \"\"\n @planets.each do |planet|\n planet_list << \"#{@planets.index(planet) + 1}. #{planet.name} \\n\"\n end\n return planet_list\n end",
"def add_new_holiday_with_supplies(holiday_supplies, season, holiday_name, supply_array)\n holiday_supplies[season][holiday_name] = supply_array\n holiday_supplies\nend",
"def add_to_array(array, item)\n\tarray += [item]\n\tp array\nend",
"def add_a_planet(solar_system)\n print \"Please enter the planet name: \"\n name = gets.chomp\n print\"What is #{name}'s color? \"\n color = gets.chomp\n print \"What is the mass of #{name}? \"\n mass_kg = gets.chomp\n print \"What is the #{name}'s distance from the sun? \"\n distance_from_sun_km = gets.chomp\n print \"What's a fun fact about #{name}? \"\n fun_fact = gets.chomp\n new_planet = Planet.new(name, color, mass_kg, distance_from_sun_km, fun_fact)\n solar_system.add_planet(new_planet)\n puts\n return \"Here is the info you entered about this new planet: \\n\" + new_planet.summary\n end",
"def <<(atlas)\n raise NotImplementedError\n end",
"def show_planet(number)\n selected = @solar_system[number-1]\n\n # Calculate planet related ages\n age = 4.5e9/(selected.rotation_time/12.0)\n age = age.to_i.to_s\n age = age.reverse.scan(/\\d{3}|.+/).join(\",\").reverse\n\n # Calculate the closest neighboring planets\n # Collect names and distances of planets\n distance_and_name = []\n @solar_system.length.times do |i|\n planet_info = {}\n planet_info[:name] = @solar_system[i].name\n planet_info[:distance] = @solar_system[i].distance_from_the_sun\n distance_and_name << planet_info\n end\n # Get only the distances and sort them\n planet_distances = []\n @solar_system.each do |planet|\n planet_distances << planet.distance_from_the_sun\n end\n ordered_planets = planet_distances.sort\n number_index = ordered_planets.index(selected.distance_from_the_sun).to_i\n\n # Find the select planet's distance neighbors (2)\n if (number_index+1) == @solar_system.length\n neighbor1_distance = 0\n neighbor1_difference = 0\n else\n neighbor1_distance = ordered_planets[(number_index+1)]\n neighbor1_difference = (selected.distance_from_the_sun - neighbor1_distance).abs.round(2)\n end\n if (number_index-1) < 0\n neighbor2_distance = 0\n neighbor2_difference = 0\n else\n neighbor2_distance = ordered_planets[(number_index-1)]\n neighbor2_difference = (selected.distance_from_the_sun - neighbor2_distance).abs.round(2)\n end\n neighbor1_name = \"\"\n neighbor2_name = \"\"\n distance_and_name.each do |planet|\n if neighbor1_distance == planet[:distance]\n neighbor1_name << planet[:name]\n end\n if neighbor2_distance == planet[:distance]\n neighbor2_name << planet[:name]\n end\n end\n if neighbor1_distance == 0 && neighbor2_distance == 0\n true_neighbor = \"not to be found\"\n true_distance = \"both infinity and negative infinity\"\n elsif neighbor1_distance == 0 && neighbor2_distance > 0\n true_neighbor = neighbor2_name\n true_distance = neighbor2_difference\n elsif neighbor2_distance == 0 && neighbor1_distance > 0\n true_neighbor = neighbor1_name\n true_distance = neighbor1_difference\n else\n true_neighbor = \"#{neighbor2_name} and #{neighbor1_name}\"\n true_distance = \"#{neighbor2_difference} and #{neighbor1_difference}\"\n end\n\n # Text summary shown to user\n text = \"\\nThe planet \\[#{selected.name}\\] is #{selected.distance_from_the_sun} Astronomical Units from the sun.\n \\rThe closest neighboring planet(s) is/are #{true_neighbor}, which is/are #{true_distance} AU away.\n \\rIt orbits the sun once every #{selected.rotation_time} Earth months, or #{(selected.rotation_time/12.0).round(2)} Earth years.\n \\rSince our sun is 4.5 billion Earth years old, this planet's age is #{age}!\n \\r#{selected.name} also enjoys #{selected.moon_count} moon(s) orbitin' around it.\\n\"\n return text\n end",
"def add_item(array, item)\n\tarray << item\nend",
"def add_weather day\n @weather.push day\n end",
"def list_planets\n x = \"Planets orbitting #{@star_name}\\n\"\n z = \"\"\n z = z + x\n l = 1\n while l <= @planets.length\n y = \"#{l}. #{@planets[l-1].name}\\n\"\n z += y\n l += 1\n end\n return z\n end",
"def summon_captain_planet(planteers)\n updated = []\n planteers.each do |planteer|\n planteer = planteer.capitalize() \n updated << \"#{planteer}!\"\n end\n updated\nend",
"def choose_pokemon(pokemon_array)\n pokemons << pokemon_array\n end",
"def summon_captain_planet(planeteer_calls)\n newArray = []\n i = 0\n while i < planeteer_calls.length do\n newArray.push(planeteer_calls[i].concat(\"!\").capitalize) \n i += 1\n end\n newArray\nend"
] |
[
"0.7932559",
"0.78777885",
"0.7816552",
"0.7790386",
"0.7790386",
"0.7790386",
"0.7790386",
"0.7790386",
"0.7786768",
"0.77813804",
"0.77813804",
"0.77813804",
"0.77813804",
"0.7590277",
"0.7590277",
"0.7590277",
"0.7590277",
"0.75370526",
"0.74905616",
"0.7486492",
"0.7422665",
"0.7372504",
"0.73484033",
"0.73098296",
"0.72668254",
"0.7065423",
"0.7060211",
"0.6897779",
"0.67832655",
"0.6741504",
"0.67260927",
"0.65260696",
"0.6403966",
"0.636241",
"0.6336624",
"0.6269023",
"0.62348855",
"0.6229872",
"0.59063756",
"0.5826944",
"0.5826444",
"0.5826444",
"0.5826444",
"0.5826444",
"0.5826444",
"0.578884",
"0.5785088",
"0.5744011",
"0.574329",
"0.57381773",
"0.5697204",
"0.56179684",
"0.55834395",
"0.55544645",
"0.5513989",
"0.55032563",
"0.5493147",
"0.54930735",
"0.5482156",
"0.54794186",
"0.547185",
"0.5456016",
"0.5453836",
"0.5444582",
"0.54198074",
"0.54166454",
"0.5408111",
"0.5400592",
"0.5374758",
"0.5372781",
"0.5361414",
"0.53478855",
"0.5346356",
"0.5335005",
"0.5333253",
"0.5332438",
"0.5321814",
"0.53144926",
"0.5314338",
"0.5310074",
"0.52940595",
"0.52937627",
"0.528432",
"0.5279357",
"0.52630883",
"0.5258281",
"0.5252976",
"0.52512723",
"0.523277",
"0.5231595",
"0.5224663",
"0.5221673",
"0.52111405",
"0.52066755",
"0.5206007",
"0.51871485",
"0.5182905",
"0.5152324",
"0.514956"
] |
0.80549
|
1
|
=begin ================================================================================ Ruby 1.8 Methods Author: N/A Version: 1.2 [ Description ] Contains methods for existing classes that may have not made its transition over to Ruby 1.9 (RGSS3). This list is ongoing as people report them. [ Instructions ] There is nothing to do here. Please keep this script in its current location. [ Version History] Ver. Date Notes 1.2 17 Apr 2018 Added: + XP's Input module (constants return ints, not symbols) 1.1 26 Mar 2017 Added: + Arrayto_s + Stringdelete/delete! + String[] 1.0 28 Feb 2016 First implemented ================================================================================ =end Object p
|
def p(*args)
Kernel.p(args)
msgbox_p(*args)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def inspect(input); end",
"def String(p0) end",
"def pstring(input)\n p = PascalString.new\n p.input = input\n p.parse\n p.value\nend",
"def resolveU(input)\r\n #first up some integer parsing\r\n if(input.length < 3)\r\n puts 'Cannot resolve command. Returning to menu.'\r\n else\r\n temp = input[2..input.length-1]\r\n temp2 = Integer(temp)\r\n\r\n if(temp2.to_s == temp)\r\n\r\n #puts temp2\r\n # now we know the input is good, lets check if its in bounds of the list of classes\r\n if (temp2 >= 0 && temp2 <= @@listSubclasses.length)\r\n newClass = @@listSubclasses[temp2]\r\n begin\r\n newClassObj = Kernel.const_get(newClass).new\r\n @@previousClasses.append(@@currClass.class.name)\r\n if(@@previousClasses.length == 4)\r\n fixPrevArr\r\n end\r\n @@currClass = newClassObj\r\n\r\n defaultInfo\r\n rescue\r\n puts 'Could not create object as it required parameters to be made. Returning.'\r\n end\r\n\r\n else\r\n puts 'Index was out of bounds. Try again.'\r\n end\r\n else\r\n puts 'No number detected.'\r\n end\r\n\r\n #puts temp\r\n end\r\n #puts input\r\n @@bLastUsed = false\r\n @@forwardClasses = []\r\n end",
"def objects_and_symbols; end",
"def p(string);end",
"def input; end",
"def input; end",
"def input; end",
"def input_string; end",
"def input; @input; end",
"def input; @input; end",
"def bornin _method, _class = [\n Fixnum,\n Float,\n String,\n Array,\n Hash,\n Range,\n Regexp,\n Math\n]\n\n # to colorize output\n require 'colorize'\n\n # Check\n if _method==nil\n return puts \"=> please pass first arg as a string\".red\n end\n\n # the patten to grep for\n re = Regexp.new '^' + _method.to_s + '$'\n\n # born in BasicObject?\n if BasicObject.instance_methods(false).grep(re).size==1\n return puts \"=> #{_method} : \" +\n \". born in BasicObject as an instance method\".green\n # born in Kernel?\n elsif Kernel.instance_methods(false).grep(re).size==1\n return puts \"=> #{_method} : \" +\n \".. born in Kernel as an instance method\".green\n # born in Object?\n elsif Object.instance_methods(false).grep(re).size==1\n return puts \"=> #{_method} : \" +\n \"... born in Object as an instance method\".green\n # born in Module?\n elsif Module.instance_methods(false).grep(re).size==1\n return puts \"=> #{_method} : \" +\n \".... born in Module as an instance method\".green\n end\n\n # puts \"check what class is _class\"\n # check what class is _class\n if _class.class == String\n _class = eval(_class)\n elsif _class.class == Symbol\n _class = Kernel.const_get(_class.to_s)\n # relying on some very basic classes listed above when\n # _class was not passed as a param\n elsif _class.is_a? Array\n _class.each do |e|\n # puts \"Checking #{_method} in #{e} ...\"\n output = bornin2 _method, e\n output || break\n # return\n end\n else\n bornin2 _method, _class\n end\n\nend",
"def str; end",
"def str; end",
"def robject2csource obj, namespace, strmax, volatilep = false, name = nil, contentsp = false\n decl = 'VALUE'\n vdef = 'Qundef'\n init = nil\n deps = Array.new\n expr = nil\n case obj\n when Quote # hack\n name ||= obj.unquote.to_s\n when Fixnum\n name ||= 'LONG2FIX(%d)' % obj\n when TrueClass, FalseClass, NilClass\n name ||= 'Q%p' % obj\n when Bignum\n # Bignums can be large enough to exceed C's string max. From this\n # method's usage a bignum reaching this stage is sourced from a Ruby\n # source code's bignum literals, so they might not be much larger\n # though.\n name ||= namespace.new 'num_' + obj.to_s\n rstr = robject2csource obj.to_s, namespace, strmax, :volatile\n init = sprintf \"rb_str2inum(%s, 10)\", rstr\n deps << rstr\n when Float\n name ||= namespace.new 'float_' + obj.to_s\n init = sprintf 'rb_float_new(%s)', obj\n when Range\n from = robject2csource obj.begin, namespace, strmax, :volatile\n to = robject2csource obj.end, namespace, strmax, :volatile\n xclp = obj.exclude_end? ? 1 : 0\n init = sprintf \"rb_range_new(%s, %s, %d)\", from, to, xclp\n name ||= namespace.new\n deps << from << to\n when Class\n # From my investigation over the MRI implementation, those three\n # classes are the only classes that can appear in an instruction\n # sequence. Don't know why though.\n init = if obj == Object then 'rb_cObject'\n elsif obj == Array then 'rb_cArray'\n elsif obj == StandardError then 'rb_eStandardError'\n else\n raise TypeError, \"unknown literal object #{obj}\"\n end\n when String\n #if obj.empty?\n ## Empty strings are lightweight enough, do not need encodings.\n #name ||= 'rb_str_new(0, 0)'\n #else\n # Like I write here and there Ruby strings can be much longer than\n # C strings can be. Plus a Ruby string has its encoding. So when\n # we reconstruct a Ruby string, we need a set of C strings plus an\n # encoding object.\n #if obj.ascii_only?\n #name ||= $namespace.new 'str_' + obj\n #aenc = Encoding.find 'US-ASCII'\n #encn = robject2csource aenc, namespace, strmax, :volatile\n #else\n name ||= namespace.new 'str_' + obj.encoding.name + '_' + obj\n encn = robject2csource obj.encoding, namespace, strmax, :volatile, nil, true\n #end\n deps << encn\n argv = rstring2cstr obj, strmax\n argv.each do |i|\n if init\n x = sprintf \";\\nrb_enc_str_buf_cat(%s, %s, %d, %s)\",\n name, *i, encn\n init << x\n else\n init = sprintf \"rb_enc_str_new(%s, %d, %s)\", *i, encn\n end\n end\n if $YARVAOT_DEBUG\n #init << \";\\n /* #{obj} */\"\n end\n #end\n when Encoding\n # Thank goodness, encoding names are short and will never contain\n # multilingual chars.\n rstr = obj.name\n if contentsp\n decl = 'rb_encoding*'\n vdef = '0'\n init = 'rb_enc_find(\"%s\")' % rstr\n name ||= namespace.new 'enc_' + rstr\n else\n encn = robject2csource obj, namespace, strmax, :volatile, nil, true\n deps << encn\n init = 'rb_enc_from_encoding(%s)' % encn\n name ||= namespace.new 'encval_' + rstr\n end\n when Symbol\n str = obj.id2name\n if str.bytesize <= strmax\n # Why a symbol is not cached as a VALUE? Well a VALUE in C static\n # variable needs to be scanned during GC because VALUEs can have\n # links against some other objects in general. But that's not the\n # case for Symbols -- they do not have links internally. An ID\n # variable needs no GC because it's clear they are not related to\n # GC at all. So a Symbol is more efficient when stored as an ID,\n # rather than a VALUE.\n a = rstring2cstr str, strmax\n e = robject2csource str.encoding, namespace, strmax, :volatile, nil, true\n name = namespace.new 'sym_' + obj.to_s\n decl = 'ID'\n vdef = '0'\n init = sprintf 'rb_intern3(%s, %d, %s);', *a[0], e\n expr = 'ID2SYM(%s)' % name.name\n deps << e\n else\n # Longer symbols are much like regexps\n name ||= namespace.new 'sym_' + str\n rstr = robject2csource str, namespace, strmax, :volatile\n init = 'rb_str_intern(%s)' % rstr\n deps << rstr\n end\n when Regexp\n opts = obj.options\n srcs = robject2csource obj.source, namespace, strmax, :volatile\n name ||= namespace.new \"reg#{opts}_\" + srcs.to_s\n init = sprintf 'rb_reg_new_str(%s, %d)', srcs, opts\n deps << srcs\n when Array\n n = obj.length\n if n == 0\n # zero-length arrays need no cache, because a creation of such\n # object is fast enough.\n name ||= 'rb_ary_new2(0)'\n #elsif n == 1\n ## no speedup, but a bit readable output\n #i = obj.first\n #e = robject2csource i, namespace, strmax, :volatile\n #j = as_tr_cpp e.to_s\n #s = 'a' + j\n #name ||= $namespace.new s\n #init = 'rb_ary_new3(1, %s)' % e\n #deps << e\n elsif n <= 30\n # STDC's max # of function arguments are 31, so at most 30 elems\n # are made at once.\n init = 'rb_ary_new3(%d' % obj.length\n obj.each do |x|\n y = robject2csource x, namespace, strmax, :volatile\n init << \",\\n \" << y.to_s\n deps << y\n end\n init << ')'\n s = init.sub %r/\\Arb_ary_new3\\(\\d+,\\s+/, 'a'\n name ||= namespace.new 'ary_' + s\n else\n # Too large to create at once. Feed litte by litte.\n name ||= namespace.new\n init = 'rb_ary_new()'\n obj.each do |i|\n j = robject2csource i, namespace, strmax, :volatile\n k = sprintf 'rb_ary_push(%s, %s)', name, j\n init << \";\\n \" << k\n deps << j\n end\n end\n when Hash\n # Hashes are not computable in a single expression...\n name ||= namespace.new\n init = \"rb_hash_new()\"\n obj.each_pair do |k, v|\n knam = robject2csource k, namespace, strmax, :volatile\n vnam = robject2csource v, namespace, strmax, :volatile\n aset = sprintf 'rb_hash_aset(%s, %s, %s)', name, knam, vnam\n init << \";\\n \" << aset\n deps << knam << vnam\n end\n else\n raise TypeError, \"unknown literal object #{obj.inspect}\"\n end\n\n name ||= namespace.new init\n case name when namespace\n static_decl = \"static #{decl}\"\n if volatilep and name.declaration == static_decl\n # OK? same object, different visibility\n elsif not volatilep and name.declaration == decl\n # OK? same object, different visibility\n name.force_set_decl! static_decl\n else\n name.declaration = volatilep ? decl : static_decl\n end\n name.definition = \"#{name.declaration} #{name.name} = #{vdef};\"\n name.initialization = \"#{name.name} = #{init};\" if init\n name.expression = expr\n deps.each do |i|\n case i when namespace\n name.dependencies.push i\n end\n end\n end\n return name\n end",
"def test_ruby_string_0\n pros = Prospector.new(0,0,0)\n assert pros.ruby_string(0).eql? ''\n end",
"def probers; end",
"def parslet; end",
"def parslet; end",
"def parslet; end",
"def parslet; end",
"def get_next_object\n tmp = ''\n while @base_str[@cursor] == ' '\n @cursor += 1 # skip whitespaces\n end\n\n string_detected = false\n case @base_str[cursor]\n when '\"'\n @cursor += 1\n string_detected = true\n\n when '{'\n return process_hash\n\n when '['\n return procecss_array\n\n end\n\n # check for empty value\n if string_detected && @base_str[@cursor] == '\"'\n @cursor += 1\n return ''\n end\n\n b_continue = true\n while b_continue\n char = @base_str[@cursor]\n if char == '\\\\'\n escaped_char = @base_str[@cursor + 1]\n case escaped_char\n when '\"'\n tmp << \"\\\"\"\n when 'a'\n tmp << \"\\a\"\n when 'b'\n tmp << \"\\b\"\n when 'r'\n tmp << \"\\r\"\n when 'n'\n tmp << \"\\n\"\n when 's'\n tmp << \"\\s\"\n when 't'\n tmp << \"\\t\"\n else # for single \\\n tmp << char\n @cursor -= 1 # compensate shifting below\n end\n # tmp << @base_str[@cursor + 1]\n @cursor += 2\n else\n tmp << char\n @cursor += 1\n end\n\n b_continue = if string_detected\n @base_str[@cursor] != '\"'\n else\n @base_str[@cursor] != ' ' &&\n @base_str[@cursor] != '}' &&\n @base_str[@cursor] != ']' &&\n @base_str[@cursor] != ','\n end\n end\n\n @cursor += 1 if string_detected # skip end quotes\n\n # puts \"found obj: '#{tmp}'\"\n unless string_detected\n tmp = tmp != 'null' ? eval(tmp) : nil\n end\n tmp\n end",
"def preprocess_input(input)\n input\nend",
"def strings; end",
"def str2; end",
"def str2; end",
"def test_to_s\n list = funcall(:list,1)\n assert_equal(\"(1)\", \"#{list}\")\n assert_equal( prin1_to_string(list), list.to_s)\n end",
"def pl(*args)\n str0 = \"=== \" + caller.first + \"\\n\"\n\n str_out = args.inject(str0){|strs, obj| strs + obj.pretty_inspect.to_s}\n\n puts str_out\n str_out\nend",
"def test_ruby_string_1\n pros = Prospector.new(0,0,0)\n assert pros.ruby_string(1).eql? '1 ruby'\n end",
"def string()\n #This is a stub, used for indexing\n end",
"def preprocess_input(input)\nend",
"def ruby_code(obj)\n case obj\n when String then obj.dump + \".freeze\"\n when Array then '[' + obj.map {|x| ruby_code x }.join(\", \") + ']'\n when Hash then\n seg = obj.keys.sort.map {|k| \"#{k.to_s.dump} => #{obj[k].to_s.dump}\" }\n \"{ #{seg.join(', ')} }\"\n when Gem::Version then obj.to_s.dump\n when DateLike then obj.strftime('%Y-%m-%d').dump\n when Time then obj.strftime('%Y-%m-%d').dump\n when Numeric then obj.inspect\n when true, false, nil then obj.inspect\n when Gem::Platform then \"Gem::Platform.new(#{obj.to_a.inspect})\"\n when Gem::Requirement then\n list = obj.as_list\n \"Gem::Requirement.new(#{ruby_code(list.size == 1 ? obj.to_s : list)})\"\n else raise Gem::Exception, \"ruby_code case not handled: #{obj.class}\"\n end\n end",
"def string_to_internal(preposition)\n\t\ttemp_kb =Array.new\n\t\t#string input of format literal_name LOGICAL_PREPOSISTION\n\t\tpreposition_array = preposition.split\n\t\n\t\tnext_negated = false\n\n\t\tsentence = []\n\t\tpreposition_array.each do |word|\n#####################################3\t\n\t\t#\tputs \" word: \" + word\n\t\t\t#don't need to handle \"or\" as long as it is in right format, will look to \"and\" and the end as limiters\n\t\t\tif (word == \"AND\" || word == \"and\")\n\t\t\t\ttemp_kb << sentence\n\t\t\t\tsentence = []\n\t\t\telsif(word == \"NOT\" || word == \"not\")\n\t\t\t\tnext_negated = true\n\t\t\telsif(word == \"OR\" || word ==\"or\")\n\n\t\t\telse\n\t\t\t\ttemp = @name_hash[word]\n\t\n\t\t\t\t#add variable if doesnt exist\n\t\t\t\tif(temp == nil)\n\t\t\t\t\ttemp_var = Literalzs.new(word,@total_variables)\n\t\t\t\t\t@id_array.push(temp_var)\n\t\t\t\t\t@name_hash[word] = @total_variables\n\t\t\t\t\ttemp = @total_variables\t\n\t\t\t\t\t@total_variables+=1\n\t\t\t\t end\n\t\t\n\t\t\t\tif(next_negated)\n\t\t\t\ttemp = temp.to_i * -1\n#########################################################3333\t\t\t\t\n\t\t\t\t#puts \" temp negated, now is: \" + temp.to_s\n\t\t\t\t\n\t\t\t\tnext_negated = false\n\t\t\t\tend\n\t\t\t\tsentence << temp\n\t\t\tend\n\t\tend\n\t\t#need to grab last sentence since it wont be ended with and\n\t\ttemp_kb << sentence\n\t\treturn temp_kb\n\tend",
"def smartify(input); end",
"def string(*) end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def inspect; end",
"def initialize aInput\n input = aInput.dup\n\n # strip comments\n input.gsub! %r{//.*$}, ''\n input.gsub! %r{/\\*.*?\\*/}m, ''\n\n @modules = input.scan(%r{(module.*?;)(.*?)endmodule}m).map do |matches|\n Module.new(*matches)\n end\n end",
"def ruby2plato (s)\n\t@@plato_output = StringIO.new\n @@vars = Set.new()\n \truby2kif(s.to_ast,nil)\n \treturn @@plato_output.string, @@vars\n end",
"def test_typecheck\n\t\tassert_raise( RuntimeError ) { PClass.new(\"1\", \"2\", \"3\", []) }\n\t\tassert_raise( RuntimeError ) { PClass.new(1, 2, \"3\", []) }\n\t\tassert_raise( RuntimeError ) { PClass.new(1, \"2\", 3, []) }\n\t\tassert_raise( RuntimeError ) { PClass.new(1, \"2\", \"3\", \"[]\") }\n\tend",
"def basic_feature(str)\n\tputs str + \" \" + str\n\tputs str * 3\n\tputs \"1\" + \"2\"\n\tputs \"1\" * 2\n\tputs str.size\n\tputs str.length\n\tputs str.capitalize\n\tputs str.reverse\n\tputs str.upcase\n\tputs str.downcase\n\tputs str.swapcase\nend",
"def convertObjectsArrToStringArr(arr)\r\n i = 0\r\n stringArr = []\r\n while i < arr.length\r\n holder = arr[i].to_s\r\n if(holder != \"\")\r\n if(holder[0] != \"#\")\r\n if(!holder.include? \"::\")\r\n stringArr.append(holder)\r\n end\r\n end\r\n end\r\n #p holder\r\n # puts stringArr[i]\r\n i += 1\r\n end\r\n return stringArr\r\n end",
"def test_turn_putter_real\n pros = Prospector.new(0,0,0)\n assert pros.turn_putter(1,0).eql? \"\\tFound 1 ruby in Enumerable Canyon\"\n end",
"def convert_to_ruby_object(rexp)\n # first try converters defined for just this instance\n success, value = apply_local_ruby_converters(rexp)\n return [success, value] if success\n\n # then try converters defined in general\n success, value = apply_ruby_converters(rexp)\n return [success, value] if success\n\n # and finally apply the default converters \n success, value = apply_default_ruby_converters(rexp)\n return [success, value] if success\n\n # give up\n [false, rexp]\n end",
"def test_Enviroment_004_SortMethods\r\n\r\n puts2(\"\")\r\n puts2(\"#######################\")\r\n puts2(\"Testcase: test_Enviroment_004_SortMethods\")\r\n puts2(\"#######################\")\r\n puts2(\" Sorted list of Methods in use:\")\r\n puts2(Object.new.methods.sort)\r\n puts2(\"######################\")\r\n\r\n end",
"def parslets; end",
"def input(prepositions)\n\t\t@kb = string_to_internal(prepositions)\n\tend",
"def read_input; end",
"def parse(input)\n # Removes white space, converts string into an array split by the possible operators (but retaining the operators).\n # Removes empty strings from the array. I'm actually not sure where these are coming from, but I noticed them when the user enters a negative number.\n parsed_input = input.gsub(/\\s+/,\"\").split(/(\\+)|(-)|(\\*)|(\\/)|(\\^)|(%)|(add)|(subtract)|(multiply)|(divide)|(exponent)|(modulo)/).reject { |x| x.empty? }\n # If the first element of the array is a negative sign,\n # reassigns the 2nd element as a joined string of the sign and existing number in the 2nd element,\n # and deletes the 1st element.\n if parsed_input[0] == \"-\"\n parsed_input[1] = parsed_input[0..1].join\n parsed_input.slice!(0)\n end\n # If the 3rd element of the array is a negative sign,\n # reassigns the 4th element as a joined string of the sign and existing number in the 4th element,\n # and deletes the 3rd element.\n if parsed_input[2] == \"-\"\n parsed_input[3] = parsed_input[2..3].join\n parsed_input.slice!(2)\n end\nreturn parsed_input\nend",
"def inspect(*) end",
"def inspect(*) end",
"def inspect(*) end",
"def inspect(*) end",
"def inspect(*) end",
"def puts(str)\nend",
"def reflection; end",
"def reflection; end",
"def string() end",
"def parse_input(input)\n input = input.strip\n case input\n when ReservedWords::TRUE\n Memory::Value.bool true\n when ReservedWords::FALSE\n Memory::Value.bool false\n when /^(-?)[0-9]+\\.[0-9]+$/\n Memory::Value.float input.to_f\n when /^(-?)[0-9]+$/\n Memory::Value.int input.to_i\n when /^\\[.*\\,.*\\]$/\n array = input.tr('[', '').tr(']', '').split(',')\n array = array.map { |s| parse_input(s) }\n Memory::Value.array array\n else\n Memory::Value.string input\n end\n end",
"def mu_pp(obj); end",
"def to_s\n self.__str__.rubify\n rescue PythonError, NoMethodError\n RubyPython::PyMain.str(self).rubify\n end",
"def initialize(p)\n super p.to_s\n end",
"def p004stringusage\n\nputs PI\n\n# Defining a local variabe\nmy_string = 'I love my city, Pune'\nputs my_string\n\nvar1 = 5\nvar2 = '2'\n\nputs var1 + var2.to_i\n\na='hello'\na << 'world'\nputs a\n\nend",
"def preprocess(input); end",
"def print_array(array)\n puts \"NOT IMPLEMENTED\"\nend",
"def string=(p0) end",
"def parse_properties(input = T.unsafe(nil)); end",
"def test_moving_string\n pros = Prospector.new(0,0,0)\n assert pros.moving_string(0,0).eql? 'Heading from Enumerable Canyon to Enumerable Canyon.'\n end",
"def text_input; end",
"def inspect; to_s; end",
"def inspect; to_s; end",
"def inspect; to_s; end",
"def inspect; to_s; end"
] |
[
"0.55995196",
"0.55424875",
"0.5381544",
"0.5305539",
"0.5301502",
"0.5289951",
"0.5258814",
"0.5258814",
"0.5258814",
"0.52157754",
"0.5120218",
"0.5120218",
"0.5093947",
"0.5093626",
"0.5093626",
"0.5027182",
"0.4956686",
"0.4953168",
"0.49506795",
"0.49506795",
"0.49506795",
"0.49506795",
"0.49460655",
"0.49408048",
"0.49303398",
"0.4916058",
"0.4916058",
"0.49104095",
"0.4899375",
"0.48900595",
"0.48840597",
"0.4877003",
"0.48708606",
"0.48511165",
"0.48479575",
"0.48390502",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48330086",
"0.48203367",
"0.48120117",
"0.4800261",
"0.47813392",
"0.47806966",
"0.47784168",
"0.47780597",
"0.47773847",
"0.47730413",
"0.47683996",
"0.4761878",
"0.47602114",
"0.47532675",
"0.47532675",
"0.47532675",
"0.47532675",
"0.47532675",
"0.47515345",
"0.47448012",
"0.47448012",
"0.4743013",
"0.47397903",
"0.4738079",
"0.47361526",
"0.47198245",
"0.4712322",
"0.4711668",
"0.47104537",
"0.47094575",
"0.47059855",
"0.47026834",
"0.46979794",
"0.46910736",
"0.46910736",
"0.46910736",
"0.46910736"
] |
0.0
|
-1
|
In Ruby 1.9, the returned string would include the square brackets []. Ruby 1.8 does not.
|
def to_s
self.join('')
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def mutate_empty_bracket(_)\n '[]'\n end",
"def to_string_no_brackets\n self.to_s.gsub(/[\\[\\]]/,'')\n end",
"def to_string_no_brackets_or_quotes\n self.to_s.gsub(/[\\\"\\[\\]]/,'')\n end",
"def s(string)\n string.to_s.gsub('[].:', '')\nend",
"def sub_brackets(nline)\n local_line = nline\n local_line.gsub!(/\\]\\s*\\,\\s*\\[/, '|')\n local_line.gsub!(/\\]\\s*\\,/, '|')\n local_line.gsub!(/\\,\\s*\\[/, '|')\n return local_line.tr('[]', '')\n end",
"def string_value\n join(\"\\0\")\n end",
"def array_method(string)\n string.join(\" \")\nend",
"def to_s ()\n\taux = @head\n\tstring= \"(\"\n\twhile aux!=nil\n\t\tstring+=\"[\"+aux.value.to_s+\"]\"\n\t\taux=aux.nest\n\t\tif aux!=nil\n\t\t\tstring+=\"-\"\n\t\tend\n\tend\n\tstring +=\")\"\n\treturn string\n end",
"def array_brackets(member)\n\n\n\n # 352:7: '[' ']'\n match(:LEFT_SQUARE_BRACKET)\n match(:RIGHT_SQUARE_BRACKET)\n member.type += '[]' \n\n\n\n end",
"def quote_name_part(part)\n part =~ /^\\[.*\\]$/ ? part : \"[#{part.gsub(']', ']]')}]\"\n end",
"def bracket(s)\n\tarr_s = s.chars\n\tbrack_arr = []\n\tarr_s.each do |w|\n\t\tif w == \"(\"\n\t\t\tbrack_arr << w \n\t\tend\n\t\tp brack_arr\n\t\tif w == \")\"\n\t\t\tlast = brack_arr.pop\n\t\t\tif last != \"(\" && w == \")\"\n\t\t\t\tp \"error!\"\n\t\t\tend\n\t\tend\n\tend\n\tif !brack_arr.empty?\n\t\tp \"error!!\"\n\tend\n\t\nend",
"def to_s\n buf = []\n each { |part| buf << part }\n buf.join\n end",
"def back_to_s(array)\n array.join(\"\")\nend",
"def to_s(exp)\n if exp.is_a?(Array)\n \"( #{exp.map{ |t| to_s(t) }.join(' ')} )\"\n else\n exp.to_s\n end\n end",
"def html_field_name_append base, append\n warn \"base #{base} append #{append}\"\n if base.to_s == ''\n append\n elsif base =~ /\\[\\]$/ and append !~ /\\[\\]$/\n base_without_brackets = base.match(/(.+)\\[\\]$/)[0]\n base_without_brackets + '[' + append + ']'\n elsif base =~ /\\[\\]$/ and append =~ /\\[\\]$/\n # wrong\n base_without_brackets = base.match(/(.+)\\[\\]$/)[0]\n base_without_brackets + '[' + append + ']'\n else\n base + '[' + append + ']'\n end\n end",
"def to_s\n \"{#{@rep.map { |c| \"\\\"#{c}\\\"\" }.join ', '}}\"\n end",
"def ArrJson(str)\n tmp = \"\"\n tmp += (\"[\" + str + \"]\")\n tmp\n end",
"def ArrJson(str)\n tmp = \"\"\n tmp += (\"[\" + str + \"]\")\n tmp\n end",
"def ArrJson(str)\n tmp = \"\"\n tmp += (\"[\" + str + \"]\")\n tmp\n end",
"def ArrJson(str)\n tmp = \"\"\n tmp += (\"[\" + str + \"]\")\n tmp\n end",
"def debracketize\n if strip[0] == 40 and strip[-1] == 41\n return strip.gsub(/^\\(+(.+?)\\)+$/) { $1.strip }\n else\n return strip.gsub(/\\(+.+?\\)+/, '').strip.squeeze(' ')\n end\n end",
"def string(arr)\n arr.join(\" \")\nend",
"def bracketed_list(values)\n temp=\"\"\n temp += \"[\"\n values.each {|val| temp += \"#{val.to_s}, \"}\n temp += \"]\"\n return temp\nend",
"def join(s = Undefined)\n # this is mostly Rubinius code, but modified for our API\n # Put in delta since we need the recursion guard found in common.\n my_size = size\n return \"\" if my_size._equal?(0)\n if s._equal?(Undefined)\n sep = $,\n elsif s._equal?(nil)\n sep = nil\n else\n sep = s.to_str # let any NoMethodError be seen by caller\n end\n\n out = \"\"\n# out.taint if sep.tainted? or self.tainted?\n i = 0\n ts = Thread.__recursion_guard_set\n while (i < my_size)\n elem = at(i)\n out << sep unless (sep._equal?(nil) || i == 0)\n\n if elem._isArray\n\tadded = ts.__add_if_absent(self)\n\tbegin\n if ts.include?(elem)\n out << \"[...]\"\n else\n out << elem.join(sep)\n end\n\tensure\n if added\n\t ts.remove(self)\n\t end\n end\n else\n out << elem.to_s\n# out.taint if elem.tainted? and not out.tainted?\n end\n i += 1\n end\n out\n end",
"def escape_quotes(beg_str, end_str)\n case [beg_str[-1], end_str]\n when ['(', ')'], ['[', ']'], ['{', '}']\n [beg_str.sub(/.\\z/) { \"\\0\" }, \"\\0\"]\n else\n [beg_str, end_str]\n end\n end",
"def print_assertion_string(str, iso)\n print(str)\n if(iso != '')\n print(' [')\n print(iso)\n print(']')\n end\nend",
"def delete_brackets(variable)\n variable.strip.delete('\\\"').sub(/\\s*\\(.+\\)$/, \"\")\n end",
"def to_s\n\t\ts = \"[\"\n\t\tcurr = @head\n\t\twhile !curr.nil?\n\t\t\ts << curr.to_s\n\t\t\tcurr = curr.next\n\t\tend\n\t\ts << \"]\"\n\tend",
"def rb_string(words: T.unsafe(nil)); end",
"def to_s\n element_string = '['\n @options.each { |option| element_string.concat(\"#{option.join(',')}|\") }\n element_string.chop.concat(']')\n end",
"def to_s\n index = 0\n return_string = \"[\"\n while (index < @hand.size)\n if index > 0\n return_string = return_string + \",\"\n end\n return_string = return_string + @hand[index].to_s\n index = index + 1\n end\n return_string = return_string + \"]\"\n end",
"def unbracket(str)\n # ? str[/[^ <]+@[^> ]+/]\n if str[0] == ?< and str[-1] == ?>\n return str[1...-1]\n else\n return str\n end\n end",
"def to_s\r\n str = \"[\"\r\n aux = @head\r\n while aux != nil do\r\n str += aux.value.to_s\r\n aux = aux.next\r\n if aux != nil\r\n str += \",\"\r\n end\r\n end\r\n str += \"]\"\r\n str\r\n end",
"def to_s\n string = \"[ \"\n nodo = @head\n while nodo != @tail\n if nodo.value != nil\n string = string + nodo.value.nombre + \", \"\n nodo = nodo.next\n end\n end\n if nodo.value != nil\n string = string + nodo.value.nombre + \" ]\"\n end\n string\n end",
"def to_s\n r = []\n each do |e|\n r << e\n end\n '[' + r.join(', ') + ']'\n end",
"def id_str\n @id.nil? ? '' : \"[#{@id.gsub(/(\\[|\\])/){|s|\"\\\\#{s}\"}}]\"\n end",
"def escape_special_char(str)\n str.gsub('[', '\\[').gsub(']', '\\]').gsub('(', '\\(').gsub(')', '\\)') if str\n end",
"def to_s\n \"[ \" + collect { |e| e.to_s }.join(\", \") + \" ]\"\n end",
"def strip_brackets(code)\n code.sub(/^\\((.*)\\)$/) { $1 }\n .sub(/^\\[(.*)\\]$/) { $1 }\n .sub(/^{(.*)}$/) { $1 }\n end",
"def quoted_string; end",
"def test_with_string6; show([[[0,0,0],[0,0,\"Hello\"]]]) end",
"def strip_brackets(text)\n text.slice(2..-3)\n end",
"def array_of_single_char_substrings\n @array_of_single_char_substrings ||= (97..122).map {|int| int.chr } << \"'\"\n end",
"def array_to_string(value)\n result = ''\n value.each { |value| result += to_cli_value(value) + ',' }\n result = '[' + result.chomp(',') + ']'\n end",
"def strip_string_array(arr)\n arr.first.lstrip! if arr.first.is_a?(String)\n arr[-1] = Sass::Util.rstrip_except_escapes(arr[-1]) if arr.last.is_a?(String)\n arr\n end",
"def to_s\n \"#{@name} \\[#{@unlocode}]\"\n end",
"def quote_array(value)\n \"(#{value.map { |entry| quote_value(entry) }.join(', ')})\"\n end",
"def extract_empty_array_from_default(default)\n return unless supports_string_to_array_coercion?\n return unless default =~ /\\AARRAY\\[\\]\\z/\n return \"{}\"\n end",
"def excl\n \"\"\n end",
"def bracketed\n false\n end",
"def surround(word, pad_width=word.length/2)\n \"[\" * pad_width + word + \"]\" * pad_width\nend",
"def parse_key(key)\n array = key.split(\"[\")\n array.map do |i| \n if i.include?(\"]\") \n i.chop\n else\n i\n end\n end\n end",
"def rfc_2045_quoted_string; end",
"def to_matlab_string\n '[' + map{|e| e.to_s}.join(', ') + ']'\n end",
"def to_s\n\t\t\t\t'[' << map(&:to_s).join(', ') << ']'\n\t\t\tend",
"def to_s\n to_a.join(' ')\n end",
"def to_string(expression)\n\t\t\tif expression.is_a? Array\n\t\t\t\texpression.map { |exp| to_string(exp) }\n\t\t\t\treturn \"(\" + expression.join(\" \") + \")\"\n\t\t\telse\n\t\t\t\treturn expression.to_s\n\t\t\tend\n\t\tend",
"def to_s\n \"#{key}#{array}\"\n end",
"def to_s\n join\n end",
"def arrayify_and_stringify_elements(arg)\n return false if arg == false\n \n case\n when arg.blank? then []\n when arg.is_a?(Array) then arg\n else arg.to_s.strip.split(/\\s/)\n end.map(&:to_s)\n end",
"def to_s\n ''\n end",
"def to_s\n ''\n end",
"def to_s\n ''\n end",
"def human_string(array)\n length = array.length\n \n new_string = array[0...-1].join(\", \")\n new_string << \" and #{array[-1]}\"\n \n return new_string\nend",
"def to_s\n to_a.join(' ')\n end",
"def name(arr)\n\tarr.join(' ')\nend",
"def endpoints_string\n \"[#{endpoints_as_string}]\"\n end",
"def endpoints_string\n \"[#{endpoints_as_string}]\"\n end",
"def array_string(array, **opt)\n list_separator = opt[:list_separator] || LIST_SEPARATOR\n normalized_list(array, **opt).join(list_separator)\n end",
"def clean_output(output)\n \"[#{output.gsub(/^}{/, '},{')}]\"\n end",
"def to_s\n return '['+self.values.join(',')+']'\n end",
"def str2warray(value)\n unquote_string(value).gsub(/ /, '\\\\ ')\n end",
"def to_s\n \"\"\n end",
"def to_s\n join(\" \")\n end",
"def test_with_string4; show([[0,\"Hello\"]]) end",
"def undent\n gsub /^.{#{slice(/^ +/).length}}/, ''\n end",
"def to_s\n @chars.join\n end",
"def to_s\n \"\"\n end",
"def to_s\n \"\"\n end",
"def stringify\n self.compact.join(' ')\n end",
"def to_s\n @string ||= STR_LEFT_BRACKET + self.to_a.compact.map {|prop| prop.to_s}.join(STR_SEPARATOR) + STR_RIGHT_BRACKET\n end",
"def extension_strings\n\t\treturn nil if @extensions.empty?\n\t\treturn @extensions.compact.join('; ')\n\tend",
"def array_to_string(arr)\n arr.map { |e| \"'#{sanitize(e)}'\" }.join(\",\")\n end",
"def esc1(code)\n\t\t[\"\\e[#{code}\", \"\\e[2#{code}\", \"\\e[3#{code}\", \"\\e[4#{code}\", \n\t\t\t\"\\e[5#{code}\", \"\\e[6#{code}\", \"\\e[7#{code}\", \"\\e[8#{code}\"] \n\tend",
"def test_with_string3; show([[\"Hello\"]]) end",
"def encode(string)\n [string]\n end",
"def array (sexp, level)\n return '[]' if sexp.empty?\n\n code, work = \"\", []\n\n until sexp.empty?\n splat = sexp.first.first == :splat\n part = process sexp.shift, :expression\n\n if splat\n if work.empty?\n code += (code.empty? ? part : \".concat(#{part})\")\n else\n join = \"[#{work.join ', '}]\"\n code += (code.empty? ? join : \".concat(#{join})\")\n code += \".concat(#{part})\"\n end\n work = []\n else\n work << part\n end\n end\n\n unless work.empty?\n join = \"[#{work.join ', '}]\"\n code += (code.empty? ? join : \".concat(#{join})\")\n end\n\n code\n end",
"def String(p0) end",
"def quotelist( *args )\n\t\t\treturn args.flatten.collect {|part| part =~ /\\s/ ? part.inspect : part}\n\t\tend",
"def string()\n #This is a stub, used for indexing\n end",
"def to_s\n to_a.join(SEPARATOR)\n end",
"def to_s\n\t\tstring = \"(\"\n\t\taux = @head\n\t\twhile(aux != nil) do\n\t\t\tstring += \"#{aux.to_s}\"\n\t\t\t@aux = @aux.next\n\t\tend\t\n\t\tstring += \")\"\n\t\treturn string\n\tend",
"def needed_rubrics(empty_rubrics_list)\n needed_rub = '<b>['\n empty_rubrics_list.each do |item|\n needed_rub += item[0...-13] + ', '\n end\n needed_rub = needed_rub[0...-2]\n needed_rub += '] </b>'\n end",
"def raw_text\n \"\"\n end",
"def sb(s)\r\n (s == '(none)' || s == '') ? '' : s\r\n end",
"def to_clp\n val = self.gsub(/[\"]/,\"\\\"\\\"\")\n #val = val.gsub(/[~]/,\"\")\n end",
"def to_s\n\t\t\"()\"\n\tend",
"def to_s\n self.join \" \"\n end",
"def extension_without_delimiter\n extension_with_delimiter.from(1).to_s\n end"
] |
[
"0.71191454",
"0.70444703",
"0.6589663",
"0.6450777",
"0.5868274",
"0.58544254",
"0.56687564",
"0.5657786",
"0.56164676",
"0.5583472",
"0.55287397",
"0.5476206",
"0.54682785",
"0.5452847",
"0.5448699",
"0.5432115",
"0.54155993",
"0.54155993",
"0.54155993",
"0.54155993",
"0.54129386",
"0.5404817",
"0.5404362",
"0.5380866",
"0.53651947",
"0.5358808",
"0.53421915",
"0.5334798",
"0.53271616",
"0.53185266",
"0.5314994",
"0.52943516",
"0.5290627",
"0.5285257",
"0.5267401",
"0.5260917",
"0.5247903",
"0.52469957",
"0.5236809",
"0.5232783",
"0.5226242",
"0.52212965",
"0.52182096",
"0.5209076",
"0.520906",
"0.5200025",
"0.5188927",
"0.5165648",
"0.51624566",
"0.5143671",
"0.513394",
"0.5126232",
"0.5124838",
"0.51216066",
"0.5119251",
"0.5109216",
"0.5106068",
"0.5103999",
"0.50935996",
"0.50842595",
"0.5076694",
"0.5076694",
"0.5076694",
"0.5074399",
"0.50741816",
"0.50684345",
"0.5066504",
"0.5066504",
"0.5064026",
"0.506366",
"0.50635266",
"0.50618505",
"0.5059861",
"0.5054299",
"0.5041714",
"0.5029539",
"0.50256264",
"0.5018371",
"0.5018371",
"0.49962646",
"0.4995824",
"0.49945837",
"0.49924058",
"0.49918583",
"0.4987682",
"0.4985135",
"0.49802357",
"0.49720532",
"0.49698967",
"0.49644956",
"0.49613374",
"0.49611562",
"0.4958459",
"0.49536908",
"0.4951649",
"0.49504957",
"0.4946088",
"0.49385417",
"0.4933676"
] |
0.49990317
|
80
|
return the sum of all of the multiples found input: an integer > 1 output: sum of all multiples of 3 and 5 between and and the given number Includes the given number in the list of multiples summed if it is a multiple of 3 or 5 store multiples in array iterate through range, if current number is multiple of 3 || 5 << multiple_array reduce sum multiple_array
|
def multisum(range_end)
multiples = []
for i in 1..range_end
multiples << i if i % 3 == 0 || i % 5 == 0
end
multiples.reduce(:+)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def multiples(number)\n number_array = Array(1..number)\n multiples_array = []\n\n number_array.each do |num|\n if num % 3 == 0 || num % 5 == 0\n multiples_array << num\n end\n end\n multiples_array.sum\nend",
"def find_multiples(number)\n sum_of_multiples = (3...number).each_with_object([]) do |element, list|\n list << element if element % 3 == 0 || element % 5 == 0\n end.sum\nend",
"def sum_multiples_of_3_or_5\n (1..999).to_a.select { |n| n.multiple_of?(3) or n.multiple_of?(5) }.inject(&:+)\nend",
"def sum_of_multiples\n multiples_of_three_or_five = []\n\n for n in 3...1000\n if n % 3 == 0\n multiples_of_three_or_five.push(n)\n end\n end\n\n for n in 5...1000\n if n % 5 == 0\n unless multiples_of_three_or_five.include?(n)\n multiples_of_three_or_five.push(n)\n end\n end\n end\n\n sum = multiples_of_three_or_five.inject { |sum, x| sum + x }\n return sum\nend",
"def multiples(number)\n number_array = Array(1..number)\n multiples_array = []\n\n number_array.each do |num|\n if num % 3 == 0 || num % 5 == 0\n multiples_array << num\n end\n end\n multiples_array.inject(:+)\nend",
"def sum_multiples_of_3_and_5(range)\n range.select { |n| n % 3 == 0 || n % 5 == 0 }.inject(:+)\nend",
"def sum_multiples_3_and_5(number)\n\tsum = 0\n\t(1...number).each do |x|\n\t\tif x % 3 == 0\n\t\t\tsum += x\n\t\telsif x % 5 == 0\n\t\t\tsum += x\n\t\tend\n\tend\n\tsum\nend",
"def multisum(num)\n # 2. Next, since I know I have to store all multiples of 3 and 5, I want to create an empty array\n multiples = []\n # 3. Now I can run the each method on the range of 1 to num\n (1..num).each do |number|\n # 4. If the number is evenly divisible by 3 or 5 I want to store it in the multiples array\n if number % 3 == 0 || number % 5 == 0\n multiples << number\n end\n end\n # 5. Now I simply return the sum of the multiples array\n multiples.sum\nend",
"def multiples(numbers)\n numbers.inject(0) do |a, e|\n # sum the elements into the accumulator\n # if they are divisible by 3 or 5\n a += e if e % 3 == 0 || e % 5 == 0\n a\n end\nend",
"def multisum(num)\n arr = [*1..num]\n multiples_3_5 = arr.select{ |ele| ele % 3 == 0 || ele % 5 == 0}\n multiples_3_5.sum\nend",
"def sum_of_multiples(n)\n multiples_of_3_or_5 = []\n for i in 1..n\n if i % 3 == 0 || i % 5 == 0\n multiples_of_3_or_5 << i\n end\n end\n multiples_of_3_or_5.sum\nend",
"def multiples_3_and_5 (top_range_num)\n three_five_array = []\n i = 1\n while i < top_range_num\n if i%3 == 0\n three_five_array.push(i)\n elsif i%5 == 0\n three_five_array.push(i)\n end\n i += 1\n end\n three_five_array = three_five_array.uniq\n sum = three_five_array.inject {|total, x| total + x}\n puts sum\nend",
"def multiples_of_three_and_five(number)\n total = 0\n\n (1..(number - 1)).each { |n| total += n if n % 3 == 0 || n % 5 == 0 }\n \n return total\nend",
"def sum_of_multiples(min,max)\n natural_set = (min...max).to_a\n multiples = natural_set.select { |n| (n % 3 == 0) or (n % 5 == 0) }\n sum = multiples.reduce(&:+)\n puts \"Sum of natural numbers between #{min} and #{max} that are divisible by 3 or 5 is #{sum}\"\n sum\nend",
"def refactored_sum_of_multiples(range)\n sum = 0 \n range.each do |num|\n if num % 3 == 0 || num % 5 == 0\n sum = sum + num\n end\n end\n sum\nend",
"def sum_of_multiples\n list_of_multiples = [ ]\n 1000.times do |number| \n list_of_multiples << number if number % 3 == 0 || number % 5 == 0\n end\n list_of_multiples.inject(&:+)\nend",
"def multiple_sum int\n (1..int).select { |n| (n % 3 == 0 || n % 5 == 0) }.sum\nend",
"def sum_of_3_or_5_multiples(n)\n n = n.to_i\n #compteur de boucle\n i = 0\n #tableu incluant les multiple de 3 et 5\n result_array = []\n while i < n\n a = i%3\n b = i%5\n if a == 0 || b == 0\n result_array << i\n i+=1\n else\n i+=1\t\n end\n \n end\n sum = 0\n result_array.each do |p|\n \t sum = sum + p\n end\n return sum \nend",
"def multiples_of_3_and_5(number)\n (1...number).select{|num| num % 3 == 0 || num % 5 == 0}.inject(:+)\nend",
"def multisum(number)\n multiples = (1..number).select { |x| (x % 3 == 0) || (x % 5 == 0) }\n multiples.reduce(:+)\nend",
"def multiples_three_five(max_number)\n sum = 0\n max_number = max_number - 1\n (0..max_number).each do |number|\n if number % 3 == 0 || number % 5 == 0\n sum = sum + number\n end\n end\n return sum\nend",
"def collect_multiples(num)\n range = (3...num)\n multiples = []\n range.each do |num|\n if num % 3 == 0 || num % 5 == 0\n multiples << num\n end\n end\n multiples\nend",
"def mult_sum num\n(1...num).select{|x| x%3==0 || x%5==0}.reduce(:+)\nend",
"def sum_of_multiples_of_three_and_five(n)\r\n (1...n).to_a.select{|x| x % 3 == 0 || x % 5 == 0 }.reduce(:+)\r\nend",
"def sum_multiples(limit)\n(3...limit).find_all {|n| n % 3 == 0 || n % 5 == 0}.inject(:+)\nend",
"def sum_of_multiples_of_three_and_five(num)\n\ta = sum_of_first_n_multiples(3, (1000/3))\n\tb = sum_of_first_n_multiples(5, (1000/5))\n\tc = sum_of_first_n_multiples(15, (1000/15))\n\treturn (a + b - c - 1000)\nend",
"def solution(number)\n # put your solution here\n my_range = (1...number).to_a\n result_arr = my_range.select {|i| i % 3 == 0 || i % 5 == 0}\n\n return result_arr.reduce(:+)\nend",
"def sum_multiples\n @sum35 = (1..@limit).select{|num| num%3 == 0 || num%5 == 0}\n @sum35 = @sum35.reduce(:+)\n @sum35\n end",
"def multiples_3_5_v1\n\tmultiples = (1...1000).find_all do |i| \n\t\ti % 3 == 0 || i % 5 == 0\n\tend\n\n\tanswer = multiples.inject do |memo, num|\n\t\tmemo + num\n\tend\n\n\treturn answer\nend",
"def multiples(input)\n (1..input).select { |num| (num % 3).zero? || (num % 5).zero? }.reduce(:+)\nend",
"def sum_multiples_3_and_5\n return 3 * 333 * 334 / 2 + 5 * 199 * 200 / 2 - 15 * 66 * 67 / 2\nend",
"def sum_multiples_of_3_and_5(num)\n arr = Array(0..(num-1))\n keep = arr.select do |n|\n n % 3 == 0 || n % 5 == 0\n end\n puts keep.reduce(:+)\nend",
"def multiples\n numbers = (1...1000)\n sum = 0\n\n numbers.each do |num|\n sum += num if num % 5 == 0 || num % 3 == 0\n end\n sum\nend",
"def multisum(number)\n (1..number).select { |multiple| multiple % 3 == 0 || multiple % 5 == 0 }.inject(:+)\nend",
"def sum_multiples\n sum = 0\n\n (1...1000).each do |n|\n sum += n if n % 3 == 0 || n % 5 == 0\n end\n\n sum\nend",
"def multiples_3_5_v2\n\tsum = 0\n\n\t1.upto(999) do |i|\n\t\tif i % 3 == 0 || i % 5 == 0\n\t\t\tsum = sum + i\n\t\tend\n\tend\n\n\treturn sum\nend",
"def sum_of_multiples(n)\n (1...n).select{ |n| n % 3 == 0 || n % 5 == 0 }.inject(:+)\nend",
"def multiples(num)\n (1...num).select { |n| n % 3 == 0 || n % 5 == 0 }.inject(:+)\nend",
"def sum_of_multiples(target, factors)\n\n# 1. Create an empty array called multiples\n\nmultiples = []\n\n# 2. Check where the list of factors is empty, and if it is, set the list to [3, 5]\n\nif factors.empty?\n factors = [3, 5]\nend\n\n# 3. For every factor in the factors list\n# 1. Set the current_multiple to factor to keep track of the multiples of factor\n# 2. While current_multiple < targe\n# 1. Append the current_multiple to multiples\n# 2. Add factor to current_multiple\n\nfactors.each do |factor|\n current_multiple = factor\n \n while current_multiple < target\n multiples.push(current_multiple)\n current_multiple += factor\n end\nend\n\n# 4. Filter duplicate numebrs from multiples\n\nmultiples.uniq!\n\n# 5. Compute and return the sum of the numbers in multiples\n\np multiples.sum\n\nend",
"def sum_of_3_and_5_multiples(nbr)\n nbr_a = (1...nbr).to_a\n ls35 = nbr_a.select { |x| (x % 3).zero? || (x % 5).zero? }\n if nbr % 1 != 0 || nbr < 0 # conditiions pour les entiers relatifs\n return 'I said natural number only idiot!'\n elsif nbr > 1000 # pour ne pas calculer les > 1000\n return 'too high!'\n else\n return ls35.sum\n end\nend",
"def sum_of_multiples(max, a, b)\n (1..max).select { |i| i % a == 0 || i % 5 == 0 }.reduce(:+)\nend",
"def sum_multiples1(numbers, mutiple)\n numbers\n .reject{ |n| n % mutiple > 0}\n .reduce(:+)\nend",
"def sum_of_multiples(number)\n sum_three = 0\n sum_five = 0\n sum_total = 0\n count_three = 3\n count_five = 5\n\n if number < 5\n sum_five\n else\n while count_five < number\n sum_five += count_five\n count_five += 5\n end\n end\n\n if number < 3\n sum_three\n else\n while count_three < number\n if count_three % 5 != 0\n sum_three += count_three\n end\n count_three += 3\n end\n end\n\n sum_total = sum_five + sum_three\n\n puts sum_total\n return sum_total\nend",
"def sum_of_multiples_3_5_below(n)\n (1...n).select {|x| x%3==0 || x%5==0}.inject(&:+)\nend",
"def multisum(number)\n\n mult_array = (1..number).select { |n| n % 3 == 0 || n % 5 == 0 }\n p mult_array\n sum = mult_array.inject(0,:+)\n p sum\nend",
"def range_sum(max_val)\n\n range = (1...max_val).to_a\n\n multiple_three_five = []\n\n range.each do |num|\n if num % 5 == 0 && num % 3 == 0\n multiple_three_five << num\n elsif num % 5 == 0 && num %3 != 0\n multiple_three_five << num\n elsif num % 3 == 0 && num %5 != 0\n multiple_three_five << num\n end\n end\n multiple_three_five.inject{|sum,num| sum + num }\nend",
"def threefive(num)\n\n if num < 1 || num > 100\n return \"Number must be between 1-100\"\n end\n mult_arr = []\n mult_arr << 0\n i = 0\n\n while num > i\n if (i % 3) == 0\n mult_arr << i\n elsif (i % 5) == 0\n mult_arr << i\n end\n i += 1\n end\n return mult_arr.inject{|sum,n| sum + n}\n\nend",
"def multisum(number)\n (0..number).reduce { |sum, n| n % 5 == 0 || n % 3 == 0 ? sum + n : sum }\nend",
"def multisum(number) # number 1..10 determines which numbers are divisible by 3 and 5\n sum = 0\n 1.upto(number) do |num|\n if num % 3 == 0 || num % 5 == 0\n sum += num # this adds the numbers from 1..num that either are multiples of 3 or 5\n end\n end\n sum # returns sum, need this here to run program successfully\nend",
"def multiples(num)\n\tresult = []\n\tsum = 0\n\ti = 1\n\twhile i < num\n\t\tif i % 3 == 0 || i % 5 == 0\n\t\t\tresult << i\n\t\tend\n\t\ti += 1\n\tend\n\tresult.each do |digit|\n\t\tsum += digit\n\tend\n\tsum\t\nend",
"def multisum(num)\n multiples_3_and_5 = (1..num).to_a.map do |n|\n n if (n % 3).zero? || (n % 5).zero?\n end\n multiples_3_and_5.compact.inject(:+)\nend",
"def multiples_sums(int)\n sum = 0\n (1...int).to_a.each do |x|\n \tif x % 3 == 0 || x % 5 == 0\n \t\tsum += x.to_int\n \tend\n end\n sum\nend",
"def multisum(num)\n numbers = (1..num).to_a\n multiples = numbers.select { |element| element % 3 == 0 || element % 5 == 0 }\n multiples.inject(:+)\nend",
"def multisum(number)\n multiples = (1..number).select do |num|\n num % 3 == 0 || num % 5 == 0\n end\n\n multiples.inject(:+)\nend",
"def multiples(n)\n (1...n).select do |num|\n num if (num % 3).zero? || (num % 5).zero?\n end.reduce(:+)\nend",
"def multisum(value)\n multiples = []\n value.each { |item| multiples << item if item % 5 == 0 or item % 3 == 0}\n muliples.reduce(&:+)\nend",
"def sum_multiple(limit, * numbers )\n (2..limit).to_a.find_all{ |x| numbers.any? {|n| x % n == 0 or x % n == 0} }.reduce(:+)\nend",
"def multisum(num)\n multiples = []\n 1.upto(num) do |x| \n if x % 3 == 0 || x % 5 == 0\n multiples << x\n end\n end\n multiples.inject(:+)\nend",
"def multiples\n sum = (1..999).select {|num| num % 3 == 0 || num % 5 == 0}.reduce(:+)\n puts sum\nend",
"def sum_multiples()\n index = sum = 0\n while index < 1000\n sum += index if index%3 == 0 || index%5 == 0\n index+=1\n end\n sum\nend",
"def find_sum_of_multiples_of_3_and_5_below_1000\n answer = 0\n for number in 1...1000\n answer += number if number % 3 == 0 || number % 5 == 0\n end\n answer\nend",
"def multisum(integer)\n multiples = []\n 1.upto(integer) do |index|\n multiples << index if index % 3 == 0 || index % 5 == 0\n end\n multiples.sum\nend",
"def multiples_of_3_and_5_recursive(num, sum = 0)\n return sum if num == 0\n\n num = num - 1\n\n if (num % 3 == 0) || (num % 5 == 0)\n sum += num\n end\n\n multiples_of_3_and_5_recursive(num, sum)\n\nend",
"def multisum(num)\n\n\t# extract multiples into an array\n\n\tmultiples_found = []\n\n\t(1..num).each do |number|\n\t\tmultiples_found << number if (number%3 == 0) || (number%5 == 0)\n\tend\n\n\t# sum all the values in the array\n\ttotal = multiples_found.reduce(:+)\nend",
"def find_multiples(integer)\n arr = (1..integer).to_a\n multiples = []\n\n arr.each do |val|\n if (val % 3).zero? || (val % 5).zero?\n multiples.push(val) # mutates original array\n end\n end\n multiples\nend",
"def multisum(num)\n array = (1..num).select {|i| i % 3 == 0 || i % 5 == 0}\n array.reduce(:+)\nend",
"def three_five_sum\n outcome = (1...1000).to_a.select do |num|\n num % 3 == 0 || num % 5 == 0\n end\n total = 0\n outcome.each do |num|\n total += num\n end\n total\nend",
"def sum_multiple_3_5\n array = [*1..999]\n starter = 0\n array.map do |n|\n if n % 3 ==0 || n % 5 == 0\n starter += n\n end\n end\n puts starter\nend",
"def sum_multiples_of_3_or_5(n)\n (1...n).inject(0) do |sum, n|\n sum + if n % 3 == 0 || n % 5 == 0\n n\n else\n 0\n end\n end\nend",
"def sum_of_3_or_5_multiples?(final_number)\n \n final_sum=0\n \n if (final_number)is_i?(Fixnum) && final_number >= 0\n \n 0.upto(final_number-1) do |current_number|\n if is_multiple_of_3_or_5? (current_number) == true \n final_sum = final_sum + current_number\n else \n end \n end\n return \"Yo ! Je ne prends que les entiers naturels. TG\"\n end\n return final_sum\n end",
"def sum_of_mults(num)\n ary = []\n num.times do |num|\n if num % 3 == 0 || num % 5 == 0\n ary << num\n end\n num -= 1\n end\n ary.inject(:+)\nend",
"def multisum(limit)\n multiples = []\n\n for num in 1..limit\n multiples << num if num % 3 == 0 || num % 5 == 0\n end\n\n multiples.inject(:+)\nend",
"def collect_multiples(number)\n \n numbers = Array.new(number - 1, 0)\n count = 0\n while count < numbers.length \n numbers[count] = count + 1\n count += 1\n end\n\n numbers.select do |element|\n element % 3 == 0 || element % 5 == 0\n end\n\nend",
"def multiples(x)\n array = []\n while x > 0\n x = x - 1\n if (x % 3 == 0) || (x % 5 == 0)\n array << x\n end\n end\n return array.inject{|sum,x| sum + x }\nend",
"def multiples_of_3_and_5\r\n total = 0\r\n (3...1000).each do |x|\r\n if x % 3 == 0 || x % 5 == 0\r\n # puts x\r\n total += x\r\n end\r\n end\r\n total\r\nend",
"def sumOf(n)\n i = 0\n multiples = []\n while i < n do\n if i % 3 == 0 || i % 5 == 0\n multiples.push(i)\n end\n i += 1\n end\n multiples.inspect\n multiples.reduce(:+)\nend",
"def sum_multiples2(numbers, mutiple)\n sum = 0\n for num in numbers\n if num % mutiple == 0\n sum += num\n end\n end\n sum\nend",
"def multiple_sum(num1, num2, maxvalue)\n multiples = []\n\n for num in 1...maxvalue\n if num % num1 == 0 || num % num2 ==0\n multiples << num\n end\nend\n puts multiples.inject{|sum,x| sum + x }\n\nend",
"def multisum(num)\n (1..num).to_a.select { |n| n % 3 == 0 || n % 5 == 0 }.sum\nend",
"def multisum(num)\n (1..num).select { |i| i % 3 == 0 || i % 5 == 0 }.reduce(:+)\nend",
"def multisum(num)\n arr = []\n (1..num).map do |n|\n if n % 3 == 0 || n % 5 == 0\n arr << n\n end\n end\n arr.inject { |n, sum| n + sum }\nend",
"def solution(number)\n sum = 0\n Array(1..number-1).each do |i|\n if i % 3 == 0 || i % 5 == 0\n sum += i\n end\n end\n sum\nend",
"def solution(int)\n multiples_3 = []\n multiples_5 = []\n threes = 3\n fives = 5\n \n until threes >= int\n multiples_3 << threes\n threes += 3\n end\n until fives >= int\n multiples_5 << fives\n fives += 5\n end\n \n (multiples_3 | multiples_5).sum\nend",
"def mult(number)\n (1..number).select { |i| i % 3 == 0 || i % 5 == 0 }.inject(:+)\nend",
"def multiple_of_three_and_five(limit)\r\n (3...limit).select { |number| number % 3 == 0 || number % 5 ==0 }.inject(:+)\r\nend",
"def sum_multiples(num)\n collect_multiples(num).inject(0, :+)\nend",
"def solution(number)\n(0...number).map{|x| x % 3 == 0 || x % 5 == 0 ? x : 0}.inject{|sum, x| sum + x}\nend",
"def solution(number)\r\n (3...number).each_with_object([]) { |n, arr| arr << n if (n % 3).zero? || (n % 5).zero? }.uniq.sum\r\nend",
"def multiples\n\t\t#select all numbers from 3-999 using iterator i...\n\t\t(3..999).select do |i|\n\t\t\t#...that are divisible by 3 or divisible by 5\n\t\t\ti%3 == 0 || i%5 == 0\n\t\tend\n\tend",
"def sum_multiples(numbers, limit)\n\tsum = 0\n\t(numbers[0]..limit-1).each { |potential_multiple|\n\t\ti = 0\n\t\thas_been_counted = false\n\t\twhile (i < numbers.length && !has_been_counted) do\n\t\t\tif (potential_multiple % numbers[i] == 0)\n\t\t\t\thas_been_counted = true\n\t\t\t\tsum += potential_multiple\n\t\t\tend\n\t\t\ti += 1\n\t\tend\n\t}\n\n\treturn sum\nend",
"def multisum(max_number, mult1, mult2)\n (1..max_number).reduce(0) do |sum, number|\n multiple?(number, mult1) || multiple?(number, mult2) ? sum + number : sum\n end\nend",
"def sumOfMultiples()\n sum = 0\n 1.upto(999) do |i|\n if (i % 3 == 0) or (i % 5 == 0)\n sum += i\n end\n end\n sum\nend",
"def multisum(int)\n array = []\n current_num_3 = 0\n current_num_5 = 0\n \n \n loop do\n break if current_num_3 == (int / 3) * 3\n current_num_3 = current_num_3 + 3\n array << current_num_3\n end\n \n loop do\n break if current_num_5 == (int / 5) * 5\n current_num_5 = current_num_5 + 5\n array << current_num_5\n end\n \n array.uniq!\n array.sum\nend",
"def multisum(number)\n sum = 0\n (1..number).each do |num|\n if num % 3 == 0 || num % 5 == 0\n sum += num\n end\n end\n sum\nend",
"def collect_multiples(limit)\n multiples = []\n numbers = (1..limit.to_i-1).to_a\n numbers.each do |i|\n if i % 3 == 0 || i % 5 == 0\n multiples.push(i)\n end\n end\n multiples \nend",
"def multisum(num)\n (1..num).select{ |x| (x % 3 == 0) || (x % 5 == 0) }.sum\nend",
"def collect_multiples(limit)\n #numbers = [1..(limit-1)]\n multiple_numbers = []\n (1..(limit-1)).map do |number|\n if number % 3 == 0 || number % 5 == 0\n multiple_numbers << number\n end\n end\n multiple_numbers\nend",
"def sum\n numbers_array = @max.select do |num|\n num % 3 == 0 || num % 5 == 0\n end\n sum = numbers_array.reduce(:+)\n\n end",
"def multisum(number)\n (0..number).select { |num| num % 3 == 0 || num % 5 == 0 }.inject(:+)\nend",
"def multiples_of_three_and_five(limit)\n arr = []\n i = 1\n\n while i < limit do\n if i % 5 == 0 || i % 3 == 0\n arr << i\n i += 1\n else\n i += 1\n end\n # puts $arr.inspect\n end\n\n arr_size = arr.count\n # puts arr_size\n total = 0\n i = 0\n\n while i < arr_size do\n total += arr[i]\n i += 1\n end\n\n return total\nend"
] |
[
"0.803105",
"0.7904115",
"0.7838052",
"0.7818846",
"0.7752806",
"0.7744883",
"0.76772016",
"0.76477814",
"0.7621858",
"0.76169044",
"0.7610242",
"0.7596771",
"0.7596756",
"0.7566219",
"0.7563507",
"0.7506362",
"0.7498923",
"0.7490373",
"0.7445057",
"0.74284554",
"0.74141574",
"0.7403837",
"0.74019563",
"0.7398401",
"0.7389115",
"0.7371048",
"0.7369947",
"0.7368884",
"0.7348845",
"0.733071",
"0.7326423",
"0.73211753",
"0.7315538",
"0.73133844",
"0.730738",
"0.7288661",
"0.72860724",
"0.7285019",
"0.72797614",
"0.72648907",
"0.7264727",
"0.7252675",
"0.7248526",
"0.7235547",
"0.7220744",
"0.72147375",
"0.7208899",
"0.7204826",
"0.72026163",
"0.7200658",
"0.7184759",
"0.7181869",
"0.7160083",
"0.7159225",
"0.7158118",
"0.7150173",
"0.7147287",
"0.713569",
"0.7135006",
"0.71312034",
"0.709425",
"0.70726246",
"0.70688075",
"0.7061887",
"0.7061418",
"0.70437276",
"0.70320076",
"0.7012113",
"0.700817",
"0.7006286",
"0.6991591",
"0.6987536",
"0.6983949",
"0.69811815",
"0.6977992",
"0.6975486",
"0.6965541",
"0.6960368",
"0.69601417",
"0.6954122",
"0.693112",
"0.6928991",
"0.6927918",
"0.6926387",
"0.69232154",
"0.69193655",
"0.69086695",
"0.69067955",
"0.69027",
"0.68906987",
"0.6867182",
"0.684841",
"0.6846437",
"0.684628",
"0.6828468",
"0.6802794",
"0.6801305",
"0.68005556",
"0.67985314",
"0.679844"
] |
0.7262475
|
41
|
Set the URL of the associated work on the web site of the original repository if not already present.
|
def normalize_title_url!(data = nil, field: :emma_webPageLink)
url = get_field_values(data, *field).first
return unless url.blank?
set_field_value!(data, field, generate_title_url)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_git_urls\n self.url = GitHosting.repository_path(self) if self.url.blank?\n self.root_url = self.url if self.root_url.blank?\n end",
"def set_git_urls\n self.url = GitHosting.repository_path(self) if url.blank?\n self.root_url = url if root_url.blank?\n end",
"def url= new_url\n new_url = self.class.standardized_url new_url\n return if new_url == url\n super new_url # Heading for trouble if url wasn't unique\n @indexing_url = nil # Clear the memoized indexing_url\n self.http_status = nil # Reset the http_status\n # We do NOT build the associated site here, because we may be BUILDING the page_ref for a site, in\n # which case that site will assign itself to us. Instead, the site attribute is memoized, and if it\n # hasn't been built by the time that it is accessed, THEN we find or build an appropriate site\n self.site = SiteServices.find_or_build_for self\n self.kind = :site if site&.page_ref == self # Site may have failed to build\n # We trigger the site-adoption process if the existing site doesn't serve the new url\n # self.site = nil if site&.persisted? && (SiteServices.find_for(url) != site) # Gonna have to find another site\n request_attributes :url # Trigger gleaning and mercury_result to validate/modify url\n attrib_ready! :url # Has been requested but is currently ready\n end",
"def set_git_urls\n self.url = git_path if url.blank?\n self.root_url = url if root_url.blank?\n end",
"def set_url\n @url = DEFAULT_URL\n end",
"def set_website\n uri = URI.parse(url)\n if website = Website.where(url: uri.host).first\n self.website = website\n else\n website = Website.create(url: uri.host)\n self.website = website\n end\n end",
"def update_related_url(work)\n updated_url = work.related_url.map { |s| change_if_necessary(s) }\n if work.update({related_url: updated_url})\n @changes << [ work.friendlier_id, work.title, updated_url ]\n else\n @errors << [ work.friendlier_id, work.title, work.updated_url, 'could not change url']\n end\n end",
"def set_remote_url(name, url)\n url = url.repo.path if url.is_a?(Git::Base)\n self.lib.remote_set_url(name, url)\n Git::Remote.new(self, name)\n end",
"def set_webpage!\n self.webpage = 'http://www.' unless self.webpage\n end",
"def new_work_url\n url = get_configuration 'url', @work_type_config.dig('hydra_endpoint', 'new_work'), @config.dig('new_work')\n URI.join(server_domain, url)\n end",
"def url\n RepoURL.new(@repo[:html_url]).repo_url\n end",
"def configure_addon_repo_urls(repoName, repoAddonURL, repoBlessedURL)\n self.log(INFO,repoName,\"Repository #{repoName} already cloned...\")\n Dir.chdir repoName\n self.log(INFO,repoName,\"Setting origin url #{repoAddonURL} for #{repoName}...\")\n s = system(\"git remote set-url origin #{repoAddonURL}\")\n if !s\n abort(\"[ERROR] Setting origin url of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n self.log(INFO,repoName,\"Fetching from origin for #{repoName}...\")\n s = system(\"git fetch origin --prune\")\n if !s\n abort(\"[ERROR] Fetching from origin for repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n self.log(INFO,repoName,\"Setting blessed url #{repoBlessedURL} for #{repoName} ...\")\n s = system(\"git remote set-url blessed #{repoBlessedURL}\")\n if !s\n abort(\"[ERROR] Setting blessed url of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n end",
"def set_url\n self.update_column(:url, '/' + self.ancestry_url)\n end",
"def website_url=(new_url)\n write_attribute(:website_url, Organization.clean_url(new_url))\n end",
"def set_site_url\n @site_url = SiteUrl.find(params[:id]) if params[:id]\n end",
"def target_repo_value\n @target_repo_url ||= value_of_or_default(params[:url_field], \"target-repository\")\n end",
"def repository_url=(repository_url)\n return false if @repository_url.nil?\n @repository_url = repository_url\n @config_doc.elements[\"/project/scm/locations/hudson.scm.SubversionSCM_-ModuleLocation/remote\"].text = repository_url\n @config = @config_doc.to_s\n update\n end",
"def url=(_); end",
"def set_url\n url 'set'\n end",
"def work\n\t\tsuper\n\t\t@link = @work\n\tend",
"def original_url; end",
"def url=(new_url)\n super(new_url)\n unless URI.parse(self.url).scheme\n self.url.prepend(\"http://\")\n end\n rescue\n end",
"def page_url\n if service == 'stash' && protocol == 'ssh'\n pattern = /(.*)@([^:]*):?([^\\/]*)\\/([^\\/]*)\\/(.*)\\.git/\n replacement = 'https://\\2/projects/\\4/repos/\\5/browse?at=' +\n current_branch\n elsif service == 'stash' && protocol == 'http'\n pattern = /(.*)@([^:\\/]*)(:?[^\\/]*)\\/(.*)scm\\/([^\\/]*)\\/(.*)\\.git/\n replacement = 'https://\\2\\3/\\4projects/\\5/repos/\\6/browse?at=' +\n current_branch\n elsif protocol == 'ssh'\n pattern = /(.*)@(.*):(.*)\\.git/\n replacement = 'https://\\2/\\3/'\n elsif protocol == 'http'\n pattern = /https?\\:\\/\\/(([^@]*)@)?(.*)\\.git/\n replacement = 'https://\\3/'\n end\n origin_url.sub(pattern, replacement)\n end",
"def add_http_to_url\n if !self.website_url.blank?\n unless self.website_url[/\\Ahttp:\\/\\//] || self.website_url[/\\Ahttps:\\/\\//]\n self.website_url = \"http://#{self.website_url}\"\n end\n end\n end",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def repository_url=(repository_url)\n return false if @repository_url.nil?\n @repository_url = repository_url\n @config_doc.elements[\"/project/scm/locations/hudson.scm.SubversionSCM_-ModuleLocation/remote\"].text = repository_url\n @config = @config_doc.to_s\n update\n end",
"def update!(**args)\n @deployed_url = args[:deployed_url] if args.key?(:deployed_url)\n @url = args[:url] if args.key?(:url)\n end",
"def web_url=(value)\n @web_url = value\n end",
"def web_url=(value)\n @web_url = value\n end",
"def web_url=(value)\n @web_url = value\n end",
"def fill_url(site, page_or_post)\r\n url = 'https:' + site.config['url'] + site.config['baseurl'] + page_or_post.location_on_server(url)\r\n \r\n url\r\n end",
"def original_url\n self.source.url\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def set_url_host_model\n if @url.present?\n @url.url_host = @url_host\n end\n end",
"def giturl(project_name, repo_name) ; end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update_profile\n response = HTTParty.get('https://api.github.com/orgs/' + org_name, :body=> {\n :username => \"9e8c7f5bb19cf14c39e38fe17c14e6d3b161f738\"\n } )\n data = response.parsed_response\n self.html_url = data['html_url']\n self.public_repos = data['public_repos']\n self.save\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def set_url\n @url = Url.find(params[:id])\n end",
"def update!(**args)\n @self_link = args[:self_link] if args.key?(:self_link)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def website_url; website end",
"def getWikiRepositoryUrl(full = true)\n\n @host = 'https://github.com/'\n\n if @conf['wikiToJekyll']['wiki_repository_url']\n url = @conf['wikiToJekyll']['wiki_repository_url'].sub('.wiki.git', '') + '/wiki'\n else\n url = @host + @conf['wikiToJekyll']['user_name'] + '/' + @conf['wikiToJekyll']['repository_name'] + '/wiki'\n end\n\n if full == false\n return url.sub(@host, '')\n else\n return url\n end\n end",
"def set_url_and_baseurl_fallbacks!\n return unless Jekyll.env == \"production\"\n\n repo = drop.send(:repository)\n site.config[\"url\"] ||= repo.url_without_path\n if site.config[\"baseurl\"].to_s.empty? && ![\"\", \"/\"].include?(repo.baseurl)\n site.config[\"baseurl\"] = repo.baseurl\n end\n end",
"def github_url\n @github_url ||= \"https://github.com/#{options[:github_owner]}/#{name}\"\n end",
"def original_url\n url\n end",
"def set_permalink(options={})\n self.permalink = state.to_url + \"/\" + name.to_url + \"/\" if (self.permalink.blank? || options[:force])\n end",
"def set_site\n @site = Site.find_by(slug: params[:site_slug])\n\n # We just want a valid URL for the site\n @url = @site.routes.first.host_with_scheme if @site.routes.any?\n end",
"def set_open_source_work\n @open_source_work = OpenSourceWork.find(params[:id])\n end",
"def content_web_url=(value)\n @content_web_url = value\n end",
"def set_url\n @url = Url.get_from_short(params[:id])\n end",
"def set_url\n @url = Url.find_by(key: params[:key])\n end",
"def set_mst_url(mst, rmt_id)\n url=\"http://#{$settings['redmine_host']}:#{$settings['redmine_port']}/issues/#{rmt_id}\"\n mst.HyperlinkAddress = url\n return url\nend",
"def web_link=(value)\n @web_link = value\n end",
"def success_url\n if GitHosting.multi_repos?\n url_for(:controller => 'repositories', :action => 'edit', :id => @repository.id)\n else\n url_for(:controller => 'projects', :action => 'settings', :id => @project.id, :tab => 'repository')\n end\n end",
"def set_url\n @url = Url.find_by_short_url(params[:id])\n end",
"def update_url(url)\n assert_type(url, Wgit::Url)\n selection = { url: url }\n url_hash = Wgit::Model.url(url).merge(Wgit::Model.common_update_data)\n update = { '$set' => url_hash }\n mutate(true, :urls, selection, update)\n end",
"def repository_url(repositiory)\n http_uri + repositiory.path\n end",
"def main_url\n homepage || linkedin || twitter_url || github_url || nil\n end",
"def set_website\n # @website = Website.find(params[:id])\n end",
"def url\n \"http://github.com/#{repo.owner.login}/#{repo.name}/#{name}\"\n end",
"def join_web_url=(value)\n @join_web_url = value\n end",
"def join_web_url=(value)\n @join_web_url = value\n end",
"def old_url\n \"http://#{site.default_host.hostname}#{path}\"\n end",
"def update_url\n self.url = 'http://whitehouse2.org/priorities/' + self.wh2_id.to_s\n if self.attribute_present?(\"name\")\n self.url += '-' + self.name.gsub(/[^a-z0-9]+/i, '-').downcase\n end\n end",
"def set_url\n @url = Url.find_by(short: params[:short])\n end",
"def set_git_hub_repo\n @git_hub_repo = GitHubRepo.find(params[:id])\n end",
"def set_url\n @url = Url.find_by_admin_slug(params[:slug])\n end",
"def set_URL(value)\n set_input(\"URL\", value)\n end",
"def set_URL(value)\n set_input(\"URL\", value)\n end"
] |
[
"0.6942858",
"0.6841633",
"0.6583025",
"0.6547299",
"0.6513899",
"0.6361469",
"0.63150156",
"0.63075256",
"0.6256537",
"0.6189582",
"0.61830795",
"0.6156341",
"0.61458796",
"0.61110634",
"0.6105617",
"0.60160905",
"0.5992066",
"0.59823495",
"0.59641",
"0.5933893",
"0.58997023",
"0.58841217",
"0.58757967",
"0.5871916",
"0.58681816",
"0.58681816",
"0.58681816",
"0.58681816",
"0.58681816",
"0.5834959",
"0.5834095",
"0.58300346",
"0.58300346",
"0.58300346",
"0.57967025",
"0.5795185",
"0.57932514",
"0.579199",
"0.5761186",
"0.5760971",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.57607543",
"0.5760127",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.5759704",
"0.57559896",
"0.5744766",
"0.5744766",
"0.5744766",
"0.5743808",
"0.57338446",
"0.5719568",
"0.57131475",
"0.5700883",
"0.5686403",
"0.5668307",
"0.5639783",
"0.5616459",
"0.559265",
"0.55794036",
"0.55790216",
"0.55779135",
"0.5568234",
"0.5559325",
"0.55560875",
"0.55526865",
"0.5546127",
"0.5544954",
"0.5540343",
"0.5539199",
"0.5539199",
"0.5536959",
"0.55348384",
"0.5533486",
"0.55280256",
"0.5527721",
"0.552676",
"0.552676"
] |
0.0
|
-1
|
Set the original repository content download URL if not already present.
|
def normalize_download_url!(data = nil, field: :emma_retrievalLink)
url = get_field_values(data, *field).first
return unless url.blank? || url.start_with?(BOOKSHARE_API_URL)
set_field_value!(data, field, generate_download_url)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def download_uri=(value)\n @download_uri = value\n end",
"def update!(**args)\n @download_url = args[:download_url] if args.key?(:download_url)\n end",
"def update!(**args)\n @download_url = args[:download_url] if args.key?(:download_url)\n end",
"def download_from_original_url\n return if self.original_url.blank?\n\n self.contents = begin\n Timeout::timeout(300) do\n io = open(URI.parse(self.original_url))\n def io.original_filename\n base_uri.path.split('/').last\n end\n io.original_filename.blank? ? nil : io\n end\n rescue\n errors.add :original_url, \"unable to download url\"\n nil\n end\n end",
"def set_default_version(version)\n return unless version\n \n self.download_url = version.download.url\n self.save\n end",
"def set_url\n @url = DEFAULT_URL\n end",
"def download_source\n unless @download_source\n if new_resource.package_url\n res = chase_redirect(new_resource.package_url)\n else\n params = URI.encode_www_form(full: 1,\n plat: node['platform_family'][0..2])\n res = chase_redirect(\"https://www.dropbox.com/download?#{params}\")\n end\n end\n @download_source ||= res\n end",
"def set_git_urls\n self.url = GitHosting.repository_path(self) if self.url.blank?\n self.root_url = self.url if self.root_url.blank?\n end",
"def set_git_urls\n self.url = GitHosting.repository_path(self) if url.blank?\n self.root_url = url if root_url.blank?\n end",
"def fetch_file_by_url\n if (self.url)\n self.file = self.url\n end\n end",
"def get_download_url()\n return @@download_url;\n end",
"def target_repo_value\n @target_repo_url ||= value_of_or_default(params[:url_field], \"target-repository\")\n end",
"def set_git_urls\n self.url = git_path if url.blank?\n self.root_url = url if root_url.blank?\n end",
"def download_original ; path_download_file(:original).download end",
"def original_url\n self.source.url\n end",
"def artifact_download_url_for(node, source)\n # TODO: Move this method into the nexus-cli\n config = data_bag_config_for(node, source)\n nexus_path = config['path']\n group_id, artifact_id, version, extension, classifier = source.split(':')\n uri_for_url = URI(config['url'])\n builder = uri_for_url.scheme =~ /https/ ? URI::HTTPS : URI::HTTP\n is_content_path_enabled = use_content_path node\n query_string = \"g=#{group_id}&a=#{artifact_id}&v=#{version}&e=#{extension}&r=#{config['repository']}&c=#{classifier}\"\n if is_content_path_enabled\n if version.downcase.include? 'snapshot'\n builder.build(:host => uri_for_url.host, :port => uri_for_url.port, :path => \"#{nexus_path}/service/local/artifact/maven/redirect\", :query => query_string).to_s\n else\n ##\n Chef::Log.info \"g-#{group_id} a-#{artifact_id} v-#{version} e-#{extension} c-#{classifier} repo #{config['repository']} url #{config['url']} path #{config['path']}\"\n gav_path=get_gav_path(group_id, artifact_id, version)\n f_name = get_download_fname(artifact_id, version, classifier, extension)\n if nexus_path ==''\n content_url=\"#{config['repository']}/#{gav_path}/#{f_name}\"\n builder.build(:host => uri_for_url.host, :port => uri_for_url.port, :path => \"/#{content_url}\").to_s\n else\n # remove leading trailing /\n path = nexus_path.gsub(/^\\//, '')\n path = \"#{path.gsub(/\\/$/, '')}/content/repositories/#{config['repository']}\"\n content_path = \"#{path}/#{gav_path}\"\n content_url = \"#{content_path}/#{f_name}\"\n Chef::Log.info \"download url #{content_url}\"\n builder.build(:host => uri_for_url.host, :port => uri_for_url.port, :path => \"/#{content_url}\").to_s\n end\n end\n else\n builder.build(:host => uri_for_url.host, :port => uri_for_url.port, :path => \"#{nexus_path}/service/local/artifact/maven/redirect\", :query => query_string).to_s\n end\n end",
"def repository_url=(repository_url)\n return false if @repository_url.nil?\n @repository_url = repository_url\n @config_doc.elements[\"/project/scm/locations/hudson.scm.SubversionSCM_-ModuleLocation/remote\"].text = repository_url\n @config = @config_doc.to_s\n update\n end",
"def download_uri\n return @download_uri\n end",
"def repository_url=(repository_url)\n return false if @repository_url.nil?\n @repository_url = repository_url\n @config_doc.elements[\"/project/scm/locations/hudson.scm.SubversionSCM_-ModuleLocation/remote\"].text = repository_url\n @config = @config_doc.to_s\n update\n end",
"def archive_download_url\n raise \"Not implemented yet!\"\n end",
"def save_url\n dir.mkpath\n File.open(dir + '.url', 'w') { |file| file.write(@url) }\n rescue => e\n raise Informative, \"Could not create '#{config.repos_dir}', the CocoaPods repo cache directory.\\n\" \\\n \"#{e.class.name}: #{e.message}\"\n end",
"def mirror_locally=(value)\n cobbler('repo', 'edit', '--name=' + @resource[:name], '--mirror-locally=' + value.to_s)\n @property_hash[:mirror_locally]=(value.to_s)\n cobbler('reposync')\n end",
"def original_url; end",
"def content_url=(value)\n @content_url = value\n end",
"def content_url=(value)\n @content_url = value\n end",
"def set_download\n @download = Download.find_by(link: params[:link])\n unless @download\n redirect_to root_path, notice: 'Incorrect download link'\n end\n end",
"def set_remote_url(name, url)\n url = url.repo.path if url.is_a?(Git::Base)\n self.lib.remote_set_url(name, url)\n Git::Remote.new(self, name)\n end",
"def uri\n \"file://\" + self.repos_path\n end",
"def set_url_and_baseurl_fallbacks!\n return unless Jekyll.env == \"production\"\n\n repo = drop.send(:repository)\n site.config[\"url\"] ||= repo.url_without_path\n if site.config[\"baseurl\"].to_s.empty? && ![\"\", \"/\"].include?(repo.baseurl)\n site.config[\"baseurl\"] = repo.baseurl\n end\n end",
"def url_for_fetching\n server = Settings.git_server(url)\n if server.mirror.present?\n url.gsub(%r{(git@|https://).*?(:|/)}, server.mirror)\n else\n url\n end\n end",
"def url\n RepoURL.new(@repo[:html_url]).repo_url\n end",
"def repository_url=(repository_url)\n if repository_url.nil?\n fail ArgumentError, 'invalid value for \"repository_url\", repository_url cannot be nil.'\n end\n @repository_url = repository_url\n end",
"def file_url= val\n return if val.blank?\n\n self.state = :pending\n self.server_data = val\n @file_last_action = __method__.to_sym\n end",
"def original_url\n url\n end",
"def source_url=(url)\n return nil if not url\n http_getter = Net::HTTP\n uri = URI.parse(url)\n response = http_getter.start(uri.host, uri.port) {|http|\n http.get(uri.path)\n }\n case response\n when Net::HTTPSuccess\n file_data = response.body\n return nil if file_data.nil? || file_data.size == 0\n self.content_type = response.content_type\n self.temp_data = file_data\n self.filename = uri.path.split('/')[-1]\n else\n return nil\n end\n end",
"def url=(new_url)\n super(new_url)\n unless URI.parse(self.url).scheme\n self.url.prepend(\"http://\")\n end\n rescue\n end",
"def url\n @client.get_download_link(@path)\n end",
"def download_url\n process_emulation 10\n clear_progress_bar\n self.downloaded_at = Time.now.utc\n save! && ready!\n end",
"def set_repo\n @path = \"#{params[:login].strip}/#{params[:repo].strip}\"\n @repo = CacheRepo.where(path: @path).first\n if !@repo\n @repo = CacheRepo.new(path: @path)\n @repo.save!\n end\n end",
"def configure_addon_repo_urls(repoName, repoAddonURL, repoBlessedURL)\n self.log(INFO,repoName,\"Repository #{repoName} already cloned...\")\n Dir.chdir repoName\n self.log(INFO,repoName,\"Setting origin url #{repoAddonURL} for #{repoName}...\")\n s = system(\"git remote set-url origin #{repoAddonURL}\")\n if !s\n abort(\"[ERROR] Setting origin url of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n self.log(INFO,repoName,\"Fetching from origin for #{repoName}...\")\n s = system(\"git fetch origin --prune\")\n if !s\n abort(\"[ERROR] Fetching from origin for repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n self.log(INFO,repoName,\"Setting blessed url #{repoBlessedURL} for #{repoName} ...\")\n s = system(\"git remote set-url blessed #{repoBlessedURL}\")\n if !s\n abort(\"[ERROR] Setting blessed url of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n end",
"def set_url(url_value)\n @path = url_value.delete_prefix \"/\"\n @dir = File.dirname(@path)\n @url = url_value\n end",
"def download(description = @component_name, &block)\n super_download @version, @uri, description, &block\n end",
"def download_url(**opt)\n opt[:expires_in] ||= ONE_TIME_USE_EXPIRATION\n attached_file&.url(**opt)\n end",
"def url\n return @url unless @url.nil?\n @url = destination.sub(::Webby.site.output_dir, '')\n end",
"def destination\n @destination ||= shared_path + \"/#{@repository_cache}\"\n end",
"def download_uri\n @attributes[:download_uri]\n end",
"def download_uri\n @attributes[:download_uri]\n end",
"def fetch\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('http', 'https')\n end\n\n super\n\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('https', 'http')\n end\n end",
"def fetch\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('http', 'https')\n end\n\n super\n\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('https', 'http')\n end\n end",
"def clone_url\n raise \"not implemented\"\n end",
"def set_url\n self.update_column(:url, '/' + self.ancestry_url)\n end",
"def doc_url=(value)\n @children['doc-url'][:value] = value\n end",
"def url=(value)\n value = \"http://#{value}\" unless value.empty? || value =~ %r{^http://} || value =~ %r{^https://}\n write_local(:url, value)\n end",
"def original_repo=(new_repo)\n # Check if the repository has changed. This may happen if the component's author offered\n # the package name to someone else for a new component. If we have a custom repo,\n # only perform a change if the original changed. This allows us to fix wrong repos.\n write_attribute :repo, nil if self.original_repo != new_repo\n\n write_attribute :original_repo, new_repo\n end",
"def content\n self.source? ? self.source.url : self.default_source_url\n end",
"def content\n self.source? ? self.source.url : self.default_source_url\n end",
"def repo=(new_repo)\n if new_repo.to_s.downcase == self.original_repo.to_s.downcase\n write_attribute :repo, nil\n else\n write_attribute :repo, new_repo\n end\n end",
"def repo\n read_attribute(:repo).presence || self.original_repo\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def setURL(url)\r\n\t\t\t\t\t@url = url\r\n\t\t\t\tend",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def downloaded_file\n filename = source[:cached_name] if source[:cached_name]\n filename ||= File.basename(source[:url], \"?*\")\n File.join(Config.cache_dir, filename)\n end",
"def external_download_url\n @file.external_bytestream_uri.to_s\n end",
"def repository_path=(path)\n @repository_path = Pathname.new(path)\n end",
"def download_url(format='original')\n @download_urls[format] ||= begin\n response = API.instance.send_request('docs.getDownloadUrl', :doc_id => self.id, :doc_type => format)\n response.elements['/rsp/download_link'].cdatas.first.to_s\n end\n end",
"def download_url(format='original')\n @download_urls[format] ||= begin\n response = API.instance.send_request('docs.getDownloadUrl', :doc_id => self.id, :doc_type => format)\n response.elements['/rsp/download_link'].cdatas.first.to_s\n end\n end",
"def remote_repository\n \"http://www.aQute.biz/repo\"\n end",
"def github_url\n @github_url ||= \"https://github.com/#{options[:github_owner]}/#{name}\"\n end",
"def url\n \"http://github.com/#{repo.owner.login}/#{repo.name}/#{name}\"\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def update!(**args)\n @url = args[:url] if args.key?(:url)\n end",
"def repo_url(path = \"\")\n if @repo.url\n url = URI::parse(@repo.url)\n url.path = (url.path + \"/\" + path).gsub(%r'//+', '/')\n url.to_s\n else\n compose_url \"/svc/repo\", @repo.name, path\n end\n end",
"def repository_url(repositiory)\n http_uri + repositiory.path\n end",
"def canonical_repository_url\n \"https://#{@settings.host}/scm/#{attributes[:repository_namespace]}/#{attributes[:repository_name]}.git\"\n end",
"def defaults!\n self.url = nil\n end",
"def download_path\n ::File.join(Chef::Config[:file_cache_path], ::File.basename(URL))\n end",
"def url= new_url\n new_url = self.class.standardized_url new_url\n return if new_url == url\n super new_url # Heading for trouble if url wasn't unique\n @indexing_url = nil # Clear the memoized indexing_url\n self.http_status = nil # Reset the http_status\n # We do NOT build the associated site here, because we may be BUILDING the page_ref for a site, in\n # which case that site will assign itself to us. Instead, the site attribute is memoized, and if it\n # hasn't been built by the time that it is accessed, THEN we find or build an appropriate site\n self.site = SiteServices.find_or_build_for self\n self.kind = :site if site&.page_ref == self # Site may have failed to build\n # We trigger the site-adoption process if the existing site doesn't serve the new url\n # self.site = nil if site&.persisted? && (SiteServices.find_for(url) != site) # Gonna have to find another site\n request_attributes :url # Trigger gleaning and mercury_result to validate/modify url\n attrib_ready! :url # Has been requested but is currently ready\n end",
"def cdn_url=(value)\n @cdn_url = value\n end",
"def set_download\n @download = Download.find(params[:id])\n end",
"def set_download\n @download = Download.find(params[:id])\n end"
] |
[
"0.67339295",
"0.6572786",
"0.6572786",
"0.6403448",
"0.63788337",
"0.63288647",
"0.62757987",
"0.62326235",
"0.6197232",
"0.61001754",
"0.59821767",
"0.59808016",
"0.5957649",
"0.5956879",
"0.59562373",
"0.59362316",
"0.5912086",
"0.58589727",
"0.58091724",
"0.5803031",
"0.57955265",
"0.57850343",
"0.5779119",
"0.5768181",
"0.5768181",
"0.57639265",
"0.57418835",
"0.5731851",
"0.57293063",
"0.5698546",
"0.5664598",
"0.5663599",
"0.56135267",
"0.5606836",
"0.5599255",
"0.55699784",
"0.55605197",
"0.55481046",
"0.5544927",
"0.5538832",
"0.55381113",
"0.5527789",
"0.55191207",
"0.5517269",
"0.55120707",
"0.54903626",
"0.54903626",
"0.54903024",
"0.54903024",
"0.5485594",
"0.5484115",
"0.54805243",
"0.5477636",
"0.5452902",
"0.54299116",
"0.54299116",
"0.5423434",
"0.54104674",
"0.54061073",
"0.54011846",
"0.54011846",
"0.54011846",
"0.54011846",
"0.54011846",
"0.53910995",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53909636",
"0.53890395",
"0.53879416",
"0.53853136",
"0.53807294",
"0.53807294",
"0.53799933",
"0.5362522",
"0.5361252",
"0.5357401",
"0.5357401",
"0.5357401",
"0.53522694",
"0.5351667",
"0.53445864",
"0.5344501",
"0.5341207",
"0.53399885",
"0.53309005",
"0.53279036",
"0.53279036"
] |
0.565957
|
32
|
pp get_mystates_from_highstate('module','chocolatey','bootstrap') pp get_mystates_from_highstate('module','user','current') pp get_mystates_from_highstate('state','system','hostname')
|
def get_highstate_from_minion
if defined?(@cache_highstate_from_minion)
Inspec::Log.debug('Returning cached @cache_highstate_from_minion.')
return @cache_highstate_from_minion
end
# ingest_from_minion('yaml', 'C:\salt\salt-call.bat --config-dir=C:\Users\vagrant\AppData\Local\Temp\kitchen\etc\salt state.show_highstate --out yaml |Select-String -Pattern "__sls__", "__env__", "- run", "- order:" -NotMatch')
highstate_from_minion = ingest_from_minion('json', 'C:\salt\salt-call.bat --config-dir=C:\Users\vagrant\AppData\Local\Temp\kitchen\etc\salt state.show_highstate --out json')
if highstate_from_minion != []
Inspec::Log.debug('Saving highstate to cache @cache_highstate_from_minion.')
@cache_highstate_from_minion = highstate_from_minion['local']
@cache_highstate_from_minion
else
Inspec::Log.error('Failed to get highstate.')
abort 'Failed to get highstate.'
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def states; @_hegemon_states.keys; end",
"def print_state(machine)\n puts \"[#{machine[:stack]}, #{machine[:register]}]\"\nend",
"def known_states; end",
"def known_states; end",
"def known_states; end",
"def get_state\n@state.keys\nend",
"def get_state\n get_yarn_application_apptempt_state.to_s.to_sym\n end",
"def read_state(hyp, machine)\n output = hyp.exec(\"vmadm get #{machine.id}\")\n\n if output.exit_code != 0 || output.stderr.chomp =~ /No such zone configured/ || output.stdout == \"\"\n nil\n else\n JSON.load(output.stdout)\n end\n end",
"def boots(state,path,descr=\"\")\n begin\n # get our current position\n curr = path.shift\n case\n when curr.instance_of?(String)\n descr=\"#{descr}.#{curr}\"\n\n # we may have a hash or a mbean from which to get attributes\n # either way, we can \"gettr\" done\n state = (state.respond_to?(:keys) ? state[curr] : state.send(curr))\n if path.empty?\n @results[descr]=state\n else\n boots(state,path,descr)\n end\n when curr.instance_of?(Array)\n curr_state = state\n curr.each do |rabbit|\n hole = path.dup\n my_desc = \"#{descr}.#{rabbit}\"\n my_state = (curr_state.respond_to?(:keys) ? curr_state[rabbit] : curr_state.send(rabbit))\n if hole.empty?\n @results[my_desc]=my_state\n else\n boots(my_state,hole,my_desc)\n end\n end\n end\n rescue Exception => e\n puts \"Exception required processing #{@name}: #{e}\"\n end\n end",
"def get_state\n \"Treasury state: #{@resources}\"\n end",
"def power_state(action = \"status\")\n connection.fetch(:hosts, :power, \"id\" => manager_ref, \"power_action\" => action).first[\"power\"]\n end",
"def states\n\t[:shelf,:in_use,:borrowed,:misplaced,:lost]\nend",
"def all_state\n result = {:cook_state => RightScale::CookState, :chef_state => RightScale::ChefState}\n end",
"def state_obj; @_hegemon_states[@_hegemon_state]; end",
"def state\n self.well_info.state\n end",
"def states; end",
"def states\n [\n ['0', 'EMERGENCY_SHUTDOWN',\n 'State machine has a bug, cannot be trusted']\n ]\n end",
"def malware_state_summary\n return @malware_state_summary\n end",
"def describe_state(state)\n $states[state.to_sym].last.join(' ,')\nend",
"def service_query_state(name)\n\t\tif session_has_services_depend?\n\t\t\t#meterpreter_service_query_state(name)\n\t\t\tNOTIMP\n\t\telse\n\t\t\tshell_service_query_state(name)\n\t\tend\t\n\tend",
"def provider_name_from_state\n ::Deepblue::LoggingHelper.bold_debug [ ::Deepblue::LoggingHelper.here,\n ::Deepblue::LoggingHelper.called_from,\n \"\" ] if browse_everything_controller2_debug_verbose\n rv = params[:state].to_s.split(/\\|/).last\n ::Deepblue::LoggingHelper.bold_debug [ ::Deepblue::LoggingHelper.here,\n ::Deepblue::LoggingHelper.called_from,\n \"provider name_from_stat rv=#{rv}\",\n \"\" ] if browse_everything_controller2_debug_verbose\n rv\n end",
"def state\n module_name = self.class.name.underscore.gsub!('skej/state_logic/','')\n @STATE_KEY ||= module_name.to_sym\n end",
"def get_state\n send_request(FUNCTION_GET_STATE, [], '', 2, '? ?')\n end",
"def get_SaleState()\n \t return @outputs[\"SaleState\"]\n \tend",
"def test_read_action_variables\n smc = a_guarded_state_machine\n \n smc.define_reader :logged_in do; @logged_in ;end\n sm = smc.state_machine\n sm.state=:HOME\n sm.click_log_in\n assert_equal(:LOG_IN_COMPLETE, sm.state , \"Check Logged in.\")\n puts\n puts \"Variables:\"\n puts sm.read_logged_in\n assert(sm.read_logged_in , \"Check logged in is accessible and true\")\n\n end",
"def malware_execution_state_summary\n return @malware_execution_state_summary\n end",
"def current_status\n if OperatingSystem.mac?\n return { os: {mac: 'mac' }}\n end\n\n if OperatingSystem.linux?\n top = %x(top -b -n 1)\n load_averages = top.split(\"\\n\")[0].partition(\"load average:\")[2].strip.split(\", \")\n puts \"Load last 1 minute: #{load_averages[0]}\"\n puts \"Load last 5 minutes: #{load_averages[1]}\"\n puts \"Load last 15 minutes: #{load_averages[2]}\"\n uptime = top.split(\"\\n\")[0].split(\", \")[0].partition(\"up\")[2].strip+','+top.split(\"\\n\")[0].split(\", \")[1]\n puts \"Uptime: #{uptime}\"\n user_sessions = top.split(\"\\n\")[0].split(\", \")[2].strip.to_i\n cpu = 100.0 - top.split(\"\\n\")[2].split(', ')[3].to_f\n puts \"Current User sessions: #{user_sessions}\"\n puts \"#{top.split(\"\\n\")[1]}\"\n puts \"% CPU (user processes): #{top.split(\"\\n\")[2].split(', ')[0].partition(\":\")[2]}\"\n puts \"% CPU (system processes): #{top.split(\"\\n\")[2].split(', ')[1]}\"\n puts \"% CPU (priority nice): #{top.split(\"\\n\")[2].split(', ')[2]}\"\n puts \"% CPU (idle): #{top.split(\"\\n\")[2].split(', ')[3]}\"\n puts \"% CPU (waiting for I/O): #{top.split(\"\\n\")[2].split(', ')[4]}\"\n puts \"% CPU (hardware interpts):#{top.split(\"\\n\")[2].split(', ')[5]}\"\n puts \"% CPU (software interpts):#{top.split(\"\\n\")[2].split(', ')[6]}\"\n puts \"RAM: #{top.split(\"\\n\")[3]}\"\n puts \"SWAP:#{top.split(\"\\n\")[4]}\"\n total_memory = top.split(\"\\n\")[3].split(' ')[2].to_f\n free_memory = top.split(\"\\n\")[3].split(' ')[6].to_f\n free_memory_perc = (free_memory / total_memory * 100).round\n swap_used = top.split(\"\\n\")[4].split(', ')[3].to_f\n\n disk_space = %x(df /tmp --total -k -h)\n puts \"Disk Space (Total): #{disk_space.split(\"\\n\")[-1].partition(\"total\")[2].split[0]}\"\n puts \"Disk Space (Used): #{disk_space.split(\"\\n\")[-1].partition(\"total\")[2].split[1]}\"\n puts \"Disk Space (Avail): #{disk_space.split(\"\\n\")[-1].partition(\"total\")[2].split[2]}\"\n puts \"Disk Space (%Used): #{disk_space.split(\"\\n\")[-1].partition(\"total\")[2].split[3]}\"\n disk_space_used = disk_space.split(\"\\n\")[-1].partition(\"total\")[2].split[3].to_i\n puts \"---\"\n\n {\n os: {\n up_time: uptime,\n load: load_averages[0],\n cpu: cpu,\n free_memory: free_memory_perc,\n disk_space: disk_space_used,\n swap_used: swap_used,\n }\n }\n end\n end",
"def init_kernel\n kernel Mash.new\n [[\"uname -s\", :name], [\"uname -r\", :release],\n [\"uname -v\", :version], [\"uname -m\", :machine],\n [\"uname -p\", :processor]].each do |cmd, property|\n so = shell_out(cmd)\n kernel[property] = so.stdout.strip\n end\n kernel\n end",
"def get_sysinfo\n\t\tsystem_data = {}\n\t\tkernel_version = cmd_exec(\"uname -a\")\n\t\tversion = read_file(\"/etc/release\").split(\"\\n\")[0].strip\n\t\tsystem_data[:version] = version\n\t\tsystem_data[:kernel] = kernel_version\n\t\tsystem_data[:hostname] = kernel_version.split(\" \")[1]\n\t\treturn system_data\n\tend",
"def get_power_state\n response = @client.rest_get(@data['uri'] + '/powerState')\n response.body\n end",
"def all_state(id)\n $app_sessions[id][:state]\nend",
"def walk()\n @state.each do |state|\n desc = state.respond_to?(:name) ? state.name : @name\n boots(state,@path,desc)\n end\n return @results\n end",
"def fetch_sensor_state\n \"#{entry_on}#{inside_on}#{exit_on}#{@beam_broken}\".to_i(2)\n end",
"def get_state\n @client.get_state\n end",
"def init_kernel\n kernel Mash.new\n [[\"uname -s\", :name], [\"uname -r\", :release],\n [\"uname -v\", :version], [\"uname -m\", :machine],\n [\"uname -p\", :processor]].each do |cmd, property|\n so = shell_out(cmd)\n kernel[property] = so.stdout.split($/)[0]\n end\n kernel\n end",
"def system_describe\n return @sd_cache if @sd_cache\n sd = {:sdversion => @sd[:sdversion], :name => @sd[:name], :id => @sd[:id]}\n sd[:version] = @sd[:version] if @sd[:version]\n sd[:summary] = @sd[:summary] if @sd[:summary]\n sd[:help] = @sd[:help] if @sd[:help]\n sd[:address] = @sd[:address] if @sd[:address]\n sd[:procs] = []\n @procs.each do |name, prop|\n next if name == 'system.describe'\n pd = {:name => name}\n pd[:summary] = prop[:summary] if prop[:summary]\n pd[:help] = prop[:help] if prop[:help]\n pd[:idempotent] = prop[:idempotent] if prop[:idempotent]\n pd[:params] = prop[:params] if prop[:params]\n pd[:return] = prop[:return] if prop[:return]\n sd[:procs] << pd\n end\n @sd_cache = sd\n end",
"def state_machine_details\n erb(:state_machines) if state_machines\nend",
"def state\n results = (nodetool_netstats || '').split(\"\\n\")\n results.map! { |line| line.strip }\n results.select! { |line| line.include? 'Mode:' }\n results.map! { |line| line.split(':')[1] }\n results.compact!\n return nil if results.size != 1\n results.first.strip.downcase.to_sym\n end",
"def blink environment\n info = Hash.new\n info[\"yp\"]=\"ng\"\n info[\"lyp\"]=\"eu-gb\"\n info[\"sydney\"]=\"au-syd\"\n info[\"ys1\"]=\"stage1.ng\"\n info[\"lys1\"]=\"stage1.eu-gb\"\n info[\"ys0\"]=\"stage0.ng\"\n info[\"lys0\"]=\"stage0.eu-gb\"\n info[\"abnamro\"]=\"abnamro.eu-nl\"\n info[\"accenture\"]=\"acn\"\n info[\"anz\"]=\"anz-blue-art-lab.au-south\"\n info[\"bendigo\"]=\"ben\"\n info[\"bpi\"]=\"bpiflashstudio.as-hk\"\n info[\"capgemini\"]=\"capgemini.eu-gb\"\n info[\"cio\"]=\"w3ibm\"\n info[\"cognizant\"]=\"cognizant.as-sg\"\n info[\"csc\"]=\"csc.us-ne\"\n info[\"dgt\"]=\"dgt.eu-gb\"\n info[\"dvla\"]=\"dvla.eu-gb\"\n info[\"dyf\"]=\"pci.na-south\"\n info[\"dys0\"]=\"dys0\"\n info[\"gts\"]=\"ibm-gts.us-south\"\n info[\"hertz1\"]=\"\"\n info[\"hertz2\"]=\"c2c.us-west\"\n info[\"infosys\"]=\"learninfy.as-sg\"\n info[\"jri\"]=\"smfg-first.as-jp\"\n info[\"kaiser1\"]=\"kpsj001.us-west\"\n info[\"kaiser2\"]=\"kpsj002.us-west\"\n info[\"lloyds\"]=\"lbg.eu-gb\"\n info[\"monitise\"]=\"moni\"\n info[\"mutua\"]=\"mutua.eu-gb\"\n info[\"nab\"]=\"nab.au-south\"\n info[\"niandc\"]=\"crb.as-jp\"\n info[\"rbc\"]=\"rbc.ca-east\"\n info[\"showroom1\"]=\"sr1.us-south\"\n info[\"showroom2\"]=\"sr2.us-south\"\n info[\"showroom3\"]=\"sr3.us-south\"\n info[\"showroom4\"]=\"sr4.as-jp\"\n info[\"showroom5\"]=\"sr5.eu-gb\"\n info[\"showroom6\"]=\"sr6.us-south\"\n info[\"sncf\"]=\"sncf-eva.eu-fr\"\n info[\"sogeti\"]=\"sogeti.eu-gb\"\n info[\"talentinsights\"]=\"ibmtalentinsights.ca-east\"\n info[\"talentinsights2\"]=\"ibmtalentinsights.eu-nl\"\n info[\"talentinsights3\"]=\"ibmtalentinsights.us-south\"\n info[\"talentinsights4\"]=\"ibmtalentinsights.eu-it\"\n info[\"tcs\"]=\"tcs.us-south\"\n info[\"techmahindra\"]=\"techmahindra.as-sg\"\n info[\"ukpostoffice1\"]=\"postofficefot.eu-gb\"\n info[\"ukpostoffice2\"]=\"\"\n info[\"wipro\"]=\"wipro.as-sg\"\n\n ace = \"https://console.#{info[\"#{environment}\"]}.bluemix.net\"\n ace_uaa = \"https://login.#{info[\"#{environment}\"]}.bluemix.net/UAALoginServerWAR/landing?realmid=UAA\"\n return \"ACE: #{ace}\n ACE UAA: #{ace_uaa}\"\nend",
"def state()\n info[:state]\n end",
"def states(refresh=false)\n @states ||= []\n assert_states if refresh\n @states\n end",
"def state(*args)\n result = self.info(\"--state\", *args).collect{ |str| str.scan(REGEX_STATE) }\n result.flatten!.compact!\n\n result.first.strip.downcase.to_sym\n end",
"def get_state(version)\n my_version = get_version(version)\n my_version['state']\n end",
"def server_power_state_get(handle:, server_id: 1)\n server_dn = ImcCoreUtils.get_server_dn(handle, server_id)\n server_mo = handle.query_dn(dn: server_dn)\n if server_mo\n return server_mo.oper_power\n end\n\n raise ImcOperationError.new(\"Get Server Power State\",\n \"Managed Object not found for dn: #{server_dn}\")\nend",
"def get_services_state()\n file = File.read('config/status.json')\n data_hash = JSON.parse(file)\n return data_hash\n end",
"def __get_initial_state__\n `var result = {}`\n if hash = self.get_initial_state\n %x{\n \n var result = {},\n keys = #{hash}.$$keys,\n smap = #{hash}.$$smap,\n key, value;\n\n for (var i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n\n //if (key.$$is_string) {\n value = smap[key];\n //} else {\n // key = key.key;\n // value = key.value;\n //}\n\n result[key] = value;\n }\n \n }\n end\n `return result`\n end",
"def states\n []\n end",
"def states\n []\n end",
"def dependency_states\n states = {}\n deps.each do |dep|\n gem = Polisher::Gem.new :name => dep.name\n states.merge! dep.name => gem.state(:check => dep)\n end\n states\n end",
"def power_state\n delegate(provider, :power_state)\n end",
"def known_states\n branch.known_states\n end",
"def states\n @finity.states.map { |name, _| name }\n end",
"def read_state(api, machine)\n\n return :not_created if machine.id.nil?\n\n serverid = machine.id\n begin\n response = api.get(\"/server/#{serverid}\")\n rescue Driver::NotFoundError\n machine.id = nil\n return :not_created\n end\n return response[\"Server\"][\"Instance\"][\"Status\"].to_sym\n end",
"def get_states\n perform(:get, 'enum/states', nil, nonauth_headers).body\n end",
"def show_state\n puts \"#{@name} a #{@life_points} de PV\"\n end",
"def basic_setup\n [\"FL\",\"IL\",\"NY\"].each do |state|\n ClosestWeightliftingGem::Scraper.scrape_state_page(state)\n end\nend",
"def state\n info[:state]\n end",
"def global_state \n @event_collector.global_state\n end",
"def setup(state) ; end",
"def state\r\n\t\t\t`#{BITS::BITSADMIN} /getstate {#{@id}}`\r\n\t\tend",
"def power_state\n response = client.exec(\"power status\")\n raise(ASM::Error, \"Invalid IPMI power status response: %s\" % response) unless response =~ /Chassis Power is\\s+(\\S+)/m\n\n state = $1.downcase\n raise(ASM::Error, \"Invalid IPMI power state %s; full response: %s\" % [state, response]) unless %w[on off].include?(state)\n\n logger.debug(\"Current power status: #{response}\")\n state.to_sym\n end",
"def human_readable_state\n hash = {}\n @state.dup.each do |c, v|\n hash[Dictionary.command_to_name(c).to_s] = (Dictionary.command_value_to_value_name(c, v) || v.to_s).to_s\n end\n hash\n end",
"def read_guest_tools_state\n state = read_settings.fetch('GuestTools', {}).fetch('state', nil)\n state ||= 'not_installed'\n state.to_sym\n end",
"def display_state(patientinfo)\n if patientinfo\n patientinfo.state\n end\n end",
"def show_state\n \tputs \"#{@name} a #{life_points} points de vie\"\n end",
"def show_state\n puts \"#{names} a #{life_points} points de vie\"\n end",
"def read_vm_state vmname\n full_name = \"#{File.basename __dir__}_#{vmname}\"\n cmd = VMSTATE_CMD_TEMPLATE % [full_name]\n output = `#{cmd}`\n\n if output =~ /^name=\"<inaccessible>\"$/\n return :inaccessible\n elsif output =~ /^VMState=\"(.+?)\"$/\n return $1.to_sym\n end\n\n nil\nend",
"def sibling_machines; end",
"def print_all_states\n STATE_DATA.each_key { |key|\n new_state = VirusPredictor.new(key, STATE_DATA[key][:population_density], STATE_DATA[key][:population])\n new_state.virus_effects\n }\n end",
"def feature_objects\r\n states\r\n end",
"def state\n end",
"def get_state(stemcell_list = nil, release_list = nil, deployment_list = nil)\n state = STATE_REMOTE_ONLY\n\n if File.exist?(bits_full_local_path_dl)\n state = STATE_DOWNLOADING\n end\n\n if File.exist?(bits_full_local_path) || Dir.exist?(bits_full_local_path)\n state = STATE_LOCAL\n end\n\n if @product.type == 'ucc'\n if $config[:version] == @version\n state = STATE_DEPLOYED\n end\n elsif @product.type == 'stemcell'\n found_on_bosh = ( stemcell_list || Uhuru::BoshCommander::Stemcell.new().list_stemcells).any? do |stemcell|\n (stemcell['name'] == @product.name) && (stemcell['version'] == @version)\n end\n\n if found_on_bosh\n state = STATE_AVAILABLE\n deployments = deployment_list || Deployment.get_director_deployments\n deployments.each do |deployment|\n deployment[\"stemcells\"].each do |stemcell|\n if (stemcell[\"name\"] == @product.name) &&\n (stemcell[\"version\"] == @version)\n state = STATE_DEPLOYED\n break\n end\n end\n if (state == STATE_DEPLOYED)\n break\n end\n end\n end\n\n elsif @product.type == 'software'\n if (state == STATE_LOCAL)\n bosh_releases = release_list || Uhuru::BoshCommander::Release.new().list_releases\n deployment_erb = File.read(File.join(bits_full_local_path, 'config', \"#{@product.name}.yml.erb\"))\n deployment_rendered = ERB.new(deployment_erb).result()\n deployment_yaml = YAML.load(deployment_rendered)\n\n releases = []\n if (deployment_yaml[\"release\"])\n releases << deployment_yaml[\"release\"]\n else\n deployment_yaml[\"releases\"].each do |release|\n releases << release\n end\n\n end\n\n releases.each do |release|\n bosh_releases.each do |bosh_release|\n if (bosh_release['name'] == release['name'])\n bosh_release['release_versions'].each do |release_version|\n if release_version['version'] == @version.to_s\n if (release_version['currently_deployed'])\n state = STATE_DEPLOYED\n else\n state = STATE_AVAILABLE\n end\n break\n end\n end\n end\n end\n if (state != STATE_DEPLOYED)\n break\n end\n end\n end\n end\n\n state\n end",
"def extra_state; end",
"def state_by_process(bp)\n state(:control_id => bp.controls)\n end",
"def read_state\n end",
"def state_objs; @_hegemon_states.clone; end",
"def printState(count,md,mq,ac)\n\tputs(count.to_s(2))\n\tputs(\"MD:\" + md.join)\n\tputs(\"AC:\" + ac.join)\n\tputs(\"MQ:\" + mq.join)\nend",
"def acquire_service_data\n if config[:tags] && config[:service]\n tags = config[:tags].split(',').to_set\n services = []\n Diplomat::Health.service(config[:service]).each do |s|\n if s['Service']['Tags'].to_set.superset? tags\n services.push(*s['Checks'])\n end\n end\n services\n elsif config[:nodename]\n data = []\n begin\n services = Diplomat::Node.get(config[:nodename]).Services\n rescue StandardError\n services = {}\n end\n services.each_value do |service|\n Diplomat::Health.checks(service['Service']).each do |check|\n data.push(check) if check.Node == config[:nodename]\n end\n end\n data\n elsif config[:all]\n Diplomat::Health.state('any')\n else\n Diplomat::Health.checks(config[:service])\n end\n end",
"def plus_state_set\n return []\n end",
"def available_states\n states = []\n states << :passive if passive?\n states << :pending if passive? || pending?\n states << :active\n states << :suspended unless deleted?\n states << :deleted\n states\n end",
"def state(params = {})\n response = client.get \"/_cluster/state{/metrics}{/indices}\", params.merge(action: \"cluster.state\", rest_api: \"cluster.state\")\n response.body\n end",
"def getstate(username)\n punchstate=''\n lastpunch = Punch.all(:username => username)\n if !lastpunch.last\n punchstate='IN'\n else\n if lastpunch.last.punchstate == 'IN'\n punchstate = 'OUT'\n else\n punchstate = 'IN'\n end\n end\n\n return punchstate\nend",
"def status\n short_state_str=SHORT_VM_STATES[state_str]\n\n if short_state_str=='actv'\n short_state_str=SHORT_LCM_STATES[lcm_state_str]\n end\n\n short_state_str\n end",
"def current_state(states)\n active_states = states.select { |_, v| v['status'] == 'active' }.keys\n states_depth = active_states.map { |state| state.split('/').length }\n active_states[states_depth.index(states_depth.max)]\n end",
"def diagnose\n result = Hash.new\n [:state_file, :driver, :provisioner, :busser].each do |sym|\n obj = send(sym)\n result[sym] = obj.respond_to?(:diagnose) ? obj.diagnose : :unknown\n end\n result\n end",
"def commands\n all = {\n 'clearev' => 'Clear the event log',\n 'drop_token' => 'Relinquishes any active impersonation token.',\n 'execute' => 'Execute a command',\n 'getpid' => 'Get the current process identifier',\n 'getprivs' => 'Attempt to enable all privileges available to the current process',\n 'getuid' => 'Get the user that the server is running as',\n 'getsid' => 'Get the SID of the user that the server is running as',\n 'getenv' => 'Get one or more environment variable values',\n 'kill' => 'Terminate a process',\n 'pkill' => 'Terminate processes by name',\n 'pgrep' => 'Filter processes by name',\n 'ps' => 'List running processes',\n 'reboot' => 'Reboots the remote computer',\n 'reg' => 'Modify and interact with the remote registry',\n 'rev2self' => 'Calls RevertToSelf() on the remote machine',\n 'shell' => 'Drop into a system command shell',\n 'shutdown' => 'Shuts down the remote computer',\n 'steal_token' => 'Attempts to steal an impersonation token from the target process',\n 'suspend' => 'Suspends or resumes a list of processes',\n 'sysinfo' => 'Gets information about the remote system, such as OS',\n 'localtime' => 'Displays the target system local date and time',\n }\n reqs = {\n 'clearev' => [\n COMMAND_ID_STDAPI_SYS_EVENTLOG_OPEN,\n COMMAND_ID_STDAPI_SYS_EVENTLOG_CLEAR\n ],\n 'drop_token' => [COMMAND_ID_STDAPI_SYS_CONFIG_DROP_TOKEN],\n 'execute' => [COMMAND_ID_STDAPI_SYS_PROCESS_EXECUTE],\n 'getpid' => [COMMAND_ID_STDAPI_SYS_PROCESS_GETPID],\n 'getprivs' => [COMMAND_ID_STDAPI_SYS_CONFIG_GETPRIVS],\n 'getuid' => [COMMAND_ID_STDAPI_SYS_CONFIG_GETUID],\n 'getsid' => [COMMAND_ID_STDAPI_SYS_CONFIG_GETSID],\n 'getenv' => [COMMAND_ID_STDAPI_SYS_CONFIG_GETENV],\n 'kill' => [COMMAND_ID_STDAPI_SYS_PROCESS_KILL],\n 'pkill' => [\n COMMAND_ID_STDAPI_SYS_PROCESS_KILL,\n COMMAND_ID_STDAPI_SYS_PROCESS_GET_PROCESSES\n ],\n 'pgrep' => [COMMAND_ID_STDAPI_SYS_PROCESS_GET_PROCESSES],\n 'ps' => [COMMAND_ID_STDAPI_SYS_PROCESS_GET_PROCESSES],\n 'reboot' => [COMMAND_ID_STDAPI_SYS_POWER_EXITWINDOWS],\n 'reg'\t => [\n COMMAND_ID_STDAPI_REGISTRY_LOAD_KEY,\n COMMAND_ID_STDAPI_REGISTRY_UNLOAD_KEY,\n COMMAND_ID_STDAPI_REGISTRY_OPEN_KEY,\n COMMAND_ID_STDAPI_REGISTRY_OPEN_REMOTE_KEY,\n COMMAND_ID_STDAPI_REGISTRY_CREATE_KEY,\n COMMAND_ID_STDAPI_REGISTRY_DELETE_KEY,\n COMMAND_ID_STDAPI_REGISTRY_CLOSE_KEY,\n COMMAND_ID_STDAPI_REGISTRY_ENUM_KEY,\n COMMAND_ID_STDAPI_REGISTRY_SET_VALUE,\n COMMAND_ID_STDAPI_REGISTRY_QUERY_VALUE,\n COMMAND_ID_STDAPI_REGISTRY_DELETE_VALUE,\n COMMAND_ID_STDAPI_REGISTRY_QUERY_CLASS,\n COMMAND_ID_STDAPI_REGISTRY_ENUM_VALUE,\n ],\n 'rev2self' => [COMMAND_ID_STDAPI_SYS_CONFIG_REV2SELF],\n 'shell' => [COMMAND_ID_STDAPI_SYS_PROCESS_EXECUTE],\n 'shutdown' => [COMMAND_ID_STDAPI_SYS_POWER_EXITWINDOWS],\n 'steal_token' => [COMMAND_ID_STDAPI_SYS_CONFIG_STEAL_TOKEN],\n 'suspend' => [COMMAND_ID_STDAPI_SYS_PROCESS_ATTACH],\n 'sysinfo' => [COMMAND_ID_STDAPI_SYS_CONFIG_SYSINFO],\n 'localtime' => [COMMAND_ID_STDAPI_SYS_CONFIG_LOCALTIME],\n }\n filter_commands(all, reqs)\n end",
"def _reservation_state(base)\n\t\t\t\t\t\n\t\t\t\t\t# Now\n\t\t\t\t\tnow = Time.current\n\t\t\t\t\t\n\t\t\t\t\t# States\n\t\t\t\t\treservation_states = config(:reservation_states)\n\n\t\t\t\t\t# Break times\n\t\t\t\t\tif config(:reservation_state_policy) == \"time_fixed\"\n\t\t\t\t\t\tbreak_times = []\n\t\t\t\t\t\treservation_states.reverse_each_with_index do |reservation_state_spec, index|\n\t\t\t\t\t\t\tif index != 0 # Do not consider first state\n\t\t\t\t\t\t\t\treservation_state_name = reservation_state_spec[:name]\n\t\t\t\t\t\t\t\ttime_fixed = self.send(\"time_fixed_#{reservation_state_name}\")\n\t\t\t\t\t\t\t\tif time_fixed\n\t\t\t\t\t\t\t\t\tbreak_times << time_fixed\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tbreak_times << break_times.last\n\t\t\t\t\t\t\t\tend\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\telse\n\t\t\t\t\t\tbreak_times = [base]\n\t\t\t\t\t\treservation_states.reverse_each_with_index do |reservation_state_spec, index|\n\t\t\t\t\t\t\tif index != 0 && index != (reservation_states.length - 1) # Do not consider first and last reservation_state\n\t\t\t\t\t\t\t\treservation_state_name = reservation_state_spec[:name]\n\t\t\t\t\t\t\t\ttime_window = self.send(\"time_window_#{reservation_state_name}\")\n\t\t\t\t\t\t\t\tif time_window\n\t\t\t\t\t\t\t\t\tbreak_times << (break_times.last - time_window.days_since_new_year.days - time_window.seconds_since_midnight.seconds)\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tbreak_times << break_times.last\n\t\t\t\t\t\t\t\tend\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\n\t\t\t\t\t# State recognititon\n\t\t\t\t\tresult_reservation_state = nil\n\t\t\t\t\tresult_reservation_state_behavior = nil\n\t\t\t\t\treservation_states.each_with_index do |reservation_state_spec, index|\n\t\t\t\t\t\tif index < reservation_states.length - 1\n\t\t\t\t\t\t\tif !break_times[reservation_states.length - 2 - index].nil? && now < break_times[reservation_states.length - 2 - index]\n\t\t\t\t\t\t\t\tresult_reservation_state = reservation_state_spec[:name].to_sym\n\t\t\t\t\t\t\t\tresult_reservation_state_behavior = reservation_state_spec[:behavior].to_sym\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\telse # Last fallback state\n\t\t\t\t\t\t\tresult_reservation_state = reservation_state_spec[:name].to_sym\n\t\t\t\t\t\t\tresult_reservation_state_behavior = reservation_state_spec[:behavior].to_sym\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\treturn [result_reservation_state, result_reservation_state_behavior]\n\t\t\t\tend",
"def get_possible_states\n raise \"This is an abstract function!\"\n end",
"def display ( )\n puts 'Parser states: ' + @states.size.to_s\n\n @states.each do |st|\n\tputs\n\tputs '*' * 80\n\tputs 'state: ' + st.statename\n\tputs 'branches: '\n\tst.branches.each do |br|\n\t puts ' ' + @states[br].statename\n\tend\n end\n end",
"def save_current_module(state_module)\n @@current_module = state_module['.module']\nend",
"def runtime_state?(sym); @runtime_states.include?(sym) end",
"def device_states_list\n get \"deviceStates\"\n end",
"def get_basic\n ver = [ 'version()', '@@version', '@@GLOBAL.VERSION' ]\n cdb = [ 'database()', '@@database', 'schema()', 'current_database()' ]\n usr = [ 'user()', 'system_user()', 'current_user()', 'session_user()' ]\n srvn = '@@hostname'\n dirz = [ '@@datadir', '@@basedir', '@@tmpdir' ]\n\n print_status(\"############### BASIC INFO ##################\")\n # Find Hostname of DB Server\n if @target_config['HOST'].nil?\n results = error_basic_inject(srvn)\n if results.nil? or results == ''\n print_error(\"Unable to determine Hostname!\")\n else\n @target_config['HOST'] = results\n print_good(\"Hostname: #{@target_config['HOST']}\")\n end\n else\n print_good(\"Hostname: #{@target_config['HOST']}\")\n end\n\n # Find Version of DB we are injecting\n if @target_config['VERSION'].nil?\n while(true)\n ver.each do |version|\n results = error_basic_inject(version)\n if not results.nil? and results != ''\n @target_config['VERSION'] = results\n print_good(\"Windows Backend OS Detected!\") if @target_config['VERSION'] =~ /-nt-log/\n print_good(\"Version: #{@target_config['VERSION']}\")\n break\n end\n end\n break\n end\n print_error(\"Unable to determine Version!\") if @target_config['VERSION'].nil?\n else\n print_good(\"Version: #{@target_config['VERSION']}\")\n end\n\n # Find Current Username\n if @target_config['USER'].nil?\n while(true)\n usr.each do |user|\n results = error_basic_inject(user)\n if not results.nil? and results != ''\n @target_config['USER'] = results\n print_good(\"Username: #{@target_config['USER']}\")\n break\n end\n end\n break\n end\n print_error(\"Unable to determine current Username!\") if @target_config['USER'].nil?\n else\n print_good(\"Username: #{@target_config['USER']}\")\n end\n\n # Find Current Database Name\n if @target_config['CURRENT_DB'].nil?\n while(true)\n cdb.each do |current_db|\n results = error_basic_inject(current_db)\n if not results.nil? and results != ''\n @target_config['CURRENT_DB'] = results\n print_good(\"Database: #{@target_config['CURRENT_DB']}\")\n break\n end\n end\n break\n end\n print_error(\"Unable to determine current database name!\") if @target_config['CURRENT_DB'].nil?\n else\n print_good(\"Database: #{@target_config['CURRENT_DB']}\")\n end\n\n # Find Directory Information (Datadir, basedir, tmpdir)\n while(true)\n dirz.each do |dirpath|\n results = error_basic_inject(dirpath)\n case dirpath\n when '@@basedir'\n if @target_config['BASEDIR'].nil?\n if results.nil?\n print_error(\"Unable to determine basedir!\")\n else\n @target_config['BASEDIR'] = results\n print_good(\"Basedir: #{@target_config['BASEDIR']}\")\n end\n else\n print_good(\"Basedir: #{@target_config['BASEDIR']}\")\n end\n when '@@datadir'\n if @target_config['DATADIR'].nil?\n if results.nil?\n print_error(\"Unable to determine datadir!\")\n else\n @target_config['DATADIR'] = results\n print_good(\"Datadir: #{@target_config['DATADIR']}\")\n end\n else\n print_good(\"Datadir: #{@target_config['DATADIR']}\")\n end\n when '@@tmpdir'\n if @target_config['TMPDIR'].nil?\n if results.nil?\n print_error(\"Unable to determine tmpdir!\")\n else\n @target_config['TMPDIR'] = results\n print_good(\"Tmpdir: #{@target_config['TMPDIR']}\")\n end\n else\n print_good(\"Tmpdir: #{@target_config['TMPDIR']}\")\n end\n end\n end\n break\n end\n print_status(\"#############################################\")\n end",
"def fetch_node_manager_states\n states = {}\n @zk.children(current_state_root).each do |child|\n full_path = \"#{current_state_root}/#{child}\"\n begin\n states[child] = symbolize_keys(decode(@zk.get(full_path).first))\n rescue ZK::Exceptions::NoNode\n # ignore, this is an edge case that can happen when a node manager\n # process dies while fetching its state\n rescue => ex\n logger.error(\"Failed to fetch states for #{full_path}: #{ex.inspect}\")\n end\n end\n states\n end",
"def user_state_summary\n return @user_state_summary\n end",
"def state_names\n @names = Set.new\n @names.merge machine.states\n @names.merge [ANY_STATE, ANY_STATE_HOOK]\n end",
"def get_metadata\n get_state.map do |get_state_resp|\n metadata = get_state_resp.dig(:data, :identity_state, :metadata)\n if metadata\n metadata.transform_values { |val| Utils.parse_string_or_byte_val(val) }\n else\n metadata\n end\n end\n end",
"def get_choices\n puts \"Welcome to BrewStats!\"\n BrewStats::Scraper.scrape_ba\n @states = BrewStats::States.all\n end",
"def access_state_data\n STATE_DATA.each do |state, population_hash|\n VirusPredictor.new(state, population_hash[:population_density], population_hash[:population]).virus_effects\n end\nend",
"def status\n short_state_str=SHORT_VM_STATES[state_str]\n\n if short_state_str==\"actv\"\n short_state_str=SHORT_LCM_STATES[lcm_state_str]\n end\n\n short_state_str\n end"
] |
[
"0.61121684",
"0.6091551",
"0.5943058",
"0.5943058",
"0.5943058",
"0.5818758",
"0.56549346",
"0.56186575",
"0.55920625",
"0.55516225",
"0.5538549",
"0.5525389",
"0.5467259",
"0.5465247",
"0.54560184",
"0.5447231",
"0.5428945",
"0.54145753",
"0.53945524",
"0.5363011",
"0.5359675",
"0.5353452",
"0.53430617",
"0.53379804",
"0.532463",
"0.5314112",
"0.5309499",
"0.52953154",
"0.5265922",
"0.5249035",
"0.5229795",
"0.5225394",
"0.5217607",
"0.52110213",
"0.52070546",
"0.51995856",
"0.5198786",
"0.5189127",
"0.5161118",
"0.51510346",
"0.5147928",
"0.5142104",
"0.51184624",
"0.5109064",
"0.5101491",
"0.5088547",
"0.50854",
"0.50854",
"0.5073604",
"0.505119",
"0.50498563",
"0.5045991",
"0.5024898",
"0.50206393",
"0.5015624",
"0.49973676",
"0.49927396",
"0.498957",
"0.49886942",
"0.49809673",
"0.49605703",
"0.49373057",
"0.49318233",
"0.49304512",
"0.49236757",
"0.49173355",
"0.49166673",
"0.49149626",
"0.49129787",
"0.49089164",
"0.4905605",
"0.48990744",
"0.48971504",
"0.4895624",
"0.4895075",
"0.48878857",
"0.4886168",
"0.48814157",
"0.48808894",
"0.48796183",
"0.48741892",
"0.48702854",
"0.4870248",
"0.48685494",
"0.48623633",
"0.48610273",
"0.4854219",
"0.4849542",
"0.48469067",
"0.48453796",
"0.48440322",
"0.4843223",
"0.48387623",
"0.4837829",
"0.48337498",
"0.483309",
"0.48294955",
"0.48280075",
"0.48251238",
"0.48215848"
] |
0.71150595
|
0
|
example: get_saltstack_package_full_name('7zip') = '7Zip'
|
def get_saltstack_package_full_name(package)
# pillar = YAML.safe_load(File.read('test/salt/pillar/windows.sls'))
url = 'https://raw.githubusercontent.com/saltstack/salt-winrepo-ng/master/'
files = [package + '.sls', package + '/init.sls']
# example: package = "7zip"=>{"version"=>"18.06.00.0", "refresh_minion_env_path"=>false}
saltstack_package_full_name = files.find do |checkme|
ps = "$f = (((Get-ChildItem -Path $env:LOCALAPPDATA -Filter 'salt-winrepo-ng' -Recurse -Directory).Fullname[0]) + '\\#{checkme.sub('/', '\\')}'); if (Test-Path $f -PathType Leaf) {Get-Content -Path $f}"
begin
file = (open(url + checkme) & :read)
rescue
begin
file = (powershell(ps).stdout)
rescue
next
end
end
unless file.nil? || file.empty?
candidate = file.match(/full_name: '([\S]+).*'/).captures[0]
end
break candidate unless candidate.nil?
end
Inspec::Log.debug('[get_saltstack_package_full_name] found candidate: ' + saltstack_package_full_name)
saltstack_package_full_name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def package_name\n name = package_drop_last(slug_parts)\n name.empty? ? '_root_' : name\n end",
"def package_name\n # TODO: verify renamed packages\n resource['title']\n end",
"def full_name\n \"#{@package}.#{parameterized_name}\"\n end",
"def package_name\n @version ? \"#{@name}-#{@version}\" : @name\n end",
"def package_name\n @package_name ||=\n Pathname(\"#{cartage.final_name}.tar#{cartage.tar_compression_extension}\")\n end",
"def package_basename(extension='.gem')\n [ package_name, version ].join('-') + extension\n end",
"def package_name(val = NULL_ARG)\n @package_name = val unless val.equal?(NULL_ARG)\n @package_name.nil? ? @name : @package_name\n end",
"def fmri_package_name\n version = project.build_version.split(/[^\\d]/)[0..2].join(\".\")\n platform = Ohai[\"platform_version\"]\n \"#{safe_base_package_name}@#{version},#{platform}-#{project.build_iteration}\"\n end",
"def package_name\n [self.config.organization, self.config.project_name].compact.collect(&:underscore).join('-')\n end",
"def fully_qualified_name\n return \".#{self.package}\"\n end",
"def package_name(val = NULL)\n if null?(val)\n @package_name || name\n else\n @package_name = val\n end\n end",
"def gem_name\n \"#{@account}-#{@name}\"\n end",
"def package_name\n ver = if new_resource.version == 'latest'\n package_metadata[:version]\n else\n new_resource.version\n end\n \"Chef Development Kit v#{ver}\"\n end",
"def full_name\n if platform == Gem::Platform::RUBY or platform.nil? then\n \"#{name}-#{version}\".untaint\n else\n \"#{name}-#{version}-#{platform}\".untaint\n end\n end",
"def package_name\n raise Puppet::Error, 'luet requires packages have a category set' unless @resource[:category]\n\n \"#{@resource[:category]}/#{@resource[:name]}\"\n end",
"def display_name\n return name unless %w(maven gradle).include?(package_manager)\n name.split(\":\").last\n end",
"def full_name\n if platform == Gem::Platform::RUBY or platform.nil?\n \"#{name}-#{version}\".dup.tap(&Gem::UNTAINT)\n else\n \"#{name}-#{version}-#{platform}\".dup.tap(&Gem::UNTAINT)\n end\n end",
"def package_name(project)\n \"#{project.name}-#{project.version}-#{project.release}.#{@architecture}.pkg.gz\"\n end",
"def get_pkg_name(candidate_tag=nil, distro=nil)\n prod_name = self.task.prod\n\n # FIXME: stop that hardcoding... one day!\n pkg_name = self.name\n\n distro = self.task.distros[0] if distro.nil?\n\n is_scl_package = MeadSchedulerService.is_scl_package?(prod_name, self.name)\n # different naming convention for different products\n if prod_name == \"eap6\" && distro == 'el7' && is_scl_package\n pkg_name = \"#{prod_name}-\" + pkg_name.sub(/-#{prod_name}$/, '')\n\n # Only enable scl thing for RHEL distros, aka when distro = el_\n elsif is_scl_package && distro.match(/^el/)\n pkg_name = \"#{prod_name}-\" + pkg_name.sub(/-#{prod_name}$/, '')\n end\n pkg_name\n end",
"def vendored_package_name(package)\n\tFile.join($package_name, 'vendor/src', package)\nend",
"def split_name_package(fullname)\n fixing = fullname.gsub(/:/, \".\")\n split = fixing.match(/^(?:((?:\\w+\\.?)*)\\.)?(\\w+)$/) || []\n name = split[2] || \"\"\n package = split[1] || \"\"\n # downcase the first letter of each package name\n package = package.split(\".\").map {|s| s[0].downcase+s[1..-1]}.join(\".\")\n [name, package]\n end",
"def package_name\n raise NotImplementedError\n end",
"def safe_base_package_name\n if project.package_name =~ /\\A[a-z0-9\\.\\+\\-]+\\z/\n project.package_name.dup\n else\n converted = project.package_name.downcase.gsub(/[^a-z0-9\\.\\+\\-]+/, \"-\")\n\n log.warn(log_key) do\n \"The `name' component of IPS package names can only include \" \\\n \"lowercase alphabetical characters (a-z), numbers (0-9), dots (.), \" \\\n \"plus signs (+), and dashes (-). Converting `#{project.package_name}' to \" \\\n \"`#{converted}'.\"\n end\n converted\n end\n end",
"def full_name\n \"#{@name}-#{@version}\"\n end",
"def manifest_name(name, pack_type)\n name.chomp(\".#{pack_type}\")\n end",
"def guess_package_name(gem_name, args)\n package_name = nil\n package_name ||= guess_package_name_from_args(gem_name, args)\n package_name ||= guess_package_name_from_environment\n package_name ||= guess_package_name_from_appfile\n package_name ||= guess_package_name_from_config_files\n package_name\n end",
"def gem_name\n @gem_name ||= @source_path.sub_ext(\"\").basename.to_s\n end",
"def manifest_name(name, pack_type)\n return name if File.extname(name.to_s).empty?\n File.basename(name, \".#{pack_type}\")\n end",
"def manifest_name(name, pack_type)\n return name if File.extname(name.to_s).empty?\n File.basename(name, \".#{pack_type}\")\n end",
"def manifest_name(name, pack_type)\n return name if File.extname(name.to_s).empty?\n File.basename(name, '.' + pack_type)\n end",
"def package_name\n if supports_ports?\n if makefile_variable_value(\"PKGNAME\", port_path) =~ /^(.+)-[^-]+$/\n $1\n else\n raise Chef::Exceptions::Package, \"Unexpected form for PKGNAME variable in #{port_path}/Makefile\"\n end\n else\n new_resource.package_name\n end\n end",
"def debian_name(pkg)\n if pkg.kind_of?(Autoproj::RubyPackage)\n debian_ruby_name(pkg.name)\n else\n \"rock-\" + canonize(pkg.name)\n end\n end",
"def package_name(buildno=nil)\n if buildno\n buildno = Time.now.strftime(\"%H*60+%M\")\n versnum = \"#{version}.#{buildno}\"\n else\n versnum = version\n end\n\n if platform\n \"#{name}-#{versnum}-#{platform}\"\n else\n \"#{name}-#{versnum}\"\n end\n end",
"def file_name\n \"#{full_name}.gem\"\n end",
"def hadoop_package(name)\n return name unless hdp22?\n return name if node['platform_family'] == 'debian'\n fw = name.split('-').first\n pv = hdp_version.tr('.', '_').tr('-', '_')\n nn = \"#{fw}_#{pv}\"\n name.gsub(fw, nn)\n end",
"def getsfLma__PackageObjName\r\n\t\t\treturn \"sfLma__Package__c\"\r\n\t\tend",
"def dmg_package_app\n case new_resource.source\n when :direct\n ::File.basename(package_metadata[:url], '.dmg')\n else\n ::File.basename(new_resource.source.to_s, '.dmg')\n end\n end",
"def fully_qualified_java_name\n return [\n present?(java_package) ? java_package : nil,\n present?(java_outer_classname) ? java_outer_classname : nil\n ].compact.join('.')\n end",
"def package_filename\n \"#{@package.name}_#{@package.version}_#{@package.architecture}.deb\"\n end",
"def get_app_name(app_name)\n app_file = $pkg_dir+\"/\"+app_name.downcase.gsub(/ |-/,'_')+\".rb\"\n if File.exist?(app_file)\n app_name = eval(\"get_#{app_name.downcase.gsub(/ |-/,'_')}_app_name()\")\n else\n app_list = Dir.entries($pkg_dir)\n tmp_name = app_list.grep(/^#{app_name.downcase.gsub(/ |-/,'_')}/)[0]\n if tmp_name\n tmp_name = tmp_name.gsub(/\\.rb/,\"\")\n else\n puts\n end\n if tmp_name =~ /[A-z]/\n if $verbose == 1\n puts \"Application profile \"+app_name+\" not found\"\n puts \"Found profile \"+tmp_name\n end\n app_name = eval(\"get_#{tmp_name.downcase.gsub(/ |-/,'_')}_app_name()\")\n else\n puts \"Application \"+app_name+\" not found\"\n puts\n puts \"Available Applications:\"\n puts\n print_avail_pkgs()\n puts\n exit\n end\n end\n return app_name\nend",
"def fully_qualified_ruby_name\n return \"::#{self.package.gsub('.', '::')}\"\n end",
"def getStackName(stack)\n stack_name = MU.deploy_id + \"-\" + stack.upcase\n stack_name.gsub!(/[_\\.]/, \"-\")\n return stack_name\n end",
"def full_name\n name_tuple.full_name\n end",
"def infer_package(names)\n # Package is longest common prefix ending in '.', if any.\n if not names.empty?\n min, max = names.minmax\n last_common_dot = nil\n min.size.times { |i|\n if min[i] != max[i] then break end\n if min[i] == \".\" then last_common_dot = i end\n }\n if last_common_dot\n return min.slice(0, last_common_dot)\n end\n end\n\n nil\n end",
"def full_name repo\n \"#{repo.owner.login}/#{repo.name}\"\n end",
"def get_setuptools\n\t\tpackage_name = \"python-setuptools\"\n\t\tcase node.platform\n\t\twhen /fedora|redhat|centos|ubuntu/\n\t\t package_name = \"python-setuptools\"\n\t\tend\n\t\tpackage_name\n\tend",
"def full_module_name\n self.class.ndx_full_module_names([id_handle]).values.first\n end",
"def find_gem_name(base)\n spec = Dir[File.join(base, '*.gemspec')].first\n File.basename(spec, '.gemspec') if spec\n end",
"def shortName\n name = @dir_ent['name'][0, 8].strip\n ext = @dir_ent['name'][8, 3].strip\n name += \".\" + ext if ext != \"\"\n return name\n end",
"def package_from_name\n case name.downcase\n when 'splunk' then package :splunk\n when 'universal_forwarder' then package :universal_forwarder\n else raise 'Package must be specified (:splunk or :universal_forwarder)'\n end\n end",
"def prefixed_label(package)\n label = ( package =~ /^#{$prefix}(.*)$/ ) && $1 || package\n label = '.' if label.empty?\n label\nend",
"def fully_qualified_wire_name\n return java_package\n end",
"def full_name\n return \"#{origin_name.nil? ? \"?\" : origin_name}.#{item_name}\"\n end",
"def determine_google_package\n return (google_package || self.class.to_s.split('::').last.downcase)\n end",
"def full_name\n if namespace\n \"#{namespace}#{SEPARATOR}#{name}\"\n else\n \"#{name}\"\n end\n end",
"def fix_name(name)\n if name.start_with?(\"python\")\n # If the python package is called \"python-foo\" strip the \"python-\" part while\n # prepending the package name prefix.\n return [attributes[:python_package_name_prefix], name.gsub(/^python-/, \"\")].join(\"-\")\n else\n return [attributes[:python_package_name_prefix], name].join(\"-\")\n end\n end",
"def package_name\n raise AbstractMethod.new(\"#{self.class.name}#package_name\")\n end",
"def full_name\n '(unknown)'\n end",
"def short\n return '' if name == domain.name\n return '' if name.blank?\n\n File.basename(name, \".#{domain.name}\")\n end",
"def bundle_name; bundle.bundle_name; end",
"def module_name\n root? ? nil : @name.camelize\n end",
"def gem_name\n @gem_name ||= \"sprout-#{clean_name}-library\"\n end",
"def gem_name\n @specification.name\n end",
"def fullname\n self.class.fullname(realm, sys, subsys)\n end",
"def gen_fullname(gem)\n \"#{gem[0]}-#{gem[1].version}#{\"-#{gem[2]}\" if gem[2] != \"ruby\"}\"\nend",
"def name\n @name ||= Dir['*.gemspec'].first.split('.').first\nend",
"def name\n @name ||= Dir['*.gemspec'].first.split('.').first\nend",
"def name\n @name ||= Dir['*.gemspec'].first.split('.').first\nend",
"def name\n @name ||= Dir['*.gemspec'].first.split('.').first\nend",
"def full_name\n if @prefix != \"\"\n File.join(@prefix, @name)\n else\n @name\n end\n end",
"def path_from_package(package_name)\n ret = package_from_name package_name\n ret && ret.root_path\n end",
"def hadoop_package(name)\n return name unless hdp22? || iop?\n return name if node['platform_family'] == 'debian'\n fw =\n if name == 'spark-core'\n name\n else\n name.split('-').first\n end\n pv =\n if hdp22?\n hdp_version.tr('.', '_').tr('-', '_')\n else\n node['hadoop']['distribution_version'].tr('.', '_')\n end\n nn = \"#{fw}_#{pv}\"\n name.gsub(fw, nn)\n end",
"def full_name\n \"#{spec.name}-#{spec.version}\"\n end",
"def key_for_package(pkg)\n if !pkg.id.nil?\n \"#{pkg.id}-#{@name}\"\n else\n return \"#{pkg.categories.split.first}/#{pkg.name}-#{@name}\"\n end\n end",
"def short_name\n short.to_s.sub(/^(-.).*$/, \"\\\\1\")\n end",
"def native_pkg_to_install_string(pkg)\n name = pkg[:metadata][:name]\n version = pkg[:metadata][:version]\n package_version = pkg[:metadata][:package_version]\n pkgname = \"#{name}-#{version}\"\n if package_version\n pkgname << \"-#{package_version}\"\n end\n pkgname\n end",
"def rest_name\n short_name.downcase\n end",
"def main_name(path)\n File.basename(path).sub(/\\.[^\\.]+$/,'')\n end",
"def key\n \"gem-package-#{name}\"\n end",
"def full_name\n \"#{ owner }/#{ name }\" if owner && name\n end",
"def get_output_filename(basename)\n package_path_base = File.basename(@package_path)\n filename = File.join(package_path_base, \"#{basename}.zip\")\n\n i = 1\n while File.exists?(filename)\n filename = File.join(package_path_base, \"#{basename}(#{i}).zip\")\n i += 1\n end\n\n filename\n end",
"def full_name\n @relative_name\n end",
"def full_name\n @relative_name\n end",
"def get_full_name\n \"#{name} (#{description})\"\n end",
"def get_full_name\n description.to_s\n end",
"def get_satellite_eyes_app_name()\n app_name = \"Satellite Eyes\"\n return app_name\nend",
"def current_package\n @current_package\n end",
"def name\n\t\tmodule_info['Name']\n\tend",
"def base()\n sub_ext('').basename.to_s\n end",
"def default_dev_package\n # Check for an override.\n return dev_package_overrides[package_name] if dev_package_overrides.include?(package_name)\n suffix = node.value_for_platform_family(debian: '-dev', rhel: '-devel', fedora: '-devel')\n # Platforms like Arch and Gentoo don't need this anyway. I've got no\n # clue how Amazon Linux does this.\n if suffix\n package_name + suffix\n else\n nil\n end\n end",
"def resolve_name(recipe_reference)\n resolved_name = nil # will return nil if can't resolve\n possible_name = recipe_reference.strip\n if possible_name[-1..-1] == '+'\n # okay lets see what recipes fit the bill\n recipe_pattern = \"^#{possible_name[0..-2]}\"\n possible_recipes = search(recipe_pattern)\n if possible_recipes.length > 0\n # get the latest version\n latest_name = possible_recipes.sort.reverse[0]\n # is it later then whats wanted?\n if latest_name > possible_name\n resolved_name = latest_name\n end\n end\n else # okay the name is good but does it exist?\n resolved_name = possible_name if File.exists?(File.join(Settings.catalog_dir, possible_name))\n end\n return resolved_name\n end",
"def package_from_name(package_name)\n return self if package_name == self.name\n local_deps.find { |pkg| pkg.name == package_name }\n end",
"def get_full_name\n get_receipt_code()\n end",
"def module_name(module_path)\n dir_name = File.dirname(module_path)\n base_name = File.basename(module_path, '.*')\n dir_name == '.' ? base_name.camelize : \"#{dir_name}/#{base_name}\".camelize\n end",
"def full_name\n get_attribute(Yoti::Attribute::FULL_NAME)\n end",
"def resolve_name(reference)\n resolved_name = nil # will return nil if can't resolve\n possible_name = reference.strip\n if File.exists?(File.join(Settings.resource_dir, possible_name))\n resolved_name = possible_name\n else \n #if possible_name[-1..-1] == '+'\n # okay lets see what recipes fit the bill\n pattern = \"#{possible_name}*\"\n possiblities = search(pattern)\n if possiblities.length > 0\n # get the latest version\n latest_name = possiblities.sort.reverse[0]\n # is it later then whats wanted?\n if latest_name > possible_name\n resolved_name = latest_name\n #puts \"Using best match...#{resolved_name}\" if Settings.opt_verbose\n end\n end\n #else # okay the name is good but does it exist?\n # resolved_name = possible_name if File.exists?(File.join(Settings.catalog_dir, possible_name))\n #end\n end\n return resolved_name\n end",
"def full_name\n name\n end",
"def extract_full_name(object)\n extract_string object, :full_name\n end",
"def get_full_name\n description\n end",
"def my_short_name\n @my_short_name ||= self.class.name.split(\"_\").last\n end"
] |
[
"0.758345",
"0.7460569",
"0.72973734",
"0.7297259",
"0.727296",
"0.7171976",
"0.68556035",
"0.682097",
"0.6756436",
"0.67478067",
"0.6664091",
"0.6590872",
"0.6589945",
"0.6572884",
"0.6560001",
"0.6554045",
"0.6530854",
"0.65306455",
"0.643837",
"0.6425542",
"0.6397732",
"0.6393766",
"0.63631237",
"0.6330497",
"0.6309664",
"0.62924784",
"0.62649053",
"0.62228566",
"0.62228566",
"0.62131524",
"0.6160239",
"0.61533725",
"0.6143704",
"0.6125904",
"0.6091895",
"0.60505533",
"0.60458475",
"0.604425",
"0.60247135",
"0.6022473",
"0.60159075",
"0.60074997",
"0.59997165",
"0.5994906",
"0.59686154",
"0.5961248",
"0.5960598",
"0.59445924",
"0.5940157",
"0.59301096",
"0.59249187",
"0.5918504",
"0.59112984",
"0.5875395",
"0.5859366",
"0.584788",
"0.584682",
"0.58447963",
"0.5791116",
"0.57902235",
"0.57892203",
"0.57759655",
"0.5756303",
"0.574867",
"0.5740898",
"0.57383406",
"0.57383406",
"0.57383406",
"0.57383406",
"0.5737268",
"0.57340276",
"0.57167995",
"0.570994",
"0.5708795",
"0.5702451",
"0.5695069",
"0.569494",
"0.5685321",
"0.567548",
"0.56726587",
"0.56562424",
"0.56532854",
"0.56532854",
"0.56495494",
"0.5648786",
"0.5644881",
"0.5639984",
"0.5639334",
"0.56341046",
"0.56315553",
"0.5626862",
"0.5625207",
"0.56244934",
"0.56231385",
"0.5620451",
"0.5619555",
"0.5618768",
"0.56147265",
"0.56112444",
"0.56081045"
] |
0.8239686
|
0
|
Override in your tests if needed
|
def modulepath
[RSpec.configuration.module_path]
rescue NoMethodError
raise "RSpec.configuration.module_path not defined set up rspec puppet or define modulepath for this test"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def spec; end",
"def spec; end",
"def testing\n # ...\n end",
"def should; super end",
"def self_test; end",
"def self_test; end",
"def private; end",
"def __dummy_test__\n end",
"def before_setup; end",
"def default_test\r\n end",
"def before_test(test); end",
"def before_test(test); end",
"def default_test\n end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def default_test; end",
"def test_defaults\n end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def tests; end",
"def tests; end",
"def before_assert\n end",
"def test_entry\n raise \"Implement this method in your test class\"\n end",
"def setup\n # override this if needed\n end",
"def test_entry_attrs\n raise \"Implement this method in your test class\"\n end",
"def default_test\n end",
"def test_method\n end",
"def test_setup\r\n \r\n end",
"def default_test\n end",
"def default_test\n end",
"def running_test_case; end",
"def test_case; end",
"def test_legacy\n # Set up legacy handlers\n setup_legacy_handling\n\n common_tests\n end",
"def before() ; end",
"def my_tests\n end",
"def before_run; end",
"def setup\n # override and do something appropriate\n end",
"def default_test\n info \"self: #{self}\"\n end",
"def test_entry_attrs\n raise 'Implement the method \"test_entry_attrs\" in your test class'\n end",
"def implementation; end",
"def implementation; end",
"def test_entry\n raise 'Implement the method \"test_entry\" in your test class'\n end",
"def overrides; end",
"def before; end",
"def test_hack\n assert(true)\n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def before() nil ; end",
"def custom; end",
"def custom; end",
"def setup\n #implement in subclass;\n end",
"def assertions; end",
"def assertions; end",
"def test_nothing\n end",
"def setup\n\n end",
"def setup\n\n end",
"def setup\n\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup; end",
"def before\n end",
"def implement_me\n flunk('Test not yet implemented.')\n end",
"def expected_method; end",
"def teardown\n super\n end",
"def teardown\n super\n end",
"def teardown\n super\n end",
"def graffiti_test\n end",
"def test_0_dummy\n\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def test_connection\n end",
"def setup\n raise NotImplementedError\n end",
"def test_legacy_helpers\n assert_equal @patron.primary_phone, @patron.primary_address_phone\n assert_equal @patron.secondary_phone, @patron.secondary_address_phone\n assert_nil @patron.primary_address_mobile_phone\n assert_nil @patron.secondary_address_mobile_phone\n end"
] |
[
"0.70830095",
"0.70830095",
"0.6994145",
"0.693958",
"0.69186485",
"0.69186485",
"0.69038844",
"0.6884993",
"0.6625571",
"0.65979177",
"0.65878195",
"0.65878195",
"0.6540236",
"0.6529807",
"0.6529807",
"0.6529807",
"0.6529807",
"0.6515239",
"0.6511668",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.65021324",
"0.6445678",
"0.6445678",
"0.6438662",
"0.6433083",
"0.64296126",
"0.6418013",
"0.64135724",
"0.63410985",
"0.6336851",
"0.631612",
"0.631612",
"0.6276156",
"0.62725395",
"0.6270802",
"0.62463164",
"0.62183857",
"0.61984366",
"0.61960655",
"0.61864513",
"0.6185712",
"0.6169082",
"0.6169082",
"0.6166954",
"0.61617",
"0.61507964",
"0.6150318",
"0.6144747",
"0.6144747",
"0.6144747",
"0.6144747",
"0.6144747",
"0.6144747",
"0.6144747",
"0.6113306",
"0.6092373",
"0.6092373",
"0.6091857",
"0.607181",
"0.607181",
"0.60691977",
"0.60687274",
"0.60687274",
"0.60687274",
"0.60229135",
"0.60229135",
"0.60229135",
"0.60229135",
"0.60229135",
"0.60229135",
"0.60194737",
"0.60179526",
"0.6001577",
"0.5999842",
"0.59935147",
"0.59935147",
"0.59935147",
"0.59836584",
"0.59689707",
"0.596749",
"0.596749",
"0.5963808",
"0.5958941",
"0.59582984"
] |
0.0
|
-1
|
Overrides inventory for tests.
|
def inventory_data
{}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def inventory=(value)\n @inventory = value\n end",
"def expected_inventory\n result = @inventory.dup\n # TODO DRY this up with `Person#eat`\n result[:fish] -= @daily_appetite = 10\n result\n end",
"def available_inventory\n return self.inventory\n end",
"def initialize\n #each item has name and inventory number\n @inventory_list = {strawberry: 6, raspberry: 4, blueberry: 8}\n end",
"def inventory\n\t\tputs \"Items: #{@player.getItemsName}\" \n\t\tputs \"Food: #{@player.getFoodName}\" \n\tend",
"def inventory_data\n YAML.load_file(File.expand_path('spec/fixtures/inventory.yaml'))\n end",
"def withInventory\n\t\t@inventoryItems = Item.where(:inventory > 0)\n\tend",
"def inventory\n unless defined?(@inventory)\n @inventory = Puppet::SSL::Inventory.new\n end\n @inventory\n end",
"def inventory()\n\t\tInventory.new(@db, 'sgt-structure:' + @id + ':inv')\n\tend",
"def available_inventory\n object.check_inventory\n end",
"def inventory_unit1\n Spree::InventoryUnit.new(variant: variant1)\n end",
"def inventory\n return @inventory\n end",
"def process_inventory\n inventory = { 'all' => { 'hosts' => {} } }\n jack.each(kind: 'system') do |system|\n if options[:use_ip]\n iface = jack.fetch(kind: 'ipv4_interface',\n all?: { 'net.dns.fqdn' => system['net.dns.fqdn'] })\n ip = { 'ansible_host' => iface['net.ipv4.address'] }\n else\n ip = nil\n end\n inventory['all']['hosts'][system['net.dns.fqdn']] = ip\n end\n inventory\n end",
"def inventory\n @inventory = Portal2Inventory.new(steam_id64) if @inventory.nil?\n @inventory\n end",
"def build_inventory\n add_to_inventory(\"cats\", 4, 50.0)\n add_to_inventory(\"dogs\", 10, 150.0)\n add_to_inventory(\"unicorn\", 1, 1000.0)\nend",
"def set_item_inventory\n @item_inventory = ItemInventory.find(params[:id])\n end",
"def inventory()\n\tputs \"Je hebt de volgende items:\"\n\tputs @inventory\nend",
"def load_inventory(first)\n first ? setup_inventory : restore_inventory\n log(RuneRb::GLOBAL[:COLOR].green(\"Loaded Inventory for #{RuneRb::GLOBAL[:COLOR].yellow(@profile.name)}\")) if RuneRb::GLOBAL[:DEBUG]\n end",
"def inventory_path\n if config.inventory_path\n config.inventory_path\n else\n @inventory_path ||= generate_inventory\n end\n end",
"def inventory(techno_id=0)\n init\n\n # ensure requirements\n error(\"No vms for #{@user[:email]}\") if @vms.empty?\n\n # filter: only running vm\n vms_run = @vms.select { |vm| vm[:status].to_i > 1 }\n\n begin\n open('inventory', 'w') do |f|\n vms_run.sort_by {|v| v[:id]}.reverse.each do |vm|\n matchgroup = 0\n\n vm[:technos].each do |t|\n matchgroup = 1 if techno_id == t\n end\n next if matchgroup == 0\n\n # if os is xenial, => python2.7\n python = '/usr/bin/python'\n f << \"#{vm[:id]} ansible_ssh_host=#{vm[:floating_ip]} ansible_ssh_user=modem ansible_ssh_private_key_file=~/.ssh/id_rsa ansible_python_interpreter=#{python}\\n\"\n end\n end\n rescue\n error(\"Create inventory file failed\")\n end\n end",
"def display_inventory\n system('clear')\n inventory = self.items\n if inventory.count == 0\n puts \"Your inventory is empty.\"\n else \n inventory.reload.map do |item|\n puts \"#{item.name}: #{item.description}\"\n end\n end\n end",
"def inventory\n\tputs \"you have the following items: \"\n\tputs @inventory\nend",
"def initialize (name)\n\t\t@name = name\n\t\t@inventory = {}\n\tend",
"def unequip!\n self.slot = EquipSlot::Inventory\n self.save!\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def test_check_inventory\n # Create a cart and add some products.\n a_cart = Order.new\n a_cart.add_product(items(:red_lightsaber), 2)\n a_cart.add_product(items(:blue_lightsaber), 4)\n assert_equal a_cart.items.length, 2\n \n an_out_of_stock_product = items(:red_lightsaber)\n assert an_out_of_stock_product.update_attributes(:quantity => 1)\n \n # Assert that the product that was out of stock was removed.\n removed_products = a_cart.check_inventory\n assert_equal removed_products, [an_out_of_stock_product.name]\n\n # Should last the right quantity of the rest.\n assert_equal a_cart.items.length, 1\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def show_inventory\n puts \"The following items are currently held in inventory:\n\n #{@inventory}\"\nend",
"def print_inventory\n print \"Current gold in pouch: #{@gold}.\\n\\n\"\n\n if @inventory.empty?\n print \"#{@name}'s inventory is empty!\\n\\n\"\n return\n end\n\n puts \"#{@name}'s inventory:\"\n @inventory.each do |couple|\n puts \"* #{couple.first.name} (#{couple.second})\"\n end\n print \"\\n\"\n end",
"def sync_inventory\n\t\t@inv \t\t\t= Redis::HashKey.new('inventory') if @inv.blank?\t\t# new is a \"new\" connection to Redis, not new :)\n\t\tself.quantity \t= @inv[self.name]\t\t\t\t\t\t\t\t\t\t# self.quantity = inventory[\"#{self.name}\"]\n\tend",
"def assign_inventory_item\n self.inventory_item ||= inventory.item_by_product_and_code(product, lot_code)\n self\n end",
"def items\n if @inventory\n return @inventory.items\n else\n return []\n end\n end",
"def add_item(inventory, item, quantity)\n\tinventory[item] = quantity\n\t@full_inventory = inventory\n\t#this is what updates your inventory with the new item & quantity.\nend",
"def list_inventory\n\n # print the table header\n @gc.d_print(\"Inventory:\")\n\n # print each item with some indent\n @inventory.each do |object|\n @gc.display(\" > #{object.get_name}\")\n end\n\n # if there is nothing in the player's inventory, say so\n if @inventory.length == 0\n @gc.display(\" - Nothing\")\n end\n\n end",
"def inventory_shortcut\n (config_params||DEFAULT_CONFIG_PARAMS)[\"Inventory Shortcut\"]\n end",
"def inventory\n @game.state = BuyingState.new @game\n\n @game.state.handle\n end",
"def ansible_inventory_list\n cmd = \"ansible-inventory -i inventories/#{test_environment} --yaml --list\"\n out = `#{cmd}`\n raise \"failed to run command `#{cmd}`\" unless $CHILD_STATUS.exitstatus.zero?\n out\nend",
"def inventory_view(inventory)\r\n \r\n system 'clear'\r\n \r\n # Presents all inventory items to user using the display_method\r\n begin\r\n sub_categories = []\r\n inventory.each { |hash| sub_categories << hash['sub_cat'] }\r\n string_in_line(\" Current Inventory \".colorize(:light_green), 114) ; puts\r\n sub_categories.uniq.each{ |i| display_method(inventory, i) }\r\n rescue NoMethodError\r\n puts \"You don't have any inventory items to view. Add some before using this function.\"\r\n return \"No items in inventory\"\r\n end\r\n\r\n end",
"def inventory_without_hiting_the_database\n variants.inject(0) {|total, variant| total += variant.inventory}\n end",
"def set_inventory\n @inventory = Inventory.find(params[:id])\n end",
"def makeInventoryLocation(name, x, y, z, testbedId)\n location = Hash.new\n\n # Fill in that received from CONFINE Portal\n location['name'] = name\n location['x'] = x\n location['y'] = y\n location['z'] = z\n location['testbed_id'] = testbedId\n\t\t\t\n\t\t\t# DUMMY\n\t\t\tlocation['switch_ip'] = '10.0.0.201'\n\t\t\tlocation['switch_port'] = '1'\n\n # return\n location\n end",
"def set_inventory_item\n @inventory_item = InventoryItem.find(params[:id])\n end",
"def set_inventory_item\n @inventory_item = InventoryItem.find(params[:id])\n end",
"def test_override\n write_var(:gear, 'DEFAULT_LABEL', 'bogus')\n\n OpenShift::Runtime::Utils::Environ.for_gear(File.join('/tmp', @uuid)).tap do |env|\n assert_equal 'bogus', env['DEFAULT_LABEL']\n end\n\n write_var(:cart, 'DEFAULT_LABEL', 'VIP')\n\n OpenShift::Runtime::Utils::Environ.for_gear(File.join('/tmp', @uuid)).tap do |env|\n assert_equal 'VIP', env['DEFAULT_LABEL']\n end\n end",
"def add_to_inventory(item)\n @items << item\n equip(item)\n items_weight\n end",
"def add_to_inventory(price, description)\n\t\tself.items << Item.new(price, description)\n\tend",
"def show_inventory\n\t\t\treturn @player_data_db.execute( \"select * from inventory\" )\n\t\tend",
"def inventoriable?\n inventory?\n end",
"def update_inventory\n self.order_items.each { |item| item.variant.add_pending_to_customer }\n end",
"def agent_inventory(nodes)\n rpc = Tasks::McollectiveTask.new(@playbook)\n\n rpc.from_hash(\n \"nodes\" => nodes,\n \"action\" => \"rpcutil.agent_inventory\",\n \"silent\" => true\n )\n\n success, msg, inventory = rpc.run\n\n # rpcutil#agent_inventory is a hash in a hash not managed by the DDL\n # this is not handled by the JSON encoding magic that does DDL based\n # symbol and string conversion so we normalise the data always to symbol\n # based structures\n inventory.each do |node|\n node[\"data\"][:agents].each do |agent|\n agent.keys.each do |key| # rubocop:disable Style/HashEachMethods\n agent[key.intern] = agent.delete(key) if key.is_a?(String)\n end\n end\n end\n\n [success, msg, inventory]\n end",
"def import_inventory_file()\n @worksheet_products.each { |row|\n if(@inventory_row = build_inventory_hash(row))\n import_inventory()\n end\n }\n end",
"def set_inventory_item\n @inventory_item = InventoryItem.find(params[:id])\n end",
"def shared_inventory\n @weapons + @armors + items_to_obj\n end",
"def storage_all_items\n storage_items + storage_equip_items\n end",
"def stock\n\n inventory = case presentation_unit_type_measurement.name\n when PresentationUnitTypeMeasurement::SUPERFICIAL\n inventory_for_superficie_presentation_unit_type_measurement\n when PresentationUnitTypeMeasurement::LOGITUDINAL\n inventory_for_longitudinal_presentation_unit_type_measurement\n else\n #TODO LOGGER\n 0\n end\n\n \n\n invoiced = case presentation_unit_type_measurement.name\n when PresentationUnitTypeMeasurement::SUPERFICIAL\n invoiced_for_superficie_presentation_unit_type_measurement\n when PresentationUnitTypeMeasurement::LOGITUDINAL\n invoiced_for_longitudinal_presentation_unit_type_measurement\n else\n #TODO LOGGER\n 0\n end\n\n inventory - invoiced\n end",
"def print_inventory\n print \"Current gold in pouch: #{@gold}.\\n\\n\"\n\n if (@inventory.empty?)\n puts \"#{@name}'s inventory is empty!\"\n else\n puts \"#{@name}'s inventory:\"\n\n @inventory.each do |couple|\n puts couple.first.name + \" (#{couple.second})\"\n end\n end\n\n print \"\\n\"\n end",
"def storage_equip_items\n storage_weapons + storage_armors\n end",
"def put_item_in_inventory(input)\n\n if find_item_by_id(input).canBePickedUp\n unless @inventory.include?(input)\n @inventory << input\n slow_type(\"\\nYou have picked up the #{find_item_by_id(input).name}.\")\n end\n\n else\n slow_type(\"You cannot pick up this item\")\n end\n end",
"def each(&block)\n @inventory.each(&block)\n end",
"def add_inventory(product_name, quantity)\n @products.each do |product|\n if product.name == product_name.upcase\n product.quantity += quantity\n end\n end\n end",
"def test_inventory_control_enabled\n setup_inventory_control()\n assert Preference.find_by_name('store_use_inventory_control').update_attribute('value', 1)\n get :show, :id => @product.code\n assert_response :success\n assert_select \"h3#out_of_stock\"\n end",
"def add_to_inventory(item)\n @inventory.push(item)\n update\n end",
"def inventory_params\n params.require(:inventory).permit(:item_name, :quantity, :inventory_type)\n end",
"def set_take_inventory\n @take_inventory = TakeInventory.find(params[:id])\n end",
"def reshelf(product, quantity)\n # NOT DEFINED IN EXAMPLES\n @inventory[product][\"quantity\"] += quantity\nend",
"def set_inventory\n @reserve_inventory = ReserveInventory.find(params[:id])\n end",
"def total_inventory\n inventory = Hash.new(0)\n @vendors.each do |vendor|\n vendor.inventory.keys.each do |item|\n inventory[item] += vendor.inventory[item]\n end\n end\n inventory\n end",
"def inventory_to_s\n\t\tputs \"------------------inventory----------------\"\n\t\tinventory.each {|book, number| puts \"Remain #{number} for <#{book.title}>\"}\n\t\tputs \"-------------------------------------------\"\n\tend",
"def print_inventory\n @player.print_inventory\n end",
"def inventory_params\n params.require(:inventory).permit(:bulk, :product, :store, :code, :roll, :width, :feet, :inches)\n end",
"def initialize(inventory_collection: nil)\n @inventory_collection = inventory_collection\n end",
"def bootstrap\n @inventory.add(@server.config['name'], @server.windows? ? @server.canonicalIP : @server.mu_name)\n play = {\n \"hosts\" => @server.config['name']\n }\n\n if !@server.windows? and @server.config['ssh_user'] != \"root\"\n play[\"become\"] = \"yes\"\n end\n\n if @server.windows?\n play[\"roles\"] = [\"mu-windows\"]\n else\n play[\"roles\"] = [\"mu-base\"]\n end\n if @server.config['run_list']\n play[\"roles\"].concat(@server.config['run_list'])\n end\n\n if @server.config['ansible_vars']\n play[\"vars\"] = @server.config['ansible_vars']\n end\n\n if @server.windows?\n play[\"vars\"] ||= {}\n play[\"vars\"][\"ansible_connection\"] = \"winrm\"\n play[\"vars\"]['ansible_python_interpreter'] = \"c:/bin/python/python310/python.exe\"\n play[\"vars\"][\"ansible_winrm_scheme\"] = \"https\"\n play[\"vars\"][\"ansible_winrm_transport\"] = \"ntlm\"\n play[\"vars\"][\"ansible_winrm_server_cert_validation\"] = \"ignore\" # XXX this sucks; use Mu_CA.pem if we can get it to work\n# play[\"vars\"][\"ansible_winrm_ca_trust_path\"] = \"#{MU.mySSLDir}/Mu_CA.pem\"\n play[\"vars\"][\"ansible_user\"] = @server.config['windows_admin_username']\n win_pw = @server.getWindowsAdminPassword\n\n pwfile = MU::Groomer::Ansible.vaultPasswordFile\n cmd = %Q{#{MU::Groomer::Ansible.ansibleExecDir}/ansible-vault}\n output = %x{#{cmd} encrypt_string '#{win_pw.gsub(/'/, \"\\\\\\\\'\")}' --vault-password-file #{pwfile}}\n\n play[\"vars\"][\"ansible_password\"] = output\n end\n\n File.open(@ansible_path+\"/\"+@server.config['name']+\".yml\", File::CREAT|File::RDWR|File::TRUNC, 0600) { |f|\n f.flock(File::LOCK_EX)\n f.puts [play].to_yaml.sub(/ansible_password: \\|-?[\\n\\s]+/, 'ansible_password: ') # Ansible doesn't like this (legal) YAML\n f.flock(File::LOCK_UN)\n }\n end",
"def display_item_inventory\n if item_inventory.length == 0\n \"You haven't picked up any items yet.\"\n else\n items_on_hand = item_inventory.join(\" & \")\n \"Right now, you have a \" + items_on_hand\n end\n end",
"def equip(entity)\n prev_item = entity.outfit[@type]\n\n entity.outfit[@type] = self\n alter_stats(entity, true)\n\n if prev_item\n prev_item.alter_stats(entity, false)\n entity.add_item(prev_item)\n end\n\n print \"#{entity.name} equips #{@name}!\\n\\n\"\n end",
"def initialize\n @max_xp = 7440\n @current_xp = 1\n @max_hp = 10\n @current_hp = 10\n @level = calculate_level(@current_xp)\n @ac = 10\n @gold = 10\n @move_speed = 30\n @inventory = { equipment: { armor: 'none',\n shield: 'none',\n weapon: 'rusted sword'\n },\n treasure: Array.new(6),\n one_use_items: Array.new(4)\n }\n\n end",
"def print_inventory\n @inventory.each do |couple|\n puts couple.first.name + \" (#{couple.second})\"\n end\n print \"\\n\"\n end",
"def vestItems _args\n \"vestItems _args;\" \n end",
"def update_inventory\n response = LcboApiHelper.get_all \"inventories\", [\"product_id=#{number}\", \"where_not=is_dead\"]\n\n response.each do |inventory|\n lcbo_updated_on = inventory[\"updated_on\"].to_date\n next if Inventory.exists?(lcbo_updated_on: lcbo_updated_on, store_id: inventory['store_id'], product: self)\n Inventory.create(\n product: self,\n store_id: inventory['store_id'],\n quantity: inventory[\"quantity\"],\n lcbo_updated_on: lcbo_updated_on,\n lcbo_updated_at: Time.parse(inventory[\"updated_at\"]).getutc\n )\n end\n end",
"def setup(items)\n\tend",
"def equip_item(item)\n\n index = has_item(item)\n if index\n actual_item = inventory[index].first\n\n # Checks for Equippable without importing the file.\n if (defined? actual_item.equip)\n actual_item.equip(self)\n\n # Equipping the item will always remove it from the entity's inventory.\n remove_item(actual_item)\n else\n print \"#{actual_item.name} cannot be equipped!\\n\\n\"\n end\n else\n print NO_SUCH_ITEM_ERROR\n end\n end",
"def setup\n super\n @default_provider_id = register_default_provider\n @default_consumer_id = register_default_consumer\n\n # Define some dummy items\n @default_items = [\n { name: \"Item1\", price: 39.99, provider: @default_provider_id },\n { name: \"Item2\", price: 10, provider: @default_provider_id }\n ]\n\n # Check everything is empty\n assert_equal(0, get_registered_number(\"api/items\"),\n \"There are registered items at test setup\")\n\n assert_equal 0, count_orders, \"There are registered orders at test setup\"\n\n # TODO: Rename the files\n Item.db_filename = \"tests/test_files/test_items.json\"\n Order.db_filename = \"tests/test_files/test_orders.json\"\n end",
"def make_object klass\n obj = $manager.make_object klass\n inventory << obj if self.respond_to? :inventory\n obj\n end",
"def show_inventory\n\t\tempty = String.new\n\t\tempty = \"empty pockets\" if @player.inventory.size == 0\n\t\tputs \"\\nYou have: \" + @player.inventory.join(\", \") + empty\n\tend",
"def inventory(card)\n unless current_user \n '0'\n else \n Card.last(scryfall_id: card['id'], user_id: current_user.id)\n end\n end",
"def find(item_name)\n @inventory.find(item_name)\n end",
"def standard_setup\n @body = Body.new(@client)\n @entity_tracker = EntityTracker.new(@client, @body)\n @chunk_tracker = ChunkTracker.new(@client)\n @inventory = Inventory.new(@client)\n end",
"def index\n @inventory_items = InventoryItem.all\n end",
"def show\n @inventory = @npc.inventory\n @items = Item.all\n end",
"def fetch_inventory\n @offer[:records] ||= Item.where(survivor_id: @offer[:survivor_id]).to_a\n @for[:records] ||= Item.where(survivor_id: @for[:survivor_id]).to_a\n end",
"def test_selectItem_must_have_quantity\n\t\t# vm = VendingMachine.new\n\t\tvm = VendingMachine.new(@db)\n\t\tvm.output = StringIO.new\n\t\t# vm.items[\"A1\"].quantity = 0\n\t\titem = @db.getItem(\"A1\")\n\t\titem.quantity = 0\n\t\t@db.updateItem(item)\n\t\tvm.inputMoney(0.50)\n\t\titem = vm.selectItem(\"A1\")\n\t\tassert_equal(\"sold out\", vm.output.string.strip)\n\tend",
"def inventory(status)\n InventoryUnit.count(:conditions => \"status = #{status} AND variant_id = #{self.id}\", :joins => \"LEFT JOIN variants on variants.id = variant_id\")\n end",
"def line_item_items_exist_in_inventory\n self.line_items.each do |line_item|\n next unless line_item.item\n inventory_item = self.from.inventory_items.find_by(item: line_item.item)\n if inventory_item.nil?\n errors.add(:inventory,\n \"#{line_item.item.name} is not available \" \\\n \"at this storage location\")\n end\n end\n end",
"def has_inventory?\n inventory_count > 0\n end",
"def has_inventory?\n inventory_count > 0\n end",
"def set_skill_inventory\n @skill_inventory = SkillInventory.find(params[:id])\n end",
"def inventory_screen\n setup_location if !@location_id || !@location_name\n clear_screen\n puts \"Inventory mode | #{@location_name} | #{@product_type} \"\n puts \"\"\n puts \"\"\n @items.each do |i|\n puts \"#{i.amount}\\t#{i.barcode}\\t#{i.name}\\t#{i.best_before_date}\\t#{i.price}\\t#{i.open_string}\"\n end\n puts \"\"\n puts \"Scan barcode (b for edit last best before, c for commit, l for locations, p for price, o open amount, r for remove last row, q for quantity of last, q! for quit)\"\n case input = gets.strip\n when \"\"\n when \"b\"\n @items.last.query_best_before unless @items.size == 0\n when \"c\"\n @items.each do |i|\n commit(i)\n end\n @items = []\n when \"l\"\n setup_location\n when \"m\"\n @items.last.query_price unless @items.size == 0\n when \"o\"\n @items.last.toggle_open unless @items.size == 0\n when \"r\"\n @items.pop\n when \"q\"\n @items.last.query_quantity unless @items.size == 0\n when \"q!\"\n exit\n else\n check(input)\n end\n end"
] |
[
"0.6951753",
"0.6739306",
"0.6636184",
"0.65454704",
"0.65146106",
"0.6502555",
"0.6481087",
"0.64170563",
"0.6403549",
"0.63148105",
"0.6306859",
"0.630202",
"0.62828773",
"0.62807155",
"0.6265003",
"0.62622",
"0.61740416",
"0.616278",
"0.6145893",
"0.6144996",
"0.6112049",
"0.60916203",
"0.6062724",
"0.59877324",
"0.5981896",
"0.5953043",
"0.5947526",
"0.5947526",
"0.5947526",
"0.5947526",
"0.5935278",
"0.59314716",
"0.59047335",
"0.58868897",
"0.5886275",
"0.5883955",
"0.5881903",
"0.5851161",
"0.5806623",
"0.57805175",
"0.57743734",
"0.57602656",
"0.5743382",
"0.5735983",
"0.5725971",
"0.5725971",
"0.5676047",
"0.567224",
"0.56666374",
"0.5656681",
"0.5641249",
"0.5636341",
"0.56350017",
"0.5628444",
"0.561434",
"0.56139636",
"0.56011724",
"0.5587477",
"0.5583386",
"0.55743325",
"0.5535065",
"0.5521633",
"0.5508575",
"0.54884106",
"0.5483992",
"0.5470234",
"0.5469208",
"0.54686534",
"0.54626673",
"0.5461192",
"0.54511946",
"0.5448447",
"0.54475015",
"0.54384065",
"0.5422988",
"0.5412881",
"0.54096043",
"0.5403716",
"0.5398673",
"0.53942317",
"0.5391753",
"0.5387464",
"0.5377228",
"0.53715414",
"0.5364834",
"0.53547317",
"0.5353327",
"0.53523284",
"0.53471935",
"0.5347064",
"0.5343735",
"0.53417253",
"0.5320949",
"0.5320845",
"0.53109807",
"0.5306867",
"0.5306867",
"0.52981",
"0.52896684"
] |
0.66573733
|
3
|
Overrides configuration for tests.
|
def config_data
{}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def setup_config\n # To be Extended\n end",
"def test_with_overrides\n config = load_config('test_configs/good-config.conf', ['ubuntu', :production, 'itscript'])\n\n assert_equal(26214400, config.common.basic_size_limit)\n assert_equal(52428800, config.common.student_size_limit)\n assert_equal(2147483648, config.common.paid_users_size_limit)\n assert_equal('/srv/tmp/', config.common.path)\n assert_equal('hello there, ftp uploading', config.ftp.name)\n assert_equal('/etc/var/uploads', config.ftp.path)\n assert_equal('/etc/var/uploads', config.ftp[:path])\n assert_equal(true, config.ftp.enabled)\n assert_equal('http uploading', config.http.name)\n assert_equal('/srv/var/tmp/', config.http.path)\n assert_equal(%w(array of values), config.http.params)\n assert_equal({:name => 'hello there, ftp uploading', :path => '/etc/var/uploads', :enabled => true}, config.ftp)\n assert_equal(false, config.http[:'foo bar'])\n assert_nil(config.ftp.foo)\n end",
"def config \n @config ||= Gem.configuration[\"test_options\"] || { }\n end",
"def configure\n load_configuration\n verify_configuration\n end",
"def _init_configuration\n\t\t# Set defaults\n\t\t@setup = { \"create\" => false, \"environment\" => false, \"test\" => true, \"destroy\" => false }\n\t\t@config = false\n\tend",
"def default_testing_config\n CLAide::Plugins::Configuration.new('CLAideTesting',\n 'claidetest',\n 'https://github.com/cocoapods/claide-plugins/something.json',\n 'https://github.com/danger/danger-plugin-template')\nend",
"def configure\n # do nothing\n end",
"def test_no_overrides\n config = load_config('test_configs/good-config.conf')\n\n assert_equal(26214400, config.common.basic_size_limit)\n assert_equal(52428800, config.common.student_size_limit)\n assert_equal(2147483648, config.common.paid_users_size_limit)\n assert_equal('/srv/var/tmp/', config.common.path)\n assert_equal('hello there, ftp uploading', config.ftp.name)\n assert_equal('/tmp/', config.ftp.path)\n assert_equal('/tmp/', config.ftp[:path])\n assert_equal(false, config.ftp.enabled)\n assert_equal('http uploading', config.http.name)\n assert_equal('/tmp/', config.http.path)\n assert_equal(%w(array of values), config.http.params)\n assert_equal({:name => 'hello there, ftp uploading', :path => '/tmp/', :enabled => false}, config.ftp)\n assert_equal(true, config.http[:'foo bar'])\n assert_nil(config.ftp.foo)\n end",
"def configure!(options={})\n self.local_config = options\n end",
"def configure; end",
"def configure\n load_all_configs \n end",
"def configure\n Rollbar.reconfigure do |config|\n # special test access token\n config.access_token = test_access_token\n config.logger = ::Rails.logger\n config.root = ::Rails.root\n config.framework = \"Rails: #{::Rails::VERSION::STRING}\"\n config.request_timeout = 60\n end\n end",
"def setup(settings = {})\n @config = defaults.merge(settings)\n end",
"def setup()\n @configuration = {}\n @configuration.merge!(defaults)\n @configuration\n end",
"def config_files(override); end",
"def test_defaults\n end",
"def configure\n end",
"def initialize\n configure_via_yaml\n configure_via_env\n end",
"def before_configuration(&block); end",
"def kitchen_config\n @kitchen_config ||= {\n defaults: {\n driver: Driver::DEFAULT_PLUGIN,\n provisioner: Provisioner::DEFAULT_PLUGIN,\n verifier: Verifier::DEFAULT_PLUGIN,\n transport: lambda do |_suite, platform|\n platform =~ /^win/i ? \"winrm\" : Transport::DEFAULT_PLUGIN\n end,\n },\n kitchen_root: kitchen_root,\n test_base_path: test_base_path,\n log_level: log_level,\n log_overwrite: log_overwrite,\n debug: debug,\n }\n end",
"def setup\n yield(configuration)\n end",
"def configurations; end",
"def configure(root_config)\n end",
"def configure(root_config)\n end",
"def configuration\n @config ||= setup\n end",
"def suite_config\n {\n 'name' => 'default',\n 'run_list' => (File.exist?(File.join(base, 'test', 'cookbook')) || File.exist?(File.join(base, 'test', 'cookbooks'))) ? [\"#{cookbook_name}_test\"] : [cookbook_name],\n }\n end",
"def configure(conf)\n super\n end",
"def config=(env, override_configurations = T.unsafe(nil)); end",
"def reconfigure(overrides={})\n config.merge!(overrides)\n self\n end",
"def configure(root_config)\n super(root_config)\n end",
"def default_configuration!\n # Overwriting Sinatra defaults\n set :app_file, caller_files.first || $0 # Assume app file is first caller\n set :environment, Padrino.env\n set :raise_errors, true if development?\n set :logging, false # !test?\n set :sessions, true\n set :public, Proc.new { Padrino.root('public', self.uri_root) }\n # Padrino specific\n set :uri_root, \"/\"\n set :reload, development?\n set :app_name, self.to_s.underscore.to_sym\n set :default_builder, 'StandardFormBuilder'\n set :flash, defined?(Rack::Flash)\n set :authentication, false\n # Padrino locale\n set :locale_path, Proc.new { Dir[File.join(self.root, \"/locale/**/*.{rb,yml}\")] }\n set :auto_locale, false\n # Plugin specific\n set :padrino_mailer, defined?(Padrino::Mailer)\n set :padrino_helpers, defined?(Padrino::Helpers)\n end",
"def reset_config\n configure do |config|\n config.provider = :payu\n\n # payu configuration\n config.pos_id = 999\n config.pos_auth_key = 'pos_auth_key'\n config.key1 = 'key1'\n config.key2 = 'key2'\n\n config.test_mode = false\n end\n end",
"def set_config(config)\n\t\tend",
"def setup\n raise \"setup already called\" if !@original_config.nil?\n @original_config = read_config\n setup_tmp_root\n # we never want tests to write to the real katas root\n set_katas_root(tmp_root + 'katas')\n end",
"def test_config\n PuppetServerExtensions.config\n end",
"def config=(config); end",
"def configure(root_config)\n\n end",
"def configure!\n yield self\n setup\n end",
"def set_config(env, override_configurations = T.unsafe(nil)); end",
"def configure(opts)\n #This is a stub, used for indexing\n end",
"def set_config_paths\n @config_file_path = \"config/dissect/\"\n end",
"def config\n config = PcaprLocal::Config.config\n config['couch']['database'] = \"#{config['couch']['database']}_test\"\n config['install_dir'] = \"/tmp/pcapr_local_test\"\n config['pcap_dir'] = \"/tmp/pcapr_local_test/pcaps\"\n config['index_dir'] = \"/tmp/pcapr_local_test/indexes\"\n config['app']['port'] = config['app']['port'].to_i + 1\n config\n end",
"def config\n config = PcaprLocal::Config.config\n config['couch']['database'] = \"#{config['couch']['database']}_test\"\n config['install_dir'] = \"/tmp/pcapr_local_test\"\n config['pcap_dir'] = \"/tmp/pcapr_local_test/pcaps\"\n config['index_dir'] = \"/tmp/pcapr_local_test/indexes\"\n config['app']['port'] = config['app']['port'].to_i + 1\n config\n end",
"def configure(root_config)\n super(root_config)\n end",
"def test_options\n base_test_options.merge(connect_options).\n merge(ssl_options).merge(compressor_options).merge(retry_writes_options)\n end",
"def initialize\n @config = DEFAULT_CONFIG.deep_dup\n end",
"def load_config()\n self.config = Kitchenplan::Config.new().config\n end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def configure_saucelabs\n end",
"def configure(settings = {})\n abstract_method\n end",
"def setup\n yield(application_config)\n end",
"def configure\n yield(config)\n end",
"def setup(config={})\n if block_given?\n yield(self.config.dup)\n end\n # merge new settings\n self.configure(config)\n end",
"def use_spec_configuration\n MiteCmd.stub(:configuration_file_path).and_return(\n File.join(File.dirname(__FILE__), 'fixtures', 'mite.yml')\n )\nend",
"def test_configure\n Moodle.configure({\n :username => 'test_username',\n :password => 'test_password'\n })\n\n assert_equal 'test_username', Moodle.config[:username]\n assert_equal 'test_password', Moodle.config[:password]\n end",
"def configure\n yield(config)\n end",
"def initialize(...)\n super()\n configure(...)\n end",
"def all_test_options\n test_options.merge(auth_options)\n end",
"def getTestSettings()\n\n [:accounts, :browser, :host, :userid, :password].each do |k|\n\n puts __FILE__ + (__LINE__).to_s + \" opt[test_config].has_key(#{k.to_s}) => #{@options[:test_config].has_key?(k.to_s)}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n\n puts __FILE__ + (__LINE__).to_s + \" options[#{k}] : #{@options[k].to_s}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n if @options.has_key?(k) && !@options[k].nil?\n Scoutui::Base::UserVars.instance.set(k, @options[k].to_s)\n elsif @options[:test_config].has_key?(k.to_s)\n\n puts __FILE__ + (__LINE__).to_s + \" opts[#{k}].nil => #{@options[k].nil?}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n # Ensure commnand line takes precedence\n if !@options[k].nil?\n puts __FILE__ + (__LINE__).to_s + \" opt[#{k.to_s} => #{@options[k].to_s}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n Scoutui::Base::UserVars.instance.set(k, @options[k].to_s)\n else\n Scoutui::Base::UserVars.instance.set(k, @options[:test_config][k.to_s].to_s)\n end\n\n elsif @env_list.has_key?(k)\n # If an ENV is available, use it.\n puts __FILE__ + (__LINE__).to_s + \" #{k} => ENV(#{@env_list[k]}) = #{ENV[@env_list[k].to_s]}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n Scoutui::Base::UserVars.instance.set(k, ENV[@env_list[k].to_s])\n end\n end\n\n puts __FILE__ + (__LINE__).to_s + \" test_config => #{@options[:test_config]}\" if Scoutui::Utils::TestUtils.instance.isDebug?\n\n\n # Applitools Eyes settings\n if @options[:test_config].has_key?('eyes')\n\n ['match_level', 'title', 'app', 'viewport'].each do |k|\n\n _v=nil\n\n if @options[:test_config]['eyes'].has_key?(k)\n _v=@options[:test_config]['eyes'][k].to_s\n end\n\n if !@options[k.to_sym].nil?\n _v=@options[k.to_sym].to_s\n end\n\n if Scoutui::Utils::TestUtils.instance.isDebug?\n puts __FILE__ + (__LINE__).to_s + \" #{k} => #{_v}\"\n end\n\n Scoutui::Base::UserVars.instance.set('eyes.' + k, _v) if !_v.nil?\n\n end\n end\n\n @options[:test_config]\n end",
"def test_config\n load_config\n assert(@config.key?('user'))\n assert(@config.key?('pass'))\n assert(@config.key?('port'))\n assert(@config.key?('uri'))\n assert(@config.key?('callback_host'))\n assert(@config.key?('autopwn_url'))\n end",
"def initialize\n @config = ::RSpec.configuration.merimee_config\n yield @config if block_given?\n end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def runner_options(transport, state = {}, platform = nil, suite = nil)\n super(transport, state, platform, suite).tap do |options|\n self.class::ConfigureInspecRunnerBackend.call hostname: state.fetch(:hostname), options: options\n self.class::ConfigureInspecRunnerHost.call hostname: state.fetch(:hostname), options: options\n self.class::ConfigureInspecRunnerPort.call group: state.fetch(:group), options: options\n self.class::ConfigureInspecRunnerUser.call group: state.fetch(:group), options: options\n self.class::ConfigureInspecRunnerAttributes\n .call(driver: driver, group: state.fetch(:group), terraform_state: driver[:state]).bind do |attributes|\n config.store :attributes, attributes\n end\n self.class::ConfigureInspecRunnerControls.call group: state.fetch(:group), options: options\n end\n end",
"def finalize_config!(kitchen_instance)\n super kitchen_instance\n\n kitchen_instance\n .transport\n .tap do |transport|\n configure_inspec_connection_options(\n transport_connection_options:\n transport\n .send(\n :connection_options,\n transport.diagnose\n )\n .dup\n )\n end\n\n configure_inspec_miscellaneous_options\n end",
"def setup_config(config=nil, &block)\n @config = config || ConfigStruct.block_to_hash(block)\n end",
"def configure(&block); end",
"def configure(&block); end",
"def runner_options(test_file)\n {\n work_dir: AYTests.work_dir,\n test_file: Pathname.new(test_file),\n default_iso_path: AYTests.obs_iso_path,\n skip_build: options[\"skip-build\"] || false,\n provider: options[\"provider\"] || ENV[\"AYTESTS_PROVIDER\"] || :libvirt,\n headless: options[:headless] || ENV[\"AYTESTS_HEADLESS\"] == \"true\"\n }\n end",
"def configure(config={})\n config.each do |(key, val)|\n self.config[key] = val\n end\n end",
"def setup(&block)\n Config.setup(&block)\n end",
"def setup\n # override this if needed\n end",
"def configure &block\n @config_helper = ConfigHelper.new(&block)\n end",
"def set_defaults!\n __load_config( DEFAULTS )\n end",
"def default_configuration=(_arg0); end",
"def getTestbedConfig(domain)\n if ((dc = @@globalConfig[self.class]['testbed']) == nil)\n raise \"Missing 'testbed' configuration\"\n end\n config = dc[domain] || dc['default']\n if (config == nil)\n raise \"Missing 'testbed' config for '#{domain}' or 'default'\"\n end\n\n config['startPort'] ||= DEF_START_PORT\n config['maxDaemons'] ||= DEF_MAX_DAEMONS\n config['timeout'] ||= DEF_TIMEOUT\n\n config\n end",
"def before_test\n super\n\n # Need local variables for access within the scoped blocks below.\n logger = @logger\n config_manager = @config_manager\n # Configure RSpec.\n RSpec.configure do |c|\n # Need access to framework methods from within the RSpec examples.\n c.include Automation::Kernel\n # The formatter that will feed RSpec notification to the framework.\n c.add_formatter(Automation::Rspec::Formatter)\n # Before each \"it\"\n c.before(:each) do\n @logger = logger\n @config_manager = config_manager\n end\n end\n end",
"def swap_rspec_configuration(key, value); end",
"def actual_config\n Config.instance\n end",
"def configure\n yield config\n end",
"def configure\n yield config\n end"
] |
[
"0.7411844",
"0.725997",
"0.6969892",
"0.6915207",
"0.68550247",
"0.677388",
"0.674662",
"0.67151976",
"0.6668239",
"0.66563845",
"0.6639244",
"0.6562396",
"0.65493923",
"0.6542717",
"0.6536379",
"0.6525121",
"0.6513968",
"0.6509291",
"0.6505835",
"0.6465914",
"0.6448059",
"0.6436424",
"0.64270836",
"0.64270836",
"0.6425017",
"0.6408662",
"0.6357325",
"0.6340963",
"0.6340098",
"0.6324715",
"0.6321021",
"0.63202715",
"0.6317797",
"0.63165486",
"0.6315755",
"0.6313312",
"0.63074297",
"0.63041973",
"0.63030285",
"0.62961644",
"0.62942845",
"0.6283977",
"0.6283977",
"0.62748325",
"0.6265311",
"0.6261914",
"0.6258543",
"0.6251449",
"0.6251449",
"0.6251449",
"0.6251449",
"0.6251449",
"0.62267286",
"0.6217823",
"0.62150663",
"0.6211884",
"0.6210041",
"0.61975366",
"0.6186524",
"0.6180106",
"0.6174592",
"0.6173734",
"0.61691487",
"0.6158414",
"0.61543524",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.6153437",
"0.61253077",
"0.6119153",
"0.611319",
"0.61114097",
"0.61114097",
"0.61037123",
"0.6102429",
"0.6101745",
"0.6091031",
"0.60897547",
"0.6086563",
"0.6086236",
"0.6082972",
"0.60816324",
"0.60810506",
"0.6077931",
"0.6069301",
"0.6069301"
] |
0.0
|
-1
|
Override in your tests
|
def config
@config ||= begin
conf = Bolt::Config.new(Bolt::Project.default_project, config_data)
conf.modulepath = [modulepath].flatten
conf
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def testing\n # ...\n end",
"def spec; end",
"def spec; end",
"def self_test; end",
"def self_test; end",
"def should; super end",
"def __dummy_test__\n end",
"def before_setup; end",
"def private; end",
"def before_test(test); end",
"def before_test(test); end",
"def default_test\r\n end",
"def default_test\n end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def setup; end",
"def test_defaults\n end",
"def tests; end",
"def tests; end",
"def test_method\n end",
"def setup\n # override this if needed\n end",
"def default_test\n end",
"def default_test; end",
"def before_assert\n end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def default_test\n end",
"def default_test\n end",
"def test_setup\r\n \r\n end",
"def test_entry\n raise \"Implement this method in your test class\"\n end",
"def default_test\n info \"self: #{self}\"\n end",
"def before_run; end",
"def my_tests\n end",
"def test_case; end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def setup\n \n end",
"def running_test_case; end",
"def setup\n # override and do something appropriate\n end",
"def before() ; end",
"def test_entry_attrs\n raise \"Implement this method in your test class\"\n end",
"def setup\n\n end",
"def setup\n\n end",
"def setup\n\n end",
"def graffiti_test\n end",
"def setup\n #implement in subclass;\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def setup\n end",
"def test_entry\n raise 'Implement the method \"test_entry\" in your test class'\n end",
"def setup; end",
"def test_connection\n end",
"def before\n end",
"def before() nil ; end",
"def teardown\n super\n end",
"def teardown\n super\n end",
"def teardown\n super\n end",
"def overrides; end",
"def before; end",
"def teardown\n super\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def test_legacy\n # Set up legacy handlers\n setup_legacy_handling\n\n common_tests\n end",
"def test_entry_attrs\n raise 'Implement the method \"test_entry_attrs\" in your test class'\n end",
"def implementation; end",
"def implementation; end",
"def test\n end",
"def test\n end",
"def test\n end",
"def test \n end",
"def test_nothing\n end",
"def setup\n\t\tend",
"def setup\n\t\tend",
"def setup\r\n end",
"def custom; end",
"def custom; end"
] |
[
"0.7342287",
"0.7246639",
"0.7246639",
"0.70462036",
"0.70462036",
"0.702796",
"0.70184964",
"0.68830997",
"0.6862838",
"0.6850526",
"0.6850526",
"0.68221325",
"0.6805791",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.67525995",
"0.6745027",
"0.6708522",
"0.6708522",
"0.66971534",
"0.6695939",
"0.66836506",
"0.6676434",
"0.66242427",
"0.6598165",
"0.6598165",
"0.6598165",
"0.6598165",
"0.65877354",
"0.65877354",
"0.6565325",
"0.6557004",
"0.6516702",
"0.6484678",
"0.6458893",
"0.6452869",
"0.64502156",
"0.64502156",
"0.64502156",
"0.64502156",
"0.64502156",
"0.64502156",
"0.64502156",
"0.6420291",
"0.64174",
"0.6414045",
"0.64087623",
"0.6402528",
"0.6402528",
"0.6402528",
"0.6357404",
"0.63525146",
"0.6346191",
"0.6346191",
"0.6346191",
"0.6346191",
"0.6346191",
"0.6346191",
"0.6335666",
"0.63335913",
"0.6329471",
"0.63055676",
"0.62782836",
"0.627394",
"0.627394",
"0.627394",
"0.6270912",
"0.62590295",
"0.62587297",
"0.6249902",
"0.6249902",
"0.6236336",
"0.6227397",
"0.621332",
"0.621332",
"0.6191205",
"0.6191205",
"0.6191205",
"0.6185092",
"0.61822486",
"0.6173214",
"0.6173214",
"0.6163699",
"0.6158503",
"0.6158503"
] |
0.0
|
-1
|
Does this belong here?
|
def allow_out_message
executor.stub_out_message.add_stub
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def private; end",
"def probers; end",
"def schubert; end",
"def used?; end",
"def placebo?; false end",
"def internal?; end",
"def refutal()\n end",
"def internal; end",
"def called_from; end",
"def called_from; end",
"def implementation; end",
"def implementation; end",
"def who_we_are\r\n end",
"def suivre; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def private_method\n end",
"def custom; end",
"def custom; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def state; end",
"def writethis; end",
"def active; end",
"def active; end",
"def _parent; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def context; end",
"def isolated; end",
"def isolated; end",
"def usable?; end",
"def informational?; end",
"def processor; end",
"def handle; end",
"def entry; end",
"def entry; end",
"def entry; end",
"def entry; end",
"def weber; end",
"def self\n @define_self = true",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def parent; end",
"def under; end",
"def internship_passed; end",
"def active?; end",
"def under_construction\n end",
"def strategy; end",
"def owner; end",
"def owner; end",
"def pausable; end",
"def extra_state; end",
"def extra; end",
"def main\n super\n return self\n end",
"def isolated?; end",
"def isolated?; end",
"def referenced; end",
"def referenced?; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end"
] |
[
"0.7674449",
"0.6736215",
"0.6619357",
"0.65748215",
"0.64430016",
"0.64017403",
"0.63982075",
"0.63916016",
"0.6357952",
"0.6357952",
"0.63525283",
"0.63525283",
"0.6279837",
"0.6263549",
"0.6219576",
"0.6219576",
"0.6219576",
"0.6219576",
"0.6216418",
"0.6210288",
"0.6210288",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6205702",
"0.6186589",
"0.61811656",
"0.61811656",
"0.6181001",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.6153307",
"0.61508644",
"0.61508644",
"0.6145527",
"0.61301064",
"0.61283",
"0.610517",
"0.6063959",
"0.6063959",
"0.6063959",
"0.6063959",
"0.6045168",
"0.6028686",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.6007002",
"0.59889054",
"0.59882736",
"0.59769744",
"0.5972844",
"0.5945991",
"0.5913476",
"0.5913476",
"0.5907589",
"0.5906686",
"0.5887172",
"0.588707",
"0.58687",
"0.58687",
"0.58612937",
"0.5845022",
"0.5838505",
"0.5838505",
"0.5838505",
"0.5838505",
"0.5838505",
"0.5838505",
"0.5838505"
] |
0.0
|
-1
|
Performs applicationlevel initialization functions.
|
def initialize(params={})
name = init_collection_name params[:define_collection_name]
@@_collection[self.class.name] ||= Schema.instance.get_collection(name)
@id = params[:id] if params[:id]
@__ref_value__ = '"*"'
# @event_types = params[:event_types] ? params[:event_types] : []
# @relation_kinds = params[:graphs] ? params[:graphs] : []
@@_cache[self.class.name] ||= SimpleCacheRequest.new(ocollection)
@@cache_store ||= SimpleCacheStore.instance
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def bootstrap_init\n end",
"def init!\n @logger = @config = @database_config = nil\n\n load_application_config\n load_database_config\n note \"Loading #{env} environment (#{Ajaila::VERSION})\"\n load_classes\n note \"Establishing database connection\"\n establish_database_connection\n note \"Running auto-upgrade migrations\"\n run_auto_upgrade_migrations\n note \"Application has been initialized\"\n self\n end",
"def run_init_script; end",
"def initialize_environment\n end",
"def initialize_environment\n end",
"def setup_application!\n return if @_configured\n self.register_framework_extensions\n self.calculate_paths\n self.register_initializers\n self.require_load_paths\n self.disable :logging # We need do that as default because Sinatra use commonlogger.\n I18n.load_path += self.locale_path\n I18n.reload!\n @_configured = true\n end",
"def app_init!(rails_env)\n if rails_env.development? || rails_env.demo?\n # If we are running a rake command like `rake db:seed` or\n # `rake db:schema:load`, we do not want to try and seed the fakes\n # because our schema may not be loaded yet and it will fail!\n if running_rake_command?\n load!\n else\n load_fakes_and_seed!\n end\n end\n end",
"def initialize\n # Create temporary data directory\n create_data_dir\n\n # Init connection to ADS\n init_ads\n\n # Initialize Data science toolkit\n init_dstk\n\n # Init connection to SQLite\n # init_sqlite3\n end",
"def startup\nend",
"def initialize!(app); end",
"def initialize!\n load_passenger\n initialize_ush_api\n initialize_debugging\n undo_bundler\n end",
"def startup\n end",
"def user_init; end",
"def startup\n end",
"def startup\n end",
"def startup\n end",
"def app_init!(rails_env)\n if rails_env.ssh_forwarding? && !running_rake_command?\n User.authentication_service = Fakes::AuthenticationService\n # This sets up the Fake::VBMSService with documents for the VBMS ID DEMO123. We normally\n # set this up in Fakes::AppealRepository.seed! which we don't call for this environment.\n Fakes::VBMSService.document_records = { \"DEMO123\" => Fakes::Data::AppealData.static_reader_documents }\n end\n\n if rails_env.demo? || rails_env.development?\n # If we are running a rake command like `rake db:seed` or\n # `rake db:schema:load`, we do not want to try and seed the fakes\n # because our schema may not be loaded yet and it will fail!\n if running_rake_command?\n load!\n else\n load_fakes_and_seed!(rails_env: rails_env)\n end\n end\n end",
"def init\n self['env'] ||= 'development'\n\n n = (self['port'] || 3000).to_i\n assert n >= 0 && n <= 65535\n self['port'] = n\n\n n = (self['workers'] || self['worker'] || ((CpuCounter.count + 1)/ 2)).to_i\n assert n > 0 && n < 1000\n self['workers'] = n\n\n unless self['root']\n set :root, Dir.pwd\n end\n self['root'] = File.realpath File.expand_path self['root']\n\n # todo warn paths not under project?\n self['views'] = project_path(self['views'] || 'views')\n if self['public']\n self['public'] = project_path(self['public'])\n end\n\n if self['assets']\n self['assets'] = project_path(self['assets'])\n end\n\n self.logger = create_logger\n\n assert !self['before_fork'] || self['before_fork'].respond_to?('call')\n assert !self['after_fork'] || self['after_fork'].respond_to?('call')\n\n self['timeout'] ||= 120\n timeout = self['timeout'].to_i\n assert timeout > 0 && timeout < 2**30\n self['timeout'] = timeout\n Ext.set_inactive_timeout timeout\n end",
"def initialize\n set_root_path!\n \n self.frameworks = default_frameworks\n self.autoload_paths = default_autoload_paths\n self.autoload_once_paths = default_autoload_once_paths\n self.dependency_loading = default_dependency_loading\n self.eager_load_paths = default_eager_load_paths\n self.log_path = default_log_path\n self.log_level = default_log_level\n self.binder_paths = default_binder_paths\n self.marshal_path = default_marshal_path\n self.cache_classes = default_cache_classes\n self.whiny_nils = default_whiny_nils\n self.database_configuration_file = default_database_configuration_file\n self.app_config_file = default_app_config_file\n self.plugin_glob = default_plugin_glob\n self.helper_glob = default_helper_glob\n self.initializer_glob = default_initalizer_glob\n self.first_run_glob = default_first_run_glob\n self.publisher = default_publisher\n self.copyright = default_copyright\n \n for framework in default_frameworks\n self.send(\"#{framework}=\", Bowline::OrderedOptions.new)\n end\n end",
"def initialize_modules\n # NOTE: this gets called after all the module initializers complete\n end",
"def post_init\n end",
"def post_init\n end",
"def do_boot\n Kernel.require Rucola::RCApp.root_path + '/config/boot'\n end",
"def startup_hook; end",
"def initialize(app); end",
"def boot\n Thread.new do\n sleep 1 until EM.reactor_running?\n\n begin\n log.info \"Loading application...\"\n app_init\n load_settings\n Fastr::Plugin.load(self)\n load_app_classes\n setup_router\n setup_watcher unless RbConfig::CONFIG['host_os'] =~ /mswin|mingw/\n\n log.info \"Application loaded successfully.\"\n\n @booting = false\n\n plugin_after_boot\n rescue Exception => e\n log.error \"#{e}\"\n puts e.backtrace\n log.fatal \"Exiting due to previous errors...\"\n exit(1)\n end\n end\n end",
"def initialize!(group=:default) #:nodoc:\n raise \"Application has been already initialized.\" if @initialized\n\n ActiveSupport.run_load_hooks(:before_initialize, self)\n @railties = Railties.new\n\n run_initializers(group, self)\n @initialized = true\n self\n end",
"def rb_main_init\n path=OSX::NSBundle.mainBundle.resourcePath.fileSystemRepresentation\n rbfiles=Dir.entries(path).select { |x| /\\.rb\\z/=~x }\n rbfiles-=[File.basename(__FILE__)]\n rbfiles.each do |path|\n require(File.basename(path))\n end\n puts \"application started\"\nend",
"def at_init\n\n\t\tend",
"def initialize\n #load_config\n load_routes\n end",
"def init\n\nend",
"def bootstrap!\n reset!\n require_relative 'kernel'\n end",
"def init(app_name='tdp')\n standard_exception_handling do\n @name = app_name\n handle_options\n collect_tasks\n end\n end",
"def post_init\n\tend",
"def init\n\n end",
"def initialize\n # Load the setup settings and any user overrides.\n @settings = Configuration::CombinedConfiguration.new\n @settings.load_configuration('default', 'Configuration/setup.yaml')\n @settings.load_configuration('user', 'Configuration/user.yaml')\n\n @ruby_bin = RbConfig::CONFIG['bindir']\n @install_flag = \".bundle/#{RUBY_VERSION}_#{ruby_platform}.flag\"\n\n # The timestamp values - the installer is run depending on these values.\n @t1 = UserSettings.last_modify_date.to_i\n @t2 = File.mtime('Gemfile').to_i\n\n @gem_path = File.join(@settings['setup.gem_path'], ruby_platform)\n @mysql_dir = File.join(FRAMEWORK_ROOT, \"#{LIB_DIR}/mysql/#{ruby_platform}\")\n\n runtime.save(:ruby_bin, @ruby_bin)\n runtime.save(:gem_path, @gem_path)\n runtime.save(:mysql_dir, @mysql_dir)\n runtime.save(:setup_settings, @settings)\n end",
"def on_init; end",
"def on_init; end",
"def init\n end",
"def init\n end",
"def init\n end",
"def initialize()\n begin\n puts \"Eis::Runner::init called\" if $DEBUG\n @loaded_modules = []\n generate_module_list()\n handle = InputHandler.new()\n set_environment()\n rescue ArgumentError =>e\n puts \"\\e[31mERROR\\e[0m: No config file given...\" + e\n puts \"--------------------------------------------\"\n raise\n end\n end",
"def initialize!\n return false if initialized? || Jun.application.nil?\n\n # Add app/* directories to autoload paths.\n Jun::ActiveSupport::Dependencies.autoload_paths += Jun.root.join(\"app\").children\n\n # Set up routes and make its helpers available to controllers & views.\n require Jun.root.join(\"config/routes.rb\")\n url_helpers = Jun.application.routes.url_helpers\n Jun::ActionController::Base.include(url_helpers)\n Jun::ActionView::Base.include(url_helpers)\n\n # Include all helpers in app/helpers directory.\n Dir.glob(Jun.root.join(\"app/helpers/**/*.rb\")).each do |filepath|\n helper_class_name = File.basename(filepath, \".rb\").camelize\n helper_class = Object.const_get(helper_class_name)\n\n Jun::ActionView::Base.include(helper_class)\n end\n\n @initialized = true\n end",
"def bootstrap!\n reset!\n require_relative 'kernel'\n end",
"def on_app_initializing(_event)\n info \"Initializing Karafka framework #{::Process.pid}\"\n end",
"def initial_setup\n # Copy across the application_record_loader.rb unless it already exists\n copy_file '../static_files/application_record_loader.rb',\n 'lib/record_loader/application_record_loader.rb',\n skip: true\n # Copy across the record_loader.rake unless it already exists\n copy_file '../static_files/record_loader.rake',\n 'lib/tasks/record_loader.rake',\n skip: true\n end",
"def local_init(args)\n end",
"def on_app_initializing(_event)\n info 'Initializing Karafka framework'\n end",
"def init; end",
"def init; end",
"def init; end",
"def init; end",
"def do_initialize\n begin\n Puppet.initialize_settings\n Puppet[:parser] = 'future' # this is required in order to work with puppet 3.8\n Puppet[:trusted_node_data] = true\n rescue ArgumentError => e\n\n rescue Puppet::DevError => e\n # do nothing otherwise calling init twice raises an error\n end\n end",
"def Init()\n end",
"def init(primaryStage) end",
"def on_initialization_finished()\n end",
"def initialize\n super\n \n run_hook :before_configuration\n \n # Search the root of the project for required files\n $LOAD_PATH.unshift(root)\n \n # Check for and evaluate local configuration\n local_config = File.join(root, \"config.rb\")\n if File.exists? local_config\n puts \"== Reading: Local config\" if logging?\n instance_eval File.read(local_config)\n end\n \n run_hook :build_config if build?\n run_hook :development_config if development?\n \n run_hook :after_configuration\n \n # Add in defaults\n default_extensions.each do |ext|\n activate ext\n end\n \n if logging?\n self.class.extensions.each do |ext|\n puts \"== Extension: #{ext}\"\n end\n end\n end",
"def setup_context\n self['console'] = Console.new\n load RUNTIME_PATH\n\n opal = self['opal']\n opal['loader'] = Loader.new opal, self\n opal['fs'] = FileSystem.new opal, self\n opal['platform']['engine'] = 'opal-gem'\n\n # eval \"opal.require('core');\", \"(opal)\"\n require_file 'core'\n end",
"def init\n @init.call if @init\n end",
"def run\n reconfigure\n setup_application\n run_application\n end",
"def pre_initialize\n end",
"def pre_initialize; end",
"def init\n Runner.in_shell = true\n Command.all_option_commands = true if @options[:option_commands]\n super\n Index.update(:verbose=>true, :libraries=>@options[:index]) if @options.key?(:index)\n if @options[:load]\n Manager.load @options[:load], load_options\n elsif @options[:execute]\n define_autoloader\n else\n load_command_by_index\n end\n end",
"def post_setup\n end",
"def setup_environment; end",
"def boot\n Rucola::Plugin.before_boot\n do_boot\n Rucola::Plugin.after_boot\n end",
"def on_startup\n\t\t# Check for modules that failed to load\n\t\tif (framework.modules.failed.length > 0)\n\t\t\tprint_error(\"WARNING! The following modules could not be loaded!\")\n\t\t\tframework.modules.failed.each_pair do |file, err|\n\t\t\t\tprint_error(\"\\t#{file}: #{err}\")\n\t\t\tend\n\t\tend\n\t\tframework.events.on_ui_start(Msf::Framework::Revision)\n\n\t\t# Build the banner message\n\t\trun_single(\"banner\")\n\t\tself.on_command_proc = Proc.new { |command| framework.events.on_ui_command(command) }\n\tend",
"def setup_common\n options[:log].each do |spec|\n mod, level, file = spec.split(\":\")\n app.log_setup(mod, level, file)\n end\n\n if options[:debug]\n app.public_logs = true\n app.filter_backtraces = false\n require \"roby/app/debug\"\n end\n\n nil\n end",
"def init; end",
"def init # should eventually take configuration options (hash || block)\n if ActiveRecord::Base.connection.tables.include? 'aux_codes'\n aux_codes_yml = File.join 'config', 'aux_codes.yml'\n if File.file? aux_codes_yml\n load_file aux_codes_yml\n create_classes!\n end\n end\n end",
"def after_init\n end",
"def init_session\n init_language\n set_page_cache_directory\n init_views\n init_votes\n init_cookies\n end",
"def do_initialize\n Puppet.initialize_settings\n Puppet[:parser] = 'future' # this is required in order to work with puppet 3.8\n Puppet[:trusted_node_data] = true\n rescue ArgumentError => e\n rescue Puppet::DevError => e\n # do nothing otherwise calling init twice raises an error\n end",
"def bootup\n Merb.trap(\"TERM\") { shutdown }\n\n Merb.logger.warn! \"Running bootloaders...\" if Merb::Config[:verbose]\n BootLoader.run\n Merb.logger.warn! \"Starting Rack adapter...\" if Merb::Config[:verbose]\n Merb.adapter.start(Merb::Config.to_hash)\n end",
"def post_init\n # puts 'Syslogger initialized'\n end",
"def setup\n @applications = find_applications(pidfile_dir())\n end",
"def initialize_rails(&block)\n # Setup the fucking rails instance. What a side-affect loaded pile of shit.\n ENV[\"RAILS_ENV\"] = \"production\"\n require_relative \"../sitepress-rails/spec/dummy/config/application\"\n require \"sitepress/rails\"\n\n # Likely a Sitepress setup going on in here.\n block.call Rails.application if block_given?\n\n # Initialize the Rails application.\n Rails.application.initialize!\n\n # Its pointless benchmarking a non-production rails app because\n # of all the class reloading performance.\n fail \"Rails environment not set to production\" unless Rails.env.production?\n end",
"def start\n\t\tinit\n\t end",
"def boot!\n adjust_load_path\n adjust_gem_path\n ENV['RACK_ENV'] = rack_env\n change_working_directory\n export_global_settings\n load_settings_from_init_rb\n set_relative_url_root\n run_boot_hooks\n self\n end",
"def initialize\n load_site\n load_creds\n end",
"def pre_initialize( *args, & block )\n # call to super in case we extend Class or Module, so we can stack calls to pre_initialize\n super if defined?( super )\n # nothing here - subclasses define\n end",
"def boot_classes!\n # very fiddly chicken 'n egg problem. Functions need to be in the right order, and in fact we have to define some \n # dummies, just for the other to compile\n obj = get_or_create_class :Object\n [:index_of , :_get_instance_variable , :_set_instance_variable].each do |f|\n obj.add_instance_method Builtin::Object.send(f , @context)\n end\n obj = get_or_create_class :Kernel\n # create main first, __init__ calls it\n @main = Builtin::Kernel.send(:main , @context)\n obj.add_instance_method @main\n underscore_init = Builtin::Kernel.send(:__init__ , @context) #store , so we don't have to resolve it below\n obj.add_instance_method underscore_init\n [:putstring,:exit,:__send].each do |f|\n obj.add_instance_method Builtin::Kernel.send(f , @context)\n end\n # and the @init block in turn _jumps_ to __init__\n # the point of which is that by the time main executes, all is \"normal\"\n @init = Virtual::Block.new(:_init_ , nil )\n @init.add_code(Register::RegisterMain.new(underscore_init))\n obj = get_or_create_class :Integer\n [:putint,:fibo].each do |f|\n obj.add_instance_method Builtin::Integer.send(f , @context)\n end\n obj = get_or_create_class :String\n [:get , :set , :puts].each do |f|\n obj.add_instance_method Builtin::String.send(f , @context)\n end\n obj = get_or_create_class :Array\n [:get , :set , :push].each do |f|\n obj.add_instance_method Builtin::Array.send(f , @context)\n end\n end",
"def initialize(options = {}, &blk)\n options ||= {}\n options[:type] = :application\n init(options, &blk)\n end",
"def init\n conf_file = \"#{__dir__}/../conf/auth.json\"\n @conf = WIKK::Configuration.new(conf_file)\n\n # Team information – Information about the team and aggregate usage data\n @dbx_info = Dropbox.new(token: @conf.team_info_token)\n @dbx_mng = Dropbox.new(token: @conf.team_management_token)\n\n @ldap = UOA_LDAP.new(conf: @conf)\n\n @counters = {}\n cache_all_team_members(trace: TRACE)\n record_research_groups_and_users\n\n @licenses = @conf.licenses\nend",
"def InitializeHooks\n end",
"def load_application_initializers\n load_trusty_initializers unless deployed_as_app?\n super\n extension_loader.load_extension_initalizers\n end",
"def initialize!\n\t\t\t\tunless @modules_config = YAML::load(File.open(Rails.root.join('config', 'modules.yml'))) rescue false\n\t\t\t\t\t$stderr.puts %Q(This app requires a valid modules config file. Please check `modules.yml` in the config folder.)\n\t\t\t\t\texit 1\n\t\t\t\tend\n\t\t\t\tload_applications\n\t\t\t\treturn true\n\t\t\tend",
"def init\n require File.expand_path( '../irbtools.rb', File.dirname(__FILE__) )\n end",
"def initialize_app_access(owner, app_name, path)\n router = ::UsrRouter.for(owner)\n\n app = ::OodApp.at(path: router.path_for(app: app_name))\n\n # app doesn't exist or you do not have access:\n raise ActionController::RoutingError.new('Not Found') unless app\n\n\n # run idempotent setup script to setup data for user and handle any errors\n app.run_setup_production\n end",
"def startup()\n check_return_code(PureHailDB.ib_startup(\"BARRACUDA\"))\n end",
"def initialize(...)\n super\n mon_initialize\n end",
"def initialize\n set_config\n end",
"def setup\n @applications = find_applications(pidfile_dir)\n end",
"def init!\n # check if configuration file is already created\n unless File.exist?(CONFIG_FILE)\n puts \"=> [PagSeguro] The configuration could not be found at #{CONFIG_FILE.inspect}\"\n return\n end\n \n # The developer mode is enabled? So install it!\n developer_mode_install! if developer?\n end",
"def initialize config={}, &block\n @config = config\n\n\n widget_shortcuts_init\n @variables = {}\n # if we are creating child objects then we will not use outer form. this object will manage\n #@current_object = [] # 2014-08-29 - 17:35 unused\n @_system_commands = %w{ bind_global bind_component field_help_text }\n\n init_vars\n $log.debug \"XXX APP CONFIG: #{@config} \" if $log.debug? \n run &block\n end",
"def after_initialize\n super\n extension_loader.activate_extensions # also calls initialize_views\n TrustyCms::Application.config.add_controller_paths(extension_loader.paths(:controller))\n TrustyCms::Application.config.add_eager_load_paths(extension_loader.paths(:eager_load))\n end",
"def post_initialize\n end",
"def definition_setup\n begin_with if respond_to?(:begin_with)\n initialize_page if respond_to?(:initialize_page)\n initialize_region if respond_to?(:initialize_region)\n initialize_regions\n end",
"def run\n if @initializer.nil?\n @initializer = new\n \n yield @initializer.configuration if block_given?\n @initializer.process\n \n start_app\n else\n yield @initializer.configuration if block_given?\n end\n end",
"def pre_init(&block)\n @hooks[:pre_init] = block\n end",
"def init_ext()\n \n end"
] |
[
"0.7670302",
"0.7613924",
"0.6924146",
"0.6807468",
"0.6807468",
"0.6774053",
"0.66600984",
"0.66397446",
"0.66210735",
"0.66168916",
"0.660155",
"0.6524836",
"0.6519737",
"0.65060496",
"0.65060496",
"0.65060496",
"0.64863914",
"0.64827174",
"0.6482114",
"0.64802104",
"0.64800876",
"0.6457499",
"0.6404865",
"0.64019483",
"0.63991195",
"0.63945186",
"0.6376295",
"0.6375072",
"0.63515174",
"0.63492024",
"0.63410676",
"0.6324715",
"0.6322694",
"0.630883",
"0.6307299",
"0.63046384",
"0.62968373",
"0.62968373",
"0.62901837",
"0.62901837",
"0.62901837",
"0.6288684",
"0.62737197",
"0.62733847",
"0.62696487",
"0.6255004",
"0.62412536",
"0.6239266",
"0.6218041",
"0.6218041",
"0.6218041",
"0.6218041",
"0.6212609",
"0.621071",
"0.6194991",
"0.6192936",
"0.61870956",
"0.6185268",
"0.6177057",
"0.6174112",
"0.6169659",
"0.6140334",
"0.6135412",
"0.612224",
"0.6106256",
"0.6092913",
"0.6089066",
"0.60774654",
"0.6066879",
"0.605927",
"0.60514534",
"0.60499805",
"0.60499567",
"0.60474604",
"0.60397255",
"0.6037632",
"0.6032057",
"0.60304064",
"0.6022985",
"0.6007515",
"0.5986616",
"0.59848905",
"0.59833366",
"0.5975948",
"0.5972614",
"0.5962162",
"0.59594065",
"0.5955599",
"0.5938162",
"0.5937554",
"0.5931019",
"0.593075",
"0.59278125",
"0.59269035",
"0.590368",
"0.59016174",
"0.58881325",
"0.5878639",
"0.5876232",
"0.58759636",
"0.5875595"
] |
0.0
|
-1
|
Instance methods collection/key Fetches the data associated with this id from the collection.
|
def orchio_get
if cache.enabled? and response = cache_request.get(id)
if response.header.status == :cache
doc = response.body.document
end
else
response = client.send_request :get, inst_args if response.nil?
doc = Document.new(
response.body.to_hash,
Metadata.new(
:collection => ocollection,
:key => @id,
:ref => response.header.etag
))
end
Result.new(
status: orchio_status(response, 200),
response: response,
results: [ doc ]
)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def [](key)\n return nil if @collection.nil?\n return_item_value key\n end",
"def get(key)\n @collection.deserialize(\n [@dataset.get(key)].compact\n ).first\n end",
"def find(collection, *key)\n command(collection).get(key)\n end",
"def collection\n if @collection.empty? && @loaded == false\n @collection = forward( :\"#{@key}_fetch!\" ) || @collection || []\n @loaded = true\n end\n\n @collection\n end",
"def id\n key\n end",
"def get_collection_key(args)\n\tapi_url = \"#{base_url}/#{args[:collection]}/#{args[:key]}\"\n\tdo_the_get_call( url: api_url, user: @user )\nend",
"def get_collection_id()\r\n return @coll_id\r\n end",
"def key\n id\n end",
"def id\n @collection.id\n end",
"def find(key)\n raise UnknownEntity unless key?(key)\n\n collection[ukey(key)]\n end",
"def id; self['_id']; end",
"def key\n self.id\n end",
"def key\n self.id\n end",
"def key\n self.id\n end",
"def get_value(collection, key)\n @data[collection][key]\n end",
"def find(id)\n @collection[id.to_s]\n end",
"def collection_key(key)\n @_collection_key = key.to_sym\n end",
"def get(id)\n collection.find_one({\n Crocoduck::Store.id_field => id.to_i\n })\n end",
"def [](key)\n key = key.to_s unless key.is_a? String\n puts \"SEARCHING for key '#{key}' in doc '#{@id}'\"\n cursor = @collection.find_one( { plgid: @id } )\n if cursor\n return cursor[key]\n end\n nil\n end",
"def id\n key = self.key\n key.first if key.size == 1\n end",
"def [](key = nil)\n return @collection unless key\n\n result = @collection.find { |f| f.name == key }\n return result.value if result\n\n nil\n end",
"def retrieve\n self.class.get( id )\n end",
"def find_collection\n @collection = Collection.find(params[:id])\n end",
"def find_in_collection(id)\n collection.find_by_id(id)\n end",
"def collection\n @collection ||= PublicEarth::Db::Collection.find_by_id!(collection_id)\n end",
"def [](key)\n fetch(key)\n end",
"def collection_data\n @collection && @collection['data']\n end",
"def key\n raise MissingID if not defined?(@id)\n model.key[id]\n end",
"def dataset_key\n :id\n end",
"def get_collection(name)\n @data[name]\n end",
"def find(id, collection)\n collection.find(id)\n end",
"def [](collection_name)\n collection(collection_name)\n end",
"def get(key)\n db.get(key)\n end",
"def key\n @key.id2name\n end",
"def id\n self['id']\n end",
"def id\n self['id']\n end",
"def key\n return @key\n end",
"def key\n return @key\n end",
"def items_by_id_collection(collection)\n FinderClass.match_by_data(@items.all, collection, :id)\n end",
"def set_data_collection\n @data_collection = DataCollection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.friendly.find(params[:id])\n end",
"def id\n return self[:id]\n end",
"def id\n self[:id]\n end",
"def fetch(key); end",
"def show\n @collection = Collection.find(params[:id])\n end",
"def collection\n @collection ||= Collection.load(self.collection_url)\n end",
"def fetch(key)\r\n obj = for_context(self) { |c| c }\r\n if obj != self\r\n return obj.fetch(key)\r\n end\r\n return super(key)\r\n end",
"def find(id)\n fail(ArgumentError, \"Missing id/slug\") unless id\n id = OAuth::Helper.escape(id)\n result = access_token.get(\"#{API_BASE}/collection/#{id}\")\n fail(ArgumentError, \"Bad request\") unless result.code == \"200\"\n\n Collection.new(result.body)\n end",
"def collection\n instance_variable_get(collection_name) || set_collection(find_collection)\n end",
"def key\n @key\n end",
"def key\n @key\n end",
"def key\n @key\n end",
"def key\n @key\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.friendly.find params[:id]\n end",
"def id\n self[:id]\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def get_key record\n record\n end",
"def collection_key?(collection, key)\n collection?(collection) && @data[collection].key?(key)\n end",
"def collection(new_collection)\n self.collection_key = new_collection\n end",
"def data\n @data || set_collection_data\n end",
"def fetch_data(key_list)\n data = self\n key_list.each { |key| data = fetch_key_with_initialization(key, data) }\n data\n end",
"def col\n volatile[:collection] ||= Collection.find(collection_id)\n end",
"def fetch_data(key)\n map { |om| om.fetch_data(key) }.flatten.compact\n end",
"def collection(data)\n @_collection_name = data.values.first if data.respond_to?(:each_pair)\n self.object(data_object(data).to_a) if data\n end",
"def fetch(key, *extras)\n super(convert_key(key), *extras)\n end",
"def fetch(key, *extras)\n super(convert_key(key), *extras)\n end",
"def fetch_all(key); end",
"def get(*key)\n key = model.typecast_key(key)\n return if key.any? { |v| v.blank? }\n\n if resource = @cache[key]\n # find cached resource\n resource\n elsif !loaded? && (query.limit || query.offset > 0)\n # current query is exclusive, find resource within the set\n\n # TODO: use a subquery to retrieve the Collection and then match\n # it up against the key. This will require some changes to\n # how subqueries are generated, since the key may be a\n # composite key. In the case of DO adapters, it means subselects\n # like the form \"(a, b) IN(SELECT a,b FROM ...)\", which will\n # require making it so the Query condition key can be a\n # Property or an Array of Property objects\n\n # use the brute force approach until subquery lookups work\n lazy_load\n @cache[key]\n else\n # current query is all inclusive, lookup using normal approach\n first(model.key(repository.name).zip(key).to_hash)\n end\n end",
"def key\n @keys.last or raise \"No key specified for collectible! (#{__FILE__}, #{__LINE__})\"\n end",
"def [](name)\n @collection[name.to_s]\n end",
"def reload\n @attributes = collection.find_one(:_id => id).with_indifferent_access\n end",
"def get key\n\t\t@data_base[ key ]\n\tend",
"def _key\n @_key || self.class.key.(self)\n end",
"def fetch(key)\n result.fetch(key)\n end",
"def show\n @collection ||= Collection.shareds.find(params[:id])\n fail ActiveRecord::RecordNotFound if @collection.nil?\n end",
"def key_id; end",
"def get_data_from_part(part, key)\n collection = Collection.find(part.containing_collection.id)\n assoc_map = AssociationMap.new(collection)\n row, column = collection.find(part).first\n assoc_map.getrc(row, column, key)\n end",
"def grab(*key)\n synchronize do\n @data.get(*key)\n end\n end",
"def fetch( key, &block )\n fail NotImplementedError\n end",
"def find(id)\n @data[id]\n end",
"def get_item(key)\n self[key]\n end",
"def collection\n klass.collection\n end",
"def reload\n requires :identity\n\n data = collection.get(identity)\n merge_attributes(data.attributes)\n self\n end",
"def _refresh_get(dataset)\n if (sql = model.fast_pk_lookup_sql) && !dataset.opts[:lock]\n sql = sql.dup\n ds = use_server(dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_first(sql)\n else\n dataset.first\n end\n end",
"def _refresh_get(dataset)\n if (sql = model.fast_pk_lookup_sql) && !dataset.opts[:lock]\n sql = sql.dup\n ds = use_server(dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_first(sql)\n else\n dataset.first\n end\n end",
"def fetch(options = {})\n validate_collection_options(options)\n\n collection_class.new(client.get(base_uri, options).body, client)\n end",
"def perform_get_with_object_from_collection(path, options, klass, collection_name)\n perform_request_with_object_from_collection(:get, path, options, klass, collection_name)\n end",
"def fetch\n @_fetch ||= begin\n path = @parent.build_request_path(@query_attrs)\n @parent.request(@query_attrs.merge(:_method => :get, :_path => path)) do |parsed_data, response|\n @parent.new_collection(parsed_data)\n end\n end\n end",
"def [](key)\n _data.fetch(key) { search_in_kept_data(key) }\n end",
"def id\n @data['id']\n end"
] |
[
"0.67267466",
"0.6711809",
"0.66536564",
"0.6619721",
"0.65680754",
"0.650593",
"0.64997953",
"0.64969677",
"0.6496539",
"0.6477692",
"0.64555687",
"0.6440232",
"0.6440232",
"0.6440232",
"0.64079565",
"0.63917506",
"0.6359318",
"0.63499117",
"0.63336873",
"0.62765396",
"0.62728405",
"0.6254495",
"0.62226886",
"0.61662376",
"0.61599696",
"0.61217314",
"0.61101687",
"0.61048657",
"0.6101913",
"0.6086138",
"0.603398",
"0.60316074",
"0.60213536",
"0.601419",
"0.5984254",
"0.5984254",
"0.59834343",
"0.59834343",
"0.5950318",
"0.5943091",
"0.59278154",
"0.5922168",
"0.59070325",
"0.5904058",
"0.59030366",
"0.589909",
"0.588278",
"0.5878417",
"0.58634067",
"0.585714",
"0.585714",
"0.584802",
"0.584802",
"0.58373123",
"0.58373123",
"0.58274883",
"0.58249533",
"0.58214617",
"0.58214617",
"0.58214617",
"0.5821234",
"0.5821234",
"0.5821234",
"0.58202213",
"0.58202213",
"0.58202213",
"0.58202213",
"0.58164024",
"0.581268",
"0.5797858",
"0.57920384",
"0.579178",
"0.57778174",
"0.5773308",
"0.57699883",
"0.5769231",
"0.5769231",
"0.5764642",
"0.5763116",
"0.57563955",
"0.57544315",
"0.57482386",
"0.57400936",
"0.5702812",
"0.56862605",
"0.56786126",
"0.56772494",
"0.56761736",
"0.5669028",
"0.5658941",
"0.5652298",
"0.5650497",
"0.56496066",
"0.5649062",
"0.5647078",
"0.5647078",
"0.56421083",
"0.5638778",
"0.5638006",
"0.562695",
"0.56236863"
] |
0.0
|
-1
|
Updates the collection with the data associated with this instance.
|
def orchio_put(jdoc)
response = client.send_request :put, inst_args(json: jdoc)
if cache.enabled?
simple_cache.save(
Document.new(
response.body.to_hash,
Metadata.new(
:collection => ocollection,
:key => @id,
:ref => response.header.etag
)))
end
set_ref_value response
orchio_status response, 201
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update attributes, collection #:nodoc:\n 0\n end",
"def reload_data\n reset_collection_data\n reload_collection_data\n end",
"def update\n # TODO: implement update\n end",
"def reload\n requires :instance, :identity\n\n data = collection.get(self.instance, self.identity)\n merge_attributes(data.attributes)\n self\n end",
"def update(attributes, collection)\n raise NotImplementedError, \"#{self.class}#update not implemented\"\n end",
"def reload\n requires :instance, :identity\n\n data = collection.get(instance, identity)\n merge_attributes(data.attributes)\n self\n end",
"def reload\n requires :identity\n\n data = collection.get(identity)\n merge_attributes(data.attributes)\n self\n end",
"def update\n @@all_items[@id] = self\n end",
"def update(attributes, collection)\n return 0 unless collection.query.valid?\n adapter.update(attributes, collection)\n end",
"def update\n render_json :status => :forbidden and return unless @collection.write?(@user, @client)\n if !params[:collection]\n render_json :status => :bad_request, :messages => \"Tried to update collection with no data.\" and return\n end\n @collection.update_attributes(params[:collection].slice(:metadata, :read_only, :title, :tags, :priv))\n render_json :entry => @collection.to_hash(@user, @client) and return\n end",
"def update\n @objects.map(&:update);\n end",
"def update\n unless params[:update_collection].nil?\n process_banner_input\n process_logo_input\n end\n\n process_member_changes\n @collection.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE unless @collection.discoverable?\n # we don't have to reindex the full graph when updating collection\n @collection.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX\n if @collection.update(collection_params.except(:members))\n # This is the reason for the monkey patch.\n redirect_to hyrax.dashboard_collection_path, notice: t('hyrax.dashboard.my.action.collection_update_success')\n else\n after_update_error\n end\n end",
"def update\n record.assign_attributes(data)\n record.save! if record.changed?\n end",
"def update(attributes, collection)\n #collection[0].model.last_query = [attributes, collection]\n fm_params = prepare_fmp_attributes(attributes)\n counter = 0\n collection.each do |resource|\n rslt = layout(resource.model).edit(resource.instance_variable_get(:@_record_id), fm_params)\n merge_fmp_response(resource, rslt[0])\n resource.persistence_state = DataMapper::Resource::PersistenceState::Clean.new resource\n counter +=1\n end\n counter \n end",
"def update(*)\n assert_source_saved 'The source must be saved before mass-updating the collection'\n super\n end",
"def update(*)\n assert_source_saved 'The source must be saved before mass-updating the collection'\n super\n end",
"def _update_dataset\n this\n end",
"def _update_dataset\n this\n end",
"def update!(*)\n assert_source_saved 'The source must be saved before mass-updating the collection'\n super\n end",
"def update!(*)\n assert_source_saved 'The source must be saved before mass-updating the collection'\n super\n end",
"def update\n if @collection.update(collection_params)\n render json: @collection, status: :ok#, location: @collection\n else\n render json: @collection.errors, status: :unprocessable_entity\n end\n end",
"def update_collection(attrs)\n # OVERRIDE: add call to custom #null_controlled_fields! method\n null_controlled_fields!(attrs)\n\n object.attributes = attrs\n object.save!\n end",
"def update_collection(collection)\n # Take the name out of the list of keys so that all that remains are fields to\n # be updated\n name = collection.delete(:name)\n # Because the name may come in many forms we must use something like titlecase to help\n # account for variations\n name = name.last.titleize\n \n # Due to the way that batches are handled a collection may appear multiple times. Presume\n # that if it has already been processed it is safe to skip any duplicates\n if (@successful_updates.include?(name) or \n @failed_updates.include?(name))\n log_message(\"Skipping duplicate collection entry\")\n return\n end\n\n coll = Collection.where(title: name).first\n \n if (coll.present? and (coll.title == name))\n log_message(\"Processing #{coll.title}\")\n update_and_save_metadata(coll, collection) \n @successful_updates << name\n else\n log_message(\"Could not locate #{name}\", Logger::WARN)\n @failed_updates << name\n end\n end",
"def reload\n @attributes = collection.find_one(:_id => id).with_indifferent_access\n end",
"def refresh\n set_attributes\n end",
"def update!(**args)\n @collection = args[:collection] if args.key?(:collection)\n end",
"def update\n begin\n @collection = Collection.find(params[:id])\n if params[:collection][:invite_only] && params[:invitations]\n @collection.invited_user_ids = params[:invitations][:user_ids] \n end\n @collection.assign_attributes(params[:collection])\n\n @collection.transaction do\n @collection.save!\n end\n\n render \"show\", handlers: [:rabl]\n \n rescue ActiveRecord::RecordInvalid => invalid\n render :json => @collection.errors.full_messages, status: 422\n end\n end",
"def update\n update_cache\n reload\n\n self\n end",
"def refresh!\n update_attributes(\n books: update_data,\n books_count: update_data.length\n )\n end",
"def data\n @data || set_collection_data\n end",
"def update\n respond_to do |format|\n if @collection.update(collection_params)\n format.html { redirect_to account_collections_url, notice: 'Collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, params[:id]\n @collection = Collection.find(params[:id])\n flash[:notice] = 'Collection was successfully updated.' if @collection.update(collection_params)\n respond_with(@collection)\n end",
"def update\n update! do |success, failure|\n success.html { redirect_to collection_path }\n end\n end",
"def collection(new_collection)\n self.collection_key = new_collection\n end",
"def update_attributes\n return transform_attributes.except(:id) if klass == Collection\n if attributes[:collection].present?\n transform_attributes.except(:id).except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })\n elsif attributes[:collections].present?\n collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|\n ids[index] = element\n end\n transform_attributes.except(:id).except(:collections).merge(member_of_collections_attributes: collection_ids)\n else\n transform_attributes.except(:id)\n end\n end",
"def update\n raise NotImplementedError\n end",
"def update\n raise NotImplementedError\n end",
"def update\n # don't need to update; hash is shared\n end",
"def update\n \n end",
"def update\n self.publish_json\n end",
"def update\n @grid.update\n end",
"def update_data\n @store.get_data true\n end",
"def update\n @dirty = true\n end",
"def update\n\t\t\n\t\tend",
"def update\n update_all\n end",
"def touch_collection_date\n self.collection.updated_at = DateTime.now()\n self.collection.save\n end",
"def reload_collection_data\n collection_view.reloadData\n true\n end",
"def update_without_callbacks\n self.class.collection.save(to_mongo_value)\n end",
"def update\n \n end",
"def update\n end",
"def update\n @collection = Collection.find(params[:id])\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n save_activity(@collection, \"updated collection\")\n \n flash[:notice] = \"Collection #{@collection.name} was successfully updated.\"\n format.html { redirect_to(:action=>:show, :id => @collection) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @collection.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update(collection, entity)\n command(collection).update(entity)\n end",
"def refresh_if_needed\n @data.nil? ? reload_collection_data : false\n end",
"def update(attributes = {})\n super(attributes)\n retrieve!\n self\n end",
"def update\n @data_collection = DataCollection.find(params[:id])\n\n respond_to do |format|\n if @data_collection.update_attributes(params[:data_collection])\n format.html { redirect_to @data_collection, notice: 'Data collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @data_collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\t super do |format|\n\t redirect_to collection_url and return if resource.valid?\n\t end\n\t end",
"def update\n @category_collection = CategoryCollection.find(params[:id])\n @collection = @category_collection.collection\n\n respond_to do |format|\n if @category_collection.update_attributes(params[:category_collection])\n flash[:notice] = 'CategoryCollection was successfully updated.'\n format.html { redirect_to(@collection) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @category_collection.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_data_collection\n @data_collection = DataCollection.find(params[:id])\n end",
"def update_document(fields, safe = false)\n collection.update({\"_id\" => self.id}, fields, :safe => safe)\n reload\n end",
"def update\n update! do |success,failure|\n success.html { redirect_to collection_path }\n failure.html { redirect_to :back, flash: { :error => \"#{I18n.t(:error_saving)}\" } }\n end\n end",
"def rebuild_document_collection()\n end",
"def update!\n self.save\n end",
"def update\n respond_to do |format|\n if @collection.update(collection_params)\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { render :show, status: :ok, location: @collection }\n else\n format.html { render :edit }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @collection.update(collection_params)\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { render :show, status: :ok, location: @collection }\n else\n format.html { render :edit }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @collection.update(collection_params)\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { render :show, status: :ok, location: @collection }\n else\n format.html { render :edit }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n validate_save_and_respond(load_change_set, :edit)\n end",
"def after_update\n super\n touch_associations\n end",
"def update(collection, entity)\n @mutex.synchronize do\n command(collection).update(entity)\n end\n end",
"def update!\n self.list = fetch(V4_URL) + fetch(V6_URL)\n end",
"def update\n @collection = Collection.find(params[:id])\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n format.html { redirect_to @collection, :notice => 'Collection was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @collection.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, @collection\n respond_to do |format|\n if @collection.update(collection_params)\n format.html { redirect_to collection_url(@collection), notice: \"Collection '#{@collection.title}' was successfully updated.\" }\n format.json { render :show, status: :ok, location: @collection }\n else\n format.html { render :edit }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def update\n @custom_collection = CustomCollection.find(params[:id])\n\n respond_to do |format|\n if @custom_collection.update_attributes(params[:custom_collection])\n format.html { redirect_to @custom_collection, notice: 'Custom collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @custom_collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n raise NotImplementedError\n end",
"def _update_dataset\n apply_instance_filters(super)\n end",
"def save\n update({})\n end",
"def update!(**args)\n @collection = args[:collection] if args.key?(:collection)\n @remodelings = args[:remodelings] if args.key?(:remodelings)\n end",
"def _find_or_update_or_build_collection!\n return _flexi_collection if _flexi_collection.present?\n\n # Find existing collection\n self._flexi_collection = COLLECTION.where(\n namespace: self.class.get_flexi_namespace,\n name: self.class.flexi_collection_name,\n partition_id: self.class.flexi_partition_id\n ).first\n\n # Update if schema changed\n if self._flexi_collection\n _update_schema\n else\n _build_collection\n end\n\n self._flexi_collection\n end",
"def update\n raise NotImplementedError\n end",
"def update!(**args)\n @collection_id = args[:collection_id] if args.key?(:collection_id)\n @collection_score = args[:collection_score] if args.key?(:collection_score)\n end",
"def refresh\n @write_lock.synchronize do\n @data = storage.retrieve(self.class, @id)\n @saved = true\n end\n end",
"def update\n @collection = Collection.find(params[:id])\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @collection = Collection.find(params[:id])\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @collection = Collection.find(params[:id])\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_collection\n @collection = Collection.find_by_friendlier_id!(params[:id])\n end",
"def update() end",
"def update_facts(data)\n record_id = assert_record_id(data)\n update_facts_record record_id, data\n end",
"def refresh\n update_attributes_from_id(@id)\n end",
"def update(attributes, collection)\n query = collection.query\n\n # TODO: if the query contains any links, a limit or an offset\n # use a subselect to get the rows to be updated\n\n properties = []\n bind_values = []\n\n # make the order of the properties consistent\n query.model.properties(name).each do |property|\n next unless attributes.key?(property)\n properties << property\n bind_values << attributes[property]\n end\n\n statement, conditions_bind_values = update_statement(properties, query)\n\n bind_values.concat(conditions_bind_values)\n\n execute(statement, *bind_values).to_i\n end",
"def update\n\t\t@components.each do |comp|\n\t\t\tcomp.update\n\t\tend\n\tend",
"def reload\n self.attributes = self.class.find(self.Id).attributes\n self\n end",
"def reload\n self.data = self.class.load_data\n self\n end",
"def update\n @return.update\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def set_collection\n @collection = Collection.find(params[:id])\n end",
"def update\n push_to_db\n end",
"def update\n push_to_db\n end",
"def update\n @collection = Collection.find(params[:id])\n expire_front\n\n\n respond_to do |format|\n if @collection.update_attributes(params[:collection])\n format.html { redirect_to @collection, notice: 'Collection was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.7060871",
"0.68224174",
"0.6822334",
"0.6797786",
"0.6758891",
"0.67026854",
"0.66997886",
"0.6696904",
"0.66311073",
"0.6617713",
"0.6393991",
"0.6373759",
"0.6328539",
"0.6275938",
"0.6268717",
"0.6268717",
"0.62546086",
"0.62546086",
"0.6201978",
"0.6201978",
"0.61372995",
"0.6073576",
"0.606586",
"0.6063489",
"0.5980487",
"0.597824",
"0.59455967",
"0.5937453",
"0.59309673",
"0.5929609",
"0.59099525",
"0.5907358",
"0.58954704",
"0.58914566",
"0.58900803",
"0.5887371",
"0.5887371",
"0.5887201",
"0.5865788",
"0.58356637",
"0.58204573",
"0.5820142",
"0.58171815",
"0.58156973",
"0.5808326",
"0.57969487",
"0.5795493",
"0.57843786",
"0.57398736",
"0.5726964",
"0.56859845",
"0.56616634",
"0.56600684",
"0.56578016",
"0.5651141",
"0.5646475",
"0.56457895",
"0.5638835",
"0.56271166",
"0.56170696",
"0.5585768",
"0.55849767",
"0.55840105",
"0.55840105",
"0.55840105",
"0.557026",
"0.55612326",
"0.5560836",
"0.55545616",
"0.5547978",
"0.5547514",
"0.55475",
"0.55475",
"0.55465347",
"0.5541006",
"0.55363435",
"0.55259335",
"0.5513941",
"0.55138314",
"0.5513022",
"0.5511453",
"0.54995584",
"0.54986745",
"0.54986745",
"0.54986745",
"0.5493708",
"0.54904836",
"0.5490123",
"0.5489696",
"0.54829",
"0.5478015",
"0.54745686",
"0.54710805",
"0.54678667",
"0.54660016",
"0.54660016",
"0.54660016",
"0.54660016",
"0.5462955",
"0.5462955",
"0.54533035"
] |
0.0
|
-1
|
Deletes the primary_key and data associated with this instance from the collection.
|
def orchio_delete
response = client.send_request :delete, inst_args
orchio_status response, 204
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def clear_primary_key\n @attributes[self.primary_key_attribute] = nil\n end",
"def destroy\n unless new_record?\n self.class.collection.remove({:_id => self.id})\n end\n freeze\n end",
"def delete\n data.delete( self ); self\n end",
"def destroy\n result = database.delete self\n if result['ok']\n self['_rev'] = nil\n self['_id'] = nil\n end\n result['ok']\n end",
"def delete\n self.class.delete(self.to_id)\n end",
"def delete\n open\n returning db.delete(self.key) do |result|\n close\n end\n end",
"def delete\n del unless new_record?\n set_deleted_properties\n end",
"def destroy\n Rails.logger.debug {\"destroying #{self}\"}\n\n self.class.collection\n .find(_id:@id)\n .delete_one\n end",
"def delete\n fail 'Can not delete an unsaved model object' if @_pkey_id.nil?\n\n query = \"DELETE FROM #{@_table} WHERE #{@_pkey} = #{@_pkey_id}\"\n\n Taupe::Database.exec query\n\n Taupe::Cache.delete @_cache_key unless @_cache_key.nil?\n end",
"def delete\n self.class.delete(id) if persisted?\n @destroyed = true\n freeze\n end",
"def destroy\n self.class.remove(key)\n end",
"def destroy\n self.class.remove(key)\n end",
"def delete\n self.class.delete(id) if persisted?\n stale_paranoid_value\n freeze\n end",
"def delete\n return WscSdk::Errors.model_does_not_exist(self.endpoint) if new_model?\n result = endpoint.delete(self)\n if result.success?\n clean!\n clear_primary_key\n @partial_data = false\n end\n return result\n end",
"def destroy\n self.run_hook :before_destroy\n result = Driver.client[self.class.coll_name].find({'_id' => self._id}).delete_one\n self.run_hook :after_destroy\n\n result ? true : false\n end",
"def delete\n self.store -= self\n end",
"def _delete_without_checking\n if sql = (m = model).fast_instance_delete_sql\n sql = sql.dup\n ds = use_server(m.dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_delete(sql)\n else\n _delete_dataset.delete \n end\n end",
"def _delete_without_checking\n if sql = (m = model).fast_instance_delete_sql\n sql = sql.dup\n ds = use_server(m.dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_delete(sql)\n else\n _delete_dataset.delete \n end\n end",
"def destroy\n db.delete(id)\n self.freeze\n end",
"def destroy\n Rails.logger.debug {\"destroying #{self}\"}\n\n self.class.collection\n .find(_id:@id)\n .delete_one \n end",
"def delete\n @@data_store.delete(self)\n end",
"def delete\n before_delete\n this.delete\n self\n end",
"def delete!\n if parent\n parent.remove_child(id)\n @parent = nil\n end\n collection.remove(_id: id)\n self.id = nil\n true\n end",
"def del\n connection.del(key_label)\n end",
"def destroy\n result = database.delete_doc self\n if result['ok']\n self['_rev'] = nil\n self['_id'] = nil\n end\n result['ok']\n end",
"def delete\n raise Couchbase::Error::MissingId, \"missing id attribute\" unless @id\n model.bucket.delete(@id)\n @id = nil\n self\n end",
"def destroy\n raise ReadOnlyRecord if readonly?\n delete\n end",
"def delete\n delete_record\n freeze\n end",
"def delete\n if self.client.delete(self.class, self.Id)\n self\n end\n end",
"def delete\n FC::DB.query(\"DELETE FROM #{self.class.table_name} WHERE id=#{@id.to_i}\") if @id\n end",
"def delete\n return super unless mti_class?\n shard_wrangler.class.cascade_delete_all(:id => id)\n if ActiveRecord::IdentityMap.enabled? and persisted?\n ActiveRecord::IdentityMap.remove(self)\n end\n @destroyed = true\n freeze\n end",
"def destroy\n unless new_record?\n connection.delete(\n \"DELETE FROM #{self.class.table_name} \" + \n \"WHERE #{self.class.primary_key} = '#{id}'\", \n \"#{self.class.name} Destroy\"\n )\n end\n\n freeze\n end",
"def destroy\n self.class.delete(id)\n end",
"def delete\n # TODO: implement delete\n end",
"def delete _key\n store.transaction() { |s| s.delete(prepare_key(_key)) }\n end",
"def delete record\n db_name = database_name_for(record)\n coll_name = collection_name_for(record)\n case\n when id = id_for(record)\n pointer = \"/#{db_name}/#{coll_name}/#{id}\"\n res = collection_for(record).remove({:_id => id})\n if res[\"err\"]\n log.error(res[\"err\"])\n else\n log.debug(\"Deleted #{pointer}\")\n end\n when query = delete_query_for(record)\n pointer = \"/#{db_name}/#{coll_name}\"\n res = collection_for(record).remove(query)\n if res[\"err\"]\n log.error(res[\"err\"])\n else\n log.debug(\"Deleted #{res['n']} records from #{pointer}\")\n end\n end\n end",
"def delete!\n StoredProcedures.delete(self.id) if self.id\n end",
"def destroy\n self.class.collection.delete_one(:_id => BSON::ObjectId.from_string(@id))\n end",
"def delete_record\n self.remote_attributes = self.class.identify(self).delete_instance if persisted?\n @destroyed = true\n end",
"def delete!\n Model.model_store.delete!(self)\n end",
"def del(key)\n @first.del(key)\n end",
"def delete\n raise \"'id' is not set.\" if @id == nil\n sql = \"DELETE FROM #{table} WHERE id=#{@id}\"\n Database.transaction(sql)\n @log.debug \"Record[#{self}] is deleted from Table[#{table}]\"\n end",
"def cache_delete\n model.cache_delete_pk(pk)\n end",
"def delete\n @@all_items.delete(@id)\n end",
"def delete\n self.class.db.delete_with_id(self.class.collection_name, id).to_promise_then do\n @deleted = true\n if cache && !cache.includes?(self.class, id)\n msg = \"#{__FILE__}[#{__LINE__}] : #{self.class.name} : expected model with id #{id} to be in cache - cannot delete\"\n Robe.logger.error(msg)\n raise DBError, msg\n end\n cache.delete(self) if cache\n results = []\n self.class.has_one_associations.each do |assoc|\n if assoc.owner\n send(assoc.local_attr).to_promise_then do |one|\n results << one.delete\n end\n end\n end\n results.to_promise_when\n end.to_promise_then do\n results = []\n self.class.has_many_associations.each do |assoc|\n if assoc.owner\n assoc_results = []\n results << send(assoc.local_attr).to_promise.to_promise_then do |many|\n many.each do |one|\n # trace __FILE__, __LINE__, self, __method__, \" deleting associated : #{one}\"\n assoc_results << one.delete\n end\n assoc_results.to_promise_when_on_client\n end\n end\n end\n results.to_promise_when.then do\n self\n end\n end\n end",
"def delete!\n raise \"A database must be setted\" unless self.database\n response = database.delete self\n pristine_copy\n response\n end",
"def destroy\n self.class.database.delete(self)\n end",
"def delete!\n clear!\n delete\n end",
"def destroy\n @key.destroy\n end",
"def delete\n uniques = {}\n model.uniques.each do |field|\n next unless (value = send(field))\n uniques[field] = value.to_s\n end\n\n script(LUA_DELETE, 0,\n { \"name\" => model.name,\n \"id\" => id,\n \"key\" => key.to_s\n }.to_json,\n uniques.to_json,\n model.tracked.to_json\n )\n\n return self\n end",
"def destroy\n self.delete_\n end",
"def destroy\n _raise_readonly_record_error if readonly?\n destroy_associations\n @_trigger_destroy_callback ||= persisted? && destroy_row > 0\n @destroyed = true\n @previously_new_record = false\n freeze\n end",
"def delete(id)\n collection.remove(id)\n end",
"def destroy\n row.delete_attribute(attr_name)\n row.save\n end",
"def _delete_without_checking\n # SEQUEL5: Remove\n if use_prepared_statements_for?(:delete)\n _set_prepared_statement_server(model.send(:prepared_delete)).call(pk_hash)\n else\n super\n end\n end",
"def del\n delete\n end",
"def delete(model)\n id = model.primary_key_value\n store.delete(id, table: table_name)\n end",
"def cache_delete_pk(pk)\n cache_delete(cache_key(pk))\n end",
"def delete\n store.transaction() { |s| s.delete(self.key) }\n self.class.expire_selector\n end",
"def delete(key)\n db.delete(key)\n end",
"def destroy\n @collection.destroy\n end",
"def destroy\n clear\n save\n end",
"def destroy\n self.class.destroy(self.hash)\n self\n end",
"def destroy\n with_redis do |redis|\n redis.del(@set_key)\n redis.del(@id)\n end\n end",
"def destroy\n result = nil\n obj = self.inst_strip_braces(self.object)\n if obj\n # first delete the record from viewable list\n result = Rhom::RhomDbAdapter::delete_from_table(Rhom::TABLE_NAME,\n {\"object\"=>obj})\n # now add delete operation\n result = Rhom::RhomDbAdapter::insert_into_table(Rhom::TABLE_NAME,\n {\"source_id\"=>self.get_inst_source_id,\n \"object\"=>obj,\n \"update_type\"=>'delete'})\n end\n result\n end",
"def destroy\n self.class.collection.find(:_id=>BSON::ObjectId.from_string(@id)).delete_one\n end",
"def delete\n @@contacts.delete(self)\n end",
"def delete\n @@contacts.delete(self)\n end",
"def prepared_delete\n # SEQUEL5: Remove\n cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}\n end",
"def delete!\n deleted\n save!\n end",
"def delete_all\n self.store.delete_keys(find_keys)\n end",
"def destroy\n self.class.collection.find(_id: BSON::ObjectId.from_string(@id)).delete_one \n end",
"def destroy\n db.transaction do\n return save_failure(:destroy) if before_destroy == false\n delete\n after_destroy\n end\n self\n end",
"def delete\n\t\t#@@contacts -= [delete_id.to_i]\n\t\t@@contacts.delete(self)\n\tend",
"def delete(record)\n record.del\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find_by_id(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def delete_record!(record)\n record.public_send(inventory_collection.delete_method)\n inventory_collection.store_deleted_records(record)\n end",
"def remove\n \n \n Document.destroy(self.document_id)\n self.destroy\n \n end",
"def delete\n association.delete association[element.dataset[:index].to_i]\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def destroy\n hashback_backend.delete(_hashback_id_key)\n end",
"def destroy\n self.is_deleted = true\n self.save!\n run_callbacks :destroy do\n delete\n end\n end",
"def delete\n deleted\n save\n end",
"def destroy!\n @domain.delete_attributes(@key)\n end",
"def delete\n redis.del key\n end",
"def destroy\n\t#Rails.logger.debug {\"destroying #{self}\"}\n\t#byebug\n\tbson_id=BSON::ObjectId.from_string(@id)\n\tself.class.collection.find(:_id=>bson_id).delete_one\nend",
"def delete(key)\n @data.delete(key).tap {\n save if autosave?\n }\n end",
"def destroy\n DB.execute <<SQL\nDELETE FROM #{self.class.table}\nWHERE id = #{@hash['id']}\nSQL\n end",
"def delete(id)\n collection.remove({ _id: id })\n end",
"def delete\n object.delete(:version_id => @version_id)\n end",
"def delete key\n rv = self[key]\n self.removeField key\n return rv\n end",
"def delete_all\n store.delete(KEY)\n self\n end",
"def destroy\n self.class.delete(id)\n end",
"def clear\n @dao.collection.remove\n end",
"def delete\n out = _delete(id) if @store\n @id = nil\n @store = nil\n out\n end",
"def delete key\n\t\tdata = @data_base.delete key\n\t\tupdate_database\n\t\tdata\n\tend",
"def delete_from_index\n SearchIndex.delete_record(self)\n end",
"def delete_from_index\n SearchIndex.delete_record(self)\n end",
"def destroy\n return super unless mti_class?\n shard_wrangler.destroy\n if ActiveRecord::IdentityMap.enabled? and persisted?\n ActiveRecord::IdentityMap.remove(self)\n end\n @destroyed = true\n freeze\n end",
"def _delete_dataset\n this\n end",
"def _delete_dataset\n this\n end"
] |
[
"0.7554091",
"0.7028249",
"0.68953925",
"0.6870763",
"0.67941034",
"0.665962",
"0.66100174",
"0.6609745",
"0.6572196",
"0.65106255",
"0.64929336",
"0.64929336",
"0.6480663",
"0.64711666",
"0.6460154",
"0.6446744",
"0.6444225",
"0.6444225",
"0.6415732",
"0.6394174",
"0.63602424",
"0.6354732",
"0.63248307",
"0.63178253",
"0.6316599",
"0.6311161",
"0.63012934",
"0.62781703",
"0.6274927",
"0.6225741",
"0.6224385",
"0.62187535",
"0.62160677",
"0.6173456",
"0.6167098",
"0.615647",
"0.61547965",
"0.6154296",
"0.6144276",
"0.6132717",
"0.6121954",
"0.6111018",
"0.6098447",
"0.6094506",
"0.60821646",
"0.6077616",
"0.6053123",
"0.6051224",
"0.6051113",
"0.6035007",
"0.60254115",
"0.6023578",
"0.60041565",
"0.6003841",
"0.6003198",
"0.6002854",
"0.59967464",
"0.5989945",
"0.5968932",
"0.5958603",
"0.5952867",
"0.5939433",
"0.59319085",
"0.59301543",
"0.59199744",
"0.5913872",
"0.59052706",
"0.59052706",
"0.59005594",
"0.5897989",
"0.58921355",
"0.5890159",
"0.5882953",
"0.5873937",
"0.58722186",
"0.5870564",
"0.5865313",
"0.5847581",
"0.58467734",
"0.5834768",
"0.58327144",
"0.58324116",
"0.58282465",
"0.58255",
"0.58234376",
"0.58208364",
"0.58198345",
"0.58053035",
"0.58044565",
"0.58018786",
"0.5801267",
"0.57977504",
"0.5796275",
"0.5792828",
"0.57771033",
"0.57759815",
"0.57727927",
"0.57727927",
"0.5761552",
"0.5746621",
"0.5746621"
] |
0.0
|
-1
|
Deletes the primary_key and purges all of its immutable data from the collection.
|
def orchio_purge
response = client.send_request :delete, inst_args(path: "?purge=true")
orchio_status response, 204
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def clear_primary_key\n @attributes[self.primary_key_attribute] = nil\n end",
"def delete _key\n store.transaction() { |s| s.delete(prepare_key(_key)) }\n end",
"def delete\n open\n returning db.delete(self.key) do |result|\n close\n end\n end",
"def prepared_delete\n # SEQUEL5: Remove\n cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}\n end",
"def delete(key)\n doozer_pool.with_connection do |doozer|\n doozer.delete(full_key(key))\n end\n end",
"def delete\n fail 'Can not delete an unsaved model object' if @_pkey_id.nil?\n\n query = \"DELETE FROM #{@_table} WHERE #{@_pkey} = #{@_pkey_id}\"\n\n Taupe::Database.exec query\n\n Taupe::Cache.delete @_cache_key unless @_cache_key.nil?\n end",
"def cache_delete_pk(pk)\n cache_delete(cache_key(pk))\n end",
"def cache_delete\n model.cache_delete_pk(pk)\n end",
"def delete\n self.class.delete(id) if persisted?\n stale_paranoid_value\n freeze\n end",
"def _delete_without_checking\n if sql = (m = model).fast_instance_delete_sql\n sql = sql.dup\n ds = use_server(m.dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_delete(sql)\n else\n _delete_dataset.delete \n end\n end",
"def _delete_without_checking\n if sql = (m = model).fast_instance_delete_sql\n sql = sql.dup\n ds = use_server(m.dataset)\n ds.literal_append(sql, pk)\n ds.with_sql_delete(sql)\n else\n _delete_dataset.delete \n end\n end",
"def destroy\n result = database.delete self\n if result['ok']\n self['_rev'] = nil\n self['_id'] = nil\n end\n result['ok']\n end",
"def delete_all\n store.delete(KEY)\n self\n end",
"def delete\n raise Couchbase::Error::MissingId, \"missing id attribute\" unless @id\n model.bucket.delete(@id)\n @id = nil\n self\n end",
"def delete\n self.store -= self\n end",
"def del(key)\n @first.del(key)\n end",
"def delete_by_primary_key(primary_key)\n query = \"DELETE FROM `#{@table_name}` WHERE \"+build_where({@primary_key => primary_key})\n\n begin\n queryresult = @mysql.query(query)\n rescue Exception => e\n @log.error(\"#{e}\")\n return false\n end\n\n expire_table_cache(get_all_related_tables)\n true\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find_by_id(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def destroy\n db.delete(id)\n self.freeze\n end",
"def destroy_all\n ids = self.all.map{|item| item.id}\n bulk_update do\n ids.each do |item|\n find(item).destroy\n end\n end\n # Note collection is not emptied, and next_id is not reset.\n end",
"def delete_all\n self.store.delete_keys(find_keys)\n end",
"def delete\n redis.del key\n end",
"def delete\n @@all_items.delete(@id)\n end",
"def delete(key)\n db.delete(key)\n end",
"def purge!\n db.transaction do |transaction|\n transaction.execute(\"DELETE FROM 'heap_objects'\")\n transaction.execute(\"DELETE FROM 'references'\")\n end\n self\n end",
"def destroy\n self.class.remove(key)\n end",
"def destroy\n self.class.remove(key)\n end",
"def destroy\n unless new_record?\n self.class.collection.remove({:_id => self.id})\n end\n freeze\n end",
"def delete(key)\n return if @no_update == true\n @store.transaction do\n @store.delete(key)\n end\n end",
"def destroy\n @key.destroy\n end",
"def delete\n return super unless mti_class?\n shard_wrangler.class.cascade_delete_all(:id => id)\n if ActiveRecord::IdentityMap.enabled? and persisted?\n ActiveRecord::IdentityMap.remove(self)\n end\n @destroyed = true\n freeze\n end",
"def cleanup\n @redis.del(key)\n @current_id = nil\n end",
"def del\n connection.del(key_label)\n end",
"def delete!\n clear!\n delete\n end",
"def destroy\n raise ReadOnlyRecord if readonly?\n delete\n end",
"def no_primary_key\n clear_setter_methods_cache\n self.simple_pk = @primary_key = nil\n end",
"def no_primary_key\n clear_setter_methods_cache\n self.simple_pk = @primary_key = nil\n end",
"def destroy\n Rails.logger.debug {\"destroying #{self}\"}\n\n self.class.collection\n .find(_id:@id)\n .delete_one\n end",
"def delete\n self.class.delete(id) if persisted?\n @destroyed = true\n freeze\n end",
"def delete(key)\n in_transaction_wr\n @table.delete key\n end",
"def delete\n out = _delete(id) if @store\n @id = nil\n @store = nil\n out\n end",
"def delete_permanently\n result = delete\n self.class.with_deleted do\n self.class.delete_permanently self.id\n end\n result\n end",
"def delete\n store.transaction() { |s| s.delete(self.key) }\n self.class.expire_selector\n end",
"def _delete_without_checking\n # SEQUEL5: Remove\n if use_prepared_statements_for?(:delete)\n _set_prepared_statement_server(model.send(:prepared_delete)).call(pk_hash)\n else\n super\n end\n end",
"def destroy\n with_redis do |redis|\n redis.del(@set_key)\n redis.del(@id)\n end\n end",
"def purge\n return nullify unless _association.destructive?\n\n after_remove_error = nil\n criteria.delete_all\n many = _target.clear do |doc|\n execute_callback :before_remove, doc\n unbind_one(doc)\n doc.destroyed = true\n begin\n execute_callback :after_remove, doc\n rescue StandardError => e\n after_remove_error = e\n end\n end\n\n raise after_remove_error if after_remove_error\n\n many\n end",
"def delete(key)\n transaction do |y|\n y.delete(key)\n end\n end",
"def purge!\n Document.delete_all\n end",
"def destroy\n Rails.logger.debug {\"destroying #{self}\"}\n\n self.class.collection\n .find(_id:@id)\n .delete_one \n end",
"def delete!\n uniq.bulk_job { |e| e.delete! }\n end",
"def delete(key)\n @data.delete(key).tap {\n save if autosave?\n }\n end",
"def delete!\n if parent\n parent.remove_child(id)\n @parent = nil\n end\n collection.remove(_id: id)\n self.id = nil\n true\n end",
"def delete\n data.delete( self ); self\n end",
"def delete\n delete_record\n freeze\n end",
"def delete key\n\t\tdata = @data_base.delete key\n\t\tupdate_database\n\t\tdata\n\tend",
"def delete row_ind\n key, row = @row_refs.at row_ind\n return unless key\n\n if key.atom?\n if @row_refs.delete row_ind\n row.send :remove!\n self\n end\n else\n if row.send :reduce_repeated\n @row_refs.taper row_ind\n self\n end\n end\n end",
"def delete\n self.class.db.delete_with_id(self.class.collection_name, id).to_promise_then do\n @deleted = true\n if cache && !cache.includes?(self.class, id)\n msg = \"#{__FILE__}[#{__LINE__}] : #{self.class.name} : expected model with id #{id} to be in cache - cannot delete\"\n Robe.logger.error(msg)\n raise DBError, msg\n end\n cache.delete(self) if cache\n results = []\n self.class.has_one_associations.each do |assoc|\n if assoc.owner\n send(assoc.local_attr).to_promise_then do |one|\n results << one.delete\n end\n end\n end\n results.to_promise_when\n end.to_promise_then do\n results = []\n self.class.has_many_associations.each do |assoc|\n if assoc.owner\n assoc_results = []\n results << send(assoc.local_attr).to_promise.to_promise_then do |many|\n many.each do |one|\n # trace __FILE__, __LINE__, self, __method__, \" deleting associated : #{one}\"\n assoc_results << one.delete\n end\n assoc_results.to_promise_when_on_client\n end\n end\n end\n results.to_promise_when.then do\n self\n end\n end\n end",
"def cleanup\n keys = redis.keys(raw_data_key('*')) + redis.keys(data_key('*'))\n multi do\n keys.each{|key| redis.del(key)}\n end\n super\n end",
"def del\n redis do |conn|\n conn.multi do |pipeline|\n pipeline.zrem(DIGESTS, key.digest)\n pipeline.del(key.digest, key.queued, key.primed, key.locked, key.info)\n end\n end\n end",
"def delete!\n raise \"A database must be setted\" unless self.database\n response = database.delete self\n pristine_copy\n response\n end",
"def delete\n self.class.delete(self.to_id)\n end",
"def delete(model)\n id = model.primary_key_value\n store.delete(id, table: table_name)\n end",
"def delete\n del unless new_record?\n set_deleted_properties\n end",
"def delete\n @@data_store.delete(self)\n end",
"def delete_key(key)\n end",
"def purge\n\n DataMapper.repository(@dm_repository) {\n\n DmExpression.all.each { |de| de.destroy }\n #\n # TODO : find simpler way to do that\n }\n end",
"def delete key\n rv = self[key]\n self.removeField key\n return rv\n end",
"def destroy\n DB.execute <<SQL\nDELETE FROM #{self.class.table}\nWHERE id = #{@hash['id']}\nSQL\n end",
"def delete\n self.class.active.delete(@id.to_i)\n unless @id.nil?\n RedisRecord.redis.del self.class::SCOPE.to_s + ':' + @id.to_s\n yield\n end\n reset\n end",
"def clear_by_key(key)\n delete(key)\n end",
"def delete(key)\n responsible_clients(key).each do |v|\n with_retries { v.logical.delete(wrap_key(key)) }\n end\n end",
"def delete\n self.class.redis_objects.each do |key, obj|\n obj = self.send(key.to_sym)\n if obj.class == Redis::Set || obj.class == Redis::HashKey || obj.class == Redis::List\n delete_key(key)\n else\n obj.delete\n end\n end\n end",
"def delete(model)\n\n # LREM key 0 <id> means remove all elements matching <id>\n # @see http://redis.io/commands/lrem\n key.call(\"LREM\", 0, model.id)\n end",
"def clear!\n @columns.clear\n @columns_hash.clear\n @primary_keys.clear\n @tables.clear\n @version = nil\n end",
"def destroy\n result = database.delete_doc self\n if result['ok']\n self['_rev'] = nil\n self['_id'] = nil\n end\n result['ok']\n end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def del\n delete\n end",
"def clear\n self.lock_acquire_time = nil\n\n redis.del(key)\n end",
"def delete(key)\n run_hook(:before_delete)\n db.delete(key)\n run_hook(:after_delete)\n end",
"def delete()\n db = PG.connect({ dbname: 'Music_Collection', host: 'localhost'})\n sql = \n \"\n DELETE FROM Music_Collection where id = #{@id};\n \"\n db.exec(sql)\n db.close()\nend",
"def del(key)\n response = db.delete_item(@table_name, {'HashKeyElement' => {'S' => key}})\n true\n end",
"def delete(key)\n data.delete(key)\n @deleted_hash[key] = nil\n end",
"def delete(key)\n @table.delete(key)\n end",
"def delete_from_index\n case self.class.update_index_policy\n when :immediate_with_refresh\n self.class.delete_id_from_index(self.id, :refresh => true)\n # As of Oct 25 2010, :refresh => true is not working\n self.class.refresh_index()\n when :enqueue\n DistributedIndexing::RemoveDocuments.perform_async(self.class.to_s, [self.id.to_s])\n else\n self.class.delete_id_from_index(self.id)\n end\n end",
"def delete record\n db_name = database_name_for(record)\n coll_name = collection_name_for(record)\n case\n when id = id_for(record)\n pointer = \"/#{db_name}/#{coll_name}/#{id}\"\n res = collection_for(record).remove({:_id => id})\n if res[\"err\"]\n log.error(res[\"err\"])\n else\n log.debug(\"Deleted #{pointer}\")\n end\n when query = delete_query_for(record)\n pointer = \"/#{db_name}/#{coll_name}\"\n res = collection_for(record).remove(query)\n if res[\"err\"]\n log.error(res[\"err\"])\n else\n log.debug(\"Deleted #{res['n']} records from #{pointer}\")\n end\n end\n end",
"def clear\n @dao.collection.remove\n end",
"def destroy\n self.class.collection.delete_one(:_id => BSON::ObjectId.from_string(@id))\n end",
"def destroy\n _raise_readonly_record_error if readonly?\n destroy_associations\n @_trigger_destroy_callback ||= persisted? && destroy_row > 0\n @destroyed = true\n @previously_new_record = false\n freeze\n end",
"def delete( *regexs )\n self.dup.delete!( *regexs )\n end",
"def purge\n @db.execute( \"DELETE FROM #{TABLE_NAME};\" )\n end",
"def delete_row(key)\n hbase.deleteAllRow(table_name, key)\n end",
"def delete(key)\n @store.delete(key)\n end",
"def destroy\n unless new_record?\n connection.delete(\n \"DELETE FROM #{self.class.table_name} \" + \n \"WHERE #{self.class.primary_key} = '#{id}'\", \n \"#{self.class.name} Destroy\"\n )\n end\n\n freeze\n end",
"def delete!\n StoredProcedures.delete(self.id) if self.id\n end",
"def delete! key = nil\n if key.nil?\n @schema.delete!\n @values.clear\n else\n key = ::Kernel.String(key).to_sym\n @schema.delete! key\n @values.delete key\n end\n self\n end",
"def delete\n FC::DB.query(\"DELETE FROM #{self.class.table_name} WHERE id=#{@id.to_i}\") if @id\n end",
"def delete(model)\n redis.srem(key, model.id)\n end"
] |
[
"0.7623547",
"0.676074",
"0.6566118",
"0.6549186",
"0.6468959",
"0.6446538",
"0.6420802",
"0.63993037",
"0.6375594",
"0.63721424",
"0.63721424",
"0.6358281",
"0.6340975",
"0.63345057",
"0.632127",
"0.6305836",
"0.6294877",
"0.6271532",
"0.62414324",
"0.6227867",
"0.62187403",
"0.6196755",
"0.61825943",
"0.6155895",
"0.6152566",
"0.6146308",
"0.6146308",
"0.6122404",
"0.6106615",
"0.6087682",
"0.6065919",
"0.6055501",
"0.6039852",
"0.60330725",
"0.60295045",
"0.6003375",
"0.6003375",
"0.5991007",
"0.5989263",
"0.59799176",
"0.5973735",
"0.5971404",
"0.59713376",
"0.5948641",
"0.59417826",
"0.5932426",
"0.5924524",
"0.5904205",
"0.58999336",
"0.58888483",
"0.58870476",
"0.5886621",
"0.58855003",
"0.5884964",
"0.58828264",
"0.58790076",
"0.58708113",
"0.5868452",
"0.5868215",
"0.58518773",
"0.5830849",
"0.5830478",
"0.58219624",
"0.5800078",
"0.579564",
"0.57929856",
"0.57928485",
"0.5790656",
"0.5786636",
"0.57832587",
"0.5774462",
"0.5769962",
"0.57643664",
"0.57559055",
"0.5742982",
"0.574277",
"0.574277",
"0.574277",
"0.574277",
"0.574277",
"0.57384056",
"0.57323366",
"0.57267106",
"0.5726433",
"0.57251257",
"0.5717364",
"0.57114196",
"0.56919533",
"0.5679733",
"0.5677473",
"0.567572",
"0.5673209",
"0.5666483",
"0.5659817",
"0.5659498",
"0.56566584",
"0.5652513",
"0.56512225",
"0.56507677",
"0.56365997",
"0.56363785"
] |
0.0
|
-1
|
Instance methods collection/key/ref Gets the key/value pair by its 'ref' value.
|
def orchio_get_by_ref(ref)
response = client.send_request :get, inst_args(ref: ref)
Result.new(
status: orchio_status(response, 200),
response: response,
results: [ Document.new(
response.body.to_hash,
Metadata.new(
:collection => ocollection,
:key => @id,
:ref => response.header.etag
))]
)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get(ref)\n @map[ref]\n end",
"def [](ref_id)\n response = @key_value.perform(:get, ref_id)\n Ref.new(@key_value.collection, @key_value.key, response)\n end",
"def [](key)\n @lock.synchronize do\n ref = @references[key]\n value = ref.object if ref\n value\n end\n end",
"def [](key)\n __getobj__[key]\n end",
"def []( ref )\n query.query_values[ ref.to_s ]\n end",
"def []( sym )\n @hash_references[sym]\n end",
"def [](key)\n @lock.synchronize do\n rkey = ref_key(key)\n @values[rkey] if rkey\n end\n end",
"def [](key)\n find_value(key)\n end",
"def get(key); end",
"def get(key); end",
"def get(key); end",
"def get(key); end",
"def reference\n value_for('reference')\n end",
"def [](key)\n\t\t\t\treturn(lookup(key))\n\t\t\tend",
"def [](key)\n\t\t\t\treturn(lookup(key))\n\t\t\tend",
"def get(key)\n \n end",
"def get(key)\n end",
"def reference(key)\n descriptors = mapping(key).descriptors\n instance_eval(&descriptors)\n end",
"def get(key)\n end",
"def get(key)\n @first.get(key)\n end",
"def dereference(obj)\n result = obj\n if(obj.is_a?(Hash))\n name = obj['Ref']\n if(name)\n p_val = parameters[name.to_s]\n if(p_val)\n result = p_val\n end\n end\n end\n result\n end",
"def get_value(key)\n self[key]\n end",
"def [](key)\n self.get(key)\n end",
"def reference\n @data['reference']\n end",
"def [](key)\n fetch(key)\n end",
"def [](key)\n get(key)\n end",
"def [](key)\n get(key)\n end",
"def [](key)\n get(key)\n end",
"def [](key)\n get(key)\n end",
"def [](key)\n self.internal_object[key.to_s]\n end",
"def ref\n @ref ||= self.node.attributes.to_h[\"ref\"]\n end",
"def lookup(ref)\n case ref\n when Enumeration,Class\n ref\n when Symbol\n get(ref) || enum(ref,nil)\n when Fixnum\n get(ref) || enum(nil,ref)\n else\n nil\n end\n end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def [](key)\n dummy = Pair.new(key,nil)\n pair = @tree.get(dummy)\n return nil unless pair\n return pair.value\n end",
"def get(key)\n position = find(key)\n if position != nil\n @values[position]\n else\n nil\n end\n end",
"def get(key)\n @ivar.each_with_index do |ele, i|\n if ele[0] == key \n return ele[1]\n end\n end\n end",
"def [](key)\n\t\tget key\n\tend",
"def [](key)\n linkmap.fetch(key)\n end",
"def get_value(collection, key)\n @data[collection][key]\n end",
"def [](key)\n ruby_get(key&&key.to_s)\n end",
"def lookup(key)\n if key_pair = pair(key, hash(key))\n key_pair[1]\n end\n end",
"def map_get(value, key = nil)\r\n case value\r\n when Symbol\r\n if respond_to?(value) ||\r\n self.class.model.try(:reflect_on_association, value)\r\n\r\n send value\r\n else\r\n resource.send value\r\n end\r\n when Proc\r\n begin\r\n instance_eval &value\r\n rescue => e # Bypass method missing.\r\n raise\r\n end\r\n when false then :__false__\r\n when Fixnum\r\n if self.class.versions[value][:attributes].try :has_key?, key\r\n map_get self.class.versions[value][:attributes][key], key\r\n else\r\n raise InvalidVersion, \"version #{value} has no attribute #{key}\"\r\n end\r\n else\r\n value\r\n end\r\n end",
"def [](key)\n\n lookup(key.to_s)\n end",
"def get(kind, key)\n end",
"def reference_attribute\n\t\t\tsorted_attributes.first\n\t\tend",
"def [] key\n\t\t\t\t@keyed[key]&.value\n\t\t\tend",
"def get(key)\n self.send(key)\n end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key); end",
"def [](key)\n field_get key\n end",
"def [](k)\n internal[k]\n end",
"def [](key); self.properties[key.to_s]; end",
"def [](k)\n @hash[k]\n end",
"def [](key)\n @internal_hash[key]\n end",
"def get(key)\n @hash[key]\n end",
"def [](key)\n to_h[key]\n end",
"def [](key)\n to_h[key]\n end",
"def get_hash_val(name)\n\t\tfetch(name) if has_key?(name)\n\tend",
"def deref(s)\n\n v = lookup_value(s)\n\n if Flor.is_tree?(v)\n\n ref =\n case v[0]\n when '_func' then true\n when '_proc' then v[1]['proc'] != s\n when '_tasker' then v[1]['tasker'] != s\n else false\n end\n\n v[1]['oref'] ||= v[1]['ref'] if ref && v[1]['ref']\n v[1]['ref'] = s if ref\n\n v\n\n else\n\n [ '_val', v, tree[2] ]\n end\n\n rescue KeyError => ke\n\n nil\n end",
"def get(key)\n @hash.get(key)\n end",
"def ref_key(hash)\n\t\t\t(REF_PROPERTIES.collect { |k| hash[k] } ).to_json\n\t\tend",
"def [](key)\n @data[@aliases[key]]\n end",
"def get(name)\n lookup(key(name.to_s))\n end",
"def [](key)\n entry = find_entry(key)\n return(entry.nil? ? nil : entry[1])\n end",
"def getValue(key)\r\n \r\n return @aHash[key]\r\n end",
"def [](key)\n hash[key]\n end",
"def [](*key)\n get(*key)\n end",
"def resolve_value(obj)\n return unless obj\n project = @parent\n kind = case\n when (ref = obj[:configMapKeyRef]) then ConfigMap\n when (ref = obj[:secretKeyRef]) then Secret\n else\n log.debug \"Unable to resolve value of #{obj}\"\n return\n end\n\n # TODO: would be nicer if this would be provided by the Project (and not need to load ALL objects of the same type)\n resource = kind.new(project, project.client.get(kind.resource_name, name: ref.fetch(:name), namespace: project.name))\n resource[ref[:key]]\n end",
"def [](key)\n values[key]\n end",
"def [](key)\n values[key]\n end",
"def [](key)\n @hash[key]\n end",
"def lookup(feature, name)\n value = @hash[feature]\n value = value[name] if value.is_a? Hash\n fail IndexError, \"No CmdRef defined for #{feature}, #{name}\" if value.nil?\n value\n end",
"def get_key_value(key)\n if v = storage.get(key.object_id)\n return key.object_id, v\n end\n storage.get_candidates(key.hash).find do |k,v|\n candidate_key = get_object(k) or next\n candidate_key.eql? key\n end\n end",
"def get(key)\n index = key_index(key)\n if( index )\n self.values.get(index)\n else\n nil\n end\n end",
"def get_item(key)\n self[key]\n end",
"def [](key)\n @hash[key]\n end",
"def [](key)\n @hash[key]\n end",
"def [](key)\n @hash[key]\n end",
"def [](key)\n @hash[key]\n end",
"def [](key)\n @values[key]\n end",
"def hget(key, field); end",
"def hget(key, field); end",
"def get(key)\n @map[key]\n end",
"def []( name )\n @hash[name]\n end",
"def [](key)\n return @item[key]\n end"
] |
[
"0.7826067",
"0.7462541",
"0.74113953",
"0.674426",
"0.6606954",
"0.6471712",
"0.6433135",
"0.64103717",
"0.64073086",
"0.64073086",
"0.64073086",
"0.64073086",
"0.63824517",
"0.63783306",
"0.63783306",
"0.63009024",
"0.62873846",
"0.6264352",
"0.6228431",
"0.6218758",
"0.62175024",
"0.6212955",
"0.6170429",
"0.6130177",
"0.6115589",
"0.6106088",
"0.6106088",
"0.6106088",
"0.6106088",
"0.60585153",
"0.6052561",
"0.6030098",
"0.6002939",
"0.6002939",
"0.5984312",
"0.5981373",
"0.5965627",
"0.596315",
"0.5948256",
"0.5944192",
"0.59369767",
"0.5931645",
"0.5922012",
"0.5918816",
"0.59081787",
"0.59026986",
"0.5883553",
"0.5878326",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5867892",
"0.5861696",
"0.58449715",
"0.5835735",
"0.5835371",
"0.58333045",
"0.58313304",
"0.5826927",
"0.5826927",
"0.5820045",
"0.58048964",
"0.5793905",
"0.57892275",
"0.5788778",
"0.57881194",
"0.57876855",
"0.5787387",
"0.5786576",
"0.5786161",
"0.5777665",
"0.5776046",
"0.5776046",
"0.5773461",
"0.5766579",
"0.5761639",
"0.5739021",
"0.57347745",
"0.5725848",
"0.5725848",
"0.5725848",
"0.5725848",
"0.5723789",
"0.5721651",
"0.5721651",
"0.57071054",
"0.57058793",
"0.57037324"
] |
0.0
|
-1
|
Updates the key/value if the send'ref' value matches the 'ref' value for the latest version in the collection.
|
def orchio_put_if_match(document, ref)
response = client.send_request :put, inst_args(json: document, ref: ref)
set_ref_value response
orchio_status response, 201
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update_refs\n return true if self.user_id or changes.has_key? :user_id\n fields = self.attributes.select {|k,v| changes.has_key? k}\n self.references.update_all(fields) unless self.user_id\n end",
"def update\n true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))\n new_value\n end",
"def get_by_ref(ref)\n res = orchio_get_by_ref ref\n (res.success?) ? res.result.update_rails(self) : false\n end",
"def orchio_update_ref_table(timestamp)\n return if ocollection == RefTable.get_collection_name\n\n if RefTable.enabled?\n primary_key = __ref_value__.gsub(/\"/, '')\n doc = {\n xcollection: ocollection,\n xkey: id,\n xref: primary_key,\n timestamp: timestamp\n }.to_json\n RefTable.new(:id => primary_key).orchio_put doc\n end\n end",
"def ref=(new_ref)\n @ref = new_ref\n end",
"def set_ref_value(response)\n unless response.header.code != 201 || response.header.etag.blank?\n @__ref_value__ = response.header.etag\n orchio_update_ref_table response.header.timestamp\n end\n end",
"def update(event)\n @update.each do |field, newvalue|\n newvalue = expand_references(event, newvalue)\n next unless event.include?(field)\n event.set(field, newvalue)\n end\n end",
"def update\n\t\treturn 0 if @setup.secure or @setup['no_cache']\n\t\tdb = DispRef2PStore.new( @setup['cache_path'] )\n\t\tr = 0\n\t\tdb.transaction do\n\t\t\tdb[Root_DispRef2URL] = Hash.new unless db[Root_DispRef2URL]\n\t\t\tbegin\n\t\t\t\tdb[Root_DispRef2URL].each_key do |url|\n\t\t\t\t\tref = DispRef2URL::new( url )\n\t\t\t\t\tt = ref.restore( db )\n\t\t\t\t\torig = t ? t.dup : nil\n\t\t\t\t\tnew = ref.parse( @setup )\n\t\t\t\t\tif orig != new then\n\t\t\t\t\t\tr += 1\n\t\t\t\t\t\tref.store( db )\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\trescue PStore::Error\n\t\t\tend\n\t\tend\n\t\tdb = nil\n\t\tr\n\tend",
"def [](ref_id)\n response = @key_value.perform(:get, ref_id)\n Ref.new(@key_value.collection, @key_value.key, response)\n end",
"def update!(**args)\n @references = args[:references] if args.key?(:references)\n end",
"def updateReference\n return @references\n end",
"def ref\n ref = @repository.refs.find { |refs_a| refs_a.include?(@sha) }\n ref ? ref.last : @sha\n end",
"def update(updates = {})\n @ref.update(updates)\n end",
"def handle_references_label(vals)\n @references_collection << vals.last\n @references = vals.last if matches_mdes_version(vals)\n end",
"def change_reference(new_reference)\n\n # In datamapper it's not possible to update the key value, so we use adapter\n # https://stackoverflow.com/questions/32302407/updating-a-property-set-as-the-key-in-datamapper\n BookingItem.change_item_reference(new_reference, reference)\n # Update the item references assigned\n BookingDataSystem::BookingLineResource.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n # Update stock locking references\n BookingDataSystem::BookingPrereservationLine.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n\n end",
"def update!(**args)\n @matching_image_reference_key = args[:matching_image_reference_key] if args.key?(:matching_image_reference_key)\n end",
"def uptouch(uid, time)\n ref = ref_for uid, true\n if time > ref.updated_at\n Rcpref.record_timestamps=false\n ref.updated_at = time \n ref.save\n Rcpref.record_timestamps=true\n else\n false\n end\n end",
"def user_reference=(ref)\n #self.update_attribute 'user_reference', ref # infinite loop, must call this setter\n write_attribute(:user_reference, ref)\n fetch\n end",
"def ref\n @ref ||= maybe_ref || api.master_ref.ref\n end",
"def update_record(client, ref)\n puts \" --- update record\" if $VERBOSE\n record = {\n kind: 'Article',\n title: 'Sample',\n text: 'Updated text.'\n }\n result = client.update('Article', record, ref)\n # Make sure the message has the correct fields and values.\n check_result_code(result)\n updated = result[:updated]\n assert_equal(1, updated.length, 'update reply.updated should contain exactly one member')\n ref = updated[0]\n refute_equal(nil, ref, 'update reply record reference can not be nil')\n refute_equal(0, ref, 'update reply record reference can not be 0')\n # verify\n result = client.read('Article', ref)\n check_result_code(result)\n results = result[:results]\n assert_equal(1, results.length, 'read after update reply.results should contain exactly one member')\n record = results[0]\n assert_equal(ref, record[:id], 'read after update reply.results[0].id should match the record reference')\n obj = record[:data]\n assert_equal('Updated text.', obj[:text], 'read after update reply obj.text incorrect')\n ref\n end",
"def update_record(http, ref)\n json = %|{\n \"kind\": \"Article\",\n \"title\": \"Sample\",\n \"text\": \"Updated text.\"\n}|\n resp = http.send_request('POST', \"/v1/Article/#{ref}\", json, { 'Content-Type' => 'application/json' })\n # Response should be an OK with a JSON body.\n assert_equal(Net::HTTPOK, resp.class, 'response not an OK')\n reply = Oj.strict_load(resp.body, symbol_keys: true)\n\n # Make sure the message has the correct fields and values.\n assert_equal(0, reply[:code], 'update reply.code should be 0 meaning no error')\n updated = reply[:updated]\n assert_equal(1, updated.length, 'update reply.updated should contain exactly one member')\n ref = updated[0]\n refute_equal(nil, ref, 'update reply record reference can not be nil')\n refute_equal(0, ref, 'update reply record reference can not be 0')\n ref\n end",
"def update!(**args)\n @page_refs = args[:page_refs] if args.key?(:page_refs)\n end",
"def merge_for_put(current)\n new_version = DeepDup.deep_dup(@document)\n\n if current[\"metadata\"]\n new_version[\"metadata\"][\"selfLink\"] = current[\"metadata\"][\"selfLink\"] if current[\"metadata\"][\"selfLink\"]\n new_version[\"metadata\"][\"uid\"] = current[\"metadata\"][\"uid\"] if current[\"metadata\"][\"uid\"]\n new_version[\"metadata\"][\"resourceVersion\"] = current[\"metadata\"][\"resourceVersion\"] if current[\"metadata\"][\"resourceVersion\"]\n end\n\n if current[\"spec\"]\n new_version[\"spec\"] = {} if !new_version[\"spec\"]\n\n # handle spec.clusterIP\n if new_version[\"spec\"][\"clusterIP\"] && new_version[\"spec\"][\"clusterIP\"] != current[\"spec\"][\"clusterIP\"]\n raise ArgumentError, \"#{@source_file}: Tried to modify spec.clusterIP from #{current[\"spec\"][\"clusterIP\"]} to #{new_version[\"spec\"][\"clusterIP\"]} but the field is immutable\"\n end\n new_version[\"spec\"][\"clusterIP\"] = current[\"spec\"][\"clusterIP\"] if current[\"spec\"][\"clusterIP\"]\n\n end\n\n @preserve_current_values.each do |jsonpath_query|\n jp = JsonPath.new(jsonpath_query)\n current_value = jp.on(current)\n if current_value.length > 1\n raise ArgumentError, \"#{@source_file}: A JSONPath query \\\"#{jsonpath_query}\\\" matched more than one element: #{current_value}. This is not allowed because it should be used to preserve the current value in the Kubernets API server for the property.\"\n end\n\n new_value = jp.on(new_version)\n if new_value.length > 1\n raise ArgumentError, \"#{@source_file}: A JSONPath query \\\"#{jsonpath_query}\\\" matched more than one element: #{new_value}. This is not allowed because it should be used to preserve the current value in the Kubernets API server for the property.\"\n end\n\n if current_value.first != new_value.first\n new_version = JsonPath.for(new_version).gsub(jsonpath_query) { |proposed_value| current_value.first }.to_hash\n end\n end\n\n return new_version\n end",
"def update\n respond_to do |format|\n if @ref.update(ref_params)\n format.html { redirect_to @ref, notice: 'Ref was successfully updated.' }\n format.json { render :show, status: :ok, location: @ref }\n else\n format.html { render :edit }\n format.json { render json: @ref.errors, status: :unprocessable_entity }\n end\n end\n end",
"def resolveVerify\n duplicateGuard = {}\n @records.each_key { |recKey|\n rec = @records[recKey]\n rec.refs.each { |ref|\n ref.resolve self\n preExisting = duplicateGuard[ref.key]\n raise \"Duplicate reference spec: #{r}(#{r.sourceRef}), pre-existing: #{preExisting}(#{preExisting.sourceRef})\" if preExisting\n duplicateGuard[ref.key] = ref\n reKey = ref.toEntity.name\n @reRefs[reKey] = [] unless @reRefs[reKey]\n @reRefs[reKey] << ref\n }\n }\n raise RuntimeError, \"No version defined on #{self}\" unless ver\n self\n end",
"def update\n # don't need to update; hash is shared\n end",
"def []=( ref, val )\n update_query( ref => val )\n val\n end",
"def update!(**args)\n @reference_score = args[:reference_score] if args.key?(:reference_score)\n @references = args[:references] if args.key?(:references)\n @subreference_metadata = args[:subreference_metadata] if args.key?(:subreference_metadata)\n end",
"def touch add_to_collection = true, user = nil\n user ||= @current_user\n # Fetch the reference for this user, creating it if necessary\n ref = ref_for(user, true) # Make if necessary\n if do_save = (add_to_collection && !ref.in_collection) # Collecting for the first time\n ref.in_collection = true\n do_stamp = ref.created_at && ((Time.now - ref.created_at) > 5) # It's been saved before => update created_at time\n end\n do_save = true if ref.created_at.nil?\n if ref.user_id # No point saving w/o a user id (recipe id is assumed)\n if do_stamp\n ref.created_at = ref.updated_at = Time.now\n Rcpref.record_timestamps=false\n ref.save\n Rcpref.record_timestamps=true\n elsif do_save # Save, whether previously saved or not\n ref.save\n else\n ref.touch\n end\n end\n \"Created: #{ref.created_at}.........Updated: #{ref.updated_at}\"\n end",
"def after_persist(doc,instance)\n\t\t\t\t\tdoc.keys.each do |f|\n\t\t\t\t\t\tif f == \"version\"\n\t\t\t\t\t\t\tinstance.send(\"#{f}=\",doc[f])\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tif instance.send(\"#{f}\") != doc[f]\n\t\t\t\t\t\t\t\tinstance.send(\"#{f}=\",doc[f])\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\treturn true\n\t\t\tend",
"def update!(**args)\n @conflicting_reference_id = args[:conflicting_reference_id] if args.key?(:conflicting_reference_id)\n @expiry_time = args[:expiry_time] if args.key?(:expiry_time)\n @id = args[:id] if args.key?(:id)\n @kind = args[:kind] if args.key?(:kind)\n @matches = args[:matches] if args.key?(:matches)\n @original_reference_id = args[:original_reference_id] if args.key?(:original_reference_id)\n @status = args[:status] if args.key?(:status)\n end",
"def on_db_ref(context, ref)\n\tend",
"def update!(**args)\n @attachment_data_ref = args[:attachment_data_ref] if args.key?(:attachment_data_ref)\n end",
"def ref?\n schema[\"$ref\"]\n end",
"def cmp(reference, checked)\n reference.each do |k,v|\n return false if checked[k] != v\n end\n \n return true\n end",
"def object_hash_update(object_doc, collection)\n logger.debug \"Updating object document from collection(#{collection}) by uuid(#{object_doc['@uuid']})\"\n @database.object_doc_update(object_doc, collection)\n end",
"def object_hash_update(object_doc, collection)\n logger.debug \"Updating object document from collection(#{collection}) by uuid(#{object_doc['@uuid']})\"\n @database.object_doc_update(object_doc, collection)\n end",
"def notify_will_change!\n collection_will_change!\n forward \"#{@key}_will_change!\"\n end",
"def update\n @ref = Ref.find(params[:id])\n\n respond_to do |format|\n if @ref.update_attributes(params[:ref])\n format.html { redirect_to(@ref, :notice => 'Ref was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @ref.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def on_db_ref(ref)\n\tend",
"def ref\n reference(@id, @revision)\n end",
"def reference=(ref)\n @reference = ref\n end",
"def update!(**args)\n @reference = args[:reference] if args.key?(:reference)\n @resolutions = args[:resolutions] if args.key?(:resolutions)\n end",
"def update!(**args)\n @web_property_ref = args[:web_property_ref] if args.key?(:web_property_ref)\n end",
"def updated?() updated.present?; end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def lazy_update(ref, track)\n pos = @entries.index { |ce| ce.ref == ref }\n return false unless pos\n\n if @view_type == VIEW_RECORDS_FULL\n least = @entries[pos].xlink.record.least_played_track\n least *= @entries[pos].xlink.record.iplaytime if @count_type == COUNT_TIME\n if @entries[pos].played < least\n @entries[pos].played = least\n else\n return false\n end\n else\n @entries[pos].played += @count_type == COUNT_PLAYED ? 1 : track.iplaytime\n end\n\n @entries.sort! { |ce1, ce2| ce2.played <=> ce1.played }\n\n rank = pos = 0\n last_played = -1\n @entries.each_with_index do |entry, i|\n if entry.played != last_played\n rank = i+1\n last_played = entry.played\n end\n entry.rank = rank\n pos = i if entry.ref == ref\n end\n display_charts(true) if pos < Cfg.max_items\n Trace.debug(\"Charts lazy update done\".green)\n return true\n end",
"def fetch_and_set_dates(refs)\n refs.map do |r|\n c = @github_client.fetch_commit(@repo_user, @repo_name, r[\"object\"][\"sha\"])\n r[\"date\"] = c[\"committer\"][\"date\"]\n r\n end\n end",
"def updated(item)\n end",
"def is_ref? ; !!metadata[:ref] ; end",
"def save_if_match\n status = orchio_put_if_match(to_json_direct, __ref_value__) if valid?\n retval status\n end",
"def update!(**args)\n @references = args[:references] if args.key?(:references)\n @title = args[:title] if args.key?(:title)\n end",
"def field_revised?(name)\n new_record? ? false : revised_changes.has_key?(name.to_s)\n end",
"def cookmarked uid=nil\n if(ref = ref_for uid, false )\n ref.in_collection\n end\n # (ref = (uid.nil? ? current_ref : ref_for(uid, false))) && ref.in_collection\n end",
"def update\n respond_to do |format|\n if @adminref.update(adminref_params)\n format.html { redirect_to @adminref, notice: 'Adminref was successfully updated.' }\n format.json { render :show, status: :ok, location: @adminref }\n else\n format.html { render :edit }\n format.json { render json: @adminref.errors, status: :unprocessable_entity }\n end\n end\n end",
"def collection_updated(object, result)\n key = object.key\n if result\n parent_add(key, object)\n object.subscribe(self)\n else\n object.unsubscribe(self)\n parent_delete(object)\n end\n end",
"def get_file_and_bump shortened\n @coll.find_one_and_update({ shortened: shortened },\n { \"$inc\" => { \"accessed.count\" => 1 },\n \"$set\" => { \"accessed.time\" => Time.now.utc } },\n return_document: :after )\n end",
"def update_collection(collection)\n # Take the name out of the list of keys so that all that remains are fields to\n # be updated\n name = collection.delete(:name)\n # Because the name may come in many forms we must use something like titlecase to help\n # account for variations\n name = name.last.titleize\n \n # Due to the way that batches are handled a collection may appear multiple times. Presume\n # that if it has already been processed it is safe to skip any duplicates\n if (@successful_updates.include?(name) or \n @failed_updates.include?(name))\n log_message(\"Skipping duplicate collection entry\")\n return\n end\n\n coll = Collection.where(title: name).first\n \n if (coll.present? and (coll.title == name))\n log_message(\"Processing #{coll.title}\")\n update_and_save_metadata(coll, collection) \n @successful_updates << name\n else\n log_message(\"Could not locate #{name}\", Logger::WARN)\n @failed_updates << name\n end\n end",
"def save_ref\n if ref = ref_for(nil, false) # Use current user, don't create ref\n ref.save \n end\n end",
"def add_reference(value)\n ref = @ref_by_value[value]\n\n unless ref.present?\n ref = new_ref!(value)\n @ref_by_value[value] = ref\n @value_by_ref[ref] = value\n end\n\n ref\n end",
"def changed_in_latest_version\n if @in_after_callback && RAILS_GTE_5_1\n @record.saved_changes.keys\n else\n @record.changed\n end\n end",
"def process_collection!(name, key, value, remote)\n if collection.key?(name)\n existing_remote = collection[name.to_s][:remote]\n # skip if the existing item is local and the new item is remote\n return if remote && !existing_remote\n raise \"Duplicate item with name '#{name}' was detected.\" unless existing_remote && !remote\n\n # override if the existing item is remote and the new is local\n logger.info \"Duplicate item with name '#{name}' was detected from the remote folder.\"\n end\n collection[name.to_s] = { name: name.to_s, type: key, value: value, remote: remote }\n end",
"def update!(**args)\n @account_ref = args[:account_ref] if args.key?(:account_ref)\n @profile_ref = args[:profile_ref] if args.key?(:profile_ref)\n @web_property_ref = args[:web_property_ref] if args.key?(:web_property_ref)\n end",
"def set_ref\n @ref = Ref.find(params[:id])\n end",
"def changes_against(ref)\n self.class.attribute_names_for_history_changes.inject({}) do |changes, attr|\n old, new = ref.public_send(attr), self.public_send(attr)\n\n changes.tap do |c|\n changed = old.respond_to?(:history_eql?) ?\n !old.history_eql?(new) : old != new\n\n c[attr] = [old, new] if changed\n end\n end\n end",
"def changes_against(ref)\n self.class.attribute_names_for_history_changes.inject({}) do |changes, attr|\n old, new = ref.public_send(attr), self.public_send(attr)\n\n changes.tap do |c|\n changed = old.respond_to?(:history_eql?) ?\n !old.history_eql?(new) : old != new\n\n c[attr] = [old, new] if changed\n end\n end\n end",
"def update_ref_id(ref_id)\r\n node_set = self.datastreams[\"VRA\"].ng_xml.xpath('/vra:vra/vra:image[@refid]')\r\n node_set[0].set_attribute(\"refid\", ref_id)\r\n self.datastreams[\"VRA\"].content = self.datastreams[\"VRA\"].ng_xml.to_s\r\n end",
"def ensure_ref_fetched\n @merge_request.ensure_ref_fetched\n end",
"def update_info_using_crossref\n result=Result.new\n ri_json=CrossrefDoi.reference_integrator_json(self[:doi])\n if ri_json\n fields = [:title, :author, :year, :journal, :volume, :pages, :doi, :journal_abbr, :abstract]\n update_data=fields.inject({}) do |ac,v|\n ac[v]=ri_json.send(v) unless ri_json.send(v).nil?\n ac\n end\n\n self.update(update_data) unless update_data.keys.length==0\n end\n result\n end",
"def get_next_version(object_doc, collection_name)\n logger.debug \"Get next version number for document in collection (#{collection_name}) with uuid (#{object_doc['@uuid']})\"\n object_array =collection_by_name(collection_name).find(\"@uuid\" => object_doc[\"@uuid\"]).sort(\"@version\",-1).to_a\n if (object_array.count < 1)\n version = 0\n else\n version = object_array[0][\"@version\"]\n end\n version += 1\n version\n end",
"def update!(**args)\n @references = args[:references] if args.key?(:references)\n @reply = args[:reply] if args.key?(:reply)\n @summary = args[:summary] if args.key?(:summary)\n end",
"def update!(**args)\n @value = args[:value] if args.key?(:value)\n @version_id = args[:version_id] if args.key?(:version_id)\n end",
"def update!(**args)\n @value = args[:value] if args.key?(:value)\n @version_id = args[:version_id] if args.key?(:version_id)\n end",
"def update!(**args)\n @value = args[:value] if args.key?(:value)\n @version_id = args[:version_id] if args.key?(:version_id)\n end",
"def flag_ref(ref_name)\n @flagged << ref_name.to_s\n @flagged.uniq!\n end",
"def update_ref_paths(data, paths = {})\n paths.each do |path, replace_path|\n replace_path = replace_path.sub(/\\/?$/, \"/\")\n data = data.gsub(/(\"\\$ref\"\\s*:\\s*\")#{Regexp.escape(path)}\\/?/, \"\\\\1#{replace_path}\")\n end\n data\n end",
"def touch entity=nil, collect=false\n return super unless entity\n ref = touched_pointers.create_with(in_collection: collect).find_or_initialize_by user_id: id, entity_type: entity.class.to_s, entity_id: entity.id\n if ref.created_at # Existed prior\n if (Time.now - ref.created_at) > 5\n ref.created_at = ref.updated_at = Time.now\n ref.in_collection ||= collect\n Rcpref.record_timestamps=false\n ref.save\n Rcpref.record_timestamps=true\n elsif collect && !ref.in_collection # Just touch if previously saved\n ref.in_collection = true\n ref.save\n else\n ref.touch\n end\n else # Just save the reference\n ref.save\n end\n end",
"def store_reference\n 5.times do\n self[:reference] = generate_reference\n return reference unless self.class.where(:reference => reference).first\n end\n\n raise \"Could not generate unique reference for order\"\n end",
"def update!(**args)\n @candidate = args[:candidate] if args.key?(:candidate)\n @reference = args[:reference] if args.key?(:reference)\n end",
"def update?(collection, id, data)\n data.each_key do |key|\n return false unless @data[collection][id].key?(key)\n end\n data.each do |key, value|\n @data[collection][id][key] = value\n end\n true\n end",
"def touch_date uid=nil\n if (ref = ref_for uid, false)\n ref.updated_at\n end\n #(ref = uid.nil? ? current_ref : ref_for(uid, false)) && ref.updated_at\n end",
"def ref_params\n params.fetch(:ref, {})\n end",
"def update\n if @reference.update(reference_params)\n redirect_to topic_references_url(@reference.topic), notice: 'Reference was successfully updated.'\n else\n render :edit\n end\n end",
"def update!(**args)\n @change = args[:change] if args.key?(:change)\n @latest_version = args[:latest_version] if args.key?(:latest_version)\n @url = args[:url] if args.key?(:url)\n end",
"def do_rev( hash, override=false )\n hash.delete(:rev) # This is omited to aleviate confusion \n # CouchDB determines _rev attribute on saving, but when #new is loading json passed from the \n # database rev needs to be added to the class. So, the :_rev param is not being deleted anymore\n end",
"def ref_update(user)\n send_as :ref\n from user\n fbml render(:action=>\"/users/profile\",:assigns=>{:user=>user_to_update})\n handle \"a_ref_handle\"\n end",
"def set_retrieved(doc, request, modified)\n doc[\"retrieved\"] = {\n from: request.url,\n at: Time.now,\n modifiedAccordingToASNApi: modified\n }\n doc\nend",
"def update_version( result ) \n self.id = result['id']\n self.rev = result['rev']\n end",
"def update!(**args)\n @versions = args[:versions] if args.key?(:versions)\n end",
"def update!(**args)\n @versions = args[:versions] if args.key?(:versions)\n end",
"def update!(**args)\n @versions = args[:versions] if args.key?(:versions)\n end",
"def update!(**args)\n @address_group_references = args[:address_group_references] if args.key?(:address_group_references)\n @next_page_token = args[:next_page_token] if args.key?(:next_page_token)\n end",
"def latest= new_latest\n frozen_check!\n @gapi.only_read_latest = new_latest\n end",
"def latest= new_latest\n frozen_check!\n @gapi.only_read_latest = new_latest\n end",
"def ref\n @references += 1\n end",
"def attribute_changed_in_latest_version?(attr_name)\n if @in_after_callback && RAILS_GTE_5_1\n @record.saved_change_to_attribute?(attr_name.to_s)\n else\n @record.attribute_changed?(attr_name.to_s)\n end\n end",
"def update_from_reference(reference, attributes = {})\n response = client.patch(\"2.0/tracks/reference/#{reference}\", attributes)\n\n Struct::Track.new(response)\n end",
"def set_ref_seq\n\n seq = segments.map(&:ref_seq).reduce(:+)\n update_attributes(:_ref_seq => seq)\n\n seq\n\n end",
"def update\n respond_to do |format|\n if @ref_attribute.update(ref_attribute_params)\n format.html { redirect_to @ref_attribute, notice: 'Ref attribute was successfully updated.' }\n format.json { render :show, status: :ok, location: @ref_attribute }\n else\n format.html { render :edit }\n format.json { render json: @ref_attribute.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.63141763",
"0.6120266",
"0.56230164",
"0.5622656",
"0.5598712",
"0.55957043",
"0.5541096",
"0.55383784",
"0.5528501",
"0.5486105",
"0.5469642",
"0.53991294",
"0.53391457",
"0.5332891",
"0.5240216",
"0.52378434",
"0.52194005",
"0.51729226",
"0.51292145",
"0.51165825",
"0.5110445",
"0.51058286",
"0.50497496",
"0.50482625",
"0.5043711",
"0.50342804",
"0.5010029",
"0.50041604",
"0.49946743",
"0.49864984",
"0.49830014",
"0.49532288",
"0.4938305",
"0.49253175",
"0.4913559",
"0.49122053",
"0.49122053",
"0.4898538",
"0.4885844",
"0.4885776",
"0.48787376",
"0.4867502",
"0.48670712",
"0.48538056",
"0.4829359",
"0.48287278",
"0.48287278",
"0.48235244",
"0.4815665",
"0.48007792",
"0.47895604",
"0.4785516",
"0.4774964",
"0.47723433",
"0.47702947",
"0.47687495",
"0.47655433",
"0.47645465",
"0.475009",
"0.47491807",
"0.47399276",
"0.47300503",
"0.47201028",
"0.4709785",
"0.4701076",
"0.46913454",
"0.46913454",
"0.46912047",
"0.4683352",
"0.46817622",
"0.46756834",
"0.4675211",
"0.46682626",
"0.46682626",
"0.46682626",
"0.46638003",
"0.46554506",
"0.46525818",
"0.46502247",
"0.4646132",
"0.46389574",
"0.46380055",
"0.4637815",
"0.4634097",
"0.46302116",
"0.46259266",
"0.46259257",
"0.46191892",
"0.4616719",
"0.4612276",
"0.4612276",
"0.4612276",
"0.46107796",
"0.46090335",
"0.46090335",
"0.4608609",
"0.46030197",
"0.4599917",
"0.4597735",
"0.45926708"
] |
0.5423326
|
11
|
Updates the key/value if the key does not already exist in the collection.
|
def orchio_put_if_none_match(document)
orchio_put_if_match(document, '"*"')
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def put (key, value)\n !table.include?(key)\n end",
"def process_collection!(name, key, value, remote)\n if collection.key?(name)\n existing_remote = collection[name.to_s][:remote]\n # skip if the existing item is local and the new item is remote\n return if remote && !existing_remote\n raise \"Duplicate item with name '#{name}' was detected.\" unless existing_remote && !remote\n\n # override if the existing item is remote and the new is local\n logger.info \"Duplicate item with name '#{name}' was detected from the remote folder.\"\n end\n collection[name.to_s] = { name: name.to_s, type: key, value: value, remote: remote }\n end",
"def ensure_value_exists!(k)\n @values[k] = nil unless @values.has_key?(k)\n end",
"def check_or_create_for!(hash, key)\n hash[key] = \"\" unless hash.include?(key)\n end",
"def update(grocery_list, food, quantity)\n grocery_list[food] = quantity if grocery_list.has_key?(food) \n\nend",
"def add_key_value?(key, val)\n @store.transaction do\n return false if @store.to_h.key? key\n @store[key]=val\n end\n true\n end",
"def set(key, value)\n updated = false\n if self.map_var[0].empty?\n self.map_var[0] = [key, value]\n updated = true\n else \n self.map_var.each do |pair| \n if pair[0] == key \n pair[1] = value \n updated = true\n end\n end \n end\n self.map_var << [key, value] if !updated\n updated \n end",
"def update(key, value)\n if @hash.has_key?(key)\n @hash.set(key, value)\n else\n raise ArgumentError, \"Cannot update nonexistent key: #{key}\"\n end\n end",
"def put(key, value)\n #if key exists\n if a_hash[key] != nil\n a_hash[key] = value\n end\n end",
"def update(list, item, quantity)\r\n if list.has_key?(item)\r\n list[item] = quantity\r\n else puts \"No item found\"\r\n end\r\n list \r\nend",
"def update(list, item, quantity)\r\n if list.has_key?(item)\r\n list[item] = quantity\r\n else\r\n puts \"That item is not in the list\"\r\n end\r\n list\r\nend",
"def put(key, value)\n @first.put(key, value)\n end",
"def update_collection(collection)\n # Take the name out of the list of keys so that all that remains are fields to\n # be updated\n name = collection.delete(:name)\n # Because the name may come in many forms we must use something like titlecase to help\n # account for variations\n name = name.last.titleize\n \n # Due to the way that batches are handled a collection may appear multiple times. Presume\n # that if it has already been processed it is safe to skip any duplicates\n if (@successful_updates.include?(name) or \n @failed_updates.include?(name))\n log_message(\"Skipping duplicate collection entry\")\n return\n end\n\n coll = Collection.where(title: name).first\n \n if (coll.present? and (coll.title == name))\n log_message(\"Processing #{coll.title}\")\n update_and_save_metadata(coll, collection) \n @successful_updates << name\n else\n log_message(\"Could not locate #{name}\", Logger::WARN)\n @failed_updates << name\n end\n end",
"def store_value_simply key, value\n @@key_value_storage[key] ||= value if key\n end",
"def set(key, val)\n return unless val\n db[key] = val\n end",
"def set(key, value)\n\t\t\t\t# TODO This could be a bit more efficient:\n\t\t\t\tself.delete(key)\n\t\t\t\tself.add(key, value)\n\t\t\tend",
"def []=(key, value)\n key = key.to_s unless key.is_a? String\n @collection.update( { plgid: @id }, { plgid: @id, key => value }, { upsert: true })\n end",
"def ensure_item_exists key, value\n item = Item.find(:key => key, :host_id => host.id)\n unless item\n Item.new(:key => key, :host_id => host.id, :applications => applications, :value_type => Item.value_type_from_value(value)).save\n\n # There is a time lag of about 15-30 seconds between (successfully)\n # creating an item on the Zabbix server and having the Zabbix accept\n # new data for that item.\n #\n # If it is crucial that *every single* data point be written, dial\n # up this sleep period. The first data point for a new key will put\n # the wrapper to sleep for this period of time, in hopes that the\n # Zabbix server will catch up and be ready to accept new data\n # points.\n #\n # If you don't care that you're going to lose the first few data\n # points you send to Zabbix, then don't worry about it.\n sleep settings['create_item_sleep']\n end\n end",
"def []=(key, value)\n entry = find_entry(key)\n @dirty = true\n if entry.nil?\n @entries << [key, value]\n else\n entry[1] = value\n end\n end",
"def upsert key, value\n # Check if there is already an entry for the given key. If there is one, we have to update the value and return.\n if (slot = find_slot(key))\n slot.value = value\n return\n end \n \n #If the entry does not exist, we have to check if there is enough room to add it to the table. \n # If the number of slots is too small, \n # we have to trigger a rebuild operation to ensure that the new entry fits into the internal storage\n rebuild if self.size > (@slots / 2)\n\n # Once we are sure that there is enough space, we have to hash the key and map it to a position into the internal storage. \n # In our case, we do that by double hashing the key’s hash code until we find an empty slot or run out of positions\n 0.upto(@slots - 1) do |i|\n index = double_hash key.hash, i\n slot = @table[index]\n if slot.nil? || slot.vacated \n # Once we successfully mapped a key to a position in the internal array, we increase the table size and return\n @table[index] = Slot.new key, value\n self.size += 1\n return\n end\n end\n raise \"Weak hash function.\"\nend",
"def update?(collection, id, data)\n data.each_key do |key|\n return false unless @data[collection][id].key?(key)\n end\n data.each do |key, value|\n @data[collection][id][key] = value\n end\n true\n end",
"def update_item(list, item, quantity)\n if list.has_key?(item)\n list[item] = quantity\n else\n puts \"ERROR: Item not in list\"\n end\n return list\nend",
"def put(key, value)\n return if @cap <= 0\n fav = @c[key]\n if fav\n return\n end\n \n end",
"def put(key, value)\n \n end",
"def put(key, value); end",
"def []=(key, value)\n there_is_a_collision = @items[index(key, size)] != nil && @items[index(key,@items.length)].key != key \n\n #When a collision occurs, expand the size of the hash by doubling its existing size.\n while there_is_a_collision\n resize\n there_is_a_collision = @items[index(key, size)] != nil\n end\n @items[index(key,@items.length)] = HashItem.new(key, value)\n\n end",
"def []=(key, value)\n #check if the index is available, if available add new HashItem\n if @items[index(key, @items.length)] == nil\n @items[index(key, @items.length)] = HashItem.new(key, value)\n elsif @items[index(key, @items.length)].key != key\n self.resize\n self[key] = value\n elsif @items[index(key, @items.length)].key == key && @items[index(key, value)].value != value\n self.resize\n @items[index(key, @items.length).value] = value\n end\n end",
"def put(key, value)\n obj = KeyValue.find_by_key(key)\n if obj\n KeyValue.update(obj.id, :value=>value)\n else\n KeyValue.create(:key=>key, :value=>value)\n end\n end",
"def add item\n self[index item] = item if check item\n# check item ? super : free key # delete key\n end",
"def set_value(key, value)\n database[key] = value\n removed_keys.delete(key)\n end",
"def []=(key, item)\n item.set_collection_key(key)\n add(item)\n end",
"def []=(key, value)\n puts \"-\" * 10\n hash_index = index(key, @items.size)\n if @items[hash_index] == nil\n # puts \"No collision. Inserting into Hash...\"\n new_hash_item = HashItem.new(key, value)\n @items[hash_index] = new_hash_item\n elsif @items[hash_index].value == value\n # puts \"This is already in the hash...exiting insertion\"\n return\n elsif @items[hash_index].key == key\n # puts \"This item has a duplicate key...resizing and exiting\"\n self.resize\n elsif @items[hash_index] != value\n # puts \"This index is taken - resizing...\"\n self.resize\n self[key] = value\n end\n puts \"Key Inserted: #{key}\"\n puts \"Value Inserted: #{value}\"\n puts \"Hash Index: #{hash_index}\"\n puts \"Hash Size: #{@items.size}\"\n puts \"Hash: #{@items}\"\n puts \"-\" * 10\n end",
"def assign(key, value)\n if lookup(key)\n @holder.each { |pair| pair[1] = value if pair[0] == key}\n else\n @holder << [key, value]\n end\n end",
"def upsert(sobject, field, attrs)\n upsert!(sobject, field, attrs)\n rescue *exceptions\n false\n end",
"def append!(key, value); end",
"def append!(key, value); end",
"def update_item(grocery_hash, item, item_hash)\n if grocery_hash.has_key?(item)\n grocery_hash.merge!(item_hash)\n else\n \"That item is not in your grocery list\"\n end\nend",
"def update_item_from_list(hash, item_to_update, new_qty)\n if hash.has_key?(item_to_update)\n hash[item_to_update] = new_qty\n else\n \"It looks like #{item_to_update} wasn't in the hash after all!\"\n end\nend",
"def update(key, value)\n set(key.to_sym => value)\n end",
"def putdup (k, v)\n\n @db.putdup(k, v)\n end",
"def update_quantity(list, list_item, item_quantity)\n if list.has_key?(list_item)\n list[list_item] = item_quantity\n else\n puts \"Item does not exist\"\n end\n p list\n list\nend",
"def generic_set(key, value)\n modify(key, value) || uncomment(key, value) || add_new(key, value)\n end",
"def get_and_set(key, value); end",
"def update_qty(list, item_to_update, new_qty)\n # if list.has_key? item_to_update\n # list[item_to_update] = new_qty\n # end\n list[item_to_update] = new_qty if list.has_key? item_to_update\n list\nend",
"def update_item(list_name, item_name, quantity)\r\n list_name[item_name] = quantity if list_name.has_key?(item_name)\r\nend",
"def add_item(item_name, item_qty)\n# $list_items[item_name] = item_qty\n # my_hash[key] = value\n # This will create a NEW key value pair\n # OR update (aka replace) the value for an existing key.\n \n # my_hash[key] += value\n # will INCREASE the value for an existing key.\n if $list_items.include?(item_name)\n # Increase that item\n $list_items[item_name] += item_qty\n else\n # Create the new item\n $list_items[item_name] = item_qty\n end\nend",
"def update_key(key, val)\n @ivar.each_with_index do |ele, i|\n if ele[0] == key\n @ivar[i][1] = val \n end\n end\n end",
"def []=(key, value)\n if @items[index(key, size)] == nil\n @items[index(key, size)] = HashItem.new(key, value)\n elsif @items[index(key, size)].key != key\n resize\n self[key] = value\n elsif (@items[index(key, size)].key == key) &&\n (@items[index(key, size)].value != value)\n resize\n @items[index(key, size)] = HashItem.new(key, value)\n end\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n end",
"def add_key_value?(key, val)\n hash = load_hash\n return false if hash.key? key\n hash[key] = val\n store_hash hash\n true\n end",
"def add(key, value)\n index = key_index(key)\n\n # Only happens if we didn't check the presence before calling this method\n return nil if index == -1\n\n rehash_step if rehashing?\n\n hash_table = rehashing? ? rehashing_table : main_table\n entry = hash_table.table[index]\n\n entry = entry.next while entry && entry.key != key\n\n if entry.nil?\n entry = DictEntry.new(key, value)\n entry.next = hash_table.table[index]\n hash_table.table[index] = entry\n hash_table.used += 1\n else\n raise \"Unexpectedly found an entry with same key when trying to add #{ key } / #{ value }\"\n end\n end",
"def set_unless_exists(key, val)\n val = redis_marshal(val)\n timeout_retry(3, 3){\n write \"SETNX #{key} #{val.to_s.size}\\r\\n#{val}\\r\\n\"\n integer_reply == 1\n }\n end",
"def update\n # don't need to update; hash is shared\n end",
"def set(key, value); end",
"def set(key, value); end",
"def upsert(locale, key, value) # rubocop:disable Metrics/MethodLength\n I18n.with_locale(locale) do\n # when an array has to be inserted with a default value, it needs to\n # be done like:\n # I18n.t('foo', default: [['bar', 'baz']])\n # because without the double array, array items are treated as fallback keys\n # - then, the last array element is the final fallback; so in this case we\n # don't specify fallback keys and only specify the final fallback, which\n # is the array\n val = value.is_a?(Array) ? [value] : value\n I18n.t(key, default: val)\n\n # this indicates that this translation already exists\n existing_translation =\n Lit::Localization.joins(:locale, :localization_key)\n .find_by('localization_key = ? and locale = ?', key, locale)\n\n return unless existing_translation\n\n if @raw\n existing_translation.update(default_value: value)\n else\n existing_translation.update(translated_value: value, is_changed: true)\n lkey = existing_translation.localization_key\n lkey.update(is_deleted: false) if lkey.is_deleted\n end\n end\n end",
"def put(key, value)\n if @values[key]\n @values.delete(key)\n elsif @values.keys.length == @capacity\n first_key = @values.keys.first\n @values.delete(first_key)\n end\n @values[key] = value\n end",
"def assign(key,value)\n #first check to see if the key value pair already exists\n pair_index = nil\n @map.each_with_index do |sub_array,idx|\n pair_index = idx if sub_array[0] == key\n end\n if pair_index.nil?\n @map << [key,value]\n else\n @map[pair_index]=[key,value]\n end\n end",
"def put(key, value)\n position = search(key)\n if (key <=> @keys[position]) == 0\n @values[position] = value\n else\n @keys.insert(position, key)\n @values.insert(position, value)\n end\n end",
"def update(value)\n key = self.key\n raise TCKeyNotFound unless self.delete\n @value = value\n put(key,value)\n end",
"def add_to_db input, key = nil, opts = {}\n #TODO: Handle repeating a already selected key (raise an error or return nil?)\n # input.each { |i| add_to_db(i) } if input.is_a? Array\n\t\tkey ||= opts[:key]\n\t\tthe_key = case\n\t\t\twhen key.nil? then assign_key(input)\n\t\t\twhen key.is_a?(Database::Reference::Variable) then key.value\n\t\t\telse\n\t\t\t\tkey\n\t\t\tend\n\t\tif db.has_key?(the_key)\n\t\t\treturn the_key if db[the_key] == input\n\t\t\tcase opts[:if_in_use]\n\t\t\t\t#Append to the set after adding to this db\n\t\t\t\twhen :append\t\t\t\tthen add_to_db(input,key); db[the_key].add(input)\n\t\t\t\twhen :overwrite then db[the_key] = input\n\t\t\t\twhen :destroy_entry then destroy_entry(db[the_key]); db[the_key] = input\n\t\t\t\twhen :destroy_input then input.destroy_self(); return nil\n\t\t\t\twhen nil\t then raise \"Attempted to overwrite an already existing key\"\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t ## TODO: Create an error class for this\n\t\t\tend\n\t\telse\n\t\t\tdb[the_key] = input\n\t\tend\n\t\tinput.set_key(the_key,self) if input.is_data?\n\t\treturn the_key\n end",
"def set(key, value)\n response = db.put_item(@table_name, {'id' => {'S' => key}, 'value' => {'S' => value}})\n true\n end",
"def no_duplicate_key_for_project\n project = Project.find(project_id)\n key = project.keys.find_by(name: name)\n\n if key.present?\n updating_key = key.id == id\n\n errors.add(:name, 'Name is already in use.') if !updating_key\n end\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update_quantity(hash, item, quantity)\n\n if hash.has_key?(item)\n hash[item] = quantity\n end\n return hash\n\nend",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def []=(_key, _value)\n false\n end",
"def put_if_absent(entity, key, value, index_type = :exact)\n index = index_for_type(index_type)\n index.put_if_absent(entity, key.to_s, value)\n end",
"def change_quantity(list,item,quantity)\r\n if list.has_key?(item)\r\n list[item] = quantity\r\n else\r\n puts \"Item not found.\"\r\n end\r\n list\r\nend",
"def update_item (item, new_quantity)\r\n if $grocery_list.include? item\r\n $grocery_list[item] = new_quantity\r\n else \r\n puts \"that item is not in the list!\"\r\n end\r\nend",
"def add(key)\n @internal_hash[key] = true\n end",
"def set(key, value)\r\n\t\t# Do not modify object if key already exists or if total exceeds size\r\n\t\treturn false if key==nil || value == nil || get(key) != nil || @total >= @size\r\n\t\t# Get the hash of our key\r\n\t\tindex = key.hash % @size\r\n\t\t# If something exists at that location then we must add a node to our \r\n\t\t# LinkedList otherwise we create a list at that location\r\n\t\tif @arr[index]\r\n\t\t\t@arr[index].add(key, value)\r\n\t\telse\r\n\t\t\t@arr[index] = LinkedList.new(key, value)\r\n\t\tend \r\n\t\t# Increase the total by 1 and return true\r\n\t\t@total += 1\r\n\t\treturn true\r\n\tend",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n @value = args[:value] if args.key?(:value)\n end"
] |
[
"0.64563084",
"0.6449862",
"0.63330483",
"0.62448895",
"0.6155126",
"0.60978067",
"0.6078446",
"0.60400426",
"0.59903085",
"0.5903193",
"0.5891571",
"0.58890986",
"0.5849512",
"0.58259314",
"0.58197373",
"0.5816852",
"0.5816465",
"0.58128405",
"0.5790125",
"0.57883614",
"0.5779037",
"0.5769883",
"0.57685053",
"0.57586664",
"0.5758453",
"0.57448083",
"0.5735227",
"0.573028",
"0.57209396",
"0.57206553",
"0.57137007",
"0.5713205",
"0.5711175",
"0.57038295",
"0.56954384",
"0.56954384",
"0.5685664",
"0.56838465",
"0.5665088",
"0.5656185",
"0.56287533",
"0.5618082",
"0.5613806",
"0.5575585",
"0.55733645",
"0.5563925",
"0.5556793",
"0.55555475",
"0.55451447",
"0.55451447",
"0.55368227",
"0.5535552",
"0.5534024",
"0.55195796",
"0.5514078",
"0.5514078",
"0.5505675",
"0.54884386",
"0.54779196",
"0.5476088",
"0.54730064",
"0.5460084",
"0.5452186",
"0.54462945",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.54454213",
"0.5444453",
"0.5444152",
"0.5435511",
"0.54301894",
"0.54230875",
"0.54183155",
"0.5403635",
"0.5402946",
"0.54028755",
"0.54028755",
"0.54028755",
"0.54028755",
"0.54028755",
"0.54028755"
] |
0.0
|
-1
|
Instance methods collection/key/graph Gets the graph for the specified kind of relation.
|
def orchio_get_graph(kind)
# add_relation_kind kind
if cache.enabled? and response = cache_request.get_graph(id, kind)
if response.header.status == :cache
docs = response.body.documents
count = docs.length
end
else
response = client.send_request :get, inst_args(kind: kind)
docs = response.body.results.map { |result|
Document.new(
result['value'].merge(id: result['path']['key']),
Metadata.new(
:collection => result['path']['collection'],
:key => result['path']['key'],
:ref => result['path']['ref'],
:kind => kind,
:from_collection => ocollection,
:from_key => @id,
))}
cache.save_graph(id, kind) if cache.enabled? and count == 0
end
Result.new(
status: orchio_status(response, 200),
response: response,
count: response.body.count,
results: docs
)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def graph(kind)\n res = orchio_get_graph(kind)\n (res.success?) ? res.results.map { |odoc| odoc.to_rails } : false\n end",
"def graph_class\n RDF::Graph\n end",
"def relation\n relation = nodes.reduce(root) do |a, e|\n a.associations[e.name.key].join(:join, a, e)\n end\n schema.(relation)\n end",
"def get_relationships_of_type(type)\n g_command = get_command(type)\n relationships = self.send(g_command.to_sym)\n end",
"def graph\n @g ||= GraphViz.new(:G, :type => :digraph)\n end",
"def graph\n @graph ||= Codependency::Graph.new\n end",
"def relationship(sym)\n self.class.relationship(sym)\n end",
"def relation\n raise NotImplementedError\n end",
"def relationship(sym)\n if @relationships\n @relationships[sym]\n else\n self.class.relationship(sym)\n end\n end",
"def node_for(relation)\n self[relation.name.to_sym]\n end",
"def eager_graph(*associations)\n eager_graph_with_options(associations)\n end",
"def nested_graph\n @nested_graph ||= ModelConverter.new(resource: Valkyrie::Types::Anything[value.value], adapter: value.adapter, subject_uri: subject_uri).convert.graph\n end",
"def gv_graph_name\n [:name, :id].each do |method|\n return send method if respond_to? method and send method\n end\n 'graph'\n end",
"def relations\n @relations ||= {}\n end",
"def relations_by_type\n relations = {}\n for i in 0..(self.relations.count-1)\n type = self.relations(i).type.first\n relations[type] ||= []\n relations[type] += self.relations(i).id\n end\n relations\n end",
"def relationship(sym, klass=nil, kinds=[])\n if klass\n relationships[sym] = Relationship.new(sym, klass, kinds)\n else\n relationships[sym]\n end\n end",
"def graph(graph_strategy = NetworkHelper::GraphStrategyDefault, elements_factory = ElementsFactoryDefault)\n graph_context = NetworkHelper::GraphContext.new(self.id, graph_strategy, elements_factory)\n\n if graph_context.graph.network.empty?\n graph_context.graph.build(self)\n end\n\n return graph_context.graph\n end",
"def relation\n\t\tbegin\n\t\t\tRelation.find(relation_id)\n\t\trescue Exception => e\n\t\t\tfname= \"#{self.class.name}.#{__method__}\"\n\t\t\tLOG.error (fname) {\"relation not found:#{e}\"}\n\t\t\tnil\n\t\tend\n\tend",
"def relation\n Proxy\n end",
"def relation\n Proxy\n end",
"def relation\n Proxy\n end",
"def orchio_put_graph(kind, to_collection, to_key)\n # add_relation_kind kind\n\n if cache.enabled?\n ref = simple_cache.get_ref to_collection, to_key\n simple_cache.get_cc(ocollection).save_graph Metadata.new(\n { from_key: @id, kind: kind, ref: ref }\n )\n end\n\n response = client.send_request(\n :put,\n inst_args(kind: kind, to_collection: to_collection, to_key: to_key)\n )\n orchio_status response, 204\n end",
"def save_graph(kind, to_collection, to_key)\n retval orchio_put_graph(kind, to_collection, to_key)\n end",
"def get_relation(ref_key)\n if @generic_relations_store.key?(ref_key)\n\n if @generic_relations_store[ref_key]['relationsubject']\n gr_subject = @generic_relations_store[ref_key]['relationsubject'].match('^http://d.opencalais.com') ?\n get_entity(@generic_relations_store[ref_key]['relationsubject']) :\n @generic_relations_store[ref_key]['relationsubject']\n else\n gr_subject = 'N/A'\n end\n\n\n if @generic_relations_store[ref_key]['relationobject']\n gr_object = @generic_relations_store[ref_key]['relationobject'].match('^http://d.opencalais.com') ?\n get_entity(@generic_relations_store[ref_key]['relationobject']) :\n @generic_relations_store[ref_key]['relationobject']\n else\n gr_object = 'N/A'\n end\n\n GenericRelation.new(gr_subject,\n @generic_relations_store[ref_key]['verb'],\n gr_object,\n @generic_relations_store[ref_key]['instances'][0]['exact'] ||= 'N/A')\n else\n nil\n end\n end",
"def load_type\n :relation\n end",
"def get_relations_referring_to_object(type, id)\n api_call_with_type(type, id, \"#{type}/#{id}/relations\")\n end",
"def relation_name\n klass.relation\n end",
"def relations_for(node) #:nodoc:\n Enumerator.new do |yielder|\n @description.relations.each do |relation_accessor|\n begin\n relations = relation_accessor[node]\n enumerable = relations.is_a?(Enumerable) ? relations : [relations].compact\n\n enumerable.each { |e| yielder << e unless visited?(e) }\n rescue NoMethodError\n # ignore errors on relation_accessor[node]\n end\n end\n end\n end",
"def calculate_relation(entity)\n if entity.is_a?(Sociographer::Entity)\n # @@neo = Neography::Rest.new\n self_node = self.get_node\n entity_node = entity.get_node\n if self_node && entity_node\n # begin\n qur = \"START r=rel(*) return distinct(type(r))\"\n relations = @@neo.execute_query(qur)[\"data\"].flatten\n all_relations = relations.map{|r| {\"type\" => r, \"direction\" => \"all\"}}\n all_rels_by_two_nodes = @@neo.get_paths(self_node, entity_node, all_relations, 2, \"allPaths\").select{ |l| l[\"length\"] == 2}.map{ |u| u[\"relationships\"]} # finds all paths between two nodes whose length == 2\n \n self_relations = all_rels_by_two_nodes.map{|u| u[0]}\n self_relations = self_relations.map{|r| Neography::Relationship.load(r.split(\"/\").last) }.flatten.map{|u| u.rel_type} \n self_relations = self_relations.group_by{|x|x}.map{|k,v| [k, v.length]}\n self_relations = self_relations.map{ |rel| self.relation_weight(rel[0])*rel[1] }.sum \n\n entity_relations = all_rels_by_two_nodes.map{|u| u[1]}\n entity_relations = entity_relations.map{|r| Neography::Relationship.load(r.split(\"/\").last) }.flatten.map{|u| u.rel_type} \n entity_relations = entity_relations.group_by{|x|x}.map{|k,v| [k, v.length]}\n entity_relations = entity_relations.map{ |rel| entity.relation_weight(rel[0])*rel[1] }.sum \n\n total_weight = self_relations+entity_relations\n # one_side.map{ |u| u[\"relationships\"].map{ |r| @@neo.get_relationship_properties(r.split(\"/\").last)[\"weight\"] } }.flatten.sum \n # one_side = @@neo.get_shortest_weighted_path(self_node, entity_node, all_relations ).select{ |l| l[\"length\"] < 3}\n # other_side = @@neo.get_shortest_weighted_path(entity_node, self_node, [{nil,\"all\"}]).select{ |l| l[\"length\"] == 2}\n # return [*one_side,*other_side].map{|l| l[\"weight\"]}.sum\n # rescue Exception\n # return 0\n # end\n else\n false\n end\n else\n false\n end\n end",
"def delete_graph(kind, to_collection, to_key)\n retval orchio_delete_graph kind, to_collection, to_key\n end",
"def relations\n self.class.relations\n end",
"def relations\n @relations ||= process_rels\n end",
"def get_graph(opts = {})\n data, _status_code, _headers = get_graph_with_http_info(opts)\n return data\n end",
"def relation_for(group)\n return if group.class != Group\n self.group_relations.select { |r| r[:group_id] == group.id }.first\n end",
"def edges\n @pathway.relations.collect do |rel|\n [ rel.node[0], rel.node[1], rel.relation ]\n end\n end",
"def relations\n _relations\n end",
"def relations\n _relations\n end",
"def get_relation(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/relations/#{args[:relation]}\"\n\tdo_the_get_call( url: api_url, user: @user )\nend",
"def to_graph(graph = RDF::Graph.new)\n properties.each do |property|\n property.to_graph(graph)\n end\n graph\n end",
"def relationships\n model.relationships(repository.name)\n end",
"def graph\n @graph ||= ordered_list.to_graph\n end",
"def inspect\n %(#<#{self.class} relation=#{relation.name.inspect}>)\n end",
"def printGraph\n\t\tp @g.graphSet\n\t\treturn @g.graphSet\n\tend",
"def relationship_kind(applicant, relative)\n return 'self' if applicant.person_hbx_id == relative.person_hbx_id\n return nil if relationships.blank?\n\n relation = relationships.detect do |rel|\n rel.applicant_reference.person_hbx_id == applicant.person_hbx_id &&\n rel.relative_reference.person_hbx_id == relative.person_hbx_id\n end\n\n relation&.kind\n end",
"def get_graph(id,vocabs=nil)\n puts \"ID: #{id}\"\n\n # Whitelist\n vocabs ||= []\n possible_vocabs = GraphBuilder.public_instance_methods\n vocabs = (vocabs & possible_vocabs)\n\n # By default, include everything\n vocabs = possible_vocabs if vocabs.empty?\n\n # by default, always include RDF.label\n vocabs << :rdfs\n\n #instantiate the graph and the data \n data = lookup(id)\n graph = RDF::Graph.new\n\n # Call all the vocabs and include them\n vocabs.each do |vocab|\n graph << self.send(vocab,data) \n end\n\n graph\n end",
"def kind\n @gapi[\"kind\"]\n end",
"def kind\n @gapi[\"kind\"]\n end",
"def relationships\n @relationships ||= {}\n end",
"def Graph(name=:G, type=:digraph, &blk)\n Gviz.new(name, type).graph(&blk)\nend",
"def all_graphs\n graphs.map { |kind| graph kind }\n end",
"def relation\n @relation ||= (klass.respond_to?(:where) ? klass.where(nil) : klass)\n end",
"def relation_for_via(property, group)\n return if group.class != Group\n return if property.class != Property\n self.property_relations.select { |r| r[:property_id] == property.id && r[:group_id] == group.id }.first\n end",
"def relations\n Relations::RelationTraverser.new(@internal_node)\n end",
"def relationship\n Relationship.new(self, CHART_R, \"../#{pn}\")\n end",
"def relation(rel, &relation_definition)\n raise NotImplementedError, 'relation is not supported yet'\n end",
"def relations; enum_relations.to_a end",
"def relationship\n return @relationship\n end",
"def graph_resource\n @graph_resource ||= ::Ldp::Container::Basic.new(connection, subject, nil, base_path)\n end",
"def relations\n return @artist_data[\"relations\"]\n end",
"def get_relations_from_api(api=Rosemary::API.new)\n api.get_relations_referring_to_object(type, self.id.to_i)\n end",
"def relation\n @relation ||= begin\n additions = false\n # TODO: merge! has unexpected results.\n frag = include_params.reduce(model.all) do |result, inclusion|\n config = config_for(inclusion)\n query = config.respond_to?(:keys) ? config.values.first : nil\n unless query.nil?\n additions = true\n result = result.merge(query)\n end\n result\n end\n additions ? frag : nil\n end\n end",
"def relations_info\n self::RELATIONS_INFO\n end",
"def relation_name\n self.class.relation_name\n end",
"def graph_for_entity(entity)\n entity.minor? ? @mine_graph : @graph\n end",
"def graph\n Graph.new(project_path_trie, tsort)\n end",
"def graph\n if @graph.nodes.empty?\n build_nodes!\n establish_edges!\n end\n\n @graph\n end",
"def graph\n if @graph.nodes.empty?\n build_nodes!\n establish_edges!\n end\n\n @graph\n end",
"def relation_reflect(relation)\n relation = relation.is_a?(Enumerable) ? relation.dup : [relation]\n\n # go from one relation to the next until we hit the last reflect object\n klass = self\n while relation.size > 0\n cur_relation = relation.shift\n reflect = klass.reflect_on_association(cur_relation)\n raise \"No relation #{cur_relation} on #{klass.name}\" if reflect.nil?\n klass = reflect.klass\n end\n\n return reflect\n end",
"def graph(name, options = {}, &block)\n GraphViz::DSL.new(name, options.merge( { :type => \"graph\" } ), &block).graph\nend",
"def eager_graph_with_options(associations, opts=OPTS)\n associations = [associations] unless associations.is_a?(Array)\n if eg = @opts[:eager_graph]\n eg = eg.dup\n [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}\n eg[:local] = opts\n ds = clone(:eager_graph=>eg)\n ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)\n else\n # Each of the following have a symbol key for the table alias, with the following values: \n # :reciprocals :: the reciprocal value to use for this association\n # :reflections :: AssociationReflection instance related to this association\n # :requirements :: array of requirements for this association\n # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading\n opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}\n ds = clone(:eager_graph=>opts)\n ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked\n end\n end",
"def relationship\n response[\"relationship\"]\n end",
"def relation_name\n fetch(:relation_name, :children)\n end",
"def relation_of(field)\n meta = meta_of(field)\n meta ? meta.relation : nil\n end",
"def generate_graph\n end",
"def relation_key\n self[:relation_key] || name.to_s\n end",
"def child_relation; end",
"def relation_klass(relation)\n relation_reflect(relation).klass\n end",
"def [](name)\n relations.fetch(name)\n end",
"def call(relation)\n relation\n end",
"def relationship_ancestry(*args)\n stringify_options = args.extract_options!\n options = stringify_options.slice!(:field_delimiter, :record_delimiter, :exclude_class, :field_method, :include_self)\n\n include_self = stringify_options.delete(:include_self)\n field_method = stringify_options[:field_method] || :id\n\n meth = include_self ? :path : :ancestors\n meth = :\"#{meth.to_s.singularize}_ids\" if field_method == :id\n rels = send(meth, options)\n\n rels_meth = :\"stringify_#{field_method == :id ? \"resource_pairs\" : \"rels\"}\"\n Relationship.send(rels_meth, rels, stringify_options)\n end",
"def belongs_to(direction, name = nil, options = { type: nil })\n if name.is_a?(Hash)\n options.merge(name)\n name = direction\n direction = nil\n elsif name.is_a?(Proc)\n name = direction\n direction = nil\n elsif name.nil?\n name = direction\n end\n reflections[name] = { direction: direction, type: options[:type], kind: :belongs_to }\n\n define_method(\"promise_#{name}\") do\n @fetch_states[name] = 'i'\n self.class._promise_get(\"#{self.class.resource_base_uri}/#{self.id}/relations/#{name}.json?timestamp=#{`Date.now() + Math.random()`}\").then do |response|\n @relations[name] = if response.json[self.class.to_s.underscore][name]\n self.class._convert_json_hash_to_record(response.json[self.class.to_s.underscore][name])\n else\n nil\n end\n @fetch_states[name] = 'f'\n _notify_observers\n @relations[name]\n end.fail do |response|\n error_message = \"#{self.class.to_s}[#{self.id}].#{name}, a belongs_to association, failed to fetch records!\"\n `console.error(error_message)`\n response\n end\n end\n # @!method [name] get records of the relation\n # @return [HyperRecord::Collection] either a empty one, if the data has not been fetched yet, or the\n # collection with the real data, if it has been fetched already\n define_method(name) do\n _register_observer\n if @fetch_states.has_key?(name) && 'fi'.include?(@fetch_states[name])\n @relations[name]\n elsif self.id\n send(\"promise_#{name}\")\n @relations[name]\n else\n @relations[name]\n end\n end\n # @!method update_[name] mark internal structures so that the relation data is updated once it is requested again\n # @return nil\n define_method(\"update_#{name}\") do\n @fetch_states[name] = 'u'\n nil\n end\n # TODO\n # define_method(\"#{name}=\") do |arg|\n # _register_observer\n # @relations[name] = arg\n # @fetch_states[name] = 'f'\n # @relations[name]\n # end\n end",
"def nodes\n relation.respond_to?(:nodes) ? relation.nodes : []\n end",
"def to_response\n RDF::Graph.new << graph\n end",
"def get_relation(id)\n get_object('relation', id)\n end",
"def _load_relation name\n relation = self.relations.select { |rel| rel.name == name }.first\n if relation.type == :has_many\n _load_has_many relation\n elsif relation.type == :belongs_to\n _load_belongs_to relation\n else\n raise \"Unkown relation type\"\n end\n end",
"def get_edges\n getEdges.to_route(:graph => self, :element_type => :edge)\n end",
"def get_edges\n getEdges.to_route(:graph => self, :element_type => :edge)\n end",
"def to_graph\n return RDF::Graph.new if target_id.blank?\n g = Resource.new(rdf_subject)\n g.proxy_for = target\n g.proxy_in = proxy_in.try(:uri)\n g.next = self.next.try(:rdf_subject)\n g.prev = prev.try(:rdf_subject)\n g.graph\n end",
"def graph_for(attribute, options = {})\n\t\t\thash = {}\n\t\t\thash[attribute] = {\n\t\t\t\t:description => :show_graph, \n\t\t\t\t:icon => \"bar-chart\", \n\t\t\t\t:controller_option => true, \n\t\t\t\t:graph => true, # this tells the controller to treat this one special\n\t\t\t\t:graph_options => options\n\t\t\t}\n\t\t\tif @_special_buttons\n\t\t\t\t@_special_buttons.merge! hash\n\t\t\telse\n\t\t\t\t@_special_buttons = hash\n\t\t\tend\n\t\tend",
"def relation_of(problem)\n\t\tif self.seen_problems.include?(problem)\n\t\t\treturn self.user_problem_relations.find_by(seen_problem_id: problem.id)\n\t\tend\n\tend",
"def graph(uri)\n @what, @uri = :graph, uri\n self\n end",
"def get_relation(id)\n @relations[id.to_i]\n end",
"def get (name:, database: Arango.current_database)\n args = { graph: name }\n result = Arango::Requests::Graph::Get.execute(server: database.server, args: args)\n from_results({}, result.graph, database: database)\n end",
"def find_relation\n if relation_name.present?\n self.relation = Relation.mode(sender_subject.class.to_s,\n receiver_subject.class.to_s).\n find_by_name(relation_name)\n end\n end",
"def relationships_with_name(input, name)\n input.relations(name)\n end",
"def repo_connections_weighted_graph\n read_all_git_repos('repos')\n graph_links_between_git_objects\n end",
"def relation_value_for(name)\n if serializer.respond_to?(name)\n serializer.send(name)\n else\n resource.send(name)\n end\n end",
"def graphs\n @graphs ||= begin\n graphs = []\n graphs << {data: data, format: RDF::Format.for(data_file.to_s).to_sym} if data_file\n graphs + graphData.map do |g|\n {\n data: RDF::Util::File.open_file(g.graph.to_s, &:read),\n format: RDF::Format.for(g.graph.to_s).to_sym,\n base_uri: g.basename\n }\n end\n end\n end",
"def name\n relation.name\n end",
"def find_relations\n puts '2nd pass: find relations'\n find :relations\n self\n end"
] |
[
"0.657574",
"0.6241088",
"0.6199209",
"0.5996835",
"0.597931",
"0.59746987",
"0.59539104",
"0.5948078",
"0.5869207",
"0.58680755",
"0.58326524",
"0.5809189",
"0.57714933",
"0.57552767",
"0.57509476",
"0.57392704",
"0.5719115",
"0.5715314",
"0.5705366",
"0.5705366",
"0.5705366",
"0.56844866",
"0.56659186",
"0.563717",
"0.56280905",
"0.5609732",
"0.5586066",
"0.5578244",
"0.5573423",
"0.5570965",
"0.5569698",
"0.5542208",
"0.5524262",
"0.5502649",
"0.5502437",
"0.5485533",
"0.5485533",
"0.54823834",
"0.5462598",
"0.54438096",
"0.5441902",
"0.54342747",
"0.5418812",
"0.5394938",
"0.5390353",
"0.53828126",
"0.53828126",
"0.53801525",
"0.53691113",
"0.53679836",
"0.536379",
"0.53632",
"0.5354174",
"0.53092396",
"0.530172",
"0.5300429",
"0.5286628",
"0.52801853",
"0.5275197",
"0.5274017",
"0.5265264",
"0.52630115",
"0.52610505",
"0.52272403",
"0.5223311",
"0.5208701",
"0.5208701",
"0.51770526",
"0.5171458",
"0.51665676",
"0.51644367",
"0.51614875",
"0.51597804",
"0.51474774",
"0.5136969",
"0.51247746",
"0.5111589",
"0.51074934",
"0.51011354",
"0.5094279",
"0.50934815",
"0.50918156",
"0.50911",
"0.5087728",
"0.50766945",
"0.50694937",
"0.50694937",
"0.5063769",
"0.5062258",
"0.505698",
"0.5050858",
"0.504859",
"0.50424504",
"0.5041626",
"0.503867",
"0.5027091",
"0.5022884",
"0.50078887",
"0.50067717",
"0.5005986"
] |
0.7672522
|
0
|
Add a graph/relation to the collection. Store the to_key's 'ref' value if caching is enabled.
|
def orchio_put_graph(kind, to_collection, to_key)
# add_relation_kind kind
if cache.enabled?
ref = simple_cache.get_ref to_collection, to_key
simple_cache.get_cc(ocollection).save_graph Metadata.new(
{ from_key: @id, kind: kind, ref: ref }
)
end
response = client.send_request(
:put,
inst_args(kind: kind, to_collection: to_collection, to_key: to_key)
)
orchio_status response, 204
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_reference key, target, opts = {}, &blk\n\t\tadd_reference_set(key,target,opts) if target.is_a? Array\n\t\tadd_to_db(target, nil, :if_in_use => opts[:add_then_reference]) if opts[:add_then_reference]\n\t\tadd_to_db Database::Reference.new(self, target, :proc => blk), key, :if_in_use => opts[:if_in_use]\n\tend",
"def add_relation(relation)\n @relations[relation.id.to_i] = relation\n relation.db = self\n end",
"def add_relationship(rel_attr); end",
"def add_edge(source, target, edge = Edge.new)\n _clear_cache\n @pathway.append(Bio::Relation.new(source, target, edge))\n edge\n end",
"def add(relation, item)\n unless item.respond_to?(:to_hash)\n raise ArgumentError.new('only items that can be converted to hashes with #to_hash are permitted')\n end\n\n @relations[relation] = @relations.fetch(relation, []) << item\n end",
"def add_to_database\n Link.add({\"assignment_id\" => \"#{self.assignment_id}\", \"link\" => \"#{self.link}\", \"type\" => \"#{self.type}\"})\n end",
"def relation_added(issue)\n journalize_action(\n :property => 'relation',\n :prop_key => 'relates',\n :value => issue.try(:id)\n )\n end",
"def add_edge( from_key, to_key, weight = 0 )\n add_vertex(from_key) unless @vertices.include? from_key\n add_vertex(to_key) unless @vertices.include? to_key\n @vertices[from_key].add_neighbor( @vertices[to_key], weight )\n end",
"def add_reference(obj_ref, var_ref, desc)\n if graph.linked?(obj_ref, var_ref)\n desc_set = obj_ref[var_ref, graph]\n if !desc_set.include?(desc)\n desc_set << desc\n end\n else\n desc_set = [desc]\n graph.link(obj_ref, var_ref, desc_set)\n end\n end",
"def add_reference(value)\n ref = @ref_by_value[value]\n\n unless ref.present?\n ref = new_ref!(value)\n @ref_by_value[value] = ref\n @value_by_ref[ref] = value\n end\n\n ref\n end",
"def add(node)\n raise 'Node must be persisted!' unless node.persisted?\n # Traverse to the end\n last_link = nil\n each_link do |link|\n last_link = link\n end\n # Create a new link\n # If there is no last node, make the link the head\n # Otherwise, throw the link at the end\n link = Likewise::Node.create :ref_id => node.id\n if last_link.nil?\n self[:head_id] = link.id\n else\n last_link[:next_id] = link.id\n end\n # Increment our length, which is memoized\n element_added!\n end",
"def add_relation source_label, relation, destination_label, direction = '<->'\n # More popular nodes have more weigth\n @node_weights[source_label] += 1\n @node_weights[destination_label] += 1\n\n @edge_buffer << Edge.new(\n source_label: source_label,\n relation: relation,\n destination_label: destination_label,\n direction: direction\n )\n end",
"def add_reference_chain key, chain, opts = {}, &blk\n\t\tadd_to_db Database::Reference::Chain.new(self, chain, :proc => blk),\n\t\t\t\t\t\t\tkey, :if_in_use => opts[:if_in_use]\n\tend",
"def add_link(key, name)\n passage = Passage.where(name: name).first\n\n self.links << Link.create({ key: key, passage: passage })\n end",
"def add_node(node)\n _clear_cache\n @pathway.graph[node] ||= {}\n self\n end",
"def add_vertex(v)\n @from_store[v] ||= Set.new\n @to_store[v] ||= Set.new\n v\n end",
"def store_path_links_to(path, links)\n return if links.empty?\n redis.sadd path_links_to_key(path), links\n end",
"def save_graph(kind, to_collection, to_key)\n retval orchio_put_graph(kind, to_collection, to_key)\n end",
"def protected_add_edge!(from, to)\n @vertices[from] << to if @vertices.has_key?(from) && @vertices.has_key?(to)\n end",
"def add_op\n\t\t\tring = current_ring\n\t\t\top = (self.respond_to?(:op) && self.op || params[:op])\n\t\t\tmodel = KojacUtils.model_class_for_key(op[:key].base_key)\n\t\t\traise \"ADD only supports associated collections at present eg order.items\" unless op[:key].index('.')\n\n\t\t\titem = KojacUtils.model_for_key(op[:key].base_key)\n\t\t\tassoc = (assoc=op[:key].key_assoc) && assoc.to_sym\n\t\t\tid = op[:value]['id']\n\n\t\t\tma = item.class.reflect_on_association(assoc)\n\t\t\tcase ma.macro\n\t\t\t\twhen :has_many\n\t\t\t\t\tassoc_class = ma.klass\n\t\t\t\t\tassoc_item = assoc_class.find(id)\n\t\t\t\t\titem.send(assoc) << assoc_item\n\n\t\t\t\t\t#ids_method = assoc.to_s.singularize+'_ids'\n\t\t\t\t\t#ids = item.send(ids_method.to_sym)\n\t\t\t\t\t#item.send((ids_method+'=').to_sym,ids + [id])\n\t\t\t\t\tresult_key = assoc_item.kojac_key\n\t\t\t\t\tmerge_model_into_results(assoc_item)\n\t\t\t\telse\n\t\t\t\t\traise \"ADD does not yet support #{ma.macro} associations\"\n\t\t\tend\n\t\t\t{\n\t\t\t\tkey: op[:key],\n\t\t\t verb: op[:verb],\n\t\t\t result_key: result_key,\n\t\t\t results: results\n\t\t\t}\n\t\tend",
"def store_path_linked_to_from(path, links)\n return if links.empty?\n redis.sadd path_linked_to_from_key(path), links\n end",
"def <<(redis_record)\n redis.lpush(base_key, redis_record.key)\n redis.ltrim(base_key, 0, @max_relation_size)\n end",
"def add(x, y, weight)\n @store[x] ||= EdgeBag.new\n @store[x].add(y, weight)\n @store[y] ||= EdgeBag.new if undirected?\n @store[y].add(x, weight) if undirected?\n end",
"def store collection\n @@graph.store collection\n end",
"def add_edge(from, to)\n from.adjacents << to\n end",
"def add_node(key, val)\n @store.append(key, val)\n end",
"def add_vertex( key )\n vertex = Vertex.new( key )\n @vertices[key] = vertex\n vertex\n end",
"def add_edge(from, to, cost)\n @vertices[from] = true unless @vertices.has_key? from\n @vertices[to] = true unless @vertices.has_key? to\n \n @edges_cost[from] = Hash.new() unless @edges_cost[from]\n @edges_cost[from].store(to, cost)\n\n @edges_up[from] = Hash.new() unless @edges_up[from]\n @edges_up[from].store(to, true)\n end",
"def add relation, &block\n b = relation.factorization.to_bin\n @mutex.synchronize do\n if @uniqe[b]\n @relations << relation\n @uniqe[b] = false\n end\n yield if block_given? # executes the given code block\n end\n end",
"def save_related\n if self.links.present?\n self.links.each do | link |\n link.parent_type = :action_item\n link.parent_key = self.key\n link.save!\n end\n end\n end",
"def add_child_object(child, relation, info = nil)\n\t relation.add_relation(self, child, info)\n\tend",
"def add(reference)\n unless @references.include?(reference)\n @references << reference\n @subpaths_and_references = nil\n end\n end",
"def put_relation(args)\n\tapi_url = \"#{@base_url}/#{args[:coll_A]}/#{args[:key_A]}/relation/\" +\n\t \"#{args[:relation]}/#{args[:coll_B]}/#{key_B}\"\n\tputs do_the_put_call( url: api_url, user: @user, json: '{}')\nend",
"def add_edge(e)\n @edges[e.from] << e\n end",
"def mark_link game, ref\n\t$links[ref] << game\nend",
"def add_directed_edge(id1,id2)\n @g[id1] ||= Array.new\n @g[id1] << id2\n end",
"def add(key, value)\r\n \t\t\t# Create new node for key, value to be added and set next to head \r\n \t\t\t# and then set head to the new node\r\n \t\t\tn = Node.new(key, value, @head)\r\n \t\t\t@head = n\r\n \t\tend",
"def link(from, to, info)\n\t if linked?(from, to)\n old_info = from[to, self]\n\t\tif info != old_info\n if info = merge_info(from, to, old_info, info)\n from[to, self] = info\n return\n else\n raise ArgumentError, \"trying to change edge information\"\n end\n\t\tend\n\t\treturn\n\t end\n\t super(from, to, info)\n\tend",
"def add_edge!(from, to)\n protected_add_edge!(from, to)\n @edge_number += 1\n end",
"def serializable_hash\n @node = links.any? ? super.merge(_links: links) : super\n end",
"def <<(rel)\n @map[rel.name] = rel if rel\n end",
"def add_vertex(v)\n @forward_edges_with_info[v] ||= IdentityHash.new\n @backward_edges[v] ||= IdentityHash.new\n end",
"def add_alias! key, to_key\n key = @schema.validate_new_key! key\n @values.delete key\n @schema.add_alias! key, to_key\n self\n end",
"def append(key, value)\n node_for(key).append(key, value)\n end",
"def add(key, value)\n current_and_parent_pair = find_current_and_parent_nodes(key)\n if current_and_parent_pair[:current]\n # update new value if key exists\n current_and_parent_pair[:current].value = value\n else\n new_node = TreeNode.new(key,value)\n parent = current_and_parent_pair[:parent]\n link_node_to_parent(parent, new_node)\n end\n end",
"def relate(attribute_name, options = {})\n options[:to] ||= '*'\n store_relation_mapping(options[:to], Internal::MappingFactory.build_relation(attribute_name, options))\n end",
"def append_to_association(association_map, key, datum_to_append, opts = {})\n if opts[:coord] # we will be interacting with the associations of a part of a collection if coord is specified\n association_map.putrc(opts[:coord][0], opts[:coord][1], key, []) if association_map.getrc(opts[:coord][0], opts[:coord][1], key).nil?\n association_map.getrc(opts[:coord][0], opts[:coord][1], key) << datum_to_append\n else\n association_map.put(key, []) if association_map.get(key).nil?\n association_map.get(key) << datum_to_append\n end\n end",
"def add_edge_to_cache(head_node, tail_node)\n @edges_cache[head_node] = {} if @edges_cache[head_node] == nil\n if @edges_cache[head_node][tail_node] == nil\n @edges_cache[head_node][tail_node] = 1\n @graphviz.add_edge(head_node, tail_node)\n end\n end",
"def add_node(graph, document)\n unless graph.node(document.key)\n node = graph.add(Refinery::Node.new(document.key, model: document))\n establish_slots(node, document)\n end\n end",
"def add_relation\n rel = @bib.relation.detect { |r| r.type == \"partOf\" }\n if rel\n title_main = rel.bibitem.title.detect { |t| t.type == \"main\" }\n @item.booktitle = title_main.title.content\n end\n end",
"def add_id\n @item.key = @bib.id\n end",
"def add_node(graph, document)\n unless graph.node(document.key)\n graph.add(Turbine::Node.new(document.key, model: document))\n end\n end",
"def <<(relation)\n new_node(relation.name, relation)\n end",
"def adding_plan_relation(transaction, parent, child, relations, info); end",
"def addRecord(rec); @records[rec.key] = rec end",
"def add(key, value)\n context.add(key, value)\n end",
"def op_add_relation!(field, objects = [])\n objects = [objects] unless objects.is_a?(Array)\n return false if objects.empty?\n relation_action = Parse::RelationAction.new(field, polarity: true, objects: objects)\n operate_field! field, relation_action\n end",
"def add_product_relation from_product_id, to_product_id\n # Add related products\n @server.call(\"call\", @session_id, \"catalog_product_link.assign\", [\"related\", from_product_id, to_product_id])\n rescue XMLRPC::FaultException => exception\n return exception\n end",
"def add_to_graph\n connection.execute <<-EOS\n REPLACE INTO #{oqgraph_table_name} (origid, destid, weight) \n VALUES (#{self.send(self.class.from_key)}, #{self.send(self.class.to_key)}, #{self.send(self.class.weight_column) || 1.0})\n EOS\n end",
"def relation_add(kind, value, sibling_id = nil)\n return if !value || value == nil\n value = value.to_s.strip\n relation = relation_first_exact(kind,value,sibling_id)\n if relation\n\t# relation.update_attributes(:value => value, :sibling_id => sibling_id )\n\treturn\n end\n Relation.create!({\n :note_id => self.id,\n :sibling_id => sibling_id,\n :kind => kind,\n :value => value\n })\n end",
"def add(key, value)\n @hash[key] = value\n @reverse[value] ||= []\n @reverse[value] << key\n end",
"def add_edge(u,v)\n if @graph.has_key?(u)\n @graph[u] << v\n else\n @graph[u] = [v]\n end\n @graph[u].uniq!\n end",
"def add_edge(edge)\n @edges.push(edge)\n end",
"def refers_to(*args)\n require \"og/relation/refers_to\"\n relations! << Og::RefersTo.new(args, :owner_class => self)\n end",
"def add_edge(u, v, weight = 1)\n\t\t@edges[u] = {} unless @edges.has_key?(u)\n\t\t@edges[v] = {} unless @edges.has_key?(v)\n\t\t@edges[u].update({v => Edge.new(u, v, weight)})\n\t\t@edges[v].update({u => Edge.new(v, u, weight)})\n\tend",
"def add(key, value = key)\n # always add element to back to bubble up\n @store << HeapNode.new(key, value) \n\n heap_up((@store.length - 1))\n end",
"def add_reference_obj(obj)\n @refs << obj\n end",
"def add_reference( type, source, component, name, weight=nil )\n r = Ref.new( type, source, component, name, \n weight ? weight : Ref::DEFAULT_WEIGHT )\n add_reference_obj(r)\n return r\n end",
"def associate_provenance(index:, key:, data:)\n to_item = @collection.part(index[0], index[1])\n data.each do |datum|\n # Make sure you aren't modifying a shared data structure\n datum = datum.dup\n from_item = datum.delete(:item)\n next unless from_item\n\n add_one_to_one_provenance(\n from_item: from_item,\n to_item: to_item,\n additional_relation_data: datum\n )\n end\n associate(index: index, key: key, data: 'added')\n end",
"def link(contact)\n contact.accounts << self\n contact.owner = self if contact.owner.nil?\n contact.save\n end",
"def add(key, value = key)\n new_node = HeapNode.new(key, value)\n @store << new_node\n\n heap_up(@store.length - 1) unless self.empty?\n end",
"def add_edge(source, target, weight = 1)\r\n\t\tself.push source unless self.include?(source)\r\n\t\tself.push target unless self.include?(target)\r\n\t\t@edges.push Edge.new(source, target, weight)\r\n\tend",
"def <<(other)\n @decl_rel.create_relationship_to(@node, other)\n self\n end",
"def add(item)\n @clxn[key_for(item)] = item\n end",
"def add_edge(u,v,weight)\n @source[u] = Hash.new unless @source.has_key?(u)\n @source[v] = Hash.new unless @source.has_key?(v)\n @source[u][v]=weight\n @source[v][u]=weight\n end",
"def relation(relation_name)\n state_depth_must_be(States::SCHEMA)\n r = relation_lookup(relation_name)\n raise \"relation #{relation_name} already exists\" if r\n n = Relation.new(@current_schema, relation_name)\n @current_schema.relations << n\n @current_relation = n\n clear_state_below(States::RELATION)\n end",
"def add_relation(relation_name, association, options={})\n if existing = find_relation_by(association)\n if relation_name =~ /^embed/\n delete_relation_for association\n else\n return\n end\n end\n Relation.new(relation_name.to_s, association, options).tap do |r|\n @relations << r\n end\n end",
"def link!\n # add to cache with pluralized key\n (row.cache[model.cache_key(pluralize: true)] ||= []) << self\n\n # add to cache with singular key (for convenience)\n row.cache[model.cache_key(pluralize: false)] = self\n end",
"def add_edge(x, y)\n if(!@g.has_key?(x)) then \n @g[x] = []\n end\n if(!@g[x].include? y) then\n @g[x] << y\n end\nend",
"def pfadd(key, member)\n node_for(key).pfadd(key, member)\n end",
"def add(key, value = key)\n @store << HeapNode.new(key, value)\n\n heap_up(@store.length - 1)\n end",
"def add(key, value = key)\n @store << HeapNode.new(key, value)\n\n heap_up(@store.length - 1)\n end",
"def relation\n relation = nodes.reduce(root) do |a, e|\n a.associations[e.name.key].join(:join, a, e)\n end\n schema.(relation)\n end",
"def add_to_database\n CONNECTION.execute(\"INSERT INTO links (link, relative_assignment) VALUES ('#{self.link}', '#{self.relative_assignment}');\")\n @id = CONNECTION.last_insert_row_id\n \n return self\n end",
"def merge(other_entry)\n @references += other_entry.references\n self\n end",
"def add(key, value = key)\n new_node = HeapNode.new(key, value)\n @store << new_node\n\n heap_up(@store.length - 1)\n end",
"def add_references(klazz, string)\n klazz.references.each do |r|\n string << \" many_to_one #{r.name.to_sym.inspect}, :class => #{r.rb_klazz.to_sym.inspect}, :key => #{r.foreignkeys.map {|fk| fk.field.to_sym}.inspect}\\n\"\n end\n string << (klazz.references.empty? ? '' : \"\\n\")\n end",
"def ref\n @references += 1\n end",
"def add(key, value = key)\n @store.append(HeapNode.new(key, value))\n curr = @store.length - 1\n\n curr = heap_up(curr)\n end",
"def add_adjacency(n1, n2)\n n1.adjacents << n2\n n2.adjacents << n1\n end",
"def populate_relation(args)\n\targs[:keys_B].each do |key_B|\n\t\tapi_url = \"#{@base_url}/#{args[:coll_A]}/#{args[:key_A]}/relation/\" +\n\t\t \"#{args[:relation]}/#{args[:coll_B]}/#{key_B}\"\n\t\tputs do_the_put_call({ url: api_url, user: @user, json: '{}' })\n\tend\nend",
"def add(key, value = key)\n new_node = HeapNode.new(key, value)\n @store << new_node\n heap_up(@store.size-1)\n end",
"def <<(object, will_save=true)\n\t\t\t\t\tif object.descendants.include? @parent\n\t\t\t\t\t\tobject.instance_variable_set :@_cyclic, true\n\t\t\t\t\telse\n\t\t\t\t\t\tobject.write_attribute object.parent_id_field, @parent._id\n\t\t\t\t\t\tobject[object.path_field] = @parent[@parent.path_field] + [@parent._id]\n\t\t\t\t\t\tobject[object.depth_field] = @parent[@parent.depth_field] + 1\n\t\t\t\t\t\tobject.instance_variable_set :@_will_move, true\n\t\t\t\t\t\tobject.save if will_save\n\t\t\t\t\tend\n\n\t\t\t\t\tsuper(object)\n\t\t\t\tend",
"def write_value_using_mongoid_strategy(writer, key)\n writer.push_value(@object.attributes[key], key)\n end",
"def add_relationship(parent_rel = nil)\n clear_relationships_cache\n all_relationships.create!(\n :relationship => (parent_rel.nil? ? relationship_type : parent_rel.relationship),\n :parent => parent_rel\n )\n end",
"def add(key, value = key)\n node = HeapNode.new(key, value)\n @store << node\n heap_up(@store.length - 1)\n end",
"def add_node_attribute(key, value, options)\n @node_attributes << { key: key, value: value, options: options }\n end",
"def add_connection(connection)\n self.connections[connection.id] = connection\n end",
"def link( entity, is_back_reference = false )\r\n fail_if_invalid()\r\n\r\n type = @links.keys.find { |acceptable| entity.is_a?( acceptable ) }\r\n unless type\r\n raise ArgumentError, \"Can't link #{self.class.name} with #{entity.class.name}. Invalid entity type.\"\r\n end\r\n # Keep record of each entity type in a hash lookup.\r\n @links[ type ] ||= []\r\n collection = @links[ type ]\r\n # Ensure backreference.\r\n entity.link( self, true ) unless is_back_reference\r\n # Ensure there's only one entry for each entity.\r\n # (?) Should the Set class be used? Or does it not give enough performance\r\n # gain for small arrays?\r\n if collection.include?( entity )\r\n return false\r\n else\r\n collection << entity\r\n return true\r\n end\r\n end",
"def add(key, value = key)\n new_node = HeapNode.new(key, value)\n @store << new_node\n heap_up(@store.length-1)\n end"
] |
[
"0.6182365",
"0.6182044",
"0.6178859",
"0.6128831",
"0.603533",
"0.5910233",
"0.5817467",
"0.57893527",
"0.57568485",
"0.57426685",
"0.573746",
"0.5715629",
"0.5675938",
"0.56750786",
"0.56678474",
"0.5661373",
"0.5653564",
"0.5631272",
"0.5629847",
"0.5629258",
"0.5624438",
"0.56000197",
"0.5595159",
"0.5580223",
"0.55682427",
"0.55523634",
"0.5480905",
"0.5455054",
"0.5440104",
"0.5426664",
"0.54238623",
"0.54000276",
"0.5388137",
"0.53746897",
"0.53682303",
"0.5352617",
"0.5351485",
"0.53465915",
"0.5345623",
"0.53362316",
"0.5327651",
"0.5308362",
"0.53081995",
"0.5307353",
"0.52914536",
"0.52783746",
"0.52658755",
"0.52651846",
"0.52523094",
"0.524656",
"0.52461845",
"0.5243768",
"0.52413213",
"0.5221539",
"0.5202245",
"0.5193914",
"0.51921254",
"0.51870286",
"0.51706934",
"0.5163393",
"0.5154047",
"0.5152725",
"0.51360995",
"0.51212794",
"0.5116606",
"0.51141393",
"0.51118493",
"0.5105863",
"0.5097276",
"0.50951517",
"0.5094274",
"0.50893563",
"0.5085778",
"0.50744855",
"0.5069735",
"0.5057431",
"0.50568074",
"0.50543505",
"0.50491774",
"0.50439763",
"0.5031169",
"0.5031169",
"0.5030407",
"0.50300574",
"0.5018412",
"0.50160193",
"0.5014776",
"0.50075346",
"0.50050765",
"0.49976996",
"0.499245",
"0.49909505",
"0.4987807",
"0.49873784",
"0.4979891",
"0.49768904",
"0.4976041",
"0.49756",
"0.49753112",
"0.49753085"
] |
0.6775267
|
0
|
Delete a graph/relation from the collection.
|
def orchio_delete_graph(kind, to_collection, to_key)
response = client.send_request(
:delete,
inst_args(
kind: kind,
to_collection: to_collection,
to_key: to_key,
path: "?purge=true"
))
orchio_status response, 204
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def delete(rel)\n @relations.delete_if do |x|\n x === rel\n end\n @graph[rel.from].delete(rel.to)\n @graph[rel.to].delete(rel.from) if @undirected\n end",
"def delete!\n graph.remove_vertex self\n end",
"def delete!\n graph.remove_edge element\n end",
"def delete!\n graph.remove_edge element\n end",
"def delete!\n graph.removeEdge element\n end",
"def delete_relation_for association\n @relations.reject!{ |r| r.association == association || r.association == association.singularize}\n end",
"def delete!\n graph.removeVertex element\n end",
"def delete!\n graph.remove_vertex element\n end",
"def destroy\n @relation = Node.find(params[:id])\n @collection = current_user.collections.find(params[:collection_id])\n\n if @relation.nil? || @collection.nil? || @relation.document.collection.id != @collection.id\n redirect_to :back, :alert => \"Cannot find an relation\"\n return\n end\n\n @document = @relation.document\n @collection = @document.collection\n\n logger.debug @relation.errors.inspect\n respond_to do |format|\n if @relation.destroy\n format.html { redirect_to \"/collections/#{@collection.id}/documents/#{@document.pmid}?tab=relation\", :notice => \"Relation was successfully deleted.\" }\n format.json { head :no_content }\n else\n format.html { redirect_to :back, :alert => \"Cannot delete relation: #{@relation.errors.full_messages}\" }\n format.json { render json: @relation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def delete_graph(kind, to_collection, to_key)\n retval orchio_delete_graph kind, to_collection, to_key\n end",
"def delete\n\t\tdb.execute{ \"delete edge #{ref_name} #{rrid}\" }\n\tend",
"def delete(key)\n @relation.delete(key)\n end",
"def delete\n @connection.call('GRAPH.DELETE', @graphname)\n rescue Redis::CommandError => e\n raise DeleteError, e\n end",
"def cascade\n if relation\n if relation.is_a?(Enumerable)\n relation.entries\n relation.each { |doc| doc.destroy }\n else\n relation.destroy\n end\n end\n end",
"def remove_relation(rel)\n relations.delete(rel)\n Roby.remove_relation(rel)\n end",
"def remove(vertex)\n return if !self.include?(vertex)\n vertex.remove_relations(self)\n super\n end",
"def delete\n unless graph.nil?\n result = graph.remove_artifact(self)\n @graph = nil\n result\n end\n end",
"def destroy\n @relation = Relation.find(params[:id])\n @relation.destroy\n\n respond_to do |format|\n format.html { redirect_to relations_url }\n format.json { head :no_content }\n end\n end",
"def delete\n CONNECTION.execute(\"DELETE FROM links WHERE id = #{self.id};\")\n end",
"def clear_vertex\n for rel in sorted_relations\n rel.remove(self)\n end\n\tend",
"def remove_relation\n relation_scope.where(@id_key => deleted_remote_objects_ids)\n end",
"def delete(object)\n tracker.queue(state(object).delete(relation))\n self\n end",
"def destroy\n @relation.destroy\n respond_to do |format|\n format.html { redirect_to relations_url, notice: 'Relation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @collection.destroy\n end",
"def destroy\n\t\t@relation = Relation.find(params[:id])\n\t\tif @relation.destroy\n\t\t\tflash[:notice] = t(:ctrl_object_deleted, :typeobj => t(:ctrl_relation), :ident => @relation.ident)\n\t\telse\n\t\t\tflash[:error] = t(:ctrl_object_not_deleted, :typeobj => t(:ctrl_relation), :ident => @project.ident)\n\t\tend\n\t\trespond_to do |format|\n\t\t\tformat.html { redirect_to(relations_url) }\n\t\t\tformat.xml { head :ok }\n\t\tend\n\tend",
"def delete\n self.class.fire_event(NodeDeletedEvent.new(self))\n relations.each {|r| r.delete}\n @internal_node.delete\n lucene_index.delete(neo_node_id)\n end",
"def delete!\n if parent\n parent.remove_child(id)\n @parent = nil\n end\n collection.remove(_id: id)\n self.id = nil\n true\n end",
"def destroy\n save_graph = RDF::Graph.new\n fill_save_graph save_graph\n save_graph.each do |s|\n puts s.inspect\n end\n Db.delete_data( save_graph, :graph => klass.object_graph )\n end",
"def destroy\n relationship = Relationships.find(params[:id])\n relationship.destroy\n head 204\n end",
"def delete(collection, entity)\n command(collection).delete(entity)\n end",
"def destroy\n success = ActiveRecord::Base.transaction do\n @graph.destroy\n @graph = $mfclient.delete_graph(@graph.path) rescue nil\n end\n respond_to do |format|\n format.html { redirect_to graphs_url }\n format.json { head :no_content }\n end\n end",
"def delete(id)\n collection.remove(id)\n end",
"def op_remove_relation!(field, objects = [])\n objects = [objects] unless objects.is_a?(Array)\n return false if objects.empty?\n relation_action = Parse::RelationAction.new(field, polarity: false, objects: objects)\n operate_field! field, relation_action\n end",
"def delete\n association.delete association[element.dataset[:index].to_i]\n end",
"def delete_connection(relation_name, other_object, bidi)\n return Relation.delete(relation_name, self.node, other_object.node, bidi)\n end",
"def destroy\n super do\n graph.delete [source.to_term, nil, nil]\n parent.delete [parent, nil, source.to_term]\n end\n end",
"def delete(collection)\n return 0 unless collection.query.valid?\n adapter.delete(collection)\n end",
"def delete\n ignore_columns = [\"id\", \"created_at\", \"updated_at\"]\n # Find all assignments associated with this element\n\t\tlist = Relationship.where({ @type.to_s => @id })\n \n # For each assignment\n\t\tlist.each do |assignment|\n # Remove this element from the assigment\n assignment[@type] = nil\n \n # Count how many elements are left\n count = 0\n Relationship.column_names.each do |column|\n if assignment[column] != nil and not ignore_columns.include?(column)\n count += 1\n end\n end\n \n # If only one element is left, destroy the assignment\n if count <= 1\n assignment.destroy\n # Otherwise, save\n else\n assignment.save\n end\n end\n \n # Destroy the desired element\n @class.destroy(@id)\n end",
"def delete\n @relationship = Relationship.find(params[:relationship_id])\n end",
"def destroy\n @subrelation = Subrelation.find(params[:id])\n @subrelation.destroy\n\n respond_to do |format|\n format.html { redirect_to(subrelations_url) }\n format.xml { head :ok }\n end\n end",
"def delete\n # TODO: implement delete\n end",
"def destroy\n @tag_relation.destroy\n respond_to do |format|\n format.html { redirect_to tag_relations_url, notice: 'Tag relation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete(object)\n key_name = attributes.key[0].name\n key_value = object.public_send(key_name)\n relation.delete(key_name => key_value)\n object\n end",
"def destroy \n @link = Link.find(params[:id]) \n @parent_collection = @link.collection #grabbing the parent collection before deleting the record \n @link.destroy \n \n #redirect to a relevant path depending on the parent collection \n if @parent_collection\n flash[:success] = \"link destroyed!\"\n\n redirect_to browse_path(@parent_collection) \n else\n flash[:success] = \"link destroyed!\"\n redirect_to :back\n end\nend",
"def delete(collection)\n raise NotImplementedError, \"#{self.class}#delete not implemented\"\n end",
"def destroy\n @tag_relationship.destroy\n respond_to do |format|\n format.html { redirect_to tag_relationships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @graph_membership_graph = GraphMembershipGraph.find(params[:id])\n @graph_membership_graph.destroy\n\n respond_to do |format|\n format.html { redirect_to graph_membership_graphs_url }\n format.json { head :no_content }\n end\n end",
"def delete_relationship(id)\n return @client.raw(\"delete\", \"/config/relationships/#{id}\")\n end",
"def remove_relation\n relation_scope.where.not(@id_key => remote_objects_ids)\n end",
"def destroy\n @graph = Graph.find(params[:id])\n @graph.destroy\n \n Action.log :controller => params[:controller], :action => params[:action], :target_id => params[:id], :user => current_user\n\n respond_to do |format|\n format.html { redirect_to :root, notice: 'Graph was successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @relationship.destroy\n redirect_to edit_character_relationships_path(@character.name), notice: 'That relationship has been removed.'\n end",
"def destroy\n @graph.destroy\n\n respond_to do |format|\n format.html { redirect_to graphs_url }\n format.json { head :no_content }\n end\n end",
"def delete(options={})\n connection.delete(\"/\", @name)\n end",
"def destroy\n @relationship = Relationship.find(params[:id])\n @relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to(relationships_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @relationship = @assembly.relationships.find(params[:id])\n child = @relationship.child\n child.used = false\n child.save\n @relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to [@plan, @assembly], notice: 'Relationship was deleted.' }\n format.json { head :no_content }\n end\n end",
"def delete\n self.class.delete(self.to_id)\n end",
"def delete_edge(v)\n count = 0\n @edges.each do |e|\n @edges.delete_at(count)if e.vertex.eql?(v)\n count+=1\n end\n end",
"def remove_relation(from, to)\n if !linked?(from, to)\n return\n end\n\n\t rel = self\n\t relations = []\n\t while rel\n\t\trelations << rel\n\t\trel = rel.parent\n\t end\n\n\t if from.respond_to?(:removing_child_object)\n\t\tfrom.removing_child_object(to, relations)\n\t end\n\t if to.respond_to?(:removing_parent_object)\n\t\tto.removing_parent_object(from, relations)\n\t end\n\n\t for rel in relations\n\t\trel.unlink(from, to)\n\t end\n\n\t if from.respond_to?(:removed_child_object)\n\t\tfrom.removed_child_object(to, relations)\n\t end\n\t if to.respond_to?(:removed_parent_object)\n\t\tto.removed_parent_object(from, relations)\n\t end\n\tend",
"def delete\n self.store -= self\n end",
"def delete_vertex(vertex)\n out_e = self[vertex].out_edges.to_a\n out_e.each { |e| delete_edge(vertex, e) }\n in_e = self[vertex].in_edges.to_a\n in_e.each { |e| delete_edge(e, vertex) }\n self.delete(vertex)\n end",
"def remove_relationship(destiny, label)\n return if destiny.nil? or destiny == self\n edge_class = ModelFabric.get_class(SocialFramework.edge_class)\n\n edge = edge_class.where([\"(origin_id = :origin_id AND destiny_id = :destiny_id OR \n destiny_id = :origin_id AND origin_id = :destiny_id) AND label = :label\",\n { origin_id: self.id, destiny_id: destiny.id, label: label }]).first\n\n self.edges.destroy(edge.id) unless edge.nil?\n end",
"def delete_related!(*names)\n # Recurse on the statement.\n @statement.delete_related!(*names)\n end",
"def destroy\n @graph.destroy\n respond_to do |format|\n format.html { redirect_to graphs_url }\n format.json { head :no_content }\n end\n end",
"def unlink(other)\n self.class.graph.disjoin(vertex, other.vertex)\n end",
"def delete(collection, entity)\n @mutex.synchronize do\n command(collection).delete(entity)\n end\n end",
"def destroy\n @edge = Edge.find(params[:id])\n @edge.destroy\n\n respond_to do |format|\n format.html { redirect_to edges_url }\n format.json { head :no_content }\n end\n end",
"def delete(model)\n @ancestors.delete(model) if @ancestors\n @descendants.delete(model)\n end",
"def destroy\n @relationship = @character.relationships.find_by_permalink!(params[:id])\n @relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to(character_relationships_url(@character)) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @package_relationship = PackageRelationship.find(params[:id])\n @package_relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to(package_relationships_url) }\n format.xml { head :ok }\n end\n end",
"def delete(connection)\n response = Hpricot.XML(connection.process(Document::Delete.new(self).xml))\n raise Exception, response.at('error').innerHTML if response.at('error')\n self.handle = nil\n self\n end",
"def delete; rest_delete(link('self')); end",
"def delete; rest_delete(link('self')); end",
"def removing_plan_relation(transaction, parent, child, relations); end",
"def delete\n self.class.delete self.href\n end",
"def delete(collection)\n query = collection.query\n\n # TODO: if the query contains any links, a limit or an offset\n # use a subselect to get the rows to be deleted\n\n statement, bind_values = delete_statement(query)\n execute(statement, *bind_values).to_i\n end",
"def destroy\n @protocol_relationship.destroy\n respond_to do |format|\n format.html { redirect_to protocol_relationships_url, notice: 'Protocol relationship was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @expression_relationship = ExpressionRelationship.find(params[:id])\n @expression_relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to expression_relationships_url }\n format.json { head :no_content }\n end\n end",
"def relation_removed(issue)\n journalize_action(\n :property => 'relation',\n :prop_key => 'relates',\n :old_value => issue.try(:id)\n )\n end",
"def destroy\n visit.destroy\n respond_with(visit)\n end",
"def destroy\n @csrelation.destroy\n respond_to do |format|\n format.html { redirect_to csrelations_url, notice: 'Csrelation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @relationships = Relationship.paginate(:page => params[:page], :per_page => 30).order('updated_at DESC')\n @relationship = Relationship.find(params[:id])\n @error = nil\n\n begin\n @relationship.destroy\n rescue ActiveRecord::DeleteRestrictionError => e\n @error = e.message\n end\n end",
"def delete(path = nil, options = {})\n connection.delete(path, options)\n end",
"def delete\n Iterable.request(conf, base_path).delete\n end",
"def delete!\n clear!\n delete\n end",
"def delete_edge!(from, to)\n protected_delete_edge!(from, to)\n @edge_number -= 1\n end",
"def del\n delete\n end",
"def destroy\n response = connection.delete(\"/collections/#{id}\")\n (200..299).include?(response.status)\n end",
"def destroy_relations(related_tag)\n Relation.where(tag: [self, related_tag],\n related_tag: [self, related_tag]).delete_all\n end",
"def delete\n self.class.db.delete_with_id(self.class.collection_name, id).to_promise_then do\n @deleted = true\n if cache && !cache.includes?(self.class, id)\n msg = \"#{__FILE__}[#{__LINE__}] : #{self.class.name} : expected model with id #{id} to be in cache - cannot delete\"\n Robe.logger.error(msg)\n raise DBError, msg\n end\n cache.delete(self) if cache\n results = []\n self.class.has_one_associations.each do |assoc|\n if assoc.owner\n send(assoc.local_attr).to_promise_then do |one|\n results << one.delete\n end\n end\n end\n results.to_promise_when\n end.to_promise_then do\n results = []\n self.class.has_many_associations.each do |assoc|\n if assoc.owner\n assoc_results = []\n results << send(assoc.local_attr).to_promise.to_promise_then do |many|\n many.each do |one|\n # trace __FILE__, __LINE__, self, __method__, \" deleting associated : #{one}\"\n assoc_results << one.delete\n end\n assoc_results.to_promise_when_on_client\n end\n end\n end\n results.to_promise_when.then do\n self\n end\n end\n end",
"def delete\n CMark.node_unlink(@pointer)\n end",
"def destroy\n @public_relation.destroy\n respond_to do |format|\n format.html { redirect_to public_relations_url, notice: 'Public relation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def unconnect\n relationship = ContactVenueRelationship.find_by(contact_id: id,\n venue_id: venue.id)\n relationship.destroy\n end",
"def delete_vertex(vertex)\n if !contains_vertex?(vertex)\n raise InvalidVertexException, \"The graph does not contain that vertex\"\n end\n \n # Need to make a copy of the graph since it's being edited in place\n Array.new(@graph[vertex]).each { |connection| delete_edge(connection, vertex) }\n @graph.delete(vertex)\n self\n end",
"def destroy\n @mergegraph.destroy\n respond_to do |format|\n format.html { redirect_to admin_mergegraph_url }\n format.json { head :no_content }\n end\n end",
"def delete(id)\n collection.remove({ _id: id })\n end",
"def destroy\n @relationship.destroy\n respond_to do |format|\n format.html { redirect_to relationships_url, notice: 'Relationship was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @relationship.destroy\n respond_to do |format|\n format.html { redirect_to relationships_url, notice: 'Relationship was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def remove_from_graph\n # Ignores trying to delete nonexistent records\n connection.execute <<-EOS\n DELETE IGNORE FROM #{oqgraph_table_name} WHERE origid = #{self.send(self.class.from_key)} AND destid = #{self.send(self.class.to_key)};\n EOS\n end",
"def destroy\n @comment_relationship = CommentRelationship.find(params[:id])\n @comment_relationship.destroy\n\n respond_to do |format|\n format.html { redirect_to comment_relationships_url }\n format.json { head :no_content }\n end\n end",
"def delete(path, options = {})\n connection.delete path, options\n end"
] |
[
"0.7398699",
"0.73630047",
"0.7266474",
"0.7266474",
"0.72542584",
"0.7244137",
"0.7128334",
"0.7120606",
"0.6999951",
"0.69869655",
"0.69194967",
"0.69048387",
"0.68649715",
"0.68160367",
"0.6667667",
"0.6652384",
"0.6650596",
"0.6558151",
"0.655143",
"0.6485748",
"0.6468044",
"0.6405469",
"0.6322743",
"0.6292157",
"0.6290258",
"0.627836",
"0.62628406",
"0.625409",
"0.6244301",
"0.6197427",
"0.61943763",
"0.6182052",
"0.61687785",
"0.61566144",
"0.6156491",
"0.61417115",
"0.6137531",
"0.6133989",
"0.60979843",
"0.6082124",
"0.6065845",
"0.6064142",
"0.60449",
"0.603151",
"0.6026586",
"0.5991467",
"0.5965171",
"0.59645075",
"0.59459716",
"0.5945753",
"0.5942582",
"0.5938468",
"0.5936674",
"0.5935812",
"0.5931278",
"0.5919758",
"0.5914595",
"0.5908514",
"0.5904533",
"0.5901866",
"0.5901303",
"0.59002197",
"0.58951974",
"0.589323",
"0.5889643",
"0.5878574",
"0.5864065",
"0.586396",
"0.5858938",
"0.5856153",
"0.5852235",
"0.5852235",
"0.585073",
"0.585031",
"0.5848161",
"0.5842373",
"0.5842134",
"0.5824498",
"0.5822333",
"0.58146775",
"0.580711",
"0.5806583",
"0.58040255",
"0.5803871",
"0.58029586",
"0.57991546",
"0.57956535",
"0.5794248",
"0.57939935",
"0.57909375",
"0.5783822",
"0.5777748",
"0.5771942",
"0.5770537",
"0.57669973",
"0.57654595",
"0.57654595",
"0.57635766",
"0.57635415",
"0.5761045"
] |
0.7154822
|
6
|
Public instance methods JMC Returns the collection name for the current instance.
|
def orchestrate_collection_name
ocollection
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def collection_name\n @collection_name ||= self.to_s.tableize.gsub(/\\//, '.')\n end",
"def collection_name\n\t\t\t\t\"#{klass.model_name.to_s.classify.pluralize}Collection\".constantize\n\t\t\tend",
"def collection_name; end",
"def collection_name; end",
"def collection_name; end",
"def get_collection_name()\r\n result = nil\r\n if @coll_id #if coll_id is false, than collection_service is used by environment\r\n info = Transformer::KeyBuilder.collection_info(@env_id, @coll_id)\r\n result = @db_interface.get_hash_value(info, Transformer::KeyBuilder::NAME_KEY)\r\n end\r\n return result\r\n end",
"def collection_name\n self.to_s.tableize\n end",
"def get_name()\n return @coll_name\n end",
"def collection_name\n __evaluate__(storage_options[:collection])\n end",
"def coll_name\n self.name.split('::').last.split(/(?=[A-Z])/).map{|x| x.downcase}.join('_')\n end",
"def flexi_collection_name\n self.name.parameterize\n end",
"def collection_names; end",
"def resource_collection_name #:nodoc:\n self.resources_configuration[:self][:collection_name]\n end",
"def ocollection\n @@_collection[self.class.name].name\n end",
"def full_collection_name(collection_name)\n \"#{@name}.#{collection_name}\"\n end",
"def collection_name\n @collection_name ||=\n if @resource_options.key?(:collection_name)\n @resource_options.fetch(:collection_name).to_s\n else\n tools.string.pluralize(qualified_resource_name)\n end # if-else\n end",
"def collection_ivar\n \"@#{class_name.model_name.plural}\"\n end",
"def full_collection_name(collection_name)\n \"#{name}.#{collection_name}\"\n end",
"def full_collection_name\n \"#{app_id}.#{name}\"\n end",
"def collection_names\n collections.keys\n end",
"def shortCollectionName(c)\n c.getName.split(',')[0].strip\nend",
"def collection_name\n :\"@#{controller_name}\"\n end",
"def camel_case_collection_name(collection)\n collection.to_s.split(\"_\").map(&:capitalize).join\n end",
"def collection_name_from_class_name(class_name)\n class_name.demodulize.underscore.pluralize.to_sym\n end",
"def collection\n database[collection_name]\n end",
"def collection_names\n names = collections_info.collect { |doc| doc['name'] || '' }\n names = names.delete_if {|name| name.index(@name).nil? || name.index('$')}\n names.map {|name| name.sub(@name + '.', '')}\n end",
"def collection_name\n singular == plural ? \"#{plural}_index\" : plural\n end",
"def collection_name\n singular == plural ? \"#{plural}_index\" : plural\n end",
"def coll_name\n return coll.college_name\n end",
"def collection\n mongo_session[collection_name]\n end",
"def collection\n mongo_session[collection_name]\n end",
"def collection_names(options = {})\n @batch_size = options[:batch_size]\n session = client.send(:get_session, options)\n cursor = read_with_retry_cursor(session, ServerSelector.primary, self) do |server|\n send_initial_query(server, session, options.merge(name_only: true))\n end\n cursor.map do |info|\n if cursor.initial_result.connection_description.features.list_collections_enabled?\n info['name']\n else\n (info['name'] &&\n info['name'].sub(\"#{@database.name}.\", ''))\n end\n end.reject do |name|\n name.start_with?('system.') || name.include?('$')\n end\n end",
"def collection_names\n Rails.logger.info \"DEPRECATED: collection_names is deprecated, please refactor\"\n @collection_names ? @collection_names : self.collections.collect(&:name).join(\",\")\n end",
"def collection\n components.values.last[:collection]\n end",
"def get_collection_id()\r\n return @coll_id\r\n end",
"def collection_name\n if not parent_report\n table_name\n else\n [parent_report.record_name, table_name].join(\".\")\n end\n end",
"def collections_coll\n settings.db['collections']\n end",
"def collection\n Rails.logger.info \"XXXXX COLLECTION NAME #{collection_hash['collection name']}\"\n\n @collection ||= CollectionCreator.find_or_create_collection(\n collection_hash['collection name'],\n collection_hash['unit name'],\n collection_hash['collection description'],\n submitter_user_key\n )\n end",
"def inspect\n \"<Montgomery::Collection:0x#{object_id.to_s(16)} @name=#{name.inspect}>\"\n end",
"def collection\n @collection ||= mongo.collection(Boom.config.attributes[\"mongodb\"][\"collection\"])\n end",
"def collection_name(solr_doc)\n solr_doc[Solrizer.solr_name(\"collection\", :facetable)]\n end",
"def collection(collection_name)\n default_scope.collection(collection_name)\n end",
"def collection_path(query_options = nil)\n self.element_name\n end",
"def collection(name)\n Kernel.const_get(\"#{name}Collection\").new(@browser)\n end",
"def out_collection_name\n if options[:out].respond_to?(:keys)\n options[:out][OUT_ACTIONS.find do |action|\n options[:out][action]\n end]\n end || options[:out]\n end",
"def collection(name = EM::Mongo::DEFAULT_NS)\n @collections[name] ||= EM::Mongo::Collection.new(@db_name, name, @em_connection)\n end",
"def collection\n @collection ||= self.db.collection(self.collection_name)\n end",
"def collection_path\n @prefix + '/' + @resource.collection_path.to_s\n end",
"def collection\n return nil if embedded?\n @collection_name = self.to_s.demodulize.tableize\n @collection ||= Mongoid.database.collection(@collection_name)\n end",
"def [](collection_name)\n collection(collection_name)\n end",
"def get_collection(name)\n @data[name]\n end",
"def collection\n @collector.collection\n end",
"def collection\n self.class.collection\n end",
"def collection\n self.class.collection\n end",
"def collection(name=nil)\n if name\n @collection = db.collection(name: name)\n else\n @collection || raise('Please give a collection name for this model')\n end\n end",
"def set_collection_name(name)\n @collection_name = name\n end",
"def collection(model = name.to_s.classify.constantize)\n model\n end",
"def name\n underscore(self.class.name)\n end",
"def source_collection\n collection = Collection.find(object.source_collection_id) if object.source_collection_id\n return collection.title unless collection.nil?\n end",
"def collection\n @options[:collection] if @options.key?(:collection)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def set_CollectionName(value)\n set_input(\"CollectionName\", value)\n end",
"def collection_names\n response = RequestResponse.new\n name_resp = collections_info.defer_as_a\n name_resp.callback do |docs|\n names = docs.collect{ |doc| doc['name'] || '' }\n names = names.delete_if {|name| name.index(self.name).nil? || name.index('$')}\n names = names.map{ |name| name.sub(self.name + '.','')}\n response.succeed(names)\n end\n name_resp.errback { |err| response.fail err }\n response\n end",
"def member_collections\n collections\n end",
"def collection_path\n self.class.collection_path\n end",
"def collection\n klass.collection\n end",
"def source_collection_title\n self['source_collection_title_ssim']\n end",
"def name\n self.class.simple_name\n end",
"def collections\n collection_names.map do |name|\n Collection.new(name, self)\n end\n end",
"def collection\n get_collection_ivar || begin\n set_collection_ivar class_name.all\n end\n end",
"def collection(collection_name)\n Collection.new(@backend, @bucket_name, @name, collection_name)\n end",
"def method_for_association_chain #:nodoc:\n resource_collection_name\n end",
"def name\n @_name\n end",
"def current_collection() instance_variable_get(\"@#{resource_plural}\") end",
"def inspect\n \"#<#{self.class} #{relative_path} collection=#{collection.label}>\"\n end",
"def collection\n @collection ||= database.collection Crocoduck::Store.server_collection\n end",
"def collection; @opts['collection'] end",
"def collection_type\n components[0].to_sym rescue nil\n end",
"def collection\n klass.collection\n end",
"def _default_type_name\n if to_s.end_with?('::Collection_')\n _name = to_s.gsub(\n 'Serializer', ''\n ).gsub(\n '::Collection_', ''\n ).downcase.split('::')[-1]\n\n \"#{_name}_collection\".to_sym\n else\n to_s.gsub('Serializer', '').downcase.split('::')[-1].to_sym\n end\n end",
"def [](collection_name)\n Collection.new(self, collection_name)\n end",
"def set_NewCollectionName(value)\n set_input(\"NewCollectionName\", value)\n end",
"def collection_names\n case config[\"collections\"]\n when Hash\n config[\"collections\"].keys\n when Array\n config[\"collections\"]\n when nil\n []\n else\n raise ArgumentError, \"Your `collections` key must be a hash or an array.\"\n end\n end",
"def collection\n return nil unless collection_member?\n @collection ||= SolrDocument.new(\n Blacklight.solr.select(\n :params => {\n :fq => \"#{SolrDocument.unique_key}:\\\"#{self[blacklight_config.collection_member_identifying_field].first}\\\"\"\n }\n )[\"response\"][\"docs\"].first\n )\n end",
"def name\n @name ||= self.class.non_namespaced_name\n end",
"def collection_key(key)\n @_collection_key = key.to_sym\n end",
"def type\n \"collection\"\n end"
] |
[
"0.79024315",
"0.7801493",
"0.7775891",
"0.7775891",
"0.7775891",
"0.76895154",
"0.7650322",
"0.76499206",
"0.75549334",
"0.7468139",
"0.74520445",
"0.73105454",
"0.72635525",
"0.72388476",
"0.7229683",
"0.72220194",
"0.7183079",
"0.7117808",
"0.707675",
"0.7059667",
"0.69695246",
"0.6955202",
"0.6877323",
"0.68717563",
"0.67997813",
"0.6797157",
"0.6750743",
"0.6750743",
"0.6721431",
"0.672019",
"0.6626561",
"0.66240245",
"0.6611819",
"0.65710235",
"0.6564337",
"0.6550812",
"0.6531319",
"0.6529883",
"0.6524068",
"0.6449243",
"0.6435899",
"0.6425827",
"0.6406739",
"0.6402574",
"0.63932914",
"0.6371693",
"0.6349521",
"0.6340658",
"0.63322854",
"0.6320103",
"0.6318707",
"0.63101214",
"0.6297342",
"0.6297342",
"0.62955356",
"0.62769336",
"0.62524474",
"0.62492037",
"0.62352294",
"0.6229835",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.6229665",
"0.61905646",
"0.61780983",
"0.6171402",
"0.61664766",
"0.6164166",
"0.6157422",
"0.6139487",
"0.61394733",
"0.6117567",
"0.6116033",
"0.61086506",
"0.6099432",
"0.60829526",
"0.6063365",
"0.60491824",
"0.60440785",
"0.60421103",
"0.6022771",
"0.6014064",
"0.60076135",
"0.59845066",
"0.5983424",
"0.5983176",
"0.5965325",
"0.5960427"
] |
0.7381959
|
12
|
Returns the ref value for the current instance. The ref value is an immutable value assigned to each version of primary_key data in an orchestrate.io collection.
|
def orchestrate_ref_value
__ref_value__
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def reference\n value_for('reference')\n end",
"def ref\n @id\n end",
"def ref\n @ref ||= self.node.attributes.to_h[\"ref\"]\n end",
"def reference\n @data['reference']\n end",
"def ref\n reference(@id, @revision)\n end",
"def ref\n @ref ||= maybe_ref || api.master_ref.ref\n end",
"def reference\n @reference\n end",
"def self_value_reference #:nodoc:\n # Make a reference for the self-value column\n @self_value_reference ||= ActiveFacts::RMap::Reference.new(self, nil).tabulate\n end",
"def [](ref_id)\n response = @key_value.perform(:get, ref_id)\n Ref.new(@key_value.collection, @key_value.key, response)\n end",
"def reference\n object.id.to_s\n end",
"def ref\n Coord.rel( self )\n end",
"def stable_reference\n raise RuntimeError.new('Model id required to generate a stable reference') unless model_id\n\n hash = Digest::SHA256.base64digest(\"#{viewmodel_class.name}.#{model_id}\")\n \"ref:h:#{hash}\"\n end",
"def ref\n ref = @repository.refs.find { |refs_a| refs_a.include?(@sha) }\n ref ? ref.last : @sha\n end",
"def ref(logical_id)\n {\"Ref\" => xref(logical_id)}\n end",
"def lookup_ref (workitem, prefix='')\n\n ref = lookup_vf_attribute(workitem, 'ref', :prefix => prefix)\n ref ? ref.to_s : nil\n end",
"def reference\n [ type, identifier ]\n end",
"def reference\n [:item, identifier.to_s]\n end",
"def reference\n [:item, identifier.to_s]\n end",
"def __drbref\n @ref\n end",
"def reference\n %x{ #{ Firebase.new `#@native.ref().toString()` } }\n end",
"def reference_attribute\n\t\t\tsorted_attributes.first\n\t\tend",
"def auto_reference(value)\n if value.is_a?(Array)\n return value.map { |v| auto_reference(v) }\n end\n\n if value.is_a?(Entity)\n # If it's from another crate, need to add it to this one.\n crate.add_contextual_entity(value)\n\n return value.reference\n end\n\n value\n end",
"def reference\n data['caseReference']\n end",
"def ref_attrs\n docidentifier.detect(&:primary)&.tap do |di|\n return { anchor: di.id.gsub(\" \", \".\").squeeze(\".\") }\n end\n end",
"def reference\n if success?\n nil\n else\n body ? self[\"reference\"] : \"No reference\"\n end\n end",
"def getRefPath()\n return @refPath\n end",
"def ref_id\n 300_000_000 + data[0].to_i\n end",
"def reference_data\n @reference_data ||= KeyValues.new(@from_profile, @source).format_data\n end",
"def to_s\n self.ref\n end",
"def ref_seq\n\n if _ref_seq\n _ref_seq\n else\n seq = Reference.ref_seq(chromosome, start, stop, strand)\n update_attributes(:_ref_seq => seq)\n seq\n end\n\n end",
"def current_key\n\n unserialized_key = nil\n\n if serialized_key_or_id_string = @cursor_instance.get_key\n\n # if we have an index we have serialized key\n if @parent_index\n unserialized_key = @parent_bucket.parent_adapter.class::SerializationClass.__send__( @parent_bucket.parent_adapter.class::UnserializationMethod, serialized_key_or_id_string )\n # if not we just have an ID string\n else\n unserialized_key = serialized_key_or_id_string.to_i\n end\n \n end\n \n # return ID\n return unserialized_key\n \n end",
"def primary\n self['primary']\n end",
"def n_ref(ref)\n `#{@native}.refs[#{ref}]`\n end",
"def reference\n @refs ||= strip(:reference)\n end",
"def idref\n \"c#{rank}\"\n end",
"def document_version_ref_id\n response = VBMSService.fetch_document_series_for(self)\n series = response.select { |obj| obj.series_id == document_series_ref_id }\n series&.first&.document_id\n end",
"def ref_key(hash)\n\t\t\t(REF_PROPERTIES.collect { |k| hash[k] } ).to_json\n\t\tend",
"def primary_key_value\n send(self.class.primary_key)\n end",
"def references_provider\n attributes.fetch(:referencesProvider)\n end",
"def inspect\n return sprintf(\n \"#<%s:%#0x REF:%s>\",\n self.class.to_s, self.object_id, self.ref\n )\n end",
"def get(ref)\n @map[ref]\n end",
"def reference_credit_note\n object.credit_note_ref.to_s\n end",
"def ref\n # memoizing this is worthwhile ~ 3 percent of calls are the \"first time\n # around\" in an average run of Puppet. --daniel 2012-07-17\n @ref ||= \"#{self.class.name.to_s.capitalize}[#{self.title}]\"\n end",
"def [](key)\n @lock.synchronize do\n ref = @references[key]\n value = ref.object if ref\n value\n end\n end",
"def store_reference\n 5.times do\n self[:reference] = generate_reference\n return reference unless self.class.where(:reference => reference).first\n end\n\n raise \"Could not generate unique reference for order\"\n end",
"def ref; end",
"def primary_key_value(obj)\n obj.pk\n end",
"def prim_val\n self[self.class.primary_key]\n end",
"def global_id_by_reference(ref)\n ref = ref.to_s\n return parent && parent.global_id if ref == \"parent\"\n substr = ref.sub(/^parent__/, \"\")\n if substr == ref # there's no \"parent__\" in the beginning\n return global_id + \"__\" + ref\n else\n return parent.global_id_by_reference(substr)\n end\n end",
"def global_id_by_reference(ref)\n ref = ref.to_s\n return parent && parent.global_id if ref == \"parent\"\n substr = ref.sub(/^parent__/, \"\")\n if substr == ref # there's no \"parent__\" in the beginning\n return global_id + \"__\" + ref\n else\n return parent.global_id_by_reference(substr)\n end\n end",
"def get_by_ref(ref)\n res = orchio_get_by_ref ref\n (res.success?) ? res.result.update_rails(self) : false\n end",
"def updateReference\n return @references\n end",
"def full_ref # rubocop:disable Metrics/AbcSize\n @full_ref ||= begin\n ref = \"#{refparts[:perfix]}#{refparts[:series]} #{refparts[:code]}\"\n ref += \"pt#{refparts[:prt]}\" if refparts[:prt] # long_to_short(refparts, \"prt\").to_s\n ref += \"ver#{refparts[:ver]}\" if refparts[:ver] # long_to_short(refparts, \"vol\").to_s\n ref += \"v#{refparts[:vol]}\" if refparts[:vol]\n ref\n end\n end",
"def resource_reference\n return @resource_reference\n end",
"def identifier\n @identifier ||= self.revlist.last\n end",
"def []( ref )\n query.query_values[ ref.to_s ]\n end",
"def first_reference_id\n nil\n end",
"def current\n if global_id = @cursor_instance.get_value\n global_id = global_id.to_i\n end\n # return ID\n return global_id\n end",
"def ref?\n schema[\"$ref\"]\n end",
"def ref\n UV.ref(@pointer)\n\n self\n end",
"def ref\n UV.ref(@pointer)\n\n self\n end",
"def global_id_by_reference(ref)\n ref = ref.to_s\n return parent && parent.global_id if ref == \"parent\"\n substr = ref.sub(/^parent__/, \"\")\n if substr == ref # there's no \"parent__\" in the beginning\n return global_id + \"__\" + ref\n else\n return parent.global_id_by_reference(substr)\n end\n end",
"def ref\n UV.ref(@handle)\n end",
"def reference_custom_fields\n reference_custom_field_ids.collect{|cf_id| CustomFields::Reference.find(cf_id) }\n end",
"def primary\n @data['primary']\n end",
"def reference_attribute\n\t\tcontent = self.send(self.class.reference_attribute)\n\t\tif extra = self.class.get_belongs_to_extra_info\n\t\t\tcontent = \"#{content} #{extra.call(self)}\"\n\t\tend\n\t\tcontent\n\tend",
"def ref_node(this_db = self.started_db)\n return Thread.current[:local_ref_node] if Thread.current[:local_ref_node]\n default_ref_node(this_db)\n end",
"def ref\n @bin\n end",
"def ems_ref_string\n object_send(:ems_ref)\n end",
"def refname\n\t\treturn self.class.refname\n\tend",
"def qualified_primary_key\n cached_fetch(:qualified_primary_key){qualify_cur(primary_key)}\n end",
"def orchio_get_by_ref(ref)\n response = client.send_request :get, inst_args(ref: ref)\n Result.new(\n status: orchio_status(response, 200),\n response: response,\n results: [ Document.new(\n response.body.to_hash,\n Metadata.new(\n :collection => ocollection,\n :key => @id,\n :ref => response.header.etag\n ))]\n )\n end",
"def ref_for uid, force=true\n uid = (uid or @current_user)\n ref = \n if uid.nil? # No user => no ref\n force && Rcpref.new(comment: \"\") \n elsif @current_ref && @current_ref.user_id && (@current_ref.user_id == uid) # Consult the cache\n @current_ref\n else\n if !users.exists?(uid) && force\n # Create a new rcpref between the user and the recipe\n users << User.find(uid)\n end\n self.rcprefs.where(\"user_id = ?\", uid)[0]\n end\n @current_ref = ref if uid == @current_user\n ref\n end",
"def item_id\r\n params['Ref'] \r\n end",
"def resolved_ref\n \"resolved-#{ref}\"\n end",
"def primary_key\n self[:primary_key]\n end",
"def ref_id\n URI.parse(self.archival_series_uri).path.split(\"/\").last unless self.archival_series_uri.nil?\n end",
"def get_value(env, ref)\n unless ref.package_id\n raise ArgumentError.new(\"package id is invalid: %s\" % ref.inspect)\n end\n\n # when it is known reference\n if expr = @table[ref.package_id][ref.name]\n return expr\n end\n\n if bound?(ref.package_id, ref.name)\n # get value from parent table\n return @parent.get_value(env, ref) if @parent\n else\n # otherwise, find by parent package id\n env.find_ancestor_ids(ref.package_id).each do |ancestor_id|\n if val = get_value(env, ref.set(package_id: ancestor_id))\n return val\n end\n end\n end\n\n return nil\n end",
"def xref_name\n self['fileRef'].xref_name\n end",
"def reference(klass)\n Reference.store klass\n end",
"def reference(klass)\n Reference.store klass\n end",
"def value\n Reac.value(self)\n end",
"def ref_node_for_class\n Neo4j.ref_node\n end",
"def default_ref_node(this_db = self.started_db)\n this_db.graph.reference_node\n end",
"def cfn_ref(s)\n\t\t\treturn cfn_raw({ \"Ref\" => s })\n\t\tend",
"def odata_table_reference\n @odata_table_reference\n end",
"def get(ref)\r\n @enclosing_pool[ref].to_s\r\n end",
"def references\n @references ||= ApiFactory.new 'GitData::References'\n end",
"def fundref_id(item:)\n return '' unless item.present? && item['external_ids'].present?\n return '' unless item['external_ids'].fetch('FundRef', {}).any?\n\n # If a preferred Id was specified then use it\n ret = item['external_ids'].fetch('FundRef', {}).fetch('preferred', '')\n return ret if ret.present?\n\n # Otherwise take the first one listed\n item['external_ids'].fetch('FundRef', {}).fetch('all', []).first\n end",
"def get_id_from_ref(def_header, ref_key)\n @sheet_results.each do |sh, res|\n ref_ids = res[:_ref_ids]\n next if ref_ids.nil? # this shouldn't really happen\n hdr_ids = ref_ids[def_header]\n next if hdr_ids.nil?\n id = hdr_ids[ref_key]\n return id unless id.nil?\n end\n return nil\n end",
"def xref_name\n self['remoteInfo']\n end",
"def primary\n @primary ||= @lmdb.transaction do\n if ret = @dbs[:control]['primary']\n ret.strip.to_sym\n end\n end\n end",
"def record_by_ref(ref)\n get('VM', :record, ref)\n end",
"def get_key record\n record\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def key\n self.id\n end",
"def key\n self.id\n end"
] |
[
"0.69407225",
"0.6844483",
"0.6630032",
"0.66170686",
"0.6571058",
"0.6551984",
"0.6502058",
"0.6470157",
"0.6365831",
"0.62379277",
"0.62237215",
"0.61483204",
"0.61453617",
"0.6140024",
"0.60695076",
"0.6066563",
"0.60533196",
"0.60533196",
"0.60437137",
"0.60432917",
"0.6016933",
"0.59633887",
"0.59057254",
"0.59056437",
"0.58961856",
"0.5883755",
"0.5834969",
"0.58294064",
"0.5818008",
"0.5808048",
"0.57914937",
"0.57889175",
"0.5772898",
"0.575778",
"0.5738494",
"0.5734215",
"0.57101554",
"0.57017046",
"0.56850106",
"0.5672197",
"0.5671902",
"0.5670972",
"0.5645059",
"0.5622079",
"0.55967045",
"0.55820537",
"0.5581229",
"0.5573697",
"0.55111885",
"0.55111885",
"0.5497682",
"0.54807687",
"0.5461019",
"0.54486644",
"0.54462606",
"0.54428345",
"0.54349244",
"0.54294366",
"0.54248476",
"0.54244965",
"0.54244965",
"0.5418718",
"0.54121566",
"0.54104155",
"0.54087806",
"0.540779",
"0.54029614",
"0.5394606",
"0.53888273",
"0.53731513",
"0.53713894",
"0.5366086",
"0.53632116",
"0.5357377",
"0.53461033",
"0.5345934",
"0.5333294",
"0.5330074",
"0.5326444",
"0.53261065",
"0.53261065",
"0.5312644",
"0.5309114",
"0.5302736",
"0.529696",
"0.5291047",
"0.5285772",
"0.52842736",
"0.52810216",
"0.52759194",
"0.52669984",
"0.52379084",
"0.52369684",
"0.5235809",
"0.52177346",
"0.52177346",
"0.52177346",
"0.5209182",
"0.5209182"
] |
0.73137236
|
1
|
Returns the primary_key for the current instance.
|
def orchestrate_primary_key
id
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def primary_key\n @primary_key ||= @klass.primary_key.to_s\n end",
"def primary_key\n self.class.primary_key\n end",
"def primary_key\n self.class.primary_key\n end",
"def primary_key\n self.class.primary_key\n end",
"def primary_key\n self[:primary_key]\n end",
"def primary_key\n @primary_key\n end",
"def primary_key\n @attributes[self.primary_key_attribute]\n end",
"def primary_key\n send( self.class.primary_key )\n end",
"def primary_key\n @primary_key ||= :id\n end",
"def primary_key\n self.class.primary_key == :id ? id : @saved_attributes[self.class.primary_key]\n end",
"def primary_key\n primary_key = attributes.find { |a| a.primary_key? }\n error(\"Unable to locate primary key for #{self.name}, attributes => #{attributes.collect { |a| a.name }}\") unless primary_key\n primary_key\n end",
"def primary_key\n @primary_key || 'id'\n end",
"def primary_key\n cached_fetch(:primary_key){associated_class.primary_key || raise(Error, \"no primary key specified for #{associated_class.inspect}\")}\n end",
"def primary_key\n \"#{quoted_table_name}.#{model_class.send :primary_key}\"\n end",
"def primary_key\n \"#{quoted_table_name}.#{model_class.send :primary_key}\"\n end",
"def primary_key_value\n send(self.class.primary_key)\n end",
"def association_primary_key(klass = nil)\n active_record.primary_key\n end",
"def pkey\n table = self.class.table_name\n key = get_primary_key_values.first\n return key\n end",
"def primary_key\n @resource_options.fetch :primary_key, :\"#{singular_resource_name}_id\"\n end",
"def primary_key\n '_id'\n end",
"def primary_key_value(obj)\n obj.pk\n end",
"def primary_key\n case primary_key_prefix_type\n when :table_name\n Inflector.foreign_key(class_name_of_active_record_descendant(self), false)\n when :table_name_with_underscore\n Inflector.foreign_key(class_name_of_active_record_descendant(self))\n else\n \"id\"\n end\n end",
"def primary_key\n return @primary_key if @primary_key\n @primary_key = dimension_table.to_s.camelize.constantize.primary_key.to_sym\n rescue NameError => e\n ETL::Engine.logger.debug \"couldn't get primary_key from dimension model class, using default :id\"\n @primary_key = :id\n end",
"def key\n get_primary_key_value_map[self.class.table_name]\n end",
"def primary_key_name\n @primary_key_name ||= @connection.schema[@table_name.to_s][:primary_key]\n end",
"def primary_key\n self[:primary_key] ||= self[:model].primary_key\n end",
"def to_param\n self.primary_key\n end",
"def autoincrementing_primary_key\n primary_key\n end",
"def autoincrementing_primary_key\n primary_key\n end",
"def primary_key(table)\n pk_and_sequence = pk_and_sequence_for(table)\n pk_and_sequence && pk_and_sequence.first\n end",
"def primary_key(value=nil)\n self.primary_key = value unless value.nil?\n \n @primary_key ||= :id\n end",
"def primary_key\n 'id'\n end",
"def key\n stores_foreign_key? ? foreign_key : primary_key\n end",
"def primary_key\n self[:primary_key] ||= associated_class.primary_key\n end",
"def association_primary_key(klass = nil)\n options[:primary_key] || primary_key(klass || self.klass)\n end",
"def primary_key table\n return nil unless table\n table = self[table]\n pk = table.column_names.find{ |c| table[c].primary_key? }\n end",
"def primary_key\n select(&:primary_key?)\n end",
"def primary_key_attribute\n :id\n end",
"def primary_key(table_name)\n 'id' # table.primary_key || 'id'\n end",
"def primary_key(table_name)\n pk_and_sequence_for(table_name)[0]\n rescue\n nil\n end",
"def primary_key(table_name)\n pk_and_sequence = pk_and_sequence_for(table_name)\n pk_and_sequence && pk_and_sequence.first\n end",
"def id\n attributes[self.class.primary_key]\n end",
"def primary_key(table_name)\n pk = super\n\n if pk == CockroachDBAdapter::DEFAULT_PRIMARY_KEY\n nil\n else\n pk\n end\n end",
"def default_primary_key\n model_name.foreign_key.to_s\n end",
"def id\n read_attribute(self.class.primary_key)\n end",
"def id\n read_attribute(self.class.primary_key)\n end",
"def full_primary_key(klass)\n \"#{klass.quoted_table_name}.#{klass.quoted_primary_key}\"\n end",
"def associated_primary_key\n self[:associated_primary_key] ||= associated_class.primary_key\n end",
"def primary_key\n fields.select { |f| f.key }.map(&:name)\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def key_id\n return @key_id\n end",
"def primary_key=(key)\n @primary_key = key\n end",
"def self_key # :nodoc:\n klass = self.class\n if klass.superclass != ActiveRecord::Base\n if klass.superclass.eav_class == klass.eav_class\n klass = klass.superclass\n end\n end\n\n \"#{klass.name.underscore}_id\".to_sym\n end",
"def pk_hash\n model.primary_key_hash(pk)\n end",
"def qualified_primary_key\n cached_fetch(:qualified_primary_key){qualify_cur(primary_key)}\n end",
"def relation_primary_key(relation)\n relation_reflect(relation).association_primary_key\n end",
"def primary_key\n return @primary_key if @primary_key\n return 'id' if @id\n \n candidates = @columns.find_all { |col| col.unique }.map { |col| col.name }\n return 'id' if candidates.include? 'id'\n candidates.find { |c| c =~ eval(\"/^#{@name}.*id$/i\") } ||\n candidates.find { |c| c =~ eval(\"/^#{singularize}.*id$/i\") } ||\n candidates.find { |c| c =~ eval(\"/^#{pluralize}.*id$/i\") } ||\n candidates.first\n end",
"def generate_primary_key\n self[self.class.primary_key] ||= self.class.new_primary_key(10_000)\n end",
"def right_primary_key\n cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, \"no primary key specified for #{associated_class.inspect}\")}\n end",
"def pk\n raise(Error, \"No primary key is associated with this model\") unless key = primary_key\n case key\n when Array\n key.collect{|k| @values[k]}\n else\n @values[key]\n end\n end",
"def primary_key_for_sphinx\n @primary_key_for_sphinx ||= read_attribute(self.class.primary_key_for_sphinx)\n end",
"def primary_key_method\n cached_fetch(:primary_key_method){primary_key}\n end",
"def config_primary_key_for(name)\n Redcrumbs.send(\"#{name}_primary_key\")\n rescue NoMethodError\n nil\n end",
"def primary\n self['primary']\n end",
"def get_primary_keys \r\n return {\"KtoNr\" => self.KtoNr}\r\n end",
"def primary_key(table_name)\n # TODO: Change this to be a pure mongo lookup by digging into document definitions\n # TODO: Manage _id and id\n id_definition = Mongo::DocumentDefinition.fields_for(table_name).find { |_, field_definition| field_definition['primary_key'] }\n Array(id_definition).first # && id_definition.first || '_id'\n end",
"def primary_key\n @json['profile']['primaryKey'] rescue nil\n end",
"def primary_key(table, opts=OPTS)\n quoted_table = quote_schema_table(table)\n Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}\n value = _select_pk_ds.where_single_value(Sequel[:pg_class][:oid] => regclass_oid(table, opts))\n Sequel.synchronize{@primary_keys[quoted_table] = value}\n end",
"def primary_key=(value)\n @primary_key = value && value.to_s\n @quoted_primary_key = nil\n end",
"def to_key\n new_record? ? nil : [ self.send(self.class.primary_key) ]\n end",
"def primary_key?\n self.primary_key\n end",
"def primary_key!\n @primary_keys << @name\n end",
"def primary_key(table)\n t = dataset.send(:input_identifier, table)\n @primary_keys.fetch(t) do\n pk = fetch(\"SELECT RDB$FIELD_NAME FROM RDB$INDEX_SEGMENTS NATURAL JOIN RDB$RELATION_CONSTRAINTS WHERE RDB$CONSTRAINT_TYPE = 'PRIMARY KEY' AND RDB$RELATION_NAME = ?\", t).single_value\n @primary_keys[t] = dataset.send(:output_identifier, pk.rstrip) if pk\n end\n end",
"def qualified_primary_key\n cached_fetch(:qualified_primary_key){self[:qualify] == false ? primary_key : qualify_assoc(primary_key)}\n end",
"def primary_key(name, type = :primary_key, options = {})\n return super\n end",
"def to_key\n respond_to?(:main_instance) && main_instance && main_instance.to_key\n end",
"def id_for_update\n { self.class.primary_key.to_s => __id }\n end",
"def current_key\n\n unserialized_key = nil\n\n if serialized_key_or_id_string = @cursor_instance.get_key\n\n # if we have an index we have serialized key\n if @parent_index\n unserialized_key = @parent_bucket.parent_adapter.class::SerializationClass.__send__( @parent_bucket.parent_adapter.class::UnserializationMethod, serialized_key_or_id_string )\n # if not we just have an ID string\n else\n unserialized_key = serialized_key_or_id_string.to_i\n end\n \n end\n \n # return ID\n return unserialized_key\n \n end",
"def primary\n @primary ||= @lmdb.transaction do\n if ret = @dbs[:control]['primary']\n ret.strip.to_sym\n end\n end\n end",
"def first_record_key\n @first_record_key ||= first_record.key\n end",
"def primary_key(name, type = :primary_key, **options)\n column(name, type, **options.merge(primary_key: true))\n end",
"def right_primary_key\n self[:right_primary_key] ||= associated_class.primary_key\n end",
"def id\n @properties[self.class.primary_key].to_i unless new_record?\n end",
"def primary_key(*attributes)\n if attributes.size == 1 and String===attributes[0]\n @relvar.set_primary_key(@relvar.candidate_key(attributes[0], true))\n else\n name = String===attributes[0] ? attributes.shift : \"pk_#{@relvar.name}\"\n attributes.unshift(name)\n @relvar.set_primary_key(candidate_key(*attributes))\n end\n end",
"def get_key record\n record\n end",
"def scaffold_primary_key\n get_key_array_safe(key).name\n end",
"def db_key\n\t\t\tself.class.db_key\n end",
"def original_primary_key\n if sourceRD.naturalKey == \"id\"\n \"original_id\"\n else\n sourceRD.naturalKey\n end\n end",
"def pk_field(klass)\n pk = klass.primary_key\n return klass.ann(pk, :field) || pk\n end",
"def key\n raise MissingID if not defined?(@id)\n model.key[id]\n end",
"def key\n self.id\n end",
"def key\n self.id\n end",
"def key\n self.id\n end",
"def id\n if primary_key.is_a?(Array)\n id = Array.new\n primary_key.each do |key|\n sub_id = self.send(key)\n return nil if (id == \"\")\n id << sub_id\n end\n else\n id = self.send(self.class.primary_key)\n return nil if (id == \"\")\n end\n return id\n end",
"def primary_key\n fail NotImplementedError\n end",
"def association_key_name\n reflection.join_primary_key(klass)\n end",
"def association_key_name\n reflection.join_primary_key(klass)\n end",
"def primary_key(table_name)\n table_name = table_name.to_s\n\n @primary_keys ||= {}\n @primary_keys[table_name] ||= if @registration[:primary_key].present?\n @registration[:primary_key].call(@connection, table_name)\n else\n @connection.primary_key(table_name)\n end\n end",
"def key\n self.class._key\n end"
] |
[
"0.8849925",
"0.8763709",
"0.8763709",
"0.8763709",
"0.8683593",
"0.8665001",
"0.86636704",
"0.8647868",
"0.84087783",
"0.8392324",
"0.8299841",
"0.827642",
"0.8207471",
"0.819137",
"0.819137",
"0.8162177",
"0.8132812",
"0.81269324",
"0.80376863",
"0.79836744",
"0.7947221",
"0.7915828",
"0.78637624",
"0.78355545",
"0.7823477",
"0.7818879",
"0.7796554",
"0.77296734",
"0.77296734",
"0.77142406",
"0.77088666",
"0.77063066",
"0.7659216",
"0.7654247",
"0.7648442",
"0.7642397",
"0.75972134",
"0.7583961",
"0.75258964",
"0.75062555",
"0.75023687",
"0.7494232",
"0.7450765",
"0.74496955",
"0.74480546",
"0.74480546",
"0.73925877",
"0.7329001",
"0.73121464",
"0.73112345",
"0.73112345",
"0.73112345",
"0.73037994",
"0.7245954",
"0.7243369",
"0.7243111",
"0.72072953",
"0.7177349",
"0.7174943",
"0.7154304",
"0.7115775",
"0.7107845",
"0.71072763",
"0.71048415",
"0.7097182",
"0.70489335",
"0.70419943",
"0.7032024",
"0.7015281",
"0.7014624",
"0.6996839",
"0.699509",
"0.69830346",
"0.697715",
"0.69681245",
"0.69477934",
"0.6933045",
"0.6931354",
"0.69210714",
"0.6909477",
"0.6898365",
"0.68854815",
"0.6881963",
"0.6872931",
"0.68589723",
"0.68406373",
"0.68393576",
"0.6837644",
"0.68353605",
"0.6827128",
"0.68212885",
"0.68182385",
"0.68182385",
"0.68182385",
"0.6815675",
"0.6788342",
"0.67864174",
"0.6780091",
"0.6762421",
"0.67602956"
] |
0.7858645
|
23
|
Returns the client handle.
|
def orchestrate_client
client
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def client\n @client || Client.connection\n end",
"def client\n @client ||= self.class.client\n end",
"def client\n Thread.current[:client]\n end",
"def client\n @client ||= Client.current\n end",
"def client\n set_connection unless @client\n @client\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def client\n @client ||= Client.new\n end",
"def client\n\t\treturn @client\n\tend",
"def get_client\n @client\n end",
"def client\n @@client\n end",
"def client\n self.class.client\n end",
"def client\n self.class.client\n end",
"def getclient\n return @client\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def client\n shell.client\n end",
"def client\n @client = Gluby::Client.instance unless @client\n @client\n end",
"def client\n @client ||= Client.new(configuration)\n end",
"def get_client\n config.client.new(self)\n end",
"def client\n self.class.client\n end",
"def get_current_client\n get_current_hub&.current_client\n end",
"def client\n return @fetcher.client\n end",
"def client\n user_thread.client\n end",
"def client\n @client ||= (begin\n if @uri.scheme\n client_class = Retrieve::Client.for(@uri.scheme)\n if client_class\n client_class.new(self)\n else\n nil\n end\n else\n nil\n end\n end)\n end",
"def client\n @client ||= client_for_host(brine_root_url || 'http://localhost:8080',\n logging: ENV['BRINE_LOG_HTTP'])\n end",
"def client\n @client ||= platform_klass::Client.new(@options)\n end",
"def client\n @client ||= Client.new(config[:credentials], config[:end_point])\n end",
"def client\n if !@client || @client.hash != options.hash\n @client = Croudia::Client.new\n end\n @client\n end",
"def client\n @parent.instance_variable_get(:@client)\n end",
"def client\n @client ||= es_node.client(true).data(false).node.client\n end",
"def connection\n client.connection\n end",
"def client(name)\n Thread.current['clients_manager'].client(name)\n end",
"def client_id\n connection.id\n end",
"def client\n @client ||= begin\n Metaforce.configure do |configuration|\n configuration.host = @config[\"client\"][\"host\"]\n configuration.log = false\n end\n\n options = {\n username: @config[\"client\"][\"username\"],\n password: @config[\"client\"][\"password\"],\n security_token: @config[\"client\"][\"security_token\"],\n }\n\n # Verify the login credentials\n Metaforce.login(options)\n Metaforce.new(options)\n end\n end",
"def connection\n client.send(:connection)\n end",
"def client\n @client ||= Curl::Easy.new\n end",
"def client\n @@client ||= Orchestrate::Application::Connect.client\n end",
"def client_context\n return @client_context\n end",
"def client_context\n return @client_context\n end",
"def client\n @client ||= VAHealthcareMessaging::Client.new(config: MHV_CONFIG, session: { user_id: correlation_id })\n end",
"def client\n @config.send(\"#{config_prefix}_client\")\n end",
"def get_client(client_class = ::Elarian::BaseClient)\n @default_client ||= client_class.new(connection_credentials)\n on_error = lambda do |error|\n puts \"Error occurred #{error}\"\n disconnect_and_stop_loop\n end\n @default_client.on(:error, on_error)\n connect(@default_client)\n @default_client\n end",
"def client(client = nil, options = nil)\n if client.nil?\n @client\n else\n @client = self.class.send(:get_client, client, options)\n end\n end",
"def get_client_id\n @client_id\n end",
"def client_id\n return @client_id\n end",
"def client\n query[\"client_id\"]\n end",
"def client_connection\n if respond_to?(:valid_raw_connection)\n valid_raw_connection\n elsif instance_variable_defined?(:@raw_connection)\n @raw_connection\n else\n @connection\n end\n end",
"def client(client, options = {})\n get(\"clients/#{client}\", options).pop\n end",
"def get_client(uri, http_type, method)\n return @client\n end",
"def client\n Hsquare.application(@application).admin_client\n end",
"def doorkeeper_client\n doorkeeper_token.resource_owner_id ? Client.find(doorkeeper_token.resource_owner_id) : Client.new\n end",
"def client\n @client ||= NPS::Client.new\n end",
"def client\n @client ||= Utils::Box::Client.new\n end",
"def client(client)\n command 'CLIENT', client.to_str.inspect do\n response 250\n end\n end",
"def client_id\n @client_id\n end",
"def client_id\n @client_id\n end",
"def client\n @client ||= Curl::Easy.new\n end",
"def current_client\n @current_client ||= @finder.call\n end",
"def public_client\n return @public_client\n end",
"def gateway_client\n @gateway_client ||= get_gateway_client({client_id: @client_id, gateway_type: gateway_type})\n end",
"def current_remote_client\n return nil unless session[:client_id]\n @remote_client ||= RemoteClient.find_by_client_id(session[:client_id])\n @remote_client\n end",
"def client\n end",
"def client\n Contentful::Management::Client.shared_instance\n end",
"def client\n @client ||= CFoundry::Client.new(@target.to_s).tap do |c|\n c.login(@username, @password)\n end\n end",
"def engine_client\n if current_user\n identity_session.access_token.http_client\n else\n Identity.http_client\n end\n end",
"def get_client_by_id client_id\n @clients[client_id]\n end",
"def _client\n @client ||= XMLRPC::Client.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.port == 443, @timeout)\n end",
"def get_client(id)\n conn = @client.get do |req|\n req.url \"/api/v2/client/#{id}\"\n req.headers[\"Authorization\"] = @token\n end\n conn.body\n end",
"def client\n @redis\n end",
"def client\n Exchange::GemLoader.new('redis').try_load unless defined?(::Redis)\n @client ||= ::Redis.new(:host => config.host, :port => config.port)\n end",
"def client\n @client ||= MemCache.new(address)\n end",
"def get_client\n @client = Ethereum::Client.create(@url) if @client.nil?\n @client\n end",
"def current_client\n @current_client ||= Replica.user_model.find(session[:user])\n @current_client\n end",
"def client\n client_object_exists = (defined?(@client) != nil)\n if client_object_exists\n return @client\n else\n # When coming through a commit hook endpoint, the github_id won't be saved\n # in the session, so we need to be able to grab it from a class instance variable.\n # @todo: actually there's a better way to do this. See it mentioned in my\n # other @todo in this file.\n if session[:github_id] != nil\n github_id = session[:github_id]\n elsif @github_id != nil\n github_id = @github_id\n else\n authenticate!\n end\n\n user = User.find_by(github_id: github_id)\n if Octokit.validate_credentials({ :access_token => user.token })\n # Auto paginate to prevent repo-list truncation on the books/new page. This may\n # hurt performance, so keep an eye on it.\n @client = Octokit::Client.new :access_token => user.token, :auto_paginate => true\n else\n authenticate!\n end\n end\nend",
"def client\n @client ||= DropboxClient.new(@bridge)\n end",
"def client\n @client = Faceberry::Client.new(options) unless defined?(@client) && @client.cache_key == options.hash\n @client\n end",
"def _client\n @client ||= XMLRPCClient.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.scheme == 'https' ? @ssl_verify : false, @timeout)\n end",
"def connection\n CryptKeeper::Connection.http_instance\n end",
"def client\n @client = Wayback::Client.new(options) unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def client_guid\n client_id\n end",
"def client; end",
"def client; end",
"def client\n @client.push()\n end",
"def client_id\n me.client.id\n end",
"def client_id\n me.client.id\n end",
"def client\n key, secret = credentials\n @client ||= Cloudkick::Base.new(key, secret)\n end",
"def client\n @client ||= Savon.client(client_options)\n return @client unless block_given?\n yield @client\n end",
"def client\n @client ||= ::Twilio::REST::Client.new(@account_sid, @auth_token)\n end",
"def connection\n retrieve_connection\n end",
"def client(name)\n @clients[name]\n end",
"def client_name\n return @hostname if defined? @hostname\n\n sockaddr = @socket.getsockname\n begin\n @hostname =\n Socket.getnameinfo( sockaddr, Socket::NI_NAMEREQD ).first\n rescue\n begin\n @hostname = Socket.getnameinfo( sockaddr ).first\n rescue\n begin\n @hostname = Socket.gethostbyname( Socket.gethostname ).first\n rescue\n @logger.error \"the client ipaddr/name could not be determined\"\n end\n end\n end\n\n return @hostname\n end",
"def client\n @client = Recereco::Client.new(options) unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def http_client\n @http_client ||= @http_adapter.new(@site_url, @connection_options)\n end",
"def client_info\n self.class.client_info\n end",
"def client\r\n @client ||= APIController.new config\r\n end",
"def client_id\n @client_id ||= Staccato.build_client_id\n end",
"def with_client\n begin\n @client = client_class.new\n rescue SystemExit,NoMemoryError\n raise\n rescue Exception => detail\n puts detail.backtrace if Puppet[:trace]\n Puppet.err \"Could not create instance of #{client_class}: #{detail}\"\n return\n end\n yield @client\n ensure\n @client = nil\n end",
"def client\n puts \"creating client\"\n @client ||= Vineyard::Client.new(options) #unless defined?(@client) && @client.hash == options.hash\n @client\n end"
] |
[
"0.75452",
"0.73574746",
"0.73489094",
"0.7344137",
"0.7295097",
"0.72854346",
"0.72854346",
"0.72854346",
"0.723161",
"0.72150177",
"0.72028685",
"0.7184067",
"0.7097447",
"0.7097447",
"0.70913494",
"0.7085543",
"0.7085543",
"0.68839234",
"0.684399",
"0.6831283",
"0.67919487",
"0.6760277",
"0.6748994",
"0.66848874",
"0.663295",
"0.6592698",
"0.65830123",
"0.6568067",
"0.6549737",
"0.6547263",
"0.6526049",
"0.64803046",
"0.6445852",
"0.6431556",
"0.64278483",
"0.6404556",
"0.6391048",
"0.63734376",
"0.6362874",
"0.6345372",
"0.6336162",
"0.63276607",
"0.6327366",
"0.6323081",
"0.6321774",
"0.63191414",
"0.63006777",
"0.62540424",
"0.62437695",
"0.62416095",
"0.62098145",
"0.62067646",
"0.6192382",
"0.61724335",
"0.6149065",
"0.6140244",
"0.6140138",
"0.6140138",
"0.611637",
"0.61114097",
"0.6105497",
"0.60761064",
"0.606703",
"0.6061148",
"0.6043021",
"0.601897",
"0.59801805",
"0.5954221",
"0.5949987",
"0.59322757",
"0.59277153",
"0.5920705",
"0.59078854",
"0.5907717",
"0.58948565",
"0.58822423",
"0.5869079",
"0.58534133",
"0.58463895",
"0.58424014",
"0.5840303",
"0.58359",
"0.5832882",
"0.5832882",
"0.58288825",
"0.58149105",
"0.58149105",
"0.58069193",
"0.58024937",
"0.57972157",
"0.5794438",
"0.57821167",
"0.5771575",
"0.5769952",
"0.57592916",
"0.57582325",
"0.5751075",
"0.57502013",
"0.5747193",
"0.5745321"
] |
0.59196246
|
72
|
After a successful PUT request, updates the current instance's ref value (also referred to as the etag) and calls orchio_update_ref_table.
|
def set_ref_value(response)
unless response.header.code != 201 || response.header.etag.blank?
@__ref_value__ = response.header.etag
orchio_update_ref_table response.header.timestamp
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def orchio_update_ref_table(timestamp)\n return if ocollection == RefTable.get_collection_name\n\n if RefTable.enabled?\n primary_key = __ref_value__.gsub(/\"/, '')\n doc = {\n xcollection: ocollection,\n xkey: id,\n xref: primary_key,\n timestamp: timestamp\n }.to_json\n RefTable.new(:id => primary_key).orchio_put doc\n end\n end",
"def orchio_put(jdoc)\n response = client.send_request :put, inst_args(json: jdoc)\n if cache.enabled?\n simple_cache.save(\n Document.new(\n response.body.to_hash,\n Metadata.new(\n :collection => ocollection,\n :key => @id,\n :ref => response.header.etag\n )))\n end\n set_ref_value response\n orchio_status response, 201\n end",
"def orchio_put_if_match(document, ref)\n response = client.send_request :put, inst_args(json: document, ref: ref)\n set_ref_value response\n orchio_status response, 201\n end",
"def get_by_ref(ref)\n res = orchio_get_by_ref ref\n (res.success?) ? res.result.update_rails(self) : false\n end",
"def on_put(resource_uri, opts)\n debug \"on_put: #{resource_uri}\"\n resource = update_resource(resource_uri, true, opts)\n show_resource(resource, opts)\n end",
"def put\n conn = @client.authorized_connection(url: @client.object_api_url)\n res = conn.put do |req|\n req.headers['Content-Type'] = \"application/json\"\n req.url resource_uri\n req.body = raw.to_json\n end\n if res.success?\n data = JSON.parse(res.body)\n self.class.new(data, @client)\n else\n nil\n end\n end",
"def put\n if(resource.collection?)\n Forbidden\n elsif(!resource.parent_exists? || !resource.parent_collection?)\n Conflict\n else\n resource.lock_check if resource.supports_locking?\n status = resource.put(request, response)\n response['Location'] = \"#{scheme}://#{host}:#{port}#{url_format(resource)}\" if status == Created\n response.body = response['Location']\n status\n end\n end",
"def update\n requires :identity, :settings_version, :tier\n\n data = service.update_instance(identity, settings_version, tier, settings)\n operation = Fog::Google::SQL::Operations.new(:service => service).get(data.name)\n operation.wait_for { ready? }\n reload\n end",
"def fire_put(url_or_path, entity, options = {}, &block)\n url = absolute_url(url_or_path)\n headers = {:Accept => MEDIA_TYPE_JSON, :'Content-type' => ENCODED_MEDIA_TYPE_JSON}.\n merge(options.fetch(:headers, {}))\n headers = merge_log_weasel_header(headers)\n timeout = options.fetch(:timeout, Ladon.default_request_timeout)\n body = encode_entity(entity)\n response = Typhoeus::Request.put(url, headers: headers, timeout: timeout, body: body)\n handle_response(response, method: :put, url: url, default_data: options[:default_data],\n raise_on_error: options[:raise_on_error], &block)\n end",
"def update\n \n begin\n DetailValue.transaction do\n # Increment the instance version\n increment_instance_version\n @resource = update_value(params[:detail_id], \n params[:id], \n {\n 'lock_version' => params[:value][:lock_version],\n 'value' => params[:value][:value] \n })\n \n end\n render :response => :PUT\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def update!(**args)\n @blob_ref = args[:blob_ref] if args.key?(:blob_ref)\n @blobstore2_info = args[:blobstore2_info] if args.key?(:blobstore2_info)\n @cosmo_binary_reference = args[:cosmo_binary_reference] if args.key?(:cosmo_binary_reference)\n @crc32c_hash = args[:crc32c_hash] if args.key?(:crc32c_hash)\n @inline = args[:inline] if args.key?(:inline)\n @length = args[:length] if args.key?(:length)\n @md5_hash = args[:md5_hash] if args.key?(:md5_hash)\n @object_id_prop = args[:object_id_prop] if args.key?(:object_id_prop)\n @path = args[:path] if args.key?(:path)\n @reference_type = args[:reference_type] if args.key?(:reference_type)\n @sha1_hash = args[:sha1_hash] if args.key?(:sha1_hash)\n end",
"def put\n RestClient.put(url, @body, @header) do |rso, req, res|\n setup(rso, req, res)\n end\n end",
"def do_sync_up(api_client, data)\n if clab_id\n # update the linked clab record\n logger.info \"#{self} updating #{clab_obj}\"\n obj = api_client.public_send('put', clab_id, data)\n else\n # create a new clab record and link it\n logger.info \"#{self} creating new clab object\"\n obj = api_client.public_send('post', data)\n self.clab_id = obj['id']\n logger.info \"#{self} created #{clab_obj}\"\n end\n t = obj['lastUpdated']\n self.clab_last_update = t ? DateTime.iso8601(t).to_time : DUMMY_TIMESTAMP\n sync_success\n true\n rescue RuntimeError => e\n sync_fail e.to_s\n false\n end",
"def perform_put_with_object(path, options, klass)\n perform_request_with_object(:put, path, options, klass)\n end",
"def update!(**args)\n @conflicting_reference_id = args[:conflicting_reference_id] if args.key?(:conflicting_reference_id)\n @expiry_time = args[:expiry_time] if args.key?(:expiry_time)\n @id = args[:id] if args.key?(:id)\n @kind = args[:kind] if args.key?(:kind)\n @matches = args[:matches] if args.key?(:matches)\n @original_reference_id = args[:original_reference_id] if args.key?(:original_reference_id)\n @status = args[:status] if args.key?(:status)\n end",
"def update\n wmi_object.put_\n end",
"def update(params)\n self.class.new reinit_endpoint(params).do_put\n end",
"def update\n\t\treturn 0 if @setup.secure or @setup['no_cache']\n\t\tdb = DispRef2PStore.new( @setup['cache_path'] )\n\t\tr = 0\n\t\tdb.transaction do\n\t\t\tdb[Root_DispRef2URL] = Hash.new unless db[Root_DispRef2URL]\n\t\t\tbegin\n\t\t\t\tdb[Root_DispRef2URL].each_key do |url|\n\t\t\t\t\tref = DispRef2URL::new( url )\n\t\t\t\t\tt = ref.restore( db )\n\t\t\t\t\torig = t ? t.dup : nil\n\t\t\t\t\tnew = ref.parse( @setup )\n\t\t\t\t\tif orig != new then\n\t\t\t\t\t\tr += 1\n\t\t\t\t\t\tref.store( db )\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\trescue PStore::Error\n\t\t\tend\n\t\tend\n\t\tdb = nil\n\t\tr\n\tend",
"def put(header = {})\n url = \"#{ApiClient.config.path}#{self.class.resource_path}\"\n response = ApiClient::Dispatcher.put(url, self.to_hash, header)\n attributes = ApiClient::Parser.response(response, url)\n update_attributes(attributes)\n end",
"def update\n respond_to do |format|\n if @aoo_ref.update(aoo_ref_params)\n format.html { redirect_to @aoo_ref, notice: 'Aoo ref was successfully updated.' }\n format.json { render :show, status: :ok, location: @aoo_ref }\n else\n format.html { render :edit }\n format.json { render json: @aoo_ref.errors, status: :unprocessable_entity }\n end\n end\n end",
"def put(data, options={})\n @hal_client.put(href, data, options).tap do\n reset\n end\n end",
"def update!(**args)\n @bucket_id = args[:bucket_id] if args.key?(:bucket_id)\n @obj_id = args[:obj_id] if args.key?(:obj_id)\n end",
"def update_record(http, ref)\n json = %|{\n \"kind\": \"Article\",\n \"title\": \"Sample\",\n \"text\": \"Updated text.\"\n}|\n resp = http.send_request('POST', \"/v1/Article/#{ref}\", json, { 'Content-Type' => 'application/json' })\n # Response should be an OK with a JSON body.\n assert_equal(Net::HTTPOK, resp.class, 'response not an OK')\n reply = Oj.strict_load(resp.body, symbol_keys: true)\n\n # Make sure the message has the correct fields and values.\n assert_equal(0, reply[:code], 'update reply.code should be 0 meaning no error')\n updated = reply[:updated]\n assert_equal(1, updated.length, 'update reply.updated should contain exactly one member')\n ref = updated[0]\n refute_equal(nil, ref, 'update reply record reference can not be nil')\n refute_equal(0, ref, 'update reply record reference can not be 0')\n ref\n end",
"def perform_update\n @resource = controller.send(model.name)\n resource.tap do\n trigger_event(:save) do\n update_and_save_resource\n end\n end\n end",
"def update\n put :update\n end",
"def update\n @ref = Ref.find(params[:id])\n\n respond_to do |format|\n if @ref.update_attributes(params[:ref])\n format.html { redirect_to(@ref, :notice => 'Ref was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @ref.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n run_callbacks :update do\n method = self.class.method_for(:update)\n path = request_path(:_owner_path => @owner_path)\n self.class.request(to_params.merge(:_method => method, :_path => path)) do |response|\n load_attributes_from_response(response)\n end\n end\n end",
"def update(params = {})\n raise \"Can't update a resource without a REST Client\" unless @client\n yield params if block_given?\n set_up_properties_from(@client.put(@path, params))\n self\n end",
"def after_update(resource)\n add_activity(:update, resource)\n end",
"def update\n handle_orcamento_update\n end",
"def _http_put resource, path\n uri = ::URI.parse(resource.auth_uri)\n path = _path uri, path\n request = Net::HTTP::Put.new(path)\n _build_request resource, request\nend",
"def put(obj)\n end",
"def _http_put resource, path\n uri = ::URI.parse(resource.auth_uri)\n path = _path uri, path\n request = Net::HTTP::Put.new(path)\n _build_request resource, request\nend",
"def update_ref_id(ref_id)\r\n node_set = self.datastreams[\"VRA\"].ng_xml.xpath('/vra:vra/vra:image[@refid]')\r\n node_set[0].set_attribute(\"refid\", ref_id)\r\n self.datastreams[\"VRA\"].content = self.datastreams[\"VRA\"].ng_xml.to_s\r\n end",
"def update(options = {})\n @client.put(self.link(:edit), self.to_json, options)\n end",
"def update options={}\n client.put(\"/#{id}\", options)\n end",
"def put( doc, opts = {} )\n response = http_action :put, doc, opts.merge( :doc => doc )\n doc['_id'], doc['_rev'] = response['id'], response['rev'] if doc.kind_of? Hash\n response\n end",
"def ref=(new_ref)\n @ref = new_ref\n end",
"def update(resource_uri, field, old_value, new_value)\n uri = build_uri_for_resource resource_uri \n log \"update for #{uri}\"\n response = Net::HTTP.start(uri.hostname, uri.port) {|http|\n request = Net::HTTP::Patch.new(uri.path)\n request[\"Content-Type\"] = \"application/sparql-update\"\n request.body = <<-eos \n PREFIX dc: <http://purl.org/dc/elements/1.1/>\n DELETE { <> #{field} #{old_value} . }\n INSERT { <> #{field} #{new_value} . }\n WHERE { }\n eos\n log request.body\n http.request(request)\n } \n doc = FedoraDoc.new(response)\n if doc.status == HTTP_NO_CONTENT\n log \"updated #{resource_uri}\"\n enable_versioning resource_uri\n else\n log(\"update failed: \\r\\n\" + http_response_to_s(response)) if doc.status != HTTP_NO_CONTENT\n end\n doc\n end",
"def base_update(resource, id, options, format = nil, headers = nil)\n headers ||= {}\n headers[:accept] = \"#{format}\" if format\n format ||= @default_format\n headers[:content_type] = \"#{format}\"\n headers[:prefer] = @return_preference if @use_return_preference\n options = {} if options.nil?\n options[:resource] = resource.class\n options[:format] = format\n options[:id] = id\n reply = put resource_url(options), resource, fhir_headers(headers)\n reply.resource = parse_reply(resource.class, format, reply) if reply.body.present?\n reply.resource_class = resource.class\n reply\n end",
"def perform_put_with_objects(path, options, klass)\n perform_request_with_objects(:put, path, options, klass)\n end",
"def update_info_using_crossref\n result=Result.new\n ri_json=CrossrefDoi.reference_integrator_json(self[:doi])\n if ri_json\n fields = [:title, :author, :year, :journal, :volume, :pages, :doi, :journal_abbr, :abstract]\n update_data=fields.inject({}) do |ac,v|\n ac[v]=ri_json.send(v) unless ri_json.send(v).nil?\n ac\n end\n\n self.update(update_data) unless update_data.keys.length==0\n end\n result\n end",
"def commit\n update\n end",
"def put(resource, body = \"\", headers = {})\n prepare_request(:put, resource, body, headers)\n end",
"def on_object_metadata_updated(event)\n return unless resource? event[:object]\n Hyrax.index_adapter.save(resource: event[:object])\n end",
"def update\n respond_to do |format|\n if @ref.update(ref_params)\n format.html { redirect_to @ref, notice: 'Ref was successfully updated.' }\n format.json { render :show, status: :ok, location: @ref }\n else\n format.html { render :edit }\n format.json { render json: @ref.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update obj, &block\n populate(obj, &block).save!\n json obj\n end",
"def update\n respond_to do |format|\n if @source_ref.update(source_ref_params)\n format.html { redirect_to @source_ref, notice: 'Source ref was successfully updated.' }\n format.json { render :show, status: :ok, location: @source_ref }\n else\n format.html { render :edit }\n format.json { render json: @source_ref.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_ref\n @ref = Ref.find(params[:id])\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def update_changed_resource(resource, response)\n resource.last_modified_hash = response.response.hash\n resource.last_updated = Time.now\n resource.body = response.response\n resource.save\n end",
"def next_auto_ref\n count = -1\n User.transaction do\n self.lock!\n count = self.image_ref_count + 1\n # for some reason update_attributes doesn't appear to work here\n self.image_ref_count = count\n self.save!\n end\n count\n end",
"def perform_put(path, options = {})\n perform_request(:put, path, options)\n end",
"def update_doc(doc)\n id = doc[\"_id\"] if doc[\"_id\"]\n\n @conn.query({url_path: \"#{database}/#{id}\", opts: doc, method: :put})\n end",
"def upsert(obj)\n collection, query, model = get_type_info(obj.dup)\n data_hash = model.merge(Wgit::Model.common_update_data)\n result = @client[collection].replace_one(query, data_hash, upsert: true)\n\n result.matched_count.zero?\n ensure\n @last_result = result\n end",
"def update_instance!\n\t\tself.last_attempted = Time.now\n\t\tself.save\n\tend",
"def change_reference(new_reference)\n\n # In datamapper it's not possible to update the key value, so we use adapter\n # https://stackoverflow.com/questions/32302407/updating-a-property-set-as-the-key-in-datamapper\n BookingItem.change_item_reference(new_reference, reference)\n # Update the item references assigned\n BookingDataSystem::BookingLineResource.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n # Update stock locking references\n BookingDataSystem::BookingPrereservationLine.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n\n end",
"def update!(**args)\n @blob_id = args[:blob_id] if args.key?(:blob_id)\n @options = args[:options] if args.key?(:options)\n @ref_id = args[:ref_id] if args.key?(:ref_id)\n @shard_bin = args[:shard_bin] if args.key?(:shard_bin)\n @size = args[:size] if args.key?(:size)\n @source_v2_blob_id = args[:source_v2_blob_id] if args.key?(:source_v2_blob_id)\n @v2_read_blob_token = args[:v2_read_blob_token] if args.key?(:v2_read_blob_token)\n end",
"def update!(**args)\n @bucket = args[:bucket] if args.key?(:bucket)\n @generation_number = args[:generation_number] if args.key?(:generation_number)\n @object = args[:object] if args.key?(:object)\n end",
"def update(ns, ref, hash)\n ref = ref.to_sym\n\n @table[ns][ref] ||= {}\n\n hash.each do |k,v|\n @table[ns][ref][k.to_sym] = v\n end\n\n # callback\n @space.annotation_added(ref, ns) #if method_defined?(:annotation_added)\n end",
"def set_aoo_ref\n @aoo_ref = AooRef.find(params[:id])\n end",
"def update\n run_callbacks :update do\n connection.put(element_path(prefix_options), encode_changes, self.class.headers).tap do |response|\n load_attributes_from_response(response)\n end\n end\n end",
"def index(obj_or_request)\n request = get_request(obj_or_request)\n Connection.new.put request if request.body\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @bindings = args[:bindings] if args.key?(:bindings)\n @etag = args[:etag] if args.key?(:etag)\n @version = args[:version] if args.key?(:version)\n end",
"def update!(**args)\n @force = args[:force] if args.key?(:force)\n @table_uri = args[:table_uri] if args.key?(:table_uri)\n end",
"def put_update\n response = self.class.put(\"/service/#{$service_id}/version/#{$service_version}/logging/sftp/#{$name}\", \n headers: { \"Fastly-Key\" => $key }, \n body: $put_form_data )\n end",
"def update\n save_doc\n end",
"def update!(**args)\n @resource_uri = args[:resource_uri] if args.key?(:resource_uri)\n @target = args[:target] if args.key?(:target)\n end",
"def update!(**args)\n @resource_uri = args[:resource_uri] if args.key?(:resource_uri)\n @target = args[:target] if args.key?(:target)\n end",
"def update\n flash[:notice] = t('scaffold.notice.updated', :item => Refenciacontable.model_name.human) if @refenciacontable.update_attributes(params[:refenciacontable])\n respond_with(@refenciacontable, :location => refenciacontables_path)\n end",
"def update\n begin\n @resource = Entity.find params[:id]\n @resource.update_attributes! params[:entity]\n render :response => :PUT\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def refresh\n raise \"Can't refresh a resource without a REST Client\" unless @client\n @updated = false\n set_up_properties_from(@client.get(@path))\n self\n end",
"def refresh\n raise \"Can't refresh a resource without a REST Client\" unless @client\n @updated = false\n set_up_properties_from(@client.get(@path))\n self\n end",
"def update\n\n @compliance = Compliance.find(params[:id])\n\n # Vendor Session\n if vendor_session?\n if !params[:compliance][:documents_attributes].nil? then\n if @compliance.documents.nil? || @compliance.documents.empty?\n bucket_name = \"Vendors/\" + Vendor.find(session[:id]).code + \"/\" + params[:compliance][:sku] + \"/\" + (Time.now.to_i).to_s\n else\n bucket_name = \"Vendors/\" + Vendor.find(session[:id]).code + \"/\" + params[:compliance][:sku] + \"/\" + @compliance.documents.first.url.rpartition(\"/\")[0].rpartition(\"/\")[2]\n end\n\n params[:compliance][:documents_attributes].each { |key, value|\n if value.has_key?(\"file\") then\n begin\n\n # key, binary_object, bucket_name --> can be replaced by store_object(bucket, key, object)\n aws_connection_instance = AmazonS3Asset.new\n aws_connection_instance.store_object(bucket_name, value[\"file\"].original_filename, value[\"file\"])\n\n value[\"url\"] = \"http://s3.amazonaws.com/\" + bucket_name + \"/\" + value[\"file\"].original_filename\n value.delete(\"file\")\n rescue\n params[:compliance][:documents_attributes] = {} unless params[:compliance][:documents_attributes].nil?\n @compliance = Compliance.find(params[:id])\n flash.now[:alert] = \"An Error occurred during the update of Compliance Set, Please resubmit with lesser upload files.\"\n render \"edit\"\n return\n end\n end\n }\n end\n\n @compliance.last_activity_at = Time.now\n\n respond_to do |format|\n if @compliance.update_attributes(params[:compliance])\n format.html {\n redirect_to vendor_asin_compliance_home_path(:sku => @compliance.sku, :vendor_id => @compliance.vendor_id)\n }\n\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @compliance.errors, :status => :unprocessable_entity }\n end\n end\n else\n # User Session\n\n if !params[:compliance][:comments_internal].nil? and !@compliance.comments_internal.eql?(params[:compliance][:comments_internal]) then\n @compliance.comments_internal = params[:compliance][:comments_internal]\n end\n\n if !params[:compliance][:comments_external].nil? and !@compliance.comments_external.eql?(params[:compliance][:comments_external]) then\n @compliance.comments_external = params[:compliance][:comments_external]\n end\n\n # User approves Compliance Set\n if !params[:compliance][:status].nil? and params[:compliance][:status].eql?(\"approved\") and !\"approved\".eql?(@compliance.status)\n @compliance.status = \"approved\"\n # Approve all Purchase Order Asins associated with the Compliance Set\n Asin.by_compliance(@compliance).each do |asin|\n asin.compliance_approved\n end\n end\n\n # User Rejects Compliance Set\n if !params[:compliance][:status].nil? and params[:compliance][:status].eql?(\"rejected\") and !\"rejected\".eql?(@compliance.status)\n @compliance.status = \"rejected\"\n # Clear any associations that Purchase Order Asins have with this Compliance Set\n Asin.by_compliance(@compliance).each do |asin|\n asin.compliance_rejected\n end\n end\n\n # User Moves Compliance Set back to Vendor\n if !params[:compliance][:status].nil? and params[:compliance][:status].eql?(\"vendor_input\") and !\"vendor_input\".eql?(@compliance.status)\n @compliance.status = \"vendor_input\"\n # Passing the Compliance Set back to the Vendor should not have any impact\n end\n\n @compliance.last_activity_at = Time.now\n\n respond_to do |format|\n if @compliance.save\n format.html {\n redirect_to user_home_path\n }\n format.xml { head :ok }\n else\n # TODO Fix this\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @compliance.errors, :status => :unprocessable_entity }\n end\n end\n\n end\n\n end",
"def update_record(client, ref)\n puts \" --- update record\" if $VERBOSE\n record = {\n kind: 'Article',\n title: 'Sample',\n text: 'Updated text.'\n }\n result = client.update('Article', record, ref)\n # Make sure the message has the correct fields and values.\n check_result_code(result)\n updated = result[:updated]\n assert_equal(1, updated.length, 'update reply.updated should contain exactly one member')\n ref = updated[0]\n refute_equal(nil, ref, 'update reply record reference can not be nil')\n refute_equal(0, ref, 'update reply record reference can not be 0')\n # verify\n result = client.read('Article', ref)\n check_result_code(result)\n results = result[:results]\n assert_equal(1, results.length, 'read after update reply.results should contain exactly one member')\n record = results[0]\n assert_equal(ref, record[:id], 'read after update reply.results[0].id should match the record reference')\n obj = record[:data]\n assert_equal('Updated text.', obj[:text], 'read after update reply obj.text incorrect')\n ref\n end",
"def put(uri, doc = nil, options = {})\n execute(uri, :put, options, doc)\n end",
"def save\n doc = bucket.get_or_new(key)\n doc.data = to_hash\n set_indexes(doc.indexes)\n doc.store\n self\n end",
"def update_with_evernote_data(cloud_resource, caption, description, credit)\n update_attributes!(\n altitude: cloud_resource.attributes.altitude,\n attachment: cloud_resource.attributes.attachment,\n camera_make: cloud_resource.attributes.cameraMake,\n camera_model: cloud_resource.attributes.cameraModel,\n caption: caption,\n credit: credit,\n data_hash: cloud_resource.data.bodyHash,\n description: description,\n dirty: true,\n external_updated_at: cloud_resource.attributes.timestamp ? Time.at(cloud_resource.attributes.timestamp / 1000).to_datetime : nil,\n file_name: cloud_resource.attributes.fileName,\n height: cloud_resource.height,\n latitude: cloud_resource.attributes.latitude,\n local_file_name: cloud_resource.guid,\n longitude: cloud_resource.attributes.longitude,\n mime: cloud_resource.mime,\n source_url: cloud_resource.attributes.sourceURL,\n width: cloud_resource.width\n )\n SyncResourceJob.perform_later(self) if cloud_resource.data.bodyHash != data_hash\n end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def orchestrate_ref_value\n __ref_value__\n end",
"def put(resource_path, body:, headers: {}, prefix: API_PREFIX)\n request(method: :put, resource_path: resource_path, headers: headers, body: body, prefix: prefix)\n end",
"def update_taxt_from_editable editable_taxt\n update_attributes taxt: Taxt.from_editable(editable_taxt)\n rescue Taxt::ReferenceNotFound => e\n errors.add :base, \"The reference '#{e}' could not be found. Was the ID changed?\"\n end",
"def update!(**args)\n @bucket_uri = args[:bucket_uri] if args.key?(:bucket_uri)\n end",
"def update!(**args)\n @bucket_uri = args[:bucket_uri] if args.key?(:bucket_uri)\n end",
"def update!(**args)\n @cause = args[:cause] if args.key?(:cause)\n @resource_uri = args[:resource_uri] if args.key?(:resource_uri)\n end",
"def update; @doc = get(link('self')); nil; end",
"def update; @doc = get(link('self')); nil; end",
"def update!(**args)\n @references = args[:references] if args.key?(:references)\n end",
"def on_put(resource_uri, opts)\n #resource = _get_resource(resource_uri, true, opts)\n \n #puts \"ON_PUT_OPTS: #{opts.inspect}\"\n body, format = parse_body(opts)\n case format\n # when :empty\n # # do nothing\n when :xml\n modifier_el = body.root\n resource = put_resource_xml(modifier_el, resource_uri, opts)\n else\n raise UnsupportedBodyFormatException.new(format)\n end\n show_resource(resource, opts)\n end",
"def update!\n @source.headers.delete(:update)\n set_updated_time(Time.now)\n save\n end"
] |
[
"0.60518837",
"0.5905862",
"0.57425874",
"0.53495914",
"0.5342749",
"0.52888364",
"0.5202367",
"0.5183367",
"0.5146458",
"0.5125581",
"0.50779533",
"0.50746596",
"0.50360227",
"0.5031999",
"0.5016165",
"0.5004753",
"0.49825615",
"0.49766934",
"0.4958231",
"0.49519026",
"0.49510717",
"0.49481964",
"0.4937364",
"0.49271455",
"0.4915409",
"0.4894276",
"0.48849416",
"0.48688042",
"0.4860013",
"0.48599818",
"0.4857646",
"0.4857092",
"0.4856907",
"0.48494825",
"0.48223308",
"0.48116598",
"0.4802888",
"0.47923487",
"0.47899318",
"0.47876585",
"0.47823116",
"0.47706208",
"0.47683197",
"0.47669482",
"0.47629184",
"0.4761281",
"0.47598562",
"0.47437745",
"0.47428635",
"0.4740505",
"0.4740505",
"0.4740505",
"0.47379065",
"0.47326508",
"0.47278786",
"0.47223482",
"0.4718745",
"0.4717485",
"0.47136962",
"0.4709562",
"0.46968615",
"0.4694218",
"0.46854421",
"0.4684589",
"0.46820372",
"0.46731615",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46716836",
"0.46653688",
"0.46637973",
"0.4661148",
"0.46559772",
"0.46559772",
"0.4655342",
"0.46533236",
"0.46497175",
"0.46497175",
"0.46380216",
"0.4629952",
"0.4621824",
"0.4620225",
"0.46175668",
"0.4613868",
"0.4613868",
"0.46103013",
"0.46073553",
"0.46062046",
"0.46062046",
"0.4602672",
"0.46000493",
"0.46000493",
"0.45938182",
"0.4591585",
"0.45858568"
] |
0.62973815
|
0
|
Updates the ref table collection with key/value data consisting of the current instance's collection, key, timestamp and ref values , using the ref value as the primary key. When the ref table feature is enabled, the ref table is updated after each sucessful put_key request.
|
def orchio_update_ref_table(timestamp)
return if ocollection == RefTable.get_collection_name
if RefTable.enabled?
primary_key = __ref_value__.gsub(/"/, '')
doc = {
xcollection: ocollection,
xkey: id,
xref: primary_key,
timestamp: timestamp
}.to_json
RefTable.new(:id => primary_key).orchio_put doc
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def [](ref_id)\n response = @key_value.perform(:get, ref_id)\n Ref.new(@key_value.collection, @key_value.key, response)\n end",
"def []=(key, value)\n ObjectSpace.define_finalizer(value, @reference_cleanup)\n key = key.dup if key.is_a?(String)\n @lock.synchronize do\n @references[key] = self.class.reference_class.new(value)\n keys_for_id = @references_to_keys_map[value.__id__]\n unless keys_for_id\n keys_for_id = []\n @references_to_keys_map[value.__id__] = keys_for_id\n end\n keys_for_id << key\n end\n value\n end",
"def write(key, value)\n @dao.collection.save({ '_id' => key, 'v' => value })\n end",
"def updateKey; @key = getKey; self end",
"def []=(key, value)\n ObjectSpace.define_finalizer(key, @reference_cleanup)\n @lock.synchronize do\n @references_to_keys_map[key.__id__] = self.class.reference_class.new(key)\n @values[key.__id__] = value\n end\n end",
"def update\n\t\treturn 0 if @setup.secure or @setup['no_cache']\n\t\tdb = DispRef2PStore.new( @setup['cache_path'] )\n\t\tr = 0\n\t\tdb.transaction do\n\t\t\tdb[Root_DispRef2URL] = Hash.new unless db[Root_DispRef2URL]\n\t\t\tbegin\n\t\t\t\tdb[Root_DispRef2URL].each_key do |url|\n\t\t\t\t\tref = DispRef2URL::new( url )\n\t\t\t\t\tt = ref.restore( db )\n\t\t\t\t\torig = t ? t.dup : nil\n\t\t\t\t\tnew = ref.parse( @setup )\n\t\t\t\t\tif orig != new then\n\t\t\t\t\t\tr += 1\n\t\t\t\t\t\tref.store( db )\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\trescue PStore::Error\n\t\t\tend\n\t\tend\n\t\tdb = nil\n\t\tr\n\tend",
"def update(ns, ref, hash)\n ref = ref.to_sym\n\n @table[ns][ref] ||= {}\n\n hash.each do |k,v|\n @table[ns][ref][k.to_sym] = v\n end\n\n # callback\n @space.annotation_added(ref, ns) #if method_defined?(:annotation_added)\n end",
"def put(key, value)\n # logger.debug \"put #{key} data\"\n db.put(key, value)\n end",
"def put_collection_key(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}\"\n\tputs do_the_put_call( url: api_url, user: @user, json: args[:json] )\nend",
"def change_reference(new_reference)\n\n # In datamapper it's not possible to update the key value, so we use adapter\n # https://stackoverflow.com/questions/32302407/updating-a-property-set-as-the-key-in-datamapper\n BookingItem.change_item_reference(new_reference, reference)\n # Update the item references assigned\n BookingDataSystem::BookingLineResource.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n # Update stock locking references\n BookingDataSystem::BookingPrereservationLine.all(booking_item_reference: reference).update(booking_item_reference: new_reference)\n\n end",
"def set key, data\n\t\t@data_base[ key ] = data\n\t\tupdate_database\n\tend",
"def collection(new_collection)\n self.collection_key = new_collection\n end",
"def save\n doc = bucket.get_or_new(key)\n doc.data = to_hash\n set_indexes(doc.indexes)\n doc.store\n self\n end",
"def add_reference key, target, opts = {}, &blk\n\t\tadd_reference_set(key,target,opts) if target.is_a? Array\n\t\tadd_to_db(target, nil, :if_in_use => opts[:add_then_reference]) if opts[:add_then_reference]\n\t\tadd_to_db Database::Reference.new(self, target, :proc => blk), key, :if_in_use => opts[:if_in_use]\n\tend",
"def updateReference\n return @references\n end",
"def object_hash_update(object_doc, collection)\n logger.debug \"Updating object document from collection(#{collection}) by uuid(#{object_doc['@uuid']})\"\n @database.object_doc_update(object_doc, collection)\n end",
"def object_hash_update(object_doc, collection)\n logger.debug \"Updating object document from collection(#{collection}) by uuid(#{object_doc['@uuid']})\"\n @database.object_doc_update(object_doc, collection)\n end",
"def put(key,value)\n open\n db[key] = value\n close \n end",
"def set(key, value)\n response = db.put_item(@table_name, {'id' => {'S' => key}, 'value' => {'S' => value}})\n true\n end",
"def on_db_ref(ref)\n\tend",
"def update(updates = {})\n @ref.update(updates)\n end",
"def on_db_ref(context, ref)\n\tend",
"def reference_data\n @reference_data ||= KeyValues.new(@from_profile, @source).format_data\n end",
"def update(value)\n key = self.key\n raise TCKeyNotFound unless self.delete\n @value = value\n put(key,value)\n end",
"def []=(key, item)\n item.set_collection_key(key)\n add(item)\n end",
"def put(key, value)\n \n end",
"def rekey_as_needed; end",
"def update(key, ctx); end",
"def write(key, value, options = {})\n entry = ::Elephas::Entry.ensure(value, key, options)\n entry.refresh\n @data[key] = entry\n entry\n end",
"def upsert key, value\n # Check if there is already an entry for the given key. If there is one, we have to update the value and return.\n if (slot = find_slot(key))\n slot.value = value\n return\n end \n \n #If the entry does not exist, we have to check if there is enough room to add it to the table. \n # If the number of slots is too small, \n # we have to trigger a rebuild operation to ensure that the new entry fits into the internal storage\n rebuild if self.size > (@slots / 2)\n\n # Once we are sure that there is enough space, we have to hash the key and map it to a position into the internal storage. \n # In our case, we do that by double hashing the key’s hash code until we find an empty slot or run out of positions\n 0.upto(@slots - 1) do |i|\n index = double_hash key.hash, i\n slot = @table[index]\n if slot.nil? || slot.vacated \n # Once we successfully mapped a key to a position in the internal array, we increase the table size and return\n @table[index] = Slot.new key, value\n self.size += 1\n return\n end\n end\n raise \"Weak hash function.\"\nend",
"def update(entry_id, field, value)\n collection.update({\n Crocoduck::Store.id_field => entry_id}, \n {'$set' => { field => value}\n }, :safe => true)\n end",
"def update!(**args)\n @references = args[:references] if args.key?(:references)\n end",
"def update_refs\n return true if self.user_id or changes.has_key? :user_id\n fields = self.attributes.select {|k,v| changes.has_key? k}\n self.references.update_all(fields) unless self.user_id\n end",
"def put(key, value); end",
"def migrate(_key, _options); end",
"def flush\n conn.transaction do\n buffer.flatten.each do |row|\n # check to see if this row's compound key constraint already exists\n # note that the compound key constraint may not utilize virtual fields\n next unless row_allowed?(row)\n\n # add any virtual fields\n add_virtuals!(row)\n \n key_names = []\n key_values = []\n @key_columns.each do |name|\n key_names << \"#{name}\"\n key_values << conn.quote(row[name]) # TODO: this is probably not database agnostic\n end\n\n names = []\n values = []\n (order - @key_columns).each do |name|\n names << \"#{name}\"\n values << conn.quote(row[name]) # TODO: this is probably not database agnostic\n end\n\n all_name_values = (key_names+names).zip(key_values+values)\n\n q = <<EOF\nMERGE INTO #{table_name} d \nUSING (SELECT #{all_name_values.collect {|c,v| \"#{v} #{c}\"}.join(',')} FROM DUAL) s\nON (#{map_src_to_dest(key_names,'s','d').join(' AND ')})\nWHEN MATCHED THEN \nUPDATE SET #{[map_src_to_dest(names,'s','d'), \"d.#{@update_ts_column}=CURRENT_TIMESTAMP\"].flatten.join(',')}\nWHEN NOT MATCHED THEN\nINSERT (#{all_name_values.collect {|c,v| 'd.'+c}.join(',')},d.#{@insert_ts_column})\nVALUES (#{all_name_values.collect {|c,v| 's.'+c}.join(',')},CURRENT_TIMESTAMP)\nEOF\n #q = \"INSERT INTO `#{table_name}` (#{names.join(',')}) VALUES (#{values.join(',')})\"\n ETL::Engine.logger.debug(\"Executing upsert: #{q}\")\n conn.insert(q, \"Upsert row #{current_row}\")\n @current_row += 1\n end\n buffer.clear\n end\n end",
"def []=( ref, val )\n update_query( ref => val )\n val\n end",
"def ref=(new_ref)\n @ref = new_ref\n end",
"def []=(key, value)\n @table.insert(key, value)\n end",
"def update!(**args)\n @reference_score = args[:reference_score] if args.key?(:reference_score)\n @references = args[:references] if args.key?(:references)\n @subreference_metadata = args[:subreference_metadata] if args.key?(:subreference_metadata)\n end",
"def autovivify( hash, key )\n\t\t\thash[ key ] = Hash.new( &Assemblage::DataUtilities.method(:autovivify) )\n\t\tend",
"def update_record(table, values, org_key = nil)\n update table_update_query(table, values, org_key)\n end",
"def touch add_to_collection = true, user = nil\n user ||= @current_user\n # Fetch the reference for this user, creating it if necessary\n ref = ref_for(user, true) # Make if necessary\n if do_save = (add_to_collection && !ref.in_collection) # Collecting for the first time\n ref.in_collection = true\n do_stamp = ref.created_at && ((Time.now - ref.created_at) > 5) # It's been saved before => update created_at time\n end\n do_save = true if ref.created_at.nil?\n if ref.user_id # No point saving w/o a user id (recipe id is assumed)\n if do_stamp\n ref.created_at = ref.updated_at = Time.now\n Rcpref.record_timestamps=false\n ref.save\n Rcpref.record_timestamps=true\n elsif do_save # Save, whether previously saved or not\n ref.save\n else\n ref.touch\n end\n end\n \"Created: #{ref.created_at}.........Updated: #{ref.updated_at}\"\n end",
"def populate_collection(args)\n\targs[:keys].each do |key|\n\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{key}\"\n\t\tputs do_the_put_call({ url: api_url, user: @user, json: args[:json][key] })\n\tend\nend",
"def construct_collection(schema, instance, key, value)\n schema[key] = instance.send(key).map do |inst|\n call(Copier.deep_copy(value), inst)\n end\n end",
"def endkey_doc(value)\n update_query(:endkey_docid => value.is_a?(String) ? value : value.id)\n end",
"def set_ref_datum\n @ref_datum = RefDatum.find(params[:id])\n end",
"def update_ref_paths(data, paths = {})\n paths.each do |path, replace_path|\n replace_path = replace_path.sub(/\\/?$/, \"/\")\n data = data.gsub(/(\"\\$ref\"\\s*:\\s*\")#{Regexp.escape(path)}\\/?/, \"\\\\1#{replace_path}\")\n end\n data\n end",
"def set_ref_seq\n\n seq = segments.map(&:ref_seq).reduce(:+)\n update_attributes(:_ref_seq => seq)\n\n seq\n\n end",
"def test_runner_using_refs\n ref = create_records(@client)\n get_record(@client, ref)\n update_record(@client, ref)\n delete_record(@client, ref)\n end",
"def annotate!(ns, ref, keys_or_class, keys=nil)\n if Class === keys_or_class\n keys ||= {}\n keys[:class] = keys_or_class\n else\n keys = keys_or_class\n end\n\n if Hash === keys\n update(ns, ref, keys)\n else\n key = keys.to_sym\n @table[ns][ref] ||= {}\n begin\n @table[ns][ref][key] = lookup(ref, ns)[key].dup\n rescue TypeError\n @table[ns][ref][key] = lookup(ref, ns)[key]\n end\n end\n end",
"def set(recs, data)\r\n # If updates are not in the form of a Proc, convert updates, which\r\n # could be an array, a hash, or a Struct into a common format (i.e.\r\n # hash).\r\n update_rec = convert_input_data(data) unless data.is_a?(Proc)\r\n\r\n updated_recs = []\r\n\r\n # For each one of the recs that matched the update query, apply the\r\n # updates to it and write it back to the database table.\r\n recs.each do |rec|\r\n temp_rec = rec.dup\r\n\r\n if data.is_a?(Proc)\r\n begin\r\n data.call(temp_rec)\r\n rescue NoMethodError\r\n raise 'Invalid field name in code block: %s' % $!\r\n end\r\n else\r\n @field_names.each { |fn| temp_rec[fn] = update_rec.fetch(fn,\r\n temp_rec.send(fn)) }\r\n end\r\n\r\n # Is the user trying to change something they shouldn't?\r\n raise 'Cannot update recno field!' unless \\\r\n rec.recno == temp_rec.recno\r\n raise 'Cannot update internal fpos field!' unless \\\r\n rec.fpos == temp_rec.fpos\r\n raise 'Cannot update internal line_length field!' unless \\\r\n rec.line_length == temp_rec.line_length\r\n\r\n # Are the data types of the updates correct?\r\n validate_input(temp_rec)\r\n\r\n check_required_fields(temp_rec)\r\n\r\n check_against_input_for_specials(temp_rec)\r\n\r\n # Apply updates to the record and add it to an array holding\r\n # updated records. We need the fpos and line_length because\r\n # the engine will use them to determine where to write the\r\n # update and whether the updated record will fit in the old\r\n # record's spot.\r\n updated_recs << { :rec => @field_names.zip(@field_types\r\n ).collect { |fn, ft| convert_to_encoded_string(ft,\r\n temp_rec.send(fn)) }, :fpos => rec.fpos,\r\n :line_length => rec.line_length }\r\n \r\n\r\n # Update any associated blob/memo fields.\r\n temp_rec.each { |r| r.write_to_file if r.is_a?(KBMemo) } if \\\r\n @field_types.include?(:Memo)\r\n temp_rec.each { |r| r.write_to_file if r.is_a?(KBBlob) } if \\\r\n @field_types.include?(:Blob)\r\n end\r\n\r\n # Take all of the update records and write them back out to the\r\n # table's file.\r\n @db.engine.update_records(self, updated_recs)\r\n\r\n # Return the number of records updated.\r\n return recs.size\r\n end",
"def set(instance)\n # TODO could we not cause a nasty bug by dropping nil value keys when the \n # user is using composite keys? Should we not rather raise an error if\n # the value is nil?\n key = instance.key\n \n raise ArgumentError.new(\"+key+ must be an Array, and can not be empty\") if key.empty? \n @cache[instance.class][key] = instance \n end",
"def []=(key, value)\n @mongo.put Marshal.dump(value),\n :_id => sanitize_key(key),\n :filename => sanitize_key(key),\n :content_type => \"application/x-ruby-marshal\"\n value\n end",
"def incr(key); end",
"def incr(key); end",
"def touch entity=nil, collect=false\n return super unless entity\n ref = touched_pointers.create_with(in_collection: collect).find_or_initialize_by user_id: id, entity_type: entity.class.to_s, entity_id: entity.id\n if ref.created_at # Existed prior\n if (Time.now - ref.created_at) > 5\n ref.created_at = ref.updated_at = Time.now\n ref.in_collection ||= collect\n Rcpref.record_timestamps=false\n ref.save\n Rcpref.record_timestamps=true\n elsif collect && !ref.in_collection # Just touch if previously saved\n ref.in_collection = true\n ref.save\n else\n ref.touch\n end\n else # Just save the reference\n ref.save\n end\n end",
"def update!(new_key_vals)\n check_keys(new_key_vals.keys)\n @key_vals.merge!(new_key_vals)\n rebuild_array\n self\n end",
"def add_reference(value)\n ref = @ref_by_value[value]\n\n unless ref.present?\n ref = new_ref!(value)\n @ref_by_value[value] = ref\n @value_by_ref[ref] = value\n end\n\n ref\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n end",
"def update!(**args)\n @key = args[:key] if args.key?(:key)\n end",
"def populate(doc)\n Base.redis_objects.select{|k,v| v[:ilk] == :base}.each do |k,v|\n self.method(\"#{k}=\").call(doc[k])\n end\n self.redis_objects.select{|k,v| v[:type] == :value && v[:ilk]}.each do |k,v|\n self.method(\"#{k}=\").call(doc[k])\n end\n self.redis_objects.select{|k,v| v[:type] == :set}.each do |k,v|\n doc[k].each { |v| self.instance_eval(\"#{k}<<'#{v}'\") }\n end\n self.lc_id = self.id\n end",
"def reference(key)\n descriptors = mapping(key).descriptors\n instance_eval(&descriptors)\n end",
"def force_set_document(key, value, args={})\n return nil unless key\n CouchbaseDocStore.force_set_document(key, value, args)\n end",
"def put(key, value)\n\t\tunless @resource_table.has_key?(key)\n\t\t\t@resource_table[key] = [value, @info] \n\t\t\tnew_resource = { key => [value, @info] }\n\n\t\t\t@neighbour_nodes.each do |n|\n\t\t\t\tsend_message [\"ADD_RESOURCE\", new_resource], 0, n.host, n.port\n\t\t\tend\n\n\t\t\tputs \"#{resource_table}\"\n\t\t\tresolve_queue(key)\n\t\tend\n\tend",
"def commit\n # {{{\n Lore.logger.debug { \"Not updating instance as not touched\" } unless @touched\n return false unless @touched\n \n Lore.logger.debug { \"Updating #{self.to_s}. \" }\n Lore.logger.debug { \"Touched values are: #{@touched_fields.inspect}\" }\n\n return false if @touched_fields.nil? || @touched_fields.length == 0\n @touched_fields.uniq!\n\n @attribute_values = self.class.distribute_attrib_values(@attribute_values_flat)\n foreign_pkey_values = false # predef\n @update_values = {}\n @update_pkey_values = {}\n @attribute_values.each_pair { |table,attributes|\n @touched_fields.each { |name|\n begin\n value = @attribute_values[table][name]\n filter = self.class.__filters__.input_filters[name]\n value = filter.call(value) if filter\n if !attributes[name].nil? then\n @update_values[table] ||= {}\n @update_values[table][name] = value \n end\n rescue ::Exception => e\n Lore.logger.error(\"Failed to commit #{table}.#{name} <- #{value.inspect} <- #{@attribute_values[table][name].inspect}: #{e.message}\")\n raise e\n end\n }\n foreign_pkey_values = get_primary_key_value_map[table]\n \n @update_pkey_values[table] = foreign_pkey_values if foreign_pkey_values\n }\n\n Validation::Parameter_Validator.validate_update(self.class, @update_values)\n\n self.class.before_commit(self)\n self.class.__update_strategy__.perform_update(self)\n self.class.after_commit(self)\n\n @touched = false\n\n return true\n end",
"def set(key, value)\n if (location = get_location_of_key(key))\n @table[location].value = value\n return true\n end\n\n match_available_space = lambda do |bucket_contents|\n if (!bucket_contents || bucket_contents.is_placeholder?)\n return true\n else\n return false\n end\n end\n if (location = quadratic_hash_search(key , match_available_space))\n @table[location] = TableEntry.new(key, value)\n @population += 1\n @used_spaces += 1\n return true\n else\n return false\n end\n end",
"def set(key, value, timestamp)\n if table.key?(key)\n table[key].push(Entry.new(value, timestamp))\n else\n table[key] = [Entry.new(value, timestamp)]\n end\n end",
"def insert(k, parent_document)\n\n # puts \"Insert #{self.id} (#{self.title}) at k = #{k}\"\n\n # Insert the TOCItem of the current document (receiver)\n # in the toc array of the parent document.\n # Note the index of the TOCItem and copy that index\n # into self.index_in_parent. Thus, at the\n # the end of these operations, the parent\n # references the child (the subdocument),\n # and vice versa.\n parent_toc = TOC.new(parent_document)\n new_toc_item = TOCItem.new(self.id, self.title, self.identifier, false)\n parent_toc.insert(k, new_toc_item)\n parent_toc.save!\n self.index_in_parent = k\n self.parent_ref = {id: parent_document.id, title: parent_document.title, identifier: parent_document.identifier, has_subdocs:true }\n self.parent_id = parent_document.id\n\n root_doc = find_root_document\n if root_doc\n self.root_document_id = root_doc.id\n self.root_ref = {id: root_doc.id, title: root_doc.title, identifier: root_doc.identifier, has_subdocs:true }\n else\n self.root_ref = {id: 0, title: '', identifier: '', has_subdocs:false }\n end\n\n # Inherit the render_option from the root document\n if root_doc and root_doc != self\n self.render_options = root_doc.render_options\n end\n\n # update index_in_parent for subdocuments\n # that were shifted to the right\n # puts \"Shifting ...\"\n # puts \"parent_document.subdoc_refs.tail(k+1): #{parent_document.subdoc_refs.tail(k)}\"\n TOC.new(parent_document).table.tail(k).each do |item|\n doc = DocumentRepository.find item.id\n doc.index_in_parent = doc.index_in_parent + 1\n DocumentRepository.update(doc )\n end\n\n DocumentRepository.update(self)\n DocumentRepository.update(parent_document)\n\n # update_neighbors\n\n end",
"def []=(key, value)\n key = key.to_s unless key.is_a? String\n @collection.update( { plgid: @id }, { plgid: @id, key => value }, { upsert: true })\n end",
"def update_content key, content\n\n # @document = content.to_hash\n # upd = false\n # @document.each do |e|\n\n # if e[:name] == key\n # upd = true\n # content.each do |k,v|\n # e[k] = v\n # end\n # break\n # end\n # end\n #\n # unless upd\n # @document << content\n # end\n # if @document[key].nil?\n # @document[key] = content\n # else\n # unless @document[key].class = Array\n # @document[key] = [@document[key]]\n # end\n # @document[key] << content.to_hash\n # end\n\n end",
"def set(key, value, timestamp)\n \n end",
"def store(contact, key, value)\n\t\t\t@logger.info \"Calling RPC `store` on #{contact.name}\"\n\t\t\tactual_key = nil\n\t\t\tbegin\n\t\t\t\tcontact.client do |c|\n\t\t\t\t\tactual_key = c.store(self.to_contact, key, value)\n\t\t\t\t\t@logger.info \"Value stored. Reference key: `#{actual_key}`\"\n\t\t\t\tend\n\t\t\trescue Soil::ClientConnectionError\n\t\t\t\t@logger.info \"store: Value not stored on #{contact.name} because of a Connection Error\"\n\t\t\tend\n\t\t\treturn actual_key\n\t\tend",
"def assign_key(obj)\n \tsuper(obj)\n \tcase \n \t\twhen obj.is_a?(Event) then \t\t\t\"even:#{@max_key}\"\n \t\twhen obj.is_a?(::Database::Reference) then \t\"ref:#{@max_key}\"\n \tend\n end",
"def put(key, value)\n @first.put(key, value)\n end",
"def update\n\n if InfoNode.duplicate_key?(params[:info_types])\n redirect_to :back, :alert => \"Key in the additional information shoud be unique\"\n return\n end\n\n @relation = Node.find(params[:id])\n @collection = current_user.collections.find(params[:collection_id])\n if @relation.nil? || @collection.nil? || @relation.document.collection.id != @collection.id\n redirect_to :back, :alert => \"Cannot find an relation\"\n return\n end \n\n @document = @relation.document\n @collection = @document.collection\n\n unless params[:rid].nil?\n @rid = params[:rid].strip\n end\n\n @rid = @document.create_new_relation_id if @rid.blank?\n @relation.entity_type = params[:type] \n @refs = []\n\n params[:refids].each_with_index do |ref_id, idx|\n @refs << {:ref_id => ref_id, :role => params[:labels][idx]}\n end unless params[:refids].nil?\n\n if @refs.empty?\n redirect_to :back, :alert => \"Please add references for a new relation\"\n return\n end\n \n @relation.update_references(@refs)\n\n keyset = []\n (0...params[:info_types].size).each do |i|\n key = params[:info_types][i]\n value = params[:info_values][i]\n if !key.nil? && !key.strip.blank? && !value.nil? && !value.strip.blank?\n keyset << key\n @relation.set_info_node(key, value)\n end\n end\n\n @relation.remove_info_node_except(keyset)\n\n\n respond_to do |format|\n if @relation.save\n format.html { redirect_to \"/collections/#{@collection.id}/documents/#{@document.pmid}?tab=relation\", notice: 'Relation was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { redirect_to :back, :alert => \"Cannot update relation: #{@relation.errors.full_messages}\" }\n format.json { render json: @relation.errors, status: :unprocessable_entity }\n end\n end\n\n \n end",
"def update_api_key(key, object, validity = 0, max_queries_per_IP_per_hour = 0, max_hits_per_query = 0, request_options = {})\n if object.instance_of?(Array)\n params = { :acl => object }\n else\n params = object\n end\n\n params['validity'] = validity.to_i if validity != 0\n params['maxHitsPerQuery'] = max_hits_per_query.to_i if max_hits_per_query != 0\n params['maxQueriesPerIPPerHour'] = max_queries_per_IP_per_hour.to_i if max_queries_per_IP_per_hour != 0\n\n client.put(Protocol.index_key_uri(name, key), params.to_json, :write, request_options)\n end",
"def set_value(key, value)\n database[key] = value\n removed_keys.delete(key)\n end",
"def set_ref_value(response)\n unless response.header.code != 201 || response.header.etag.blank?\n @__ref_value__ = response.header.etag\n orchio_update_ref_table response.header.timestamp\n end\n end",
"def set key, value, expiration\n backend.set key.to_s, serialize(value), expiration rescue nil\n end",
"def update!(**args)\n @matching_image_reference_key = args[:matching_image_reference_key] if args.key?(:matching_image_reference_key)\n end",
"def write_entry(key, value, options) # :nodoc:\n method = if options[:unless_exists] || options[:unless_exist]\n :add\n else\n :set\n end\n if ttl = options.delete(:expires_in)\n options[:ttl] ||= ttl\n end\n @data.send(method, key, value, options)\n rescue ::Couchbase::Error::Base => e\n logger.error(\"#{e.class}: #{e.message}\") if logger\n raise if @raise_errors\n false\n end",
"def put(key, value)\n if @table[key].nil?\n insert_into_cache(key, value)\n else\n update_cache(key, value)\n end\n end",
"def associate(index:, key:, data:)\n part = @collection.part(index[0], index[1])\n part.associate(key, data)\n end",
"def atomic_updates(*args)\n r = super(*args)\n if @records\n (r['$set'] ||= {})['records'] = serialize_records\n end\n r\n end",
"def heal_associated_docs\n bad_keys = []\n @document.doc_refs do |key, value|\n if DocumentRepository.find key == nil\n bad_keys << key\n end\n end\n bad_keys.each do |key|\n @document.doc_refs.delete(key)\n end\n DocumentRepository.update @document\n end",
"def updates_from_data_key_documents(documents)\n documents.map do |doc|\n {\n update_one: {\n filter: { _id: doc[:_id] },\n update: {\n '$set' => {\n masterKey: doc[:masterKey],\n keyMaterial: doc[:keyMaterial]\n },\n '$currentDate' => { updateDate: true },\n },\n }\n }\n end\n end",
"def ref_key(hash)\n\t\t\t(REF_PROPERTIES.collect { |k| hash[k] } ).to_json\n\t\tend",
"def set key, value\n @reverse_cache[value.object_id] = key\n @cache[key] = value.object_id\n ObjectSpace.define_finalizer(value, @finalize)\n end",
"def rebuild\n raise \"Too many entries.\" if @rebuilds >= MAX_REBUILDS old = @table\n @slots = PRIMES[@rebuilds]\n self.size = 0\n fill_table @slots\n old.each do |e|\n upsert e.key, e.value if e\n end\n @rebuilds += 1\nend",
"def set(key, value)\n self.data ||= {}\n self.data[key.to_s] = value\n self.save!\n end",
"def do_sync_up(api_client, data)\n if clab_id\n # update the linked clab record\n logger.info \"#{self} updating #{clab_obj}\"\n obj = api_client.public_send('put', clab_id, data)\n else\n # create a new clab record and link it\n logger.info \"#{self} creating new clab object\"\n obj = api_client.public_send('post', data)\n self.clab_id = obj['id']\n logger.info \"#{self} created #{clab_obj}\"\n end\n t = obj['lastUpdated']\n self.clab_last_update = t ? DateTime.iso8601(t).to_time : DUMMY_TIMESTAMP\n sync_success\n true\n rescue RuntimeError => e\n sync_fail e.to_s\n false\n end",
"def orchio_put(jdoc)\n response = client.send_request :put, inst_args(json: jdoc)\n if cache.enabled?\n simple_cache.save(\n Document.new(\n response.body.to_hash,\n Metadata.new(\n :collection => ocollection,\n :key => @id,\n :ref => response.header.etag\n )))\n end\n set_ref_value response\n orchio_status response, 201\n end",
"def migrate_update_keys update_keys\n path = '/activities'\n get(path, ids: update_keys)\n end",
"def put(key, value)\n obj = KeyValue.find_by_key(key)\n if obj\n KeyValue.update(obj.id, :value=>value)\n else\n KeyValue.create(:key=>key, :value=>value)\n end\n end",
"def couchdb_put(urn, host = '127.0.0.1', options = @@default_options)\n query_couchdb(urn, 'PUT', host, options)\n end",
"def data_kv table, key, value\n\t\tname = \"#{table}-#{key}-#{value}\".to_sym\n\t\t@cache ||= {}\n\t\tunless @cache.has_key? name\n\t\t\t@cache[name] = Sdb[table].to_hash(key, value)\n\t\tend\n\t\t@cache[name]\n\tend",
"def update_doc(doc)\n id = doc[\"_id\"] if doc[\"_id\"]\n\n @conn.query({url_path: \"#{database}/#{id}\", opts: doc, method: :put})\n end",
"def exchange_keys; end",
"def exchange_keys; end"
] |
[
"0.5803649",
"0.5662252",
"0.5499384",
"0.54875493",
"0.5399688",
"0.5387158",
"0.53680176",
"0.5276618",
"0.5271424",
"0.5255198",
"0.52550596",
"0.5187772",
"0.5175624",
"0.5142534",
"0.5048935",
"0.503664",
"0.503664",
"0.5031836",
"0.5026367",
"0.5008508",
"0.49969405",
"0.4993438",
"0.49923807",
"0.49535817",
"0.49326086",
"0.49264905",
"0.49216327",
"0.48865774",
"0.48820412",
"0.48809743",
"0.48620984",
"0.48141384",
"0.4792348",
"0.47801661",
"0.47762468",
"0.47728628",
"0.47688437",
"0.47636732",
"0.47597218",
"0.47595787",
"0.47551143",
"0.4747406",
"0.47383216",
"0.4734779",
"0.4724255",
"0.47216192",
"0.4711629",
"0.4709748",
"0.47074762",
"0.46992028",
"0.4697065",
"0.46942803",
"0.46928987",
"0.4692303",
"0.46882677",
"0.46882677",
"0.46829608",
"0.46699634",
"0.46659717",
"0.4665022",
"0.4665022",
"0.4664545",
"0.46612352",
"0.46567816",
"0.46554872",
"0.4653349",
"0.46516335",
"0.46503013",
"0.4646591",
"0.46401784",
"0.46400982",
"0.46393743",
"0.46291935",
"0.46281764",
"0.46254992",
"0.46232933",
"0.46174893",
"0.46116123",
"0.4599282",
"0.45907098",
"0.45790446",
"0.45787138",
"0.45785567",
"0.45761847",
"0.45758432",
"0.45755625",
"0.4557027",
"0.4554662",
"0.45523998",
"0.4551867",
"0.45489866",
"0.45486483",
"0.4547165",
"0.45452502",
"0.45428845",
"0.4540542",
"0.45400652",
"0.45398396",
"0.4536772",
"0.4536772"
] |
0.7107745
|
0
|
:startdoc: Returns the client handle for requests to the orchestrate.io api.
|
def client
@@client ||= Orchestrate::Application::Connect.client
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def orchestrate_client\n client\n end",
"def orchestrator_client\n @orchestrator ||= Orchestrator.new(master.uri.to_s, username: 'admin', password: 'pie', ssl_verify: false)\nend",
"def client\r\n @client ||= APIController.new config\r\n end",
"def doorkeeper_client\n doorkeeper_token.resource_owner_id ? Client.find(doorkeeper_token.resource_owner_id) : Client.new\n end",
"def client\n @client ||= Client.new(config[:credentials], config[:end_point])\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def setupClient!()\n @octo_client = Octokit::Client.new(\n :access_token => apiKey(),\n :api_endpoint => githubAPIEndpoint(),\n :web_endpoint => githubWebEndpoint()\n )\n @octo_client.auto_paginate = true\n end",
"def octokit_client\n # Check if we already have the octokit client stored in an instance variable else fetch it using\n # the user's access token to authenticate.\n @client ||= Octokit::Client.new :access_token => token\n @client\n end",
"def perform(secret, endpoint, _args = {})\n @client = ::OpenNebula::Client.new(secret, endpoint)\n end",
"def client\n @client\n end",
"def client\n @client\n end",
"def client\n end",
"def client; end",
"def client; end",
"def api\n @api ||= Octokit::Client.new(:login => login, :oauth_token => token)\n end",
"def client\n @client ||= client_for_host(brine_root_url || 'http://localhost:8080',\n logging: ENV['BRINE_LOG_HTTP'])\n end",
"def get_client(uri, http_type, method)\n return @client\n end",
"def initialize_api_client(options = {})\n require 'right_api_client'\n\n options = {\n rl10: true,\n timeout: 20 * 60\n }.merge options\n\n client = RightApi::Client.new(options)\n client.log(Chef::Log.logger)\n client\n end",
"def client\n\t\treturn @client\n\tend",
"def orchio_get\n if cache.enabled? and response = cache_request.get(id)\n if response.header.status == :cache\n doc = response.body.document\n end\n else\n response = client.send_request :get, inst_args if response.nil?\n doc = Document.new(\n response.body.to_hash,\n Metadata.new(\n :collection => ocollection,\n :key => @id,\n :ref => response.header.etag\n ))\n end\n Result.new(\n status: orchio_status(response, 200),\n response: response,\n results: [ doc ]\n )\n end",
"def client\n @client ||= Client.new(configuration)\n end",
"def client\n @client ||= Curl::Easy.new\n end",
"def client\n @@client\n end",
"def client\n OAuth2::Client.new(api_key,api_secret, :site=>{:url=>'https://graph.renren.com',:response_type=>'code'}, :access_token_url=>'https://graph.renren.com/oauth/token')\n end",
"def app_client\n @app_client ||= Octokit::Client.new :client_id => CLIENT_ID, :client_secret => CLIENT_SECRET\nend",
"def client\n @client ||= Client.new\n end",
"def client\n @client ||= OAuth2::Client.new( get_config('SMARTCAR_CLIENT_ID'),\n get_config('SMARTCAR_SECRET'),\n :site => OAUTH_PATH\n )\n end",
"def client\n @client ||= OpenIDConnect::Client.new(\n identifier: @client_id,\n secret: @secret,\n redirect_uri: @redirect_url,\n realm: 'esdl-mapeditor',\n audience: @audience,\n authorization_endpoint: discovery.authorization_endpoint,\n token_endpoint: discovery.token_endpoint,\n userinfo_endpoint: discovery.userinfo_endpoint\n )\n end",
"def client\n # @client ||= MyService::Client.new(SinaToken.consumer.key, SinaToken.consumer.secret, token, secret)\n end",
"def client\n @client ||= Contentful::Client.new(\n access_token: options.access_token,\n space: options.space,\n dynamic_entries: :auto,\n api_url: options.api_url\n )\n end",
"def client(uri)\n params = {\n :site => site,\n :http_method => :post,\n :request_token_path => \"\",\n :authorize_path => \"\",\n :access_token_path => \"\"}\n\n consumer = OAuth::Consumer.new(AppConfig.candlepin.oauth_key,\n AppConfig.candlepin.oauth_secret, params)\n request = Net::HTTP::Post.new(\"#{site}#{uri}\")\n consumer.sign!(request)\n headers = {\n 'Authorization' => request['Authorization'],\n # TODO: This should be moved to a new helper - this is quite ugly\n 'cp-user' => Thread.current[:request].env['warden'].user\n }\n\n # Creating a new client for every request:\n RestClient::Resource.new(site, :headers => headers)\n end",
"def api_client\n @api_client ||= ::Lokalise.client LokaliseRails.api_token, {enable_compression: true}.merge(LokaliseRails.timeouts)\n end",
"def client\n @client ||= self.class.client\n end",
"def client\n Octokit::Client.new(:access_token => \"#{token}\")\n end",
"def client\n @client ||= EvernoteOAuth::Client.new token: auth_token\n end",
"def get_oauth_clients_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: OAuthApi.get_oauth_clients ...\"\n end\n \n # resource path\n local_var_path = \"/api/v2/oauth/clients\".sub('{format}','json')\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n local_header_accept = ['application/json']\n local_header_accept_result = @api_client.select_header_accept(local_header_accept) and header_params['Accept'] = local_header_accept_result\n\n # HTTP header 'Content-Type'\n local_header_content_type = ['application/json']\n header_params['Content-Type'] = @api_client.select_header_content_type(local_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n \n auth_names = ['PureCloud OAuth']\n data, status_code, headers = @api_client.call_api(:GET, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'OAuthClientEntityListing')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: OAuthApi#get_oauth_clients\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def client\n ENV[\"CHEF_API_CLIENT\"] || config[\"CHEF_API_CLIENT\"]\n end",
"def client\n if !@client || @client.hash != options.hash\n @client = Croudia::Client.new\n end\n @client\n end",
"def client\n @client ||= CFoundry::Client.new(@target.to_s).tap do |c|\n c.login(@username, @password)\n end\n end",
"def client\n @client = Recereco::Client.new(options) unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def client\n client_object_exists = (defined?(@client) != nil)\n if client_object_exists\n return @client\n else\n # When coming through a commit hook endpoint, the github_id won't be saved\n # in the session, so we need to be able to grab it from a class instance variable.\n # @todo: actually there's a better way to do this. See it mentioned in my\n # other @todo in this file.\n if session[:github_id] != nil\n github_id = session[:github_id]\n elsif @github_id != nil\n github_id = @github_id\n else\n authenticate!\n end\n\n user = User.find_by(github_id: github_id)\n if Octokit.validate_credentials({ :access_token => user.token })\n # Auto paginate to prevent repo-list truncation on the books/new page. This may\n # hurt performance, so keep an eye on it.\n @client = Octokit::Client.new :access_token => user.token, :auto_paginate => true\n else\n authenticate!\n end\n end\nend",
"def get_client\n @client\n end",
"def get_client(uri, http_type, method)\n final_url = @base_url + URI.escape(uri)\n params = {\n :site => @base_url,\n :http_method => method,\n :request_token_path => \"\",\n :authorize_path => \"\",\n :access_token_path => \"\"}\n #params[:ca_file] = self.ca_cert_file unless self.ca_cert_file.nil?\n\n consumer = OAuth::Consumer.new(@oauth_consumer_key,\n @oauth_consumer_secret, params)\n request = http_type.new(final_url)\n consumer.sign!(request)\n headers = {\n 'Authorization' => request['Authorization'],\n 'accept_language' => @lang,\n 'cp-user' => 'admin'\n }\n\n # Creating a new client for every request:\n client = RestClient::Resource.new(@base_url,\n :headers => headers)\n return client\n end",
"def client\n @client ||= Client.current\n end",
"def edubase_client\n @uri = API_PATH + \"RunQuery/?\"\n end",
"def open(options={}, &block)\n begin\n # Call the appropriate client's open method.\n if self.client\n self.client.open(options)\n else\n if self.uri\n raise Retrieve::NoClientError,\n \"No client was registered to handle the \" +\n \"'#{self.uri.scheme}' scheme.\"\n else\n raise Retrieve::NoClientError,\n \"Cannot find a client without a URI scheme.\"\n end\n end\n if block\n # If we were supplied a block, yield to it, then close.\n yield self\n else\n self\n end\n ensure\n # Make sure we close if there's a block.\n self.close if block rescue nil\n end\n end",
"def client\n @client ||= ::OAuth2::Client.new(\n @consumer_token,\n @consumer_secret,\n :site => 'https://api-ssl.bitly.com',\n :token_url => '/oauth/access_token'\n )\n end",
"def authorizator_client\n @authorizator_client ||= Authorizator::Client.new(caller_service: caller_service, authorizator_service: authorizator_service)\n end",
"def client\n @client ||= Curl::Easy.new\n end",
"def client\n puts \"creating client\"\n @client ||= Vineyard::Client.new(options) #unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def client\n @client ||= OAuth2::Client.new(\n client_id,\n client_secret,\n :site => site,\n :authorize_url => authorize_url,\n :token_url => token_url\n )\n end",
"def oauth_client\n @oauth_client ||= OAuth2::Client.new @app_key, @app_secret, site: @workxp_site do |stack|\n stack.request :multipart\n stack.request :url_encoded\n stack.adapter :net_http\n end\n end",
"def client\n @client || Client.connection\n end",
"def client\n self.class.client\n end",
"def client\n self.class.client\n end",
"def client\n Etapper.client\nend",
"def client\n @client ||= OAuth2::Client.new(caller_service.client_id,\n caller_service.client_secret,\n :site => called_service.site,\n :raise_errors => false)\n end",
"def init_client; end",
"def srch_client\n\t\t\t\t@@client ||= Srchio::Client.new(:searcher_id => srch_config[:searcher_id])\n\t\t\tend",
"def client\n @client ||= (begin\n if @uri.scheme\n client_class = Retrieve::Client.for(@uri.scheme)\n if client_class\n client_class.new(self)\n else\n nil\n end\n else\n nil\n end\n end)\n end",
"def ocs(args)\n OcsApi.new(args)\n end",
"def client\n ::OAuth2::Client.new(\n options.client_id,\n options.client_secret,\n deep_symbolize(options.client_options).merge(site: site)\n )\n end",
"def getclient\n return @client\n end",
"def client\n @client ||= es_node.client(true).data(false).node.client\n end",
"def client\n return @fetcher.client\n end",
"def client\n OAuth2::Client.new(\n API_KEY,\n API_SECRET,\n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def authenticating_client\n #return false unless signed?\n @authenticating_client ||= OohAuth::AuthenticatingClient.first(:api_key=>consumer_key)\n end",
"def client\n @client ||= ::Flickr.new({:key => @appid, :secret => @secret, :token => @token.token})\n end",
"def api_client\n self.class.api_client\n end",
"def client\n shell.client\n end",
"def client\n @client ||= Github::ApiProxy.new(@options[:access_token])\n end",
"def client\n Hsquare.application(@application).admin_client\n end",
"def octokit\n @octokit ||= Octokit::Client.new(access_token: token)\n end",
"def client\n OAuth2::Client.new(\n API_KEY, \n API_SECRET, \n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def client\n OAuth2::Client.new(\n API_KEY, \n API_SECRET, \n :authorize_url => \"/uas/oauth2/authorization?response_type=code\", #LinkedIn's authorization path\n :token_url => \"/uas/oauth2/accessToken\", #LinkedIn's access token path\n :site => \"https://www.linkedin.com\"\n )\n end",
"def client\n @client ||= platform_klass::Client.new(@options)\n end",
"def client\n @admin ||= User.find_by(is_admin: true)\n @auth_record ||= @admin.auth_record\n @client ||= CiscoAmpApi::V1::Client.new(@auth_record.api_client, @auth_record.api_key )\n end",
"def client\n @client ||= Twitter::REST::Client.new(client_params)\n end",
"def client\n self.class.client\n end",
"def client\n @client ||= begin\n require 'packagecloud'\n creds = Packagecloud::Credentials.new('socrata-platform', token)\n Packagecloud::Client.new(creds)\n end\n end",
"def client(resource, parameters = {})\n url = \"https://#{self.subdomain}.freeagentcentral.com/#{resource}#{parameters.empty? ? \"\" : \"?\" + parameters.collect { |p| p.join(\"=\") }.join(\"&\")}\"\n RestClient::Resource.new(url, self.username, self.password)\n end",
"def client\n @client ||= NPS::Client.new\n end",
"def request(*)\n raise 'HttpApiBuilder::BaseClient#request must be implemented, see documentation'\n end",
"def request(*args, &blk)\n (@client ||= connect).request(*args, &blk)\n end",
"def oauth_client\n if @oauth_client\n @oauth_client\n else\n conn ||= Faraday::Connection.new \\\n :url => \"https://api.gowalla.com\",\n :headers => default_headers\n\n oauth= OAuth2::Client.new(api_key, api_secret, oauth_options = {\n :site => 'https://api.gowalla.com',\n :authorize_url => 'https://gowalla.com/api/oauth/new',\n :access_token_url => 'https://gowalla.com/api/oauth/token'\n })\n oauth.connection = conn\n oauth\n end\n end",
"def _client\n @client ||= XMLRPCClient.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.scheme == 'https' ? @ssl_verify : false, @timeout)\n end",
"def connection\n @connection ||= RestClient::Resource.new(api_uri.to_s)\n end",
"def octokit\n @octokit ||= Octokit::Client.new(access_token: settings.github_admin_token, auto_paginate: true)\n end",
"def get_client\n config.client.new(self)\n end",
"def client\n OpenSourceStats.client\n end",
"def open_api_spec\r\n OpenAPISpecController.instance\r\n end",
"def api_client\n env[:api_client]\n end",
"def index\n clients = request do\n api.request(\n :expects => 200,\n :headers => headers,\n :method => :get,\n :path => \"/oauth/clients\"\n ).body\n end\n styled_header(\"OAuth Clients\")\n styled_array(clients.map { |client|\n [client[\"name\"], client[\"id\"], client[\"redirect_uri\"]]\n })\n end",
"def client\n @client = Zaim::Client.new(options) unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def client\n # Merge in authorize url if supplied\n options.authorize_params[:clientId] = options.client_id\n options.authorize_params[:redirect] = callback_url\n options.client_options[:authorize_url] = options.authorize_url if options.authorize_url.present?\n options.client_options[:site] = options.site if options.site.present?\n\n ::OAuth2::Client.new(\n options.client_id,\n options.client_secret,\n deep_symbolize(options.client_options)\n )\n end",
"def getToolsIodocs( mode, path, endpoint, doctype)\n params = Hash.new\n params['mode'] = mode\n params['path'] = path\n params['endpoint'] = endpoint\n params['doctype'] = doctype\n return doCurl(\"get\",\"/tools/iodocs\",params)\n end",
"def client\n @client ||= OAuth2::Client.new(@apikey, @apisecret, :site => @graph_api_url)\n end",
"def engine_client\n if current_user\n identity_session.access_token.http_client\n else\n Identity.http_client\n end\n end"
] |
[
"0.7770018",
"0.6813021",
"0.6468379",
"0.6243656",
"0.6196577",
"0.616108",
"0.616108",
"0.616108",
"0.6159669",
"0.61101985",
"0.6074567",
"0.60618055",
"0.60618055",
"0.60547",
"0.6049865",
"0.6049865",
"0.60364646",
"0.60264724",
"0.60033923",
"0.5948854",
"0.5933244",
"0.5928497",
"0.5928259",
"0.59274805",
"0.5926812",
"0.59252065",
"0.59200495",
"0.5918576",
"0.59142977",
"0.5914131",
"0.5905582",
"0.58923507",
"0.5891813",
"0.58663964",
"0.58374786",
"0.583527",
"0.582801",
"0.5816736",
"0.5813192",
"0.58130723",
"0.5801938",
"0.5798724",
"0.5787302",
"0.5784048",
"0.5777622",
"0.57769",
"0.5773435",
"0.5763811",
"0.5757623",
"0.57541066",
"0.57397175",
"0.57268554",
"0.5725997",
"0.5723599",
"0.57084674",
"0.5702735",
"0.5702735",
"0.5698658",
"0.5689591",
"0.5684334",
"0.5670998",
"0.56682414",
"0.5640986",
"0.5640409",
"0.562337",
"0.5619525",
"0.5613615",
"0.56082165",
"0.56081086",
"0.5604878",
"0.55936325",
"0.5590747",
"0.5587257",
"0.5581117",
"0.5575458",
"0.5566389",
"0.5566389",
"0.55571246",
"0.555665",
"0.55484897",
"0.55430067",
"0.55325186",
"0.5517136",
"0.5511143",
"0.55095077",
"0.5508719",
"0.550473",
"0.5498563",
"0.54676616",
"0.54651684",
"0.5464691",
"0.5464593",
"0.5463336",
"0.54600817",
"0.5458894",
"0.54542",
"0.5453774",
"0.5451509",
"0.5447954",
"0.5445968"
] |
0.67314106
|
2
|
Returns the collection name associated with the current instance's class.
|
def ocollection
@@_collection[self.class.name].name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def collection_name\n\t\t\t\t\"#{klass.model_name.to_s.classify.pluralize}Collection\".constantize\n\t\t\tend",
"def collection_name\n @collection_name ||= self.to_s.tableize.gsub(/\\//, '.')\n end",
"def collection_name\n self.to_s.tableize\n end",
"def collection_name_from_class_name(class_name)\n class_name.demodulize.underscore.pluralize.to_sym\n end",
"def get_collection_name()\r\n result = nil\r\n if @coll_id #if coll_id is false, than collection_service is used by environment\r\n info = Transformer::KeyBuilder.collection_info(@env_id, @coll_id)\r\n result = @db_interface.get_hash_value(info, Transformer::KeyBuilder::NAME_KEY)\r\n end\r\n return result\r\n end",
"def resource_collection_name #:nodoc:\n self.resources_configuration[:self][:collection_name]\n end",
"def collection_name\n __evaluate__(storage_options[:collection])\n end",
"def collection_name\n @collection_name ||=\n if @resource_options.key?(:collection_name)\n @resource_options.fetch(:collection_name).to_s\n else\n tools.string.pluralize(qualified_resource_name)\n end # if-else\n end",
"def collection_ivar\n \"@#{class_name.model_name.plural}\"\n end",
"def full_collection_name(collection_name)\n \"#{@name}.#{collection_name}\"\n end",
"def coll_name\n self.name.split('::').last.split(/(?=[A-Z])/).map{|x| x.downcase}.join('_')\n end",
"def collection_name; end",
"def collection_name; end",
"def collection_name; end",
"def orchestrate_collection_name\n ocollection\n end",
"def orchestrate_collection_name\n ocollection\n end",
"def get_name()\n return @coll_name\n end",
"def full_collection_name(collection_name)\n \"#{name}.#{collection_name}\"\n end",
"def flexi_collection_name\n self.name.parameterize\n end",
"def full_collection_name\n \"#{app_id}.#{name}\"\n end",
"def camel_case_collection_name(collection)\n collection.to_s.split(\"_\").map(&:capitalize).join\n end",
"def name\n underscore(self.class.name)\n end",
"def name\n @class_name\n end",
"def name\n self.class.name || self.class.to_s\n end",
"def collection_name\n if not parent_report\n table_name\n else\n [parent_report.record_name, table_name].join(\".\")\n end\n end",
"def collection(model = name.to_s.classify.constantize)\n model\n end",
"def class_name\n name = @klass.name\n name.name\n end",
"def collection_names\n collections.keys\n end",
"def collection_name(solr_doc)\n solr_doc[Solrizer.solr_name(\"collection\", :facetable)]\n end",
"def current_class_name\n @klass.to_s\n end",
"def _default_type_name\n if to_s.end_with?('::Collection_')\n _name = to_s.gsub(\n 'Serializer', ''\n ).gsub(\n '::Collection_', ''\n ).downcase.split('::')[-1]\n\n \"#{_name}_collection\".to_sym\n else\n to_s.gsub('Serializer', '').downcase.split('::')[-1].to_sym\n end\n end",
"def name\n self.class.name\n end",
"def class_name\n self.class.class_name\n end",
"def class_name\n @class_name ||= association.target_class.name\n end",
"def collection_type\n components[0].to_sym rescue nil\n end",
"def name\n self.class.name\n end",
"def name\n self.class.name\n end",
"def name\n self.class.simple_name\n end",
"def collection_name\n :\"@#{controller_name}\"\n end",
"def collection_path\n self.class.collection_path\n end",
"def collection_names; end",
"def name\n Properties[self.class] ||= {}\n return Properties[self.class][:name] || \"\"\n end",
"def class_name\n self.class.to_s.split('::').last\n end",
"def collection_name\n singular == plural ? \"#{plural}_index\" : plural\n end",
"def collection_name\n singular == plural ? \"#{plural}_index\" : plural\n end",
"def class_name\n self.class.name.split(\"::\").last.downcase\n end",
"def collection\n database[collection_name]\n end",
"def class_name\n @class_name ||= derive_class_name\n end",
"def name\n\t\tself.class.name\n\tend",
"def class_name\n @class_name ||= (@options[:class_name] || @name).to_s.camelize\n end",
"def name\n self.class.to_s.split('::').last\n end",
"def collection_path(query_options = nil)\n self.element_name\n end",
"def collection\n mongo_session[collection_name]\n end",
"def collection\n klass.collection\n end",
"def shortCollectionName(c)\n c.getName.split(',')[0].strip\nend",
"def class_name\n klass = single_class\n while klass.name == ''\n klass = klass.superclass\n end\n if list_context?\n \"[#{klass}]\"\n else\n klass.name\n end\n end",
"def type\n @type ||= @collection.nil? ? nil : @collection.label.to_sym\n end",
"def class_name\n self.class.name.split(\"::\").last\n end",
"def className\r\n\t\tself.class.to_s\r\n\tend",
"def name\n @klass\n end",
"def to_s\n self.class.name\n end",
"def to_s\n self.class.name\n end",
"def name\n @name ||= self.class.non_namespaced_name\n end",
"def collection_path\n @prefix + '/' + @resource.collection_path.to_s\n end",
"def collection\n components.values.last[:collection]\n end",
"def name\n return self.class.name.split('::').last\n end",
"def className\n\t\tself.class.to_s\n\tend",
"def className\n\t\tself.class.to_s\n\tend",
"def to_s\n self.class.name\n end",
"def name\n self.class.name.split(\"::\").last.downcase\n end",
"def inspect\n \"#<#{self.class} #{relative_path} collection=#{collection.label}>\"\n end",
"def class_name\n self.class.to_s\n end",
"def class_name\n self.class.to_s\n end",
"def underscore\n class_name.to_s.underscore\n end",
"def classname\n @classname ||= self.class.name.split(\"::\")[1..-1].join(\"::\")\n end",
"def collection\n mongo_session[collection_name]\n end",
"def name\n @name ||= self.class.name\n end",
"def collection_path\n self.class.collection_path\n end",
"def collection(collection_name)\n default_scope.collection(collection_name)\n end",
"def collection_names\n Rails.logger.info \"DEPRECATED: collection_names is deprecated, please refactor\"\n @collection_names ? @collection_names : self.collections.collect(&:name).join(\",\")\n end",
"def collection\n self.class.collection\n end",
"def collection\n self.class.collection\n end",
"def collection_names\n names = collections_info.collect { |doc| doc['name'] || '' }\n names = names.delete_if {|name| name.index(@name).nil? || name.index('$')}\n names.map {|name| name.sub(@name + '.', '')}\n end",
"def className\r\n self.class.to_s\r\n end",
"def name\n self.class.name.split('::').last\n end",
"def name; self.class.name; end",
"def name\n klass.name.split('::').last\n end",
"def method_for_association_chain #:nodoc:\n resource_collection_name\n end",
"def collection\n return nil if embedded?\n @collection_name = self.to_s.demodulize.tableize\n @collection ||= Mongoid.database.collection(@collection_name)\n end",
"def collection\n klass.collection\n end",
"def name\n self.class.name.split('::').last\n end",
"def class_name\n @class_name ||= (options[:class_name] || derive_class_name).to_s\n end",
"def class_name\n @class_name ||= (options[:class_name] || derive_class_name).to_s\n end",
"def name\n self.class.name.split(\"::\").last\n end",
"def class_name\n %x{\n var first = self[0];\n return (first && first.className) || \"\";\n }\n end",
"def to_s\n\t\tself.class.name\n\tend",
"def class_name\n (self.type.to_s || self.class.name).demodulize\n end",
"def qualified_name\n self.class.name\n end",
"def collection\n get_collection_ivar || begin\n set_collection_ivar class_name.all\n end\n end",
"def to_s\n \"#{DbAgile::RubyTools::unqualified_class_name(self.class)}: #{name}\"\n end"
] |
[
"0.8395584",
"0.8322516",
"0.8047097",
"0.79113543",
"0.7585694",
"0.7529532",
"0.75034964",
"0.7494685",
"0.7436805",
"0.7406892",
"0.73804134",
"0.7366862",
"0.7366862",
"0.7366862",
"0.73289126",
"0.73289126",
"0.731209",
"0.7301634",
"0.72815853",
"0.7159421",
"0.715592",
"0.7096759",
"0.6953959",
"0.6907546",
"0.68617725",
"0.68594825",
"0.6846393",
"0.68391156",
"0.68290216",
"0.6775738",
"0.67754006",
"0.67746776",
"0.6760894",
"0.67422557",
"0.67411065",
"0.6696782",
"0.6696782",
"0.66834956",
"0.6677294",
"0.66757077",
"0.6672763",
"0.66559726",
"0.66420615",
"0.66409206",
"0.66409206",
"0.66319567",
"0.6629788",
"0.662894",
"0.66140014",
"0.6584366",
"0.65841997",
"0.65675604",
"0.65606266",
"0.65552807",
"0.6550588",
"0.6547168",
"0.6546267",
"0.65275335",
"0.6521477",
"0.6517828",
"0.6516319",
"0.6516319",
"0.6510146",
"0.6500174",
"0.6495552",
"0.6494908",
"0.64898413",
"0.64898413",
"0.6486263",
"0.6481388",
"0.6461408",
"0.6456506",
"0.6456506",
"0.6449538",
"0.6445471",
"0.6445059",
"0.6441358",
"0.64355266",
"0.64350075",
"0.6430419",
"0.6427822",
"0.6427822",
"0.6414348",
"0.64028746",
"0.6394937",
"0.63907194",
"0.63776445",
"0.63672394",
"0.6362567",
"0.63596815",
"0.63584065",
"0.63549715",
"0.63549715",
"0.63332653",
"0.6332199",
"0.6329485",
"0.6317006",
"0.6312771",
"0.63108045",
"0.63062894"
] |
0.72106934
|
19
|
Returns hash that merges additional arguments with the everpresent collection and key args.
|
def inst_args(args={})
args.merge(collection: ocollection, key: id)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def prepare_method_arg_hash(args)\n # SEQUEL5: Remove\n h = {}\n prepare_method_args('a', args.length).zip(args).each{|k, v| h[k] = v}\n h\n end",
"def hash\n [name, args].hash\n end",
"def hash\n hash_args.hash\n end",
"def hashed_key_and_args(key, *args)\n base = args.inject('') do |memo, arg|\n memo << (':' + arg.class.to_s + ':') << case arg\n when Array\n hashed_key_and_args(key, *arg)\n when Hash\n hashed_key_and_args(key, *arg.to_a)\n when NilClass, Numeric, String, Symbol\n arg.to_s\n else\n raise ArgumentError, 'can only compute digest for primitive objects'\n end\n\n Digest::SHA1::hexdigest(memo)\n end\n\n key + ':' + base\n end",
"def serializer_args_hash\n result = {}\n #TODO: Should probably safety check these somewhere\n result[:entry_type] = params[:entry_type] if params[:entry_type].present? \n result[:section] = params[:section] if params[:section].present?\n return result\n end",
"def meaningful_arguments(arguments)\n self_arguments = self.arguments\n result = {}\n arguments.each_assigned_argument do |key, value|\n if self_arguments.include?(key)\n result[key] = value\n end\n end\n result\n end",
"def lookup_hash_args(*args, **kwargs)\n if args.empty?\n [kwargs]\n elsif args.length == 1 && args.last.is_a?(Hash)\n [args.first.symbolize_keys]\n else\n args\n end\n end",
"def extend_build_args(from, to)\n from ||= {}\n to ||= {}\n from.merge(to)\n end",
"def named_arguments\n arguments.select { |arg| arg.is_a? Hash }.first || {}\n end",
"def to_hash\n args_hash = {}\n arguments.each { |k,v| args_hash[k] = v.attributes } if arguments\n { return_type: return_type }.merge args_hash\n end",
"def arguments\n @arguments ||= Launchr::OrderedHash.new\n @arguments\n end",
"def merge!(new_args); end",
"def hash\n [@collection.full_namespace, @opts.hash, @selector.hash].hash\n end",
"def _key(*args); args.hash; end",
"def extract_args(args, arg_names)\n arg_names.each_with_object({}) do |key, hash|\n hash[key] = args.delete(key)\n end\n end",
"def extract_args(*args)\n options = args.extract_options!\n if options.length.positive?\n [args.pop, options.fetch(:keys) { [] }, options.fetch(:argv) { [] }]\n else\n keys, argv = args.shift(2)\n keys ||= []\n argv ||= []\n [args.pop, keys, argv]\n end\n end",
"def fold_kwargs!(args)\n hash = args&.[](0)\n return unless hash.respond_to?(:key)\n\n Rails5Shims::ControllerTests::REQUEST_KWARGS.each do |kwarg|\n next unless hash.key?(kwarg)\n\n value = hash.delete(kwarg)\n if value.is_a? String\n args.insert(0, value)\n else\n hash.merge! value\n end\n end\n end",
"def as_hash(add_ins = {})\n hash = {\n :id => self.id,\n :name => self.name,\n :user_id => self.user_id,\n :wrapped_user_id => self.wrapped_user_id,\n }\n hash = hash.merge(add_ins)\n # if a wrapped user, add in user related info\n hash[:user] = wrapped_user.basic_user_info_hash if self.wrapped_user_id\n hash\n end",
"def build_args(args)\n args.each do |arg|\n arg.each do |key, value|\n case key.to_s\n when 'query_params'\n @query_params = value\n when 'request_headers'\n update_headers(value)\n when 'request_body'\n @request_body = value\n end\n end\n end\n end",
"def options_arguments\n @options_arguments ||= Launchr::OrderedHash.new\n @options_arguments\n end",
"def _equality_extract_options(args)\n (args.pop if args.last.kind_of?(Hash)) || {}\n end",
"def all_extra_arguments\n\t\t\t\t%i[req opt].each_with_object({}) do |type, extra_arguments|\n\t\t\t\t\textra_arguments[type] = {\n\t\t\t\t\t\tctrl: action_arguments[type] - path_arguments[type],\n\t\t\t\t\t\tpath: path_arguments[type] - action_arguments[type]\n\t\t\t\t\t}\n\t\t\t\tend\n\t\t\tend",
"def to_hash(options={})\n call\n\n @hash = { name => @args } unless @hash && @hash[name] && ! @hash[name].empty?\n\n if @aggregations\n @hash[:aggregations] = @aggregations.to_hash\n end\n @hash\n end",
"def method_missing(key, *args)\n if key.to_s.end_with?('=')\n key = key.to_s.sub(/\\=$/,'').to_sym\n options[key] = ARRAY_KEYS.include?(key) ? [args].flatten.compact : args.first\n else\n if ARRAY_KEYS.include?(key)\n options[key] = [options[key] + args].flatten.compact.uniq\n else\n options[key] = args.first\n end\n end\n end",
"def bag_or_node_args(*args)\n Hash[*args.flatten.map{|k| [k.to_sym,bag_or_node(k.to_sym)]}.flatten]\n end",
"def make_params(args)\n {}.tap do |result|\n param = args.deep_dup\n next unless param.class == Hash\n param = param.stringify_keys\n make_query_params(args).each_key do |qk|\n param.delete(qk)\n end\n properties.each_key do |pk|\n result[pk] = param[pk] if param.key?(pk)\n end\n end\n end",
"def convert_args_to_options_hash *args\n case args.count\n when 0 then {}\n when 1 then args[0].is_a?(Hash) ? args[0] : { :data => args[0] }\n when 2 then args[1].merge(:data => args[0])\n else\n msg = \"expected 0, 1 or 2 arguments, got #{args.count}\"\n raise ArgumentError, msg\n end\n end",
"def to_hash( *args )\n h = {}\n args = [ args ].flatten\n args = self.collected_stats if args.empty?\n args.each do |meth|\n h[meth] = self.send( meth )\n end\n return h\n end",
"def extract_options(args)\n options = args.last\n options.respond_to?(:to_hash) ? options.to_hash.dup : {}\n end",
"def show_arguments\n @arguments ||= Launchr::OrderedHash.new\n summarize_arguments\n end",
"def hash(\n before: Pass.instance,\n mandatory: {},\n optional: {},\n other_keys: :keep,\n after: Pass.instance\n )\n HashV.new(\n before: before,\n mandatory: mandatory,\n optional: optional,\n other_keys: other_keys,\n after: after\n )\n end",
"def collect_on_hash(hash)\n @args.collect{|arg| hash[arg]}\n end",
"def infer_args(opts)\n opts.map do |hash|\n if hash.has_key?(:name)\n hash\n else\n check = [:type, :match, :constraint, :within, :default]\n if check.any? {|key| hash.has_key?(key) }\n hash.merge! :name => 'arg'\n end\n\n if hash.has_key?(:default) && !hash.has_key?(:optional)\n hash.merge! :optional => true\n end\n\n hash\n end\n end\n end",
"def encode_args_hash\n if self.run_args_hash && self.run_args_hash.is_a?(Hash)\n self.run_args_hash = Yajl::Encoder.encode(self.run_args_hash)\n end\n end",
"def argumentos(args)\n\thash = Hash.new\n\targs.each do |arg| \n\t\thash[arg.split('=').first] = arg.split('=').second\n\tend \n\treturn hash\nend",
"def hash_args\n [@offset_start] + super\n end",
"def extract_options(*args)\n args = args.dup\n index = args.rindex { |e| e.is_a?(Hash) } || args.length\n args[-1] = args[index] || {}\n args[index] = nil if index < args.length - 1\n args\n end",
"def split_args(args, keys_in_first) # :nodoc:\n args1 = {}\n args2 = {}\n args.each do |key, val|\n if keys_in_first.include?(key)\n args1[key] = val\n else\n args2[key] = val\n end\n end\n [args1, args2]\n end",
"def map_args(args) \n args.merge({'key' => @key}).map { |ary|\n key, val = ary\n\n if val && %w{claim highlight}.include?(key)\n val = '1' \n elsif key == 'current'\n val = val ? 'yes' : 'no'\n else\n val = val ? val.to_s : ''\n end\n \n \"#{key}=#{u(val)}\"\n }.join('&')\n end",
"def hash\n [key, name, description, kind, creation_date, include_in_snippet, temporary, maintainer_id, tags, variations, goal_ids, _version, custom_properties, _links, _maintainer, environments, archived_date, archived, client_side_availability, defaults].hash\n end",
"def hash_including(*args)\n if defined?(super)\n super\n else\n WebMock::Matchers::HashIncludingMatcher.new(anythingize_lonely_keys(*args))\n end\n end",
"def anythingize_lonely_keys(*args)\n hash = args.last.class == Hash ? args.delete_at(-1) : {}\n args.each { | arg | hash[arg] = WebMock::Matchers::AnyArgMatcher.new(nil) }\n hash\n end",
"def serializable_hash(*)\n\n excludes = ['id', 'created_at', 'updated_at', 'from_searcher', 'searcher_key']\n output = super.except(*excludes)\n output.merge!(search_data) if search_data\n\n # Flatten the extra data fields into output\n return output\n\n end",
"def initialize hashed_args\n hash_make hashed_args, Signal::ARG_SPECS\n end",
"def to_hash(args = {}) # :nodoc:\n args ||= {}\n hash = {}\n\n self.attributes.each do |name, value|\n hash[name] = if value.is_a?(::Array)\n value.map {|x| x.respond_to?(:to_hash) ? call_method_with_optional_parameters(x, :to_hash, :nested => true) : x}\n elsif value.respond_to?(:to_hash)\n call_method_with_optional_parameters(value, :to_hash, :nested => true)\n elsif value.respond_to?(:as_json)\n value.as_json(:nested => true)\n else\n value\n end\n end\n\n hash\n end",
"def config\n @default_args || Surrealist::HashUtils::EMPTY_HASH\n end",
"def load_params args\n\tparams = {}\n\targs.each_slice(2) do | key_value |\n\t\t# puts \"o #{key_value}\"\n\t\tparams[key_value[0][1..-1]] = key_value[1]\n\tend\n\tparams\nend",
"def serializable_hash(*args)\n args[0] = (args[0] || {}).merge(:except => [:password, :twitter_access_token, :twitter_access_secret, :facebook_access_token] )\n user_hash = super\n\n if self.current_trip\n user_hash[:due] = self.current_trip.total_due_to(self)\n user_hash[:owe] = self.current_trip.total_owed_from(self)\n user_hash[:contributed] = self.current_trip.total_contributed_from(self)\n user_hash[:obligated] = self.current_trip.total_obligated_from(self)\n user_hash[:purchases] = self.purchases.where(:trip_id => self.current_trip.id)\n user_hash[:contributions] = self.contributions.includes(:expense).where([\"expenses.trip_id = ?\", self.current_trip.id])\n user_hash[:obligations] = self.obligations.includes(:expense).where([\"expenses.trip_id = ?\", self.current_trip.id])\n\n user_hash[:owe_members] = self.current_trip.members.collect{|x| {:user => x, :amount => self.amount_owed_from(x, self.current_trip)}}.select{|x| !x[:amount].zero?}\n user_hash[:due_members] = self.current_trip.members.collect{|x| {:user => x, :amount => self.amount_due_to(x, self.current_trip)}}.select{|x| !x[:amount].zero?}\n end\n\n user_hash\n end",
"def to_hash\n {}.tap do |hash|\n # the \"key\" here is to call to_hash on all containers.\n [@wrapped_options.to_hash, @mutable_options.to_hash].each do |options|\n options.each { |k, v| hash[k.to_sym] = v }\n end\n end\n end",
"def shared_params(extra_vars:)\n {:cmdline => \"--extra-vars '#{JSON.dump(extra_vars)}'\"}\n end",
"def hash_args\n [@month, @day_of_week] + super\n end",
"def to_hash(*_arg0); end",
"def hash(*args, **_arg1, &block); end",
"def before_filter_to_hash args\n filter = {}\n\n #Process args for the uncommon but possible situation\n #in which some variables are used in the filter.\n args.each do |a|\n if sexp? a\n a = process_default a\n end\n end\n\n filter[:methods] = [args[0][1]]\n\n args[1..-1].each do |a|\n filter[:methods] << a[1] if a.node_type == :lit\n end\n\n if args[-1].node_type == :hash\n option = args[-1][1][1]\n value = args[-1][2]\n case value.node_type\n when :array\n filter[option] = value[1..-1].map {|v| v[1] }\n when :lit, :str\n filter[option] = value[1]\n else\n Brakeman.debug \"[Notice] Unknown before_filter value: #{option} => #{value}\"\n end\n else\n filter[:all] = true\n end\n\n filter\n end",
"def combine_args(provides, version, arch)\n provides = provides.to_s.strip\n version = if !version.nil? && !version.empty?\n version.to_s.strip\n end\n arch = if !arch.nil? && !arch.empty?\n arch.to_s.strip\n end\n if version =~ /^[><=]/\n if arch\n return { \"provides\" => \"#{provides}.#{arch} #{version}\" }\n else\n return { \"provides\" => \"#{provides} #{version}\" }\n end\n end\n maybe_arch = provides.rpartition(\".\").last\n if is_arch?(maybe_arch)\n arch = maybe_arch\n provides.delete_suffix!(\".#{arch}\")\n end\n provides = \"#{provides}-#{version}\" if version\n provides = \"#{provides}.#{arch}\" if arch\n # yum (on rhel7) can't handle an epoch in provides, but\n # deconstructing the args can't handle dealing with globs\n if provides =~ /-\\d+:/ && provides !~ /[\\*\\?]/\n deconstruct_args(provides)\n else\n { \"provides\" => provides }\n end\n end",
"def extract_params(args, params_hash={})#:nodoc:\n positional_params = []\n params_hash = params_hash.clone\n args.each do |arg|\n if arg.kind_of?(Hash)\n params_hash.merge!(arg)\n else\n positional_params << arg\n end\n end\n [positional_params, params_hash]\n end",
"def hashify(*args, &block)\n key_value_pairs = args.map {|a| yield(a) }\n\n # if using Ruby 1.9,\n # Hash[ key_value_pairs ]\n # is all that's needed, but for Ruby 1.8 compatability, these must\n # be flattened and the resulting array unpacked. flatten(1) only\n # flattens the arrays constructed in the block, it won't mess up\n # any values (or keys) that are themselves arrays.\n Hash[ *( key_value_pairs.flatten(1) )]\n end",
"def generator_args_for_metadata\n result = {}\n result[\"ruby-cloud-description\"] = description\n result[\"ruby-cloud-env-prefix\"] = env_prefix if env_prefix\n result[\"ruby-cloud-product-url\"] = product_documentation_url if product_documentation_url\n path_overrides = @api.overrides_of(:file_path).map { |k, v| \"#{k}=#{v}\" }.join \";\"\n result[\"ruby-cloud-path-override\"] = path_overrides unless path_overrides.empty?\n namespace_overrides = @api.overrides_of(:namespace).map { |k, v| \"#{k}=#{v}\" }.join \";\"\n result[\"ruby-cloud-namespace-override\"] = namespace_overrides unless namespace_overrides.empty?\n service_overrides = @api.overrides_of(:service).map { |k, v| \"#{k}=#{v}\" }.join \";\"\n result[\"ruby-cloud-service-override\"] = service_overrides unless service_overrides.empty?\n result\n end",
"def build_opts(hash, *args)\n opts = args\n hash.each do |key, value|\n case key\n when :secure, :soft\n value == :yes && opts << '--%s' % key\n when :appname, :appversion\n when :name\n else\n opts << '--%s' % key << value\n end\n end\n opts << hash[:appname]\n opts << hash[:appversion]\n opts.compact\n end",
"def params_from_args(args)\n params = {}\n args.each { |arg| params = arg if arg.is_a?(Hash) and ! arg.empty? }\n params\n end",
"def combined_hash\n y = if @process_global\n normalize(global_yaml).rmerge(normalize(yaml))\n else\n normalize(yaml)\n end\n @process_local ? y.rmerge(normalize(local_yaml)) : y\n end",
"def to_hash(version = 1, *a)\n hash = {}\n if version == 1\n instance_variables.each do |var|\n if var.to_s == '@type'\n hash[:measure_type] = instance_variable_get(var)\n elsif var.to_s == '@arguments'\n hash[:arguments] = []\n @arguments.each do |a|\n # This will change in version 2 but right now, if the argument is a variable, then the argument will\n # be in the variables hash, not the arguments hash.\n next unless @variables.find { |v| v[:argument][:name] == a[:name] }.nil?\n hash[:arguments] << a\n end\n elsif var.to_s == '@variables'\n # skip until after looping over instance_variables\n elsif var.to_s == '@__swigtype__'\n # skip the swig variables caused by using the same namespace as OpenStudio\n else\n hash[var.to_s.delete('@')] = instance_variable_get(var)\n end\n\n # TODO: iterate over the variables and create UUIDs, or not?\n end\n\n # fix everything to support the legacy version\n # we need to make a deep copy since multiple calls to .to_hash deletes :type, :mode, etc below\n # and we still want those args to be avail for future calls, but not end up in the final OSA hash.\n # without this, the v.delete() below (line ~278-281) will remove :type from @variables. \n # this would be okay if there was only 1 call to .to_hash. but thats not guaranteed\n variables_dup = Marshal.load(Marshal.dump(@variables))\n hash[:variables] = variables_dup\n\n # Clean up the variables to match the legacy format\n hash[:variables].each_with_index do |v, index|\n v[:variable_type] == 'pivot' ? v[:pivot] = true : v[:variable] = true\n v[:static_value] = v[:argument][:default_value] unless v[:static_value]\n @variables[index][:static_value] = v[:static_value]\n\n v[:uncertainty_description] = {}\n # In Version 0.5 the _uncertain text will be removed from distribution\n if v[:type] =~ /uncertain/\n v[:type].delete!('_uncertain')\n end\n v[:uncertainty_description][:type] = v[:type]\n\n # This is not neatly coded. This should be a new object that knows how to write itself out.\n v[:uncertainty_description][:attributes] = []\n if v[:type] =~ /discrete/\n new_h = {}\n new_h[:name] = 'discrete'\n\n # check the weights\n new_h[:values_and_weights] = v.delete(:values).zip(v.delete(:weights)).map { |w| { value: w[0], weight: w[1] } }\n v[:uncertainty_description][:attributes] << new_h\n end\n\n # always write out these attributes\n v[:uncertainty_description][:attributes] << { name: 'lower_bounds', value: v[:minimum] }\n v[:uncertainty_description][:attributes] << { name: 'upper_bounds', value: v[:maximum] }\n v[:uncertainty_description][:attributes] << { name: 'modes', value: v[:mode] }\n v[:uncertainty_description][:attributes] << { name: 'delta_x', value: v[:step_size] ? v[:step_size] : nil }\n v[:uncertainty_description][:attributes] << { name: 'stddev', value: v[:standard_deviation] ? v[:standard_deviation] : nil }\n\n v[:workflow_index] = index\n\n # remove some remaining items\n v.delete(:type)\n v.delete(:mode) if v.key?(:mode)\n v.delete(:step_size) if v.key?(:step_size)\n v.delete(:standard_deviation) if v.key?(:standard_deviation)\n end\n\n else\n raise \"Do not know how to create the Hash for Version #{version}\"\n end\n\n hash\n end",
"def merge_opts(args, opts)\n res = args.dup\n if res.last.is_a? Hash\n # there are already options\n # keep them\n orig_opts = res.last\n orig_opts.replace(opts.merge(orig_opts))\n else\n res << opts\n end\n res\n end",
"def merge_opts(args, opts)\n res = args.dup\n if res.last.is_a? Hash\n # there are already options\n # keep them\n orig_opts = res.last\n orig_opts.replace(opts.merge(orig_opts))\n else\n res << opts\n end\n res\n end",
"def additional_parameters\n @additional_parameters ||= {}\n end",
"def hash\n [name, operator, expanded].hash\n end",
"def opts(**kws)\n res = {}\n kws.each_pair do |kw, v|\n res[kw] = v[0] unless v[0] == v[1]\n end\n res\n end",
"def hash\n [compute, group_by, index, multi_compute, search].hash\n end",
"def minimal_arguments(method)\n # Build an arguments array with holds all required parameters. The actual\n # values for these arguments doesn't matter at all.\n args = method.parameters.select { |mode, _name| mode == :req }\n\n # Add a hash with all required named arguments\n required_keyword_args = method.parameters.each_with_object({}) do |(mode, name), hsh|\n hsh[name] = :anything if mode == :keyreq\n end\n args << required_keyword_args if required_keyword_args\n\n args\n end",
"def hash\n [type, arguments, base_justification, maximum_distribution, object_distribution, row_spacing_rule, row_spacing].hash\n end",
"def to_hash *args\n hsh = super(*args)\n hsh.each do |attr, val|\n hsh[attr] = val.to_hash if val.respond_to?(:to_hash)\n end\n hsh\n end",
"def all_attrs\n key_attrs.merge(other_attrs)\n end",
"def to_hash\n self.class.operands.inject({}) do |result, (param_name, param_options)|\n result[param_name] = instance_variable_get(\"@#{param_name}\")\n result\n end\n end",
"def setup(hash_args); end",
"def arguments\n @args ||= {}\n unless @args.size > 0\n ARGV.each_with_index do |arg, index|\n if arg.start_with?('-')\n if index + 1 < ARGV.size\n next_arg = ARGV[index + 1]\n if next_arg.start_with?('-') then\n @args.update(argument_present_or_direct(arg))\n else\n @args.update(arg => next_arg)\n end\n else\n @args.update(argument_present_or_direct(arg))\n end\n end\n end\n end\n @args\n end",
"def prep_updater_method_args\n logger.warn \"DEPRECATED: Hydra::AssetsControllerHelper.prep_updater_method_args is deprecated. Use/override sanitize_update_params instead.\"\n args = {:params=>{}, :opts=>{}}\n \n params[\"asset\"].each_pair do |datastream_name,fields|\n \n args[:opts][:datastreams] = datastream_name\n \n # TEMPORARY HACK: special case for supporting textile \n if params[\"field_id\"]==\"abstract_0\" \n params[:field_selectors] = {\"descMetadata\" => {\"abstract\" => [:abstract]}}\n end\n \n if params.fetch(\"field_selectors\",false) && params[\"field_selectors\"].fetch(datastream_name, false)\n # If there is an entry in field_selectors for the datastream (implying a nokogiri datastream), retrieve the field_selector for this field.\n # if no field selector, exists, use the field name\n fields.each_pair do |field_name,field_values|\n parent_select = OM.destringify( params[\"field_selectors\"][datastream_name].fetch(field_name, field_name) )\n args[:params][parent_select] = field_values \n end \n else\n args[:params] = unescape_keys(params[:asset][datastream_name])\n end\n end\n \n @sanitized_params = args\n return args\n \n end",
"def zadd(key, *args, **_arg2); end",
"def extra_keys(options, recall={})\n generate_extras(options, recall).last\n end",
"def to_hash\n rethash = {}\n\n @parameters.each do |name, obj|\n rethash[name] = obj.value\n end\n\n rethash\n end",
"def digestable_hash\n @item.slice(CLASS, QUEUE, LOCK_ARGS, APARTMENT).tap do |hash|\n hash.delete(QUEUE) if unique_across_queues?\n hash.delete(CLASS) if unique_across_workers?\n end\n end",
"def parse_args(args)\n result = {}\n args.each do |arg|\n pair = arg.split(\"=\")\n result[pair[0]]=pair[1]\n end\n result\n end",
"def parse_arguments(args={})\n result = {}\n (result[:all] = ['all'].to_set) and return result if args.to_s == 'all'\n [:only, :except, :skip].each do |key|\n unless args[key].nil?\n result[key] = [args[key].to_s].to_set and next if args[key].to_s == 'all' && key == :skip\n raise ActionsValueException unless args[key].instance_of?(Array)\n result[key] = args[key].map!{ |v| v.to_s }.to_set\n end\n end\n result\n end",
"def hash=(_arg0); end",
"def make_args(args_hash)\n # The routin should be provided in the inherited class\n end",
"def extra_keys(options, recall = T.unsafe(nil)); end",
"def keyword_value_hash\n self.data_attributes.inject({}) do |hsh, a| \n if a.class == ImportAttribute\n hsh.merge!(a.import_predicate => a.value)\n else # there are only two\n hsh.merge!(a.predicate.name => a.value)\n end\n end \n end",
"def args\n defined_args = []\n self.class.init_args.keys.each do | arg |\n if arg_val = send(arg)\n defined_args << \":#{arg} => #{arg_val}\"\n end\n end\n defined_args.join(\",\\n\")\n end",
"def sendgrid_unique_args unique_args = {}\n @sg_unique_args = unique_args\n end",
"def duplicate_keys\n profile_param_keys & user_param_keys\n end",
"def extra_keys(options, recall = {})\n generate_extras(options, recall).last\n end",
"def to_hash_exposing(*exposed_methods_and_initialize_hashes)\n exposed_attributes = exposed_methods_and_initialize_hashes.select do |arg|\n [ Symbol, String ].include?(arg.class)\n end\n \n initialize_hash = exposed_methods_and_initialize_hashes.select do |arg|\n arg.is_a?(Hash)\n end.inject({}, &:merge) # combine all hashes just in case\n\n for attr in exposed_attributes\n initialize_hash[attr] = send(attr)\n end\n \n initialize_hash.symbolize_keys\n end",
"def params_to_hash\n {}\n end",
"def to_hash(options={})\n case\n # 1. Create hash from the block\n when @block\n @hash = (@args && ! @args.empty?) ? { name => { @args => {} } } : { name => {} }\n call\n @hash[self.name.to_sym].update @options unless @options.empty?\n @hash\n # 2. Hash created with option methods\n when @hash[self.name.to_sym] && ! @args.is_a?(Hash) && @hash[self.name.to_sym][@args]\n @hash[self.name.to_sym].update @options unless @options.empty?\n @hash\n # 3. Hash passsed as @args\n when @hash[self.name.to_sym] && @args.respond_to?(:to_hash) && ! @args.empty?\n { name => @args.to_hash }\n # 4. Hash already built\n else\n @hash\n end\n end",
"def with_arguments(arguments)\n\t @arguments ||= Hash.new\n\t self.arguments.merge!(arguments) do |k, old, new| \n\t\tif old != new\n\t\t raise ArgumentError, \"a constraint has already been set on the #{k} argument\" \n\t\tend\n\t\told\n\t end\n\t self\n\tend",
"def load_args\n hash = instance_eval(File.read(File.join(__dir__, 'consts', 'sys_arg.rb')))\n Hash.new do |_h, k|\n next hash[k] if hash[k]\n next hash[k.to_s[4..].to_sym] if k.to_s.start_with?('x32_')\n\n nil\n end\n end",
"def fpm_attributes(args=nil)\n if args.is_a?(Hash)\n @fpm_attributes.merge!(args)\n end\n @fpm_attributes\n end",
"def serializable_hash(options)\n hash = super(options)\n extra_hash = {\n 'project' => project,\n }\n hash.merge!(extra_hash)\n end",
"def map_to_prepared_args(hash)\n prepared_args.map{|k| hash[k.to_sym]}\n end",
"def to_hash\n {\n :name => @name,\n :options => @options,\n :provisioner => @provisioner,\n :dependencies => @dependencies.to_hash,\n :run_list => @run_list.to_hash\n }\n end",
"def pfmerge(dest_key, *source_key); end"
] |
[
"0.686136",
"0.66113806",
"0.6460353",
"0.6459943",
"0.64443856",
"0.6351106",
"0.6026337",
"0.6011251",
"0.60047877",
"0.59954244",
"0.5991559",
"0.59628654",
"0.59418786",
"0.59189785",
"0.5915888",
"0.5874264",
"0.58566463",
"0.5802745",
"0.57890964",
"0.5787585",
"0.57680416",
"0.5763558",
"0.57522726",
"0.57300043",
"0.57214725",
"0.57048327",
"0.5633366",
"0.56224084",
"0.56003004",
"0.55681235",
"0.55633426",
"0.5540503",
"0.5529008",
"0.5507414",
"0.5503691",
"0.547291",
"0.5471102",
"0.54681367",
"0.5451078",
"0.54377913",
"0.5416273",
"0.5416183",
"0.54132867",
"0.54082245",
"0.54075706",
"0.5401734",
"0.54003567",
"0.5397692",
"0.5388597",
"0.5384319",
"0.53791565",
"0.5378633",
"0.53707063",
"0.53704816",
"0.5365009",
"0.5361022",
"0.5342718",
"0.53397846",
"0.5335213",
"0.53345025",
"0.53336215",
"0.53322303",
"0.53268886",
"0.53268886",
"0.5297302",
"0.5280067",
"0.5273839",
"0.5268131",
"0.52666783",
"0.52575505",
"0.5257117",
"0.52538085",
"0.52518606",
"0.5246892",
"0.52362484",
"0.52321506",
"0.5215434",
"0.5212817",
"0.5207319",
"0.5202079",
"0.5201067",
"0.5181888",
"0.51814556",
"0.5180929",
"0.51792943",
"0.51759547",
"0.51675063",
"0.51672816",
"0.51663977",
"0.516536",
"0.5159974",
"0.5158243",
"0.5152096",
"0.5139279",
"0.51246154",
"0.5119229",
"0.51148987",
"0.51148593",
"0.51073474",
"0.5098839"
] |
0.59801024
|
11
|
Returns handle to the SimpleCacheCollection instance for this class.
|
def cache
@@_cache[self.class.name]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def simple_cache\n @@cache_store\n end",
"def collection\n @collection ||= Collection.load(self.collection_url)\n end",
"def cache\n @__cache ||= Cache.new self\n end",
"def getCollection\n return @coll\n end",
"def cache\n @cache ||= Flareshow::Cache.new\n end",
"def collection\n @collection ||= load_collection\n end",
"def collection\n Jrodb::Collection::Basic.new(self)\n end",
"def _collection(name)\n @collections[name] ||= Memory::Collection.new(name, _identity(name))\n end",
"def get_cache_object\n return @cache_obj unless @cache_obj == nil\n @cache_obj = ChaiIo::Cache::RedisCache.new\n @cache_obj\n end",
"def method_missing(method, *args, &block)\n method = method.to_s\n options = args.last.is_a?(Hash) ? args.pop : {}\n unless config.use_resource_cache\n resource_class = resource_class_for(method)\n raise \"Resource for #{method} does not exist\" unless resource_class\n return ZendeskAPI::Collection.new(self, resource_class, options)\n end\n\n @resource_cache[method] ||= { :class => nil, :cache => ZendeskAPI::LRUCache.new }\n if !options.delete(:reload) && (cached = @resource_cache[method][:cache].read(options.hash))\n cached\n else\n @resource_cache[method][:class] ||= resource_class_for(method)\n raise \"Resource for #{method} does not exist\" unless @resource_cache[method][:class]\n @resource_cache[method][:cache].write(options.hash, ZendeskAPI::Collection.new(self, @resource_cache[method][:class], options))\n end\n end",
"def cache\n @cache ||= MemoryCache.new\n end",
"def collection\n if @collection.empty? && @loaded == false\n @collection = forward( :\"#{@key}_fetch!\" ) || @collection || []\n @loaded = true\n end\n\n @collection\n end",
"def cache\n @cache ||= ::Shopidav::Cache.new(site)\n end",
"def collection\n klass.collection\n end",
"def cached\n self\n end",
"def reader\n @proxy ||= CollectionProxy.new(klass, self)\n end",
"def singleton_cache; end",
"def cache; shrine_class.new(cache_key); end",
"def cache\n @cache ||= build_cache\n end",
"def collection\n klass.collection\n end",
"def cache_client\n @m ||= Mutex.new\n @m.synchronize do\n if instance_variable_defined?(:@cache_client)\n @cache_client\n else\n dir = Rails.root.join(CacheDirectory.find_by(name: 'efs_twitter_user')&.dir || 'tmp/efs_cache')\n FileUtils.mkdir_p(dir) unless File.exists?(dir)\n options = {expires_in: 1.month, race_condition_ttl: 5.minutes}\n @cache_client = ActiveSupport::Cache::FileStore.new(dir, options)\n end\n end\n end",
"def initialize\n @coll = self.class.collection\n end",
"def cache\n $Redis\n end",
"def cache_read_multi(collection_serializer, adapter_instance, include_tree)\n return {} if ActiveModelSerializers.config.cache_store.blank?\n\n keys = object_cache_keys(collection_serializer, adapter_instance, include_tree)\n\n return {} if keys.blank?\n\n ActiveModelSerializers.config.cache_store.read_multi(*keys)\n end",
"def collection(name)\n Kernel.const_get(\"#{name}Collection\").new(@browser)\n end",
"def collection\n @collection ||= database.collection Crocoduck::Store.server_collection\n end",
"def collection\n self.class.collection\n end",
"def collection\n self.class.collection\n end",
"def [](collection_name)\n Collection.new(self, collection_name)\n end",
"def cache\n @cache ||= Chef::Cache.new()\n end",
"def cache\n DataCache\n end",
"def cache_object\n if !@href.nil? && @href =~ /^file:\\/\\//\n return nil\n end\n unless FeedTools.feed_cache.nil?\n if @cache_object.nil?\n begin\n if @href != nil\n begin\n @cache_object = FeedTools.feed_cache.find_by_href(@href)\n rescue RuntimeError => error\n if error.message =~ /sorry, too many clients already/\n warn(\"There are too many connections to the database open.\")\n raise error\n else\n raise error\n end\n rescue => error\n warn(\"The feed cache seems to be having trouble with the \" +\n \"find_by_href method. This may cause unexpected results.\")\n raise error\n end\n end\n if @cache_object.nil?\n @cache_object = FeedTools.feed_cache.new\n end\n rescue\n end \n end\n end\n return @cache_object\n end",
"def cached\n @cached ||= Rails.cache.read(self.cache_key, opts_for_cache)\n end",
"def _collection(name)\n @collections[name] ||= Dynamodb::Collection.new(\n @client,\n Lotus::Model::Adapters::Dynamodb::Coercer.new(_mapped_collection(name)),\n name,\n _identity(name),\n )\n end",
"def singleton0_cache; end",
"def cache_read_multi(collection_serializer, adapter_instance, include_directive)\n return {} if ActiveModelSerializers.config.cache_store.blank?\n\n keys = object_cache_keys(collection_serializer, adapter_instance, include_directive)\n\n return {} if keys.blank?\n\n ActiveModelSerializers.config.cache_store.read_multi(*keys)\n end",
"def cached_instance\n @cached_instance ||= read_instance\n end",
"def cached\n raise NotImplementedError\n end",
"def instance_cache; end",
"def collection(objectName)\n Hirsute::Collection.new(objectName)\nend",
"def initialize\n @collection = []\n end",
"def initialize\n @coll=self.class.collection\n end",
"def collection\n unless @collection\n @collection = @connection.use(@database_name)[\"sunspot_index_queue_entries\"]\n\n @collection.indexes.create_one(:record_class_name => 1, :record_id => 1)\n @collection.indexes.create_one(:priority => -1, :record_class_name => 1, :run_at => 1, :lock => 1)\n end\n\n @collection\n end",
"def class_cache # :nodoc:\n end",
"def class_cache # :nodoc:\n end",
"def cache\n if Esi.config.cache.nil?\n @cache ||= ActiveSupport::Cache::NullStore.new\n else\n Esi.config.cache\n end\n end",
"def collection\n @collection ||= collection_values\n end",
"def get(options={})\n res, status = @client.get(\"#{path(options)}/#{URI.escape options[:name]}\")\n return Cache.new(self, res)\n end",
"def cache\n @cache ||= {}\n end",
"def cache\n @cache ||= {}\n end",
"def initialize\n @cache = {}\n end",
"def default_collection\n Collection.new(@backend, @name, \"_default\", \"_default\")\n end",
"def collection\n @collector.collection\n end",
"def cache\n @cache ||= {}\n end",
"def cache\n @cache ||= {}\n end",
"def collection\n return nil unless collection_member?\n @collection ||= SolrDocument.new(\n Blacklight.solr.select(\n :params => {\n :fq => \"#{SolrDocument.unique_key}:\\\"#{self[blacklight_config.collection_member_identifying_field].first}\\\"\"\n }\n )[\"response\"][\"docs\"].first\n )\n end",
"def db_cache_collection(options)\n\n if options[:collection].is_a?(ActiveRecord::Relation)\n\n whole_cache_key = options[:collection].try(:cache_key)\n cached_result = NitroCache.where( nitro_cache_key: whole_cache_key, nitro_cacheable_id: nil, nitro_cacheable_type: nil).first\n\n if cached_result\n cached_result.update_attributes(viewed_at: Time.now)\n return cached_result.try(:nitro_cached_value).try(:html_safe)\n end\n\n render_result = options[:straight_cache] ? db_cache_collection_s( options ) : db_cache_collection_r( options )\n\n # why not NitroCache.create( nitro_cached_value: render_result, nitro_cache_key: whole_cache_key, nitro_cacheable_id: nil, nitro_cacheable_type: nil) &\n # because on large collections raw insert is 1.2 faster, i.e. same speed as memcache.\n NitroCache.connection.execute( <<INSERT_STR\n INSERT INTO \"nitro_caches\" (\"nitro_cached_value\", \"nitro_cache_key\", \"nitro_partial_id\", \"viewed_at\" )\n VALUES ('#{render_result}', '#{whole_cache_key}', '#{@current_cache_aggregator[:nitro_partial_id]}', '#{Time.now}')\nINSERT_STR\n )\n render_result\n else\n db_cache_array( options )\n end\n end",
"def collection\n Rails.logger.info \"XXXXX COLLECTION NAME #{collection_hash['collection name']}\"\n\n @collection ||= CollectionCreator.find_or_create_collection(\n collection_hash['collection name'],\n collection_hash['unit name'],\n collection_hash['collection description'],\n submitter_user_key\n )\n end",
"def collection\n @collection ||= PublicEarth::Db::Collection.find_by_id!(collection_id)\n end",
"def cache\n @cache ||= {}\n end",
"def get_instance\n @redis\n end",
"def collection\n if @collection.kind_of? Proc\n @collection = @collection.call\n ensure_indices if @collection.kind_of? Mongo::Collection\n end\n return @collection\n end",
"def cache\n # Do a deep copy\n Marshal.load(Marshal.dump(@@cache))\n end",
"def initialize\n @collection={}\n end",
"def collection(resource_name, model = nil)\n @collections[resource_name] = {:parent => self, :target => (model ? model : resource_name)} # workaround for weird bug with passing a class to Collection\n class_eval(<<-EOS)\n def #{resource_name}\n @#{resource_name} ||= []\n end\n\n def #{resource_name}=(array)\n @#{resource_name} = SurveyGizmo::Collection.new(#{self}, :#{resource_name}, array)\n end\n EOS\n end",
"def get_memcache_key_object\n MemcacheKey.new('aml.aml_search')\n end",
"def collections\n with_caching({}, 'collections') do\n sibling_nodes_for('collection').map {|n| Collection.new(n, authentication_options) }\n end\n end",
"def collection\n @collection ||= google_session.collection_by_title('riskcovry_uploads')\n end",
"def globalcache\n @globalcache ||= GlobalCacheHelper.new(@parent)\n end",
"def [](key)\n return nil if @collection.nil?\n return_item_value key\n end",
"def collection\n return @client.api_helper.collection(\"items\")\n end",
"def adapter\n unless @_adapter && @_adapter.valid?\n @_adapter = Cachetastic::Adapters.build(cache_klass)\n end\n @_adapter\n end",
"def ocollection\n @@_collection[self.class.name].name\n end",
"def cache_class(options={})\n @cache_class ||= {}\n return @cache_class[options[:cache] || self.cache] if @cache_class[options[:cache] || self.cache]\n \n @cache_class[options[:cache] || self.cache] = if self.cache\n Cache.const_get((options[:cache] || self.cache).to_s.gsub(/(?:^|_)(.)/) { $1.upcase })\n else\n Cache::NoCache\n end\n end",
"def server_cache\n Facebooker::ServerCache.new(self)\n end",
"def cache!\n @@cache\n end",
"def new_collection\n Models::Collection.new\n end",
"def cache\n store = Moneta.new :File, dir: 'moneta'\n Cachy.cache_store = store\n Cachy\n end",
"def collection\n instance_variable_get(collection_name) || set_collection(find_collection)\n end",
"def collection(collection_name)\n Collection.new(@backend, @bucket_name, @name, collection_name)\n end",
"def [](name)\n name = \"#{self.name}.#{name}\"\n return Collection.new(name, db) if !db.strict? ||\n db.collection_names.include?(name.to_s)\n raise \"Collection #{name} doesn't exist. Currently in strict mode.\"\n end",
"def collection\n get_collection_ivar || begin\n set_collection_ivar class_name.all\n end\n end",
"def make_cache\n if !@thread_safe \n @@c = {}\n elsif defined?(ThreadSafe)\n @@c = ThreadSafe::Hash.new\n else\n raise 'ThreadSafe is required to use the Memory cache.'\n end \n end",
"def fetch\n @_fetch ||= begin\n path = @parent.build_request_path(@query_attrs)\n @parent.request(@query_attrs.merge(:_method => :get, :_path => path)) do |parsed_data, response|\n @parent.new_collection(parsed_data)\n end\n end\n end",
"def cache_store; end",
"def cache_store; end",
"def collection\n @collection.is_a?(Proc) ? @collection.call : @collection\n end",
"def get_collection(name)\n @data[name]\n end",
"def adapter\n a = cache_conn_instance.get(cache_name)\n if adapter_supported?(a.class)\n return a\n else\n raise Cachetastic::Errors::UnsupportedAdapter.new(cache_name, a.class)\n end\n end",
"def model\n options.key?(:collection) ? call(:collection).klass : collection\n end",
"def make_collection\n raise NotImplementedError\n end",
"def get_flexi_collection\n _find_or_update_or_build_collection!\n\n self._flexi_collection\n end",
"def client\n @client ||= MemCache.new(address)\n end",
"def cache_instance(klass)\n klass.instance_variable_get('@static_record_cache')\n end",
"def [](key)\n puts \"STUB: [] in CacheMethods::Cache\"\n end",
"def key\n :cache\n end",
"def find(*args)\n Collection.new(super, @mapped_collection)\n end",
"def collection\n @collection ||= self.db.collection(self.collection_name)\n end",
"def cache_control\n @cache_control ||= CacheControl.new(headers['Cache-Control'])\n end",
"def [](collection_name)\n collection(collection_name)\n end"
] |
[
"0.6766352",
"0.62372154",
"0.6154042",
"0.6026701",
"0.6015287",
"0.59810215",
"0.5913124",
"0.5864374",
"0.58624977",
"0.5841348",
"0.5778938",
"0.5768889",
"0.57607627",
"0.5755973",
"0.57548344",
"0.5700296",
"0.56876427",
"0.5684823",
"0.5671278",
"0.56704986",
"0.5630614",
"0.562593",
"0.5624934",
"0.56247604",
"0.5621256",
"0.5609667",
"0.5592751",
"0.5592751",
"0.55512047",
"0.55303156",
"0.5528216",
"0.5489787",
"0.54871875",
"0.5463366",
"0.5450953",
"0.54346967",
"0.54210466",
"0.5402319",
"0.5401284",
"0.5400847",
"0.53991395",
"0.5387058",
"0.53862697",
"0.53834635",
"0.53834635",
"0.5369851",
"0.53681403",
"0.5350981",
"0.53433883",
"0.53433883",
"0.5342424",
"0.5336937",
"0.5333045",
"0.53214055",
"0.53214055",
"0.5318528",
"0.53119403",
"0.5306396",
"0.5296787",
"0.5283938",
"0.5271949",
"0.52528375",
"0.5246245",
"0.52412647",
"0.5230549",
"0.52265674",
"0.52042276",
"0.5199579",
"0.51988244",
"0.51950264",
"0.5190744",
"0.5186948",
"0.51837975",
"0.51822335",
"0.5182201",
"0.5182046",
"0.51795316",
"0.5175121",
"0.5168205",
"0.5163845",
"0.5155368",
"0.5153524",
"0.5152496",
"0.51393795",
"0.5127273",
"0.5127273",
"0.51193947",
"0.5114169",
"0.51086235",
"0.51078963",
"0.5079974",
"0.50690824",
"0.506643",
"0.5061339",
"0.50604",
"0.5055998",
"0.5052585",
"0.5047015",
"0.5026628",
"0.5022286"
] |
0.60143065
|
5
|
Calls cache. Explain! Used for clarity? JMC
|
def cache_request
cache
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache=(_arg0); end",
"def cache=(_arg0); end",
"def cache=(_arg0); end",
"def cache=(_arg0); end",
"def cached?; end",
"def cache!\n @@cache\n end",
"def cache(data); end",
"def cache_on?; end",
"def cache_on?; end",
"def update_cache\n # Does nothing...up to subclasses to implement.\n end",
"def cached\n raise NotImplementedError\n end",
"def cache_store; end",
"def cache_store; end",
"def set_cache(value); end",
"def set_cache(value); end",
"def cache_value?; end",
"def counter_cache; end",
"def cache_store=(_arg0); end",
"def cache_store=(_arg0); end",
"def counter_cache=(_arg0); end",
"def cache\n yield\n end",
"def instance_cache; end",
"def cached_call(compiler)\n cache_check(compiler) << call_cached_method(compiler)\n end",
"def cached_call(compiler)\n cache_check(compiler) << call_cached_method(compiler)\n end",
"def call_with_cache(key)\n cache.key?(key) ? cache[key] : cache[key] = fetch(key).call\n end",
"def singleton_cache; end",
"def configure_cache; end",
"def filter_cache; end",
"def flush_cache; end",
"def disable_caching=(_arg0); end",
"def cache\n @cache ||= build_cache\n end",
"def without_cache(&block); end",
"def without_cache(&block); end",
"def cache\n DataCache\n end",
"def cache\n @cache ||= {}\n end",
"def cache\n @cache ||= {}\n end",
"def singleton0_cache; end",
"def cached\n self\n end",
"def set_compiled_method_cache; end",
"def test_cached\n cached = TestCache.new\n \n # force = false\n assert !cached.cached?(:m1)\n cached.m1\n assert cached.cached?(:m1)\n sleep 4\n assert cached.cached?(:m1)\n \n # force = true\n assert !cached.cached?(:m2)\n cached.m2\n sleep 1\n assert cached.cached?(:m2)\n sleep 3\n assert !cached.cached?(:m2)\n end",
"def cache\n @cache ||= {}\n end",
"def caching\n @caching = \"data_update[#{data_path}]\"\n end",
"def caching\n @caching = \"data_update[#{data_path}]\"\n end",
"def caching\n @caching = \"data_update[#{data_path}]\"\n end",
"def caching\n @caching = \"data_update[#{data_path}]\"\n end",
"def cache_get(ck)\n cache_op(:get, ck)\n end",
"def cache?\n false\n end",
"def _cache_control; end",
"def clear_cache; end",
"def cache_key\n end",
"def cache\n @cache ||= {}\n end",
"def cache\n @cache ||= {}\n end",
"def move_to_cache\r\n true\r\n end",
"def use_cache?\n super && !against_head?\n end",
"def use_cache?\n super && !against_head?\n end",
"def try_with_cache(obj, source, consume_all); end",
"def move_to_cache\n true\n end",
"def cache_fetch(*args)\n super { |key| @store[key] }\n end",
"def cache(new_cache = nil)\n @cache = new_cache if new_cache\n @cache\n end",
"def cache\n rows.each(&:cache)\n end",
"def cache_get(k)\n synchronize{@cache[k]}\n end",
"def use_cache(cache)\n @cache = cache\n end",
"def cache\n @__cache ||= Cache.new self\n end",
"def clear_cache() @cache = {}; end",
"def cache_key; @cache.to_sym; end",
"def disable_caching; end",
"def move_to_cache\n true\n end",
"def move_to_cache\n true\n end",
"def move_to_cache\n true\n end",
"def cache_for(expires, *args, &blk)\n @cache_data ||= CacheData.new\n @cache_data.value caller_locations(1,1)[0].label.to_sym, expires, args, &blk\n end",
"def cache(key, action, cache_store)\n binding.pry\n cache_key = key.to_s + \"_\" + action.to_s\n if cache_store[cache_key]\n return cache_store[cache_key]\n else\n result = yield # run the block\n cache_store[cache_key] = result # store it in our cache\n return result\n end\nend",
"def cached?(key)\n false\n end",
"def cache?\n caching && true\n end",
"def class_cache # :nodoc:\n end",
"def class_cache # :nodoc:\n end",
"def counter_cache_enable=(_arg0); end",
"def cache\n @cache ||= begin\n if @old_commit_oid == @commit_oid\n @old_stats\n else\n compute_stats(@old_commit_oid, @old_stats)\n end\n end\n end",
"def load_cache\n @load_cache\n end",
"def cache(key = nil, &code)\n key ||= Stash.caller_name\n @store[key.to_sym] ||= code.call\n end",
"def line_cache; end",
"def should_cache?\n false\n end",
"def cache\n clone.tap { |crit| crit.options.merge!(:cache => true) }\n end",
"def cache\n @cache ||= Flareshow::Cache.new\n end",
"def cache_classes; end",
"def cache_classes; end",
"def cache\n @cache ||= MemoryCache.new\n end",
"def do_cached( key, &block )\n \n # have a look in the cache\n value = fetch( key )\n\n # Cache HIT?\n return value unless value.nil?\n\n # Cache MISS : execute the block\n value = block.call( key )\n\n # Store value in the cache\n return store( key, value )\n end",
"def simple_cache\n @@cache_store\n end",
"def cacheable?\n true\n end",
"def define_cachedp_method\n # we don't expect this to be called more than once, but we're being\n # defensive.\n return if defined?(cached?)\n\n if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= '5.1.0'\n def cached?(payload)\n payload.fetch(:cached, false)\n end\n else\n def cached?(payload)\n payload[:name] == CACHED_QUERY_NAME\n end\n end\n end",
"def interface_cache; end",
"def refresh_cache\n @cache = build_cache\n end",
"def command_show_cache chan, nick, arg\n items = []\n scanitems(arg||\"\") { |ref| items << ref }\n if items.empty?\n super\n else\n data = {}\n items.each { |ref|\n rec = cache_get ref, raw: true\n rec and data[ref] = rec\n }\n say_to chan, okmsg(nick, \"cached items: {\")\n data.to_yaml.each_line { |l| say_to chan, l }\n say_to chan, \"}\"\n end\n end"
] |
[
"0.8610231",
"0.8610231",
"0.8610231",
"0.8610231",
"0.8610231",
"0.8610231",
"0.8610231",
"0.80098027",
"0.80098027",
"0.80098027",
"0.80098027",
"0.7966051",
"0.7725617",
"0.77210045",
"0.77095777",
"0.77095777",
"0.758299",
"0.7553271",
"0.7504092",
"0.7504092",
"0.7422502",
"0.7422502",
"0.74012053",
"0.7335802",
"0.7273401",
"0.7273401",
"0.72616965",
"0.72586083",
"0.7235968",
"0.7229954",
"0.7229954",
"0.7216624",
"0.72089994",
"0.7182304",
"0.71349424",
"0.7113114",
"0.7089223",
"0.7058042",
"0.7040833",
"0.7040833",
"0.70147824",
"0.69180024",
"0.69180024",
"0.6900784",
"0.6890622",
"0.6890369",
"0.6870208",
"0.68619853",
"0.6858692",
"0.6858692",
"0.6858692",
"0.6858692",
"0.6839684",
"0.6829146",
"0.68082213",
"0.6776534",
"0.6775522",
"0.6773734",
"0.6773734",
"0.6739448",
"0.6714913",
"0.6714913",
"0.6686916",
"0.6666809",
"0.66579723",
"0.66495436",
"0.6634486",
"0.6633412",
"0.6629802",
"0.661396",
"0.6605381",
"0.65959597",
"0.6581501",
"0.6580585",
"0.6580585",
"0.6580585",
"0.6580189",
"0.65651286",
"0.6559025",
"0.6555498",
"0.65542555",
"0.65542555",
"0.65469146",
"0.65453345",
"0.6542463",
"0.6526861",
"0.65259254",
"0.65203875",
"0.650936",
"0.6506299",
"0.6504738",
"0.6504738",
"0.65024143",
"0.6495715",
"0.64848155",
"0.64825904",
"0.64785194",
"0.64770913",
"0.64704114",
"0.64673996"
] |
0.6805519
|
55
|
Returns handle to the SimpleCacheStore singleton instance.
|
def simple_cache
@@cache_store
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def new_store\n Cache.new\n end",
"def cache_store\n return nil if context.environment.cache.nil?\n\n CacheStore.new context.environment\n end",
"def cache; shrine_class.new(cache_key); end",
"def store\n @store ||= storage.new self\n end",
"def singleton_cache; end",
"def cached_instance\n @cached_instance ||= read_instance\n end",
"def cache_client\n @m ||= Mutex.new\n @m.synchronize do\n if instance_variable_defined?(:@cache_client)\n @cache_client\n else\n dir = Rails.root.join(CacheDirectory.find_by(name: 'efs_twitter_user')&.dir || 'tmp/efs_cache')\n FileUtils.mkdir_p(dir) unless File.exists?(dir)\n options = {expires_in: 1.month, race_condition_ttl: 5.minutes}\n @cache_client = ActiveSupport::Cache::FileStore.new(dir, options)\n end\n end\n end",
"def cache_store\n {\n redis: @redis,\n ttl: @ttl,\n cached: @cached,\n }\n end",
"def store\n @@store ||= Store.get_store(0)\n end",
"def cache\n @cache ||= ::Shopidav::Cache.new(site)\n end",
"def cache_store\n return nil if _cache.nil?\n return _cache if _cache.class != ActiveSupport::Cache::NullStore\n if ActiveModelSerializers.config.cache_store\n self._cache = ActiveModelSerializers.config.cache_store\n else\n nil\n end\n end",
"def cache_store\n return nil if _cache.nil?\n return _cache if _cache.class != ActiveSupport::Cache::NullStore\n if ActiveModelSerializers.config.cache_store\n self._cache = ActiveModelSerializers.config.cache_store\n else\n nil\n end\n end",
"def get_instance\n @redis\n end",
"def store\n @cache.compute_if_absent(current_store_id) { new_store }\n end",
"def singleton0_cache; end",
"def fetch_store\n @store ||= self.store || create_store!\n end",
"def cache\n if Esi.config.cache.nil?\n @cache ||= ActiveSupport::Cache::NullStore.new\n else\n Esi.config.cache\n end\n end",
"def get_cache_object\n return @cache_obj unless @cache_obj == nil\n @cache_obj = ChaiIo::Cache::RedisCache.new\n @cache_obj\n end",
"def get_store\n ActiveRecord::MemoryStore.new\n end",
"def cache_store_type\n \"dummy\"\n end",
"def cache_store\n @@cache_store ||= begin\n # if config.search_cache_store was not previously set, a no method error would be raised\n config = Rails.application.config.redmine_search_cache_store rescue :memory_store\n if config\n ActiveSupport::Cache.lookup_store config\n end\n end\n end",
"def initialize_cache( type=nil )\n case type\n when /memcache/\n servers = [\"localhost\"]\n opts = { :namespace => \"martsearch\", :no_reply => true }\n \n if self.config[\"cache\"][\"servers\"]\n servers = self.config[\"cache\"][\"servers\"]\n end\n \n if self.config[\"cache\"][\"namespace\"]\n opts[:namespace] = self.config[\"cache\"][\"namespace\"]\n end\n \n return ActiveSupport::Cache::MemCacheStore.new( servers, opts )\n when /file/\n file_store = \"#{File.dirname(__FILE__)}/../tmp/cache\"\n if self.config[\"cache\"][\"file_store\"]\n file_store = self.config[\"cache\"][\"file_store\"]\n end\n return ActiveSupport::Cache::FileStore.new( file_store )\n else\n return ActiveSupport::Cache::MemoryStore.new()\n end\n end",
"def cache_store; end",
"def cache_store; end",
"def cache_instance(klass)\n klass.instance_variable_get('@static_record_cache')\n end",
"def store\n @store ||= Store.new\n end",
"def store\n return self.class.store\n end",
"def retrieve_store_class(store)\n # require_relative cannot be used here because the class might be\n # provided by another gem, like redis-activesupport for example.\n require \"active_support/cache/#{store}\"\n rescue LoadError => e\n raise \"Could not find cache store adapter for #{store} (#{e})\"\n else\n ActiveSupport::Cache.const_get(store.to_s.camelize)\n end",
"def store\n @store ||= OpenStruct.new\n end",
"def cache\n $Redis\n end",
"def store; shrine_class.new(store_key); end",
"def cache\n @__cache ||= Cache.new self\n end",
"def store\n @store ||= Store.first || Store.create\n end",
"def get_memcache_key_object\n MemcacheKey.new('aml.aml_search')\n end",
"def cache_store\n\t\t\t\treturn nil if context.environment.cache.nil?\n\n\t\t\t\tif defined?(Sprockets::SassCacheStore)\n\t\t\t\t\tSprockets::SassCacheStore.new context.environment\n\t\t\t\telse\n\t\t\t\t\tCacheStore.new context.environment\n\t\t\t\tend\n\t\t\tend",
"def store\r\n return @store\r\n end",
"def in(store)\n store_class = if store.is_a? Symbol\n MobileStores::STORES[store]\n elsif store.is_a? String\n Object.const_get(store) rescue nil\n elsif store.is_a? Class\n store\n end\n\n raise NotImplementedError, \"#{ store } is not implemented yet.\" if store.nil?\n\n store_class.new\n end",
"def initialize_store\n if (type = @store).is_a?(Symbol)\n params = []\n options = @store_options&.dup || {}\n case type\n when :file_store\n @cache_dir ||= File.join(FARADAY_CACHE_DIR, @namespace)\n @cache_dir ||= FARADAY_CACHE_DIR\n params << @cache_dir\n when :redis_cache_store\n options.merge!(RAILS_CONFIG)\n options.merge!(namespace: @namespace)\n end\n params << options\n @store = ActiveSupport::Cache.lookup_store(type, *params)\n end\n unless @store.is_a?(ActiveSupport::Cache::Store)\n raise \"expected Symbol, got #{@store.class} #{@store.inspect}\"\n end\n end",
"def cache\n @cache ||= Flareshow::Cache.new\n end",
"def cache\n if self.cache_store\n self.cache_store\n else\n self.cache_store = :file_store, root.join(\"tmp\").to_s\n self.cache_store\n end\n end",
"def cache_store_type\n \"memcache\"\n end",
"def cache\n @@_cache[self.class.name]\n end",
"def cache\n @cache ||= MemoryCache.new\n end",
"def store\n @store ||= {}\n end",
"def initialize\n @memory_store = ActiveSupport::Cache::MemoryStore.new\n end",
"def cache\n DataCache\n end",
"def lookup_store(store = nil, *parameters)\n case store\n when Symbol\n options = parameters.extract_options!\n # clean this up once Ruby 2.7 support is dropped\n # see https://github.com/rails/rails/pull/41522#discussion_r581186602\n if options.empty?\n retrieve_store_class(store).new(*parameters)\n else\n retrieve_store_class(store).new(*parameters, **options)\n end\n when Array\n lookup_store(*store)\n when nil\n ActiveSupport::Cache::MemoryStore.new\n else\n store\n end\n end",
"def make_cache\n if !@thread_safe \n @@c = {}\n elsif defined?(ThreadSafe)\n @@c = ThreadSafe::Hash.new\n else\n raise 'ThreadSafe is required to use the Memory cache.'\n end \n end",
"def get\n Rails.cache.read(session_id, namespace: 'check-in-cache')\n end",
"def cache\n @@cache ||= PStore.new(File.expand_path(@@cache_file))\n end",
"def server_cache\n Facebooker::ServerCache.new(self)\n end",
"def fetch_from_cache\n get_cache_object().get make_key\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('manager.devices')\n end",
"def store\n @store ||= Hash.new\n end",
"def entitystore\n uri = options['rack-cache.entitystore']\n storage.resolve_entitystore_uri(uri)\n end",
"def cache\n @cache ||= build_cache\n end",
"def cache_store_type\n \"memory\"\n end",
"def query_cache_store(key)\n raise NotImplementedError\n end",
"def store\n @store ||= Globot::Plugins.store.proxy_for(self)\n end",
"def ensure_store\n @store ||= LocalStorage.new\n end",
"def backend_instance\n if Rails.env.test?\n # turn off caching for tests\n @backend_instance = Backend.new(current_user)\n else\n @backend_instance ||= Backend.new(current_user)\n end\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('client.api_credentials')\n end",
"def client\n @client ||= MemCache.new(address)\n end",
"def cached\n self\n end",
"def get(options={})\n res, status = @client.get(\"#{path(options)}/#{URI.escape options[:name]}\")\n return Cache.new(self, res)\n end",
"def instance_cache; end",
"def store\n @store ||= begin\n raise \"This is Maglev only\" unless defined?(Maglev)\n # In the future, it might be nice to use something\n # other than an IdentitySet. Set? Bag?\n Maglev::PERSISTENT_ROOT[self.to_s.intern] ||= IdentitySet.new\n end\n end",
"def redis\n @redis ||= Redis.new\n end",
"def redis\n @redis ||= Redis.new\n end",
"def redis\n @redis ||= Redis.new\n end",
"def redis\n Redis.current\nend",
"def cache_store(key, value, options = {})\n key = namespaced(key)\n ttl = options[:ttl] rescue nil\n expires = Time.now + ttl if !ttl.nil?\n record = @store[:key => key]\n\n # Figure out if the record is new or already exists\n if !record\n record = @store.create(:key => key, :value => value, :expires => expires)\n record.value\n else\n record = record.update(:value => value, :expires => expires)\n record.value\n end\n end",
"def cache\n persist('memory_only_ser')\n end",
"def cached\n @cached ||= Rails.cache.read(self.cache_key, opts_for_cache)\n end",
"def redis\n self.class.redis\n end",
"def redis\n self.class.redis\n end",
"def middleware\n @middleware ||= Middleware.new(\n \"ActiveSupport::Cache::Strategy::LocalCache\",\n local_cache_key)\n end",
"def store\n @store ||= Globot::Store.new(Globot.config.for_plugin('database'))\n end",
"def preset_lazy_sync\n preset_direct\n use(WCC::Contentful::Middleware::Store::CachingMiddleware,\n ActiveSupport::Cache.lookup_store(*options))\n end",
"def [](*args)\n args = args.first if (args.size == 1)\n return super(args) if args.is_a?(Hash)\n ck = cache_key(args)\n if obj = @cache_store.get(ck)\n return obj\n end\n if obj = super(args)\n @cache_store.set(ck, obj, @cache_ttl)\n end \n obj\n end",
"def key\n :cache\n end",
"def store\n @store ||= Store.find(options[:store]).new(options[:source])\n end",
"def singleton\n class << self; self end\n end",
"def redis\n @redis ||= Redis.new url: LcEnv.redis_url\n end",
"def simple_cache_key\n \"#{self.class.name.underscore}/#{id}\"\n end",
"def store\n self.class.store\n end",
"def storage_instance; end",
"def cache\n @cache ||= Chef::Cache.new()\n end",
"def cache_fetch(*args)\n super { |key| @store[key] }\n end",
"def build_cache_store(input, version)\n CacheStore.new(input[:cache], version)\n end",
"def metastore\n uri = options['rack-cache.metastore']\n storage.resolve_metastore_uri(uri)\n end",
"def store\n _store_id = store_id\n ::Spree::User.logger.debug \"| ByParameters: store_id #{_store_id}\"\n store = _store_id ? ::Spree::Store.where(id: _store_id).first : nil\n store || Spree::Store.new\n end",
"def session_from_redis\n redis_handler.get\n end",
"def upstream\n return Upstream::NullStore unless enabled?\n return Upstream::MemoryStore if type == \"memory\"\n Upstream::FileStore\n end",
"def redis\n @@redis ||= Redis.new\n end",
"def get_memcache_key_object\n MemcacheKey.new('aml.all_aml_match')\n end",
"def cache_class(options={})\n @cache_class ||= {}\n return @cache_class[options[:cache] || self.cache] if @cache_class[options[:cache] || self.cache]\n \n @cache_class[options[:cache] || self.cache] = if self.cache\n Cache.const_get((options[:cache] || self.cache).to_s.gsub(/(?:^|_)(.)/) { $1.upcase })\n else\n Cache::NoCache\n end\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('client.token_details')\n end",
"def cache_store=(_arg0); end",
"def cache_store=(_arg0); end"
] |
[
"0.6644324",
"0.65349",
"0.6361972",
"0.63534564",
"0.6315308",
"0.6243158",
"0.61991364",
"0.61588085",
"0.6147739",
"0.61404",
"0.61287725",
"0.61287725",
"0.61124194",
"0.61002916",
"0.60885304",
"0.60814565",
"0.6072397",
"0.60501343",
"0.60280156",
"0.6013275",
"0.59978694",
"0.5957849",
"0.5921919",
"0.5921919",
"0.5914462",
"0.5890364",
"0.5870209",
"0.5868293",
"0.5848417",
"0.5843693",
"0.5840649",
"0.58041316",
"0.5789938",
"0.57623124",
"0.57547027",
"0.5747084",
"0.5745063",
"0.5739617",
"0.5729713",
"0.572786",
"0.5682279",
"0.5667054",
"0.5654157",
"0.56115013",
"0.560688",
"0.5581331",
"0.55723166",
"0.5570295",
"0.55655545",
"0.5555706",
"0.55509204",
"0.55403167",
"0.55377185",
"0.5484054",
"0.54763967",
"0.5463076",
"0.54580134",
"0.5452534",
"0.54479057",
"0.54243684",
"0.54141915",
"0.5405556",
"0.5399469",
"0.5387311",
"0.5369416",
"0.536147",
"0.5346277",
"0.53369164",
"0.53369164",
"0.53369164",
"0.5333347",
"0.5318888",
"0.53112084",
"0.53030115",
"0.52976817",
"0.52976817",
"0.52863",
"0.52809334",
"0.52796566",
"0.5278832",
"0.5272863",
"0.52687454",
"0.5267367",
"0.52661353",
"0.5265527",
"0.5257748",
"0.52560294",
"0.5252425",
"0.52505755",
"0.5242577",
"0.5241864",
"0.5240667",
"0.52397925",
"0.5237083",
"0.52334666",
"0.52252126",
"0.5222831",
"0.52170116",
"0.5216521",
"0.5216521"
] |
0.7578753
|
0
|
The code does not execute properly. Try to figure out why. Original:
|
def multiply(a b)
a * b
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def private; end",
"def suivre; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def run; end",
"def probers; end",
"def schubert; end",
"def run() end",
"def zuruecksetzen()\n end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def fail\n\t\t# throw up this code and feed plezi your own lines :)\n\t\traise \"Plezi raising hell!\"\n\tend",
"def refutal()\n end",
"def terpene; end",
"def bug\n end",
"def run\n end",
"def continued_exception; end",
"def run\n end",
"def p15\n\t\nend",
"def execute; end",
"def execute; end",
"def run\n \n end",
"def run\n \n end",
"def run\n end",
"def run\n end",
"def run_failed; end",
"def executor; end",
"def executor; end",
"def executor; end",
"def exec; end",
"def exec; end",
"def br3ak\n raise RuntimeError, \"OMFG!!1!\"\n end",
"def check_starting(_lang_result)\n end",
"def villian; end",
"def verdi; end",
"def running; end",
"def running; end",
"def run\n end",
"def run\n end",
"def run\n end",
"def run\n end",
"def run\n end",
"def run\n end",
"def run\n end",
"def berlioz; end",
"def operations; end",
"def operations; end",
"def runnables; end",
"def diagnostic; end",
"def celebration; end",
"def upc_e; end",
"def prepare_result\n\t\t\tsuper\n\t\t\t@lowest_old = MM.get_lowest_old(@current_point, @start_vector, @hd_config, false, @tuning_range)\n if @lowest_old[0] == nil\n\t\t\t\t@initial_run = true\n\t\t\t\tthrow :jump_back\n\t\t\tend\n\t\tend",
"def run\n end",
"def processor; end",
"def finished; end",
"def rossini; end",
"def placebo?; false end",
"def pre_loop; end",
"def awaken!\n\t\traise 'Not implemented'\n\tend",
"def semact?; false; end",
"def runs; end",
"def jack_handey; end",
"def trd; end",
"def superweening_adorningly(counterstand_pyrenomycetales)\n end",
"def bellini; end",
"def starting; end",
"def run(_); end",
"def run(_); end",
"def ibu; end",
"def compilereturn\n\n end",
"def checks; end",
"def post_process; end",
"def thread; end",
"def thread; end",
"def thread; end",
"def run()\n end",
"def anchored; end",
"def proceed!; end",
"def proceed!; end",
"def gounod; end",
"def pass; end",
"def pass; end",
"def stderrs; end",
"def incomplete\r\n\r\n end",
"def execute\n end",
"def execute\n end",
"def processing_instruction?; end",
"def processing_instruction?; end",
"def r; end",
"def r; end"
] |
[
"0.6102568",
"0.59635013",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.59587896",
"0.592695",
"0.58857346",
"0.57640874",
"0.56410444",
"0.5631545",
"0.5631545",
"0.5631545",
"0.5631545",
"0.5631545",
"0.5631545",
"0.5631545",
"0.56069887",
"0.5511096",
"0.5494428",
"0.5478408",
"0.5443674",
"0.54239357",
"0.5419664",
"0.5412792",
"0.5406687",
"0.5406687",
"0.5397799",
"0.5397799",
"0.536625",
"0.536625",
"0.5338195",
"0.53250194",
"0.53250194",
"0.53250194",
"0.530537",
"0.530537",
"0.5304843",
"0.5304562",
"0.5288883",
"0.5283619",
"0.52760524",
"0.52760524",
"0.5273381",
"0.5273381",
"0.5273381",
"0.5273381",
"0.5273381",
"0.5273381",
"0.5273381",
"0.5271685",
"0.52654374",
"0.52654374",
"0.52652884",
"0.5264897",
"0.5255975",
"0.5244335",
"0.5240766",
"0.52399355",
"0.5238891",
"0.5236231",
"0.52360016",
"0.52356404",
"0.52311856",
"0.5225967",
"0.5219203",
"0.52052903",
"0.5204971",
"0.5199016",
"0.5184479",
"0.5177596",
"0.5176146",
"0.5163657",
"0.5163657",
"0.5153848",
"0.5152783",
"0.5150385",
"0.5140911",
"0.5138699",
"0.5138699",
"0.5138699",
"0.5137563",
"0.51366806",
"0.5135233",
"0.5135233",
"0.5134776",
"0.51303256",
"0.51303256",
"0.51202434",
"0.51066697",
"0.51001513",
"0.51001513",
"0.5099927",
"0.5099927",
"0.5083176",
"0.5083176"
] |
0.0
|
-1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.